You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1 lines
821 KiB
1 lines
821 KiB
{"version":3,"sources":["utils.js"],"names":["_global","window","global","self","this","BI","prepares","apply","func","thisArg","args","length","call","arrayAggregator","array","setter","iteratee","accumulator","index","value","arrayEach","arrayEvery","predicate","arrayFilter","resIndex","result","arrayIncludes","baseIndexOf","arrayIncludesWith","comparator","arrayMap","Array","arrayPush","values","offset","arrayReduce","initAccum","arraySome","asciiToArray","string","split","baseFindKey","collection","eachFunc","key","baseFindIndex","fromIndex","fromRight","strictIndexOf","baseIsNaN","baseProperty","object","undefined","basePropertyOf","baseReduce","baseSortBy","comparer","sort","baseTimes","n","baseUnary","baseValues","props","cacheHas","cache","has","charsStartIndex","strSymbols","chrSymbols","charsEndIndex","countHolders","placeholder","getValue","hasUnicode","reHasUnicode","test","iteratorToArray","iterator","data","next","done","push","mapToArray","map","size","forEach","overArg","transform","arg","replaceHolders","PLACEHOLDER","safeGet","setToArray","set","stringSize","unicodeSize","asciiSize","stringToArray","unicodeToArray","reUnicode","lastIndex","match","lodash","isObjectLike","isArray","LazyWrapper","LodashWrapper","hasOwnProperty","wrapperClone","baseLodash","chainAll","__wrapped__","__actions__","__chain__","__index__","__values__","__dir__","__filtered__","__iteratees__","__takeCount__","MAX_ARRAY_LENGTH","__views__","lazyClone","copyArray","lazyReverse","clone","lazyValue","dir","isArr","isRight","arrLength","view","getView","start","end","iteratees","iterLength","takeCount","nativeMin","baseWrapperValue","outer","iterIndex","type","computed","LAZY_MAP_FLAG","LAZY_FILTER_FLAG","Hash","entries","clear","entry","hashClear","__data__","nativeCreate","hashDelete","hashGet","HASH_UNDEFINED","hashHas","hashSet","ListCache","listCacheClear","listCacheDelete","assocIndexOf","pop","splice","listCacheGet","listCacheHas","listCacheSet","MapCache","mapCacheClear","hash","Map","mapCacheDelete","getMapData","mapCacheGet","get","mapCacheHas","mapCacheSet","SetCache","add","setCacheAdd","setCacheHas","Stack","stackClear","stackDelete","stackGet","stackHas","stackSet","pairs","LARGE_ARRAY_SIZE","arrayLikeKeys","inherited","isArg","isArguments","isBuff","isBuffer","isType","isTypedArray","skipIndexes","String","isIndex","assignMergeValue","eq","baseAssignValue","assignValue","objValue","baseAggregator","baseEach","baseAssign","source","copyObject","keys","baseAssignIn","keysIn","defineProperty","configurable","enumerable","writable","baseAt","paths","skip","baseClamp","number","lower","upper","baseClone","bitmask","customizer","stack","isDeep","CLONE_DEEP_FLAG","isFlat","CLONE_FLAT_FLAG","isFull","CLONE_SYMBOLS_FLAG","isObject","initCloneArray","tag","getTag","isFunc","funcTag","genTag","cloneBuffer","objectTag","argsTag","initCloneObject","copySymbolsIn","copySymbols","cloneableTags","initCloneByTag","stacked","isSet","subValue","isMap","keysFunc","getAllKeysIn","getAllKeys","baseDelay","wait","TypeError","FUNC_ERROR_TEXT","setTimeout","baseDifference","includes","isCommon","valuesLength","valuesIndex","baseEvery","baseExtremum","current","isSymbol","baseFilter","baseFlatten","depth","isStrict","isFlattenable","baseForOwn","baseFor","baseForOwnRight","baseForRight","baseFunctions","isFunction","baseGet","path","castPath","toKey","baseGetAllKeys","symbolsFunc","baseGetTag","undefinedTag","nullTag","symToStringTag","Object","getRawTag","objectToString","baseGt","other","baseHas","baseHasIn","baseIntersection","arrays","othLength","othIndex","caches","maxLength","Infinity","seen","baseInverter","baseInvoke","parent","last","baseIsArguments","baseIsDate","dateTag","baseIsEqual","baseIsEqualDeep","equalFunc","objIsArr","othIsArr","objTag","arrayTag","othTag","objIsObj","othIsObj","isSameTag","equalArrays","equalByTag","COMPARE_PARTIAL_FLAG","objIsWrapped","othIsWrapped","objUnwrapped","othUnwrapped","equalObjects","baseIsMap","mapTag","baseIsMatch","matchData","noCustomizer","srcValue","COMPARE_UNORDERED_FLAG","baseIsNative","isMasked","pattern","reIsNative","reIsHostCtor","toSource","baseIsRegExp","regexpTag","baseIsSet","setTag","baseIsTypedArray","isLength","typedArrayTags","baseIteratee","identity","baseMatchesProperty","baseMatches","property","baseKeys","isPrototype","nativeKeys","baseKeysIn","nativeKeysIn","isProto","baseLt","baseMap","isArrayLike","getMatchData","matchesStrictComparable","isKey","isStrictComparable","hasIn","baseMerge","srcIndex","baseMergeDeep","newValue","mergeFunc","isTyped","isArrayLikeObject","cloneTypedArray","isPlainObject","toPlainObject","baseOrderBy","orders","criteria","compareMultiple","basePick","basePickBy","baseSet","basePropertyDeep","baseRandom","nativeFloor","nativeRandom","baseRange","step","nativeMax","nativeCeil","baseRest","setToString","overRest","nested","baseSlice","baseSome","baseToString","symbolToString","INFINITY","baseUniq","createSet","seenIndex","baseUnset","actions","action","baseZipObject","assignFunc","valsLength","castArrayLikeObject","stringToPath","toString","castSlice","buffer","slice","allocUnsafe","constructor","copy","cloneArrayBuffer","arrayBuffer","byteLength","Uint8Array","cloneDataView","dataView","byteOffset","cloneRegExp","regexp","reFlags","exec","cloneSymbol","symbol","symbolValueOf","typedArray","compareAscending","valIsDefined","valIsNull","valIsReflexive","valIsSymbol","othIsDefined","othIsNull","othIsReflexive","othIsSymbol","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","createBaseEach","iterable","createBaseFor","createBind","wrapper","fn","root","Ctor","isBind","arguments","WRAP_BIND_FLAG","createCtor","thisBinding","baseCreate","prototype","createCurry","arity","getHolder","createRecurry","createHybrid","createFind","findIndexFunc","partialsRight","holdersRight","argPos","ary","holdersCount","newHolders","isBindKey","reorder","isFlip","reverse","isAry","WRAP_ARY_FLAG","WRAP_BIND_KEY_FLAG","WRAP_CURRY_FLAG","WRAP_CURRY_RIGHT_FLAG","WRAP_FLIP_FLAG","createInverter","toIteratee","createPartial","createRange","toFinite","wrapFunc","isCurry","newHoldersRight","newPartials","newPartialsRight","WRAP_PARTIAL_FLAG","WRAP_PARTIAL_RIGHT_FLAG","WRAP_CURRY_BOUND_FLAG","newData","isLaziable","setData","setWrapToString","createWrap","toInteger","getData","mergeData","baseSetData","customDefaultsMerge","customOmitClone","isPartial","arrValue","othValue","compared","dataViewTag","arrayBufferTag","boolTag","numberTag","errorTag","name","message","stringTag","convert","symbolTag","objProps","objLength","othProps","skipCtor","objCtor","othCtor","flatRest","flatten","getFuncName","realNames","otherFunc","isKeyable","getNative","isOwn","unmasked","e","nativeObjectToString","transforms","getWrapDetails","reWrapDetails","reSplitDetails","hasPath","hasFunc","input","getPrototype","float32Tag","float64Tag","int8Tag","int16Tag","int32Tag","uint8Tag","uint8ClampedTag","uint16Tag","uint32Tag","insertWrapDetails","details","join","replace","reWrapComment","spreadableSymbol","MAX_SAFE_INTEGER","reIsUint","reIsPlainProp","reIsDeepProp","funcName","maskSrcKey","proto","objectProto","memoizeCapped","memoize","MAX_MEMOIZE_SIZE","srcBitmask","newBitmask","isCombo","WRAP_REARG_FLAG","otherArgs","indexes","oldArray","reference","updateWrapDetails","shortOut","count","lastCalled","stamp","nativeNow","remaining","HOT_SPAN","HOT_COUNT","funcToString","wrapFlags","pair","compact","concat","drop","findIndex","findLastIndex","flattenDeep","head","indexOf","initial","nativeReverse","take","takeRight","uniq","uniqBy","unzip","group","zipObject","chain","tap","interceptor","thru","wrapperChain","wrapperCommit","wrapperNext","toArray","wrapperToIterator","wrapperPlant","previous","wrapperReverse","wrapped","wrapperValue","every","filter","reduce","reject","negate","isString","some","before","debounce","options","invokeFunc","time","lastArgs","lastThis","lastInvokeTime","leadingEdge","timerId","timerExpired","leading","remainingWait","timeSinceLastCall","lastCallTime","timeSinceLastInvoke","timeWaiting","maxing","maxWait","shouldInvoke","now","trailingEdge","trailing","cancel","clearTimeout","flush","debounced","isInvoking","toNumber","resolver","memoized","Cache","once","rest","throttle","cloneDeep","isBoolean","isEmpty","isEqual","isFinite","nativeIsFinite","asyncTag","proxyTag","isNaN","isNumber","isNull","objectCtorString","isUndefined","symIterator","sign","MAX_INTEGER","remainder","NAN","valueOf","reTrim","isBinary","reIsBinary","reIsOctal","freeParseInt","reIsBadHex","create","properties","findKey","findLastKey","defaultValue","omitBy","pickBy","prop","clamp","random","floating","temp","rand","freeParseFloat","escape","reHasUnescapedHtml","reUnescapedHtml","escapeHtmlChar","trim","chars","constant","matches","mixin","methodNames","methodName","noConflict","_","oldDash","noop","stubArray","stubFalse","uniqueId","prefix","id","idCounter","max","min","VERSION","LAZY_WHILE_FLAG","promiseTag","weakMapTag","RegExp","rePropName","reRegExpChar","reEscapeChar","rsAstralRange","rsComboMarksRange","reComboHalfMarksRange","rsComboSymbolsRange","rsComboRange","rsVarRange","rsAstral","rsCombo","rsFitz","rsModifier","rsNonAstral","rsRegional","rsSurrPair","rsZWJ","reOptMod","rsOptVar","rsOptJoin","rsSeq","rsSymbol","htmlEscapes","&","<",">","\"","'","parseFloat","parseInt","freeGlobal","freeSelf","Function","freeExports","exports","nodeType","freeModule","module","moduleExports","freeProcess","process","nodeUtil","binding","nodeIsDate","isDate","nodeIsMap","nodeIsRegExp","isRegExp","nodeIsSet","nodeIsTypedArray","arrayProto","funcProto","coreJsData","uid","IE_PROTO","Buffer","Symbol","getPrototypeOf","objectCreate","propertyIsEnumerable","isConcatSpreadable","toStringTag","Math","ceil","floor","nativeGetSymbols","getOwnPropertySymbols","nativeIsBuffer","Date","DataView","Promise","Set","WeakMap","metaMap","dataViewCtorString","mapCtorString","promiseCtorString","setCtorString","weakMapCtorString","symbolProto","baseSetToString","ArrayBuffer","resolve","ctorString","charCodeAt","quote","subString","difference","intersection","mapped","union","without","zip","wrapperAt","countBy","find","groupBy","sortBy","bind","defer","delay","assignIn","defaults","propsIndex","propsLength","defaultsDeep","mergeWith","invert","invertBy","merge","omit","pick","range","extend","each","first","isFilter","getIteratee","takeName","dropName","findLast","invokeMap","dropRight","takeRightWhile","takeWhile","checkIteratee","isTaker","lodashFunc","retUnwrapped","isLazy","useLazy","isHybrid","isUnwrapped","onlyLazy","chainName","names","define","amd","MAX","MIN","EVENT_RESPONSE_TIME","zIndex_layer","zIndex_popover","zIndex_popup","zIndex_masker","zIndex_tip","emptyStr","emptyFn","empty","Key","48","49","50","51","52","53","54","55","56","57","65","66","67","68","69","70","71","72","73","74","75","76","77","78","79","80","81","82","83","84","85","86","87","88","89","90","96","97","98","99","100","101","102","103","104","105","106","107","109","110","111","KeyCode","BACKSPACE","COMMA","DELETE","DOWN","END","ENTER","ESCAPE","HOME","LEFT","NUMPAD_ADD","NUMPAD_DECIMAL","NUMPAD_DIVIDE","NUMPAD_ENTER","NUMPAD_MULTIPLY","NUMPAD_SUBTRACT","PAGE_DOWN","PAGE_UP","PERIOD","RIGHT","SPACE","TAB","UP","Status","SUCCESS","WRONG","START","WAITING","READY","RUNNING","OUTOFBOUNDS","NULL","Direction","Top","Bottom","Left","Right","Custom","Axis","Vertical","Horizontal","Selection","Default","None","Single","Multi","All","HorizontalAlign","Center","Stretch","VerticalAlign","Middle","StartOfWeek","pushArray","sArray","i","pushDistinct","obj","contains","pushDistinctArray","len","num","accAdd","arg1","arg2","r1","r2","m","c","abs","pow","cm","Number","sub","accSub","toFixed","mul","accMul","s1","s2","div","digitLength","eSplit","float2Fixed","dLen","times","num1","num2","others","_i","num1Changed","num2Changed","baseNum","leftValue","accDivide","startWith","str","startTag","substr","endWith","endTag","substring","getQuery","reg","r","unescape","appendQuery","paras","src","replaceAll","perfectStart","allIndexOf","location","loc","SECOND","MINUTE","HOUR","DAY","WEEK","getTimezone","date","getMonthDays","month","year","getFullYear","getMonth","_MD","getLastDateOfMonth","getDate","getDayOfYear","then","getWeekNumber","d","week","getDay","startOfWeek","middleDay","offsetWeekStartCount","offsetWeekMiddleCount","setDate","ms","setMonth","getQuarter","getOffsetDate","getTime","getHours","getMinutes","getSeconds","getOffsetQuarter","dt","day","monthDay","getQuarterStartMonth","quarterStartMonth","nowMonth","getQuarterStartDate","getQuarterEndDate","quarterEndMonth","getOffsetMonth","getWeekStartDate","w","_OFFSET","getWeekEndDate","print","y","yWith4number","wn","qr","s","hr","pm","ir","dy","sec","_SDN","_DN","_SMN","_MN","re","isKhtml","navigator","userAgent","par","a","tmp","Func","createDistinctName","idx","item","getGBWidth","getSearchResult","items","keyword","param","deepClone","t","text","py","toUpperCase","matched","stripEL","val","isNotNull","makeFirstPY","splitChar","pidx","beforeFunc","sFunc","__self","afterFunc","ret","traverse","context","_apply","_applyFunc","assert","v","is","Error","deepContains","warn","console","UUID","f","isWidget","widget","Widget","View","createWidgets","createWidget","createItems","innerAttr","outerAttr","makeArray","shift","el","packageItems","layouts","k","it","formatEL","trans2Element","widgets","wi","element","from","to","inverse","firstKey","res","any","lastKey","firstObject","lastObject","obj1","obj2","backEach","backAny","backEvery","backFindKey","backFind","remove","target","removeAt","string2Array","array2String","abc2Int","charAt","int2Abc","DIGITS","makeObject","makeArrayByArray","callee","isSorted","inherit","sb","sp","overrides","F","spp","superclass","init","initialized","freeze","isCapitalEqual","b","toLowerCase","isWidthOrHeight","isEmptyArray","arr","isNotEmptyArray","isEmptyObject","isNotEmptyObject","isEmptyString","isNotEmptyString","isWindow","deepExtend","isDeepMatch","attrs","deepIndexOf","deepRemove","deepWithout","deepUnique","deepDiff","used","nextTick","nextTickHandler","pending","copies","callbacks","timerFunc","p","MutationObserver","counter","observer","textNode","document","createTextNode","observe","characterData","queueNextTick","cb","_resolve","performance","webkitNow","radix","parseSafeInt","isNaturalNumber","isPositiveInteger","isNegativeInteger","isInteger","isNumeric","isFloat","isOdd","isEven","sum","average","toLocaleUpperCase","toLocaleLowerCase","isEndWithBlank","isLiteral","exp","literalValueRE","stripQuotes","camelize","character","hyphenate","encrypt","CRYPT_TYPE","AES","aesEncrypt","leftPad","ch","format","isLeapYear","checkDateVoid","YY","MM","DD","minDate","maxDate","back","checkDateLegal","ar","MD","parseDateTime","fmt","today","yearlength","otherlength","j","search","timeZone","localTime","localOffset","getTimezoneOffset","utc","OB","config","_constructor","destroyed","_initProps","_init","_initRef","_defaultConfig","_initListeners","listeners","lis","eventName","ref","_purgeRef","_getEvents","events","on","fns","proxy","un","newFns","ifn","purgeListeners","fireEvent","destroy","isInvalidDate","_eFormat","eFormat","neg","magnitudeNeg","magnitude","log","integerLen","getInteger","precision","getPrecision","isValueCarry","isValueCarried","round","formatExponential","isAllZero","formatLeft","valueLeftLen","roundNum","_dealNumberPrecision","fright","_numberFormat","numMod","fp","fleft","tp","tleft","tright","paddingZero","right","_dealWithRight","leftPlus","left","_dealWithLeft","rll","numReg","orilen","newnum","combo","com","tll","newstr","lres","cjkEncode","newText","code","cjkDecode","rightIdx","subText","fromCharCode","eval","SPECIAL_TAGS"," ","htmlEncode","htmlDecode","cjkEncodeDO","o","jsonEncode","useHasOwn","\b","\t","\n","\f","\r","\\","encodeString","encodeArray","l","__time__","jsonDecode","_hasDateInJson","json","jo","$","parseJSON","JSON","parse","getEncodeURL","urlTemplate","ori","encodeURIComponent","url","specialCharsMap","decodeURIComponent","reserveSpecialCharsMap","initialChar","encodeChar","contentFormat","cv","needTrim","date2Str","parseFmt","str2Date","compileJFmt","jfmt","hour","flagch","char","object2Number","object2Date","object2Time","moduleInjection","xtype","cls","error","constantInjection","modelInjection","model","storeInjection","store","serviceInjection","service","providerInjection","provider","configFunctions","configFn","providers","Plugin","configWidget","queue","globalAction","actionFn","points","point","pointFn","after","Modules","getModule","getAllModules","Constants","getConstant","callPoint","inst","bfns","aspect","afns","Models","getModel","stores","Stores","getStore","services","Services","getService","providerInstance","Providers","getProvider","$get","Actions","runAction","event","act","runGlobalAction","getContext","i18nStore","addI18n","i18n","i18nText","localeText","CryptoJS","C","C_lib","lib","Base","subtype","mixIn","$super","instance","propertyName","WordArray","words","sigBytes","encoder","Hex","stringify","wordArray","thisWords","thatWords","thisSigBytes","thatSigBytes","thatByte","nBytes","C_enc","enc","hexChars","bite","hexStr","hexStrLength","Latin1","latin1Chars","latin1Str","latin1StrLength","Utf8","utf8Str","BufferedBlockAlgorithm","reset","_data","_nDataBytes","_append","_process","doFlush","dataWords","dataSigBytes","blockSize","blockSizeBytes","nBlocksReady","_minBufferSize","nWordsReady","nBytesReady","_doProcessBlock","processedWords","Hasher","cfg","_doReset","update","messageUpdate","finalize","_doFinalize","_createHelper","hasher","_createHmacHelper","C_algo","HMAC","algo","Base64","_map","base64Chars","byte1","byte2","byte3","triplet","paddingChar","base64Str","base64StrLength","paddingIndex","bits1","bits2","FF","x","GG","HH","II","T","sin","MD5","_hash","M","offset_i","M_offset_i","H","M_offset_0","M_offset_1","M_offset_2","M_offset_3","M_offset_4","M_offset_5","M_offset_6","M_offset_7","M_offset_8","M_offset_9","M_offset_10","M_offset_11","M_offset_12","M_offset_13","M_offset_14","M_offset_15","nBitsTotal","nBitsLeft","nBitsTotalH","nBitsTotalL","H_i","HmacMD5","EvpKDF","keySize","iterations","compute","password","salt","derivedKey","derivedKeyWords","block","Cipher","createEncryptor","_ENC_XFORM_MODE","createDecryptor","_DEC_XFORM_MODE","xformMode","_xformMode","_key","dataUpdate","finalProcessedData","ivSize","selectCipherStrategy","PasswordBasedCipher","SerializableCipher","cipher","decrypt","ciphertext","StreamCipher","finalProcessedBlocks","C_mode","mode","BlockCipherMode","iv","Encryptor","Decryptor","_cipher","_iv","CBC","xorBlock","_prevBlock","processBlock","encryptBlock","thisBlock","decryptBlock","C_pad","pad","Pkcs7","nPaddingBytes","paddingWord","paddingWords","padding","unpad","BlockCipher","modeCreator","_mode","CipherParams","cipherParams","formatter","C_format","OpenSSLFormatter","OpenSSL","openSSLStr","ciphertextWords","encryptor","cipherCfg","algorithm","_parse","plaintext","C_kdf","kdf","OpenSSLKdf","execute","derivedParams","ECB","SBOX","INV_SBOX","SUB_MIX_0","SUB_MIX_1","SUB_MIX_2","SUB_MIX_3","INV_SUB_MIX_0","INV_SUB_MIX_1","INV_SUB_MIX_2","INV_SUB_MIX_3","xi","sx","x2","x4","x8","RCON","keyWords","nRounds","_nRounds","ksRows","keySchedule","_keySchedule","ksRow","invKeySchedule","_invKeySchedule","invKsRow","_doCryptBlock","s0","s3","t0","t1","t2","t3","base64Cipher","advice","exist","dispatcher","beforeArr","rs","method","afterArr","ii","aspectArr","_index","_keyStr","_utf8_encode","utftext","_utf8_decode","c3","c2","encode","output","chr1","chr2","chr3","enc1","enc2","enc3","enc4","decode","_prefix","setUsername","username","localStorage","setItem","getUsername","getItem","_getKeyPrefix","_generateKey","removeItem","addCookie","expiresHours","cookieString","setTime","toGMTString","cookie","getCookie","deleteCookie","CellSizeAndPositionManager","cellCount","cellSizeGetter","estimatedCellSize","_cellSizeGetter","_cellCount","_estimatedCellSize","_cellSizeAndPositionData","_lastMeasuredIndex","configure","getCellCount","getEstimatedCellSize","getLastMeasuredIndex","getSizeAndPositionOfCell","lastMeasuredCellSizeAndPosition","getSizeAndPositionOfLastMeasuredCell","getTotalSize","getUpdatedOffsetForIndex","align","containerSize","currentOffset","targetIndex","datum","maxOffset","minOffset","idealOffset","totalSize","getVisibleCellRange","_findNearestCell","stop","resetCell","_binarySearch","high","low","middle","_exponentialSearch","interval","lastMeasuredIndex","ScalingCellSizeAndPositionManager","maxScrollSize","_cellSizeAndPositionManager","_maxScrollSize","getOffsetAdjustment","safeTotalSize","offsetPercentage","_getOffsetPercentage","_safeOffsetToOffset","_offsetToSafeOffset","_ChineseFirstPY","oMultiDiff","19969","19975","19988","20048","20056","20060","20094","20127","20167","20193","20250","20256","20282","20285","20291","20314","20315","20340","20375","20389","20391","20415","20446","20447","20504","20608","20854","20857","20911","20985","21032","21048","21049","21089","21119","21242","21273","21305","21306","21330","21333","21345","21378","21397","21414","21442","21477","21480","21484","21494","21505","21512","21523","21537","21542","21549","21571","21574","21588","21589","21618","21621","21632","21654","21679","21683","21710","21719","21734","21769","21780","21804","21834","21899","21903","21908","21939","21956","21964","21970","22003","22031","22040","22060","22066","22079","22129","22179","22237","22244","22280","22300","22313","22331","22343","22351","22395","22412","22484","22500","22534","22549","22561","22612","22771","22831","22841","22855","22865","23013","23081","23487","23558","23561","23586","23614","23615","23631","23646","23663","23673","23762","23769","23780","23884","24055","24113","24162","24191","24273","24324","24377","24378","24439","24554","24683","24694","24733","24925","25094","25100","25103","25153","25170","25179","25203","25240","25282","25303","25324","25341","25373","25375","25384","25457","25528","25530","25552","25774","25874","26044","26080","26292","26333","26355","26366","26397","26399","26415","26451","26526","26552","26561","26588","26597","26629","26638","26646","26653","26657","26727","26894","26937","26946","26999","27099","27449","27481","27542","27663","27748","27784","27788","27795","27812","27850","27852","27895","27898","27973","27981","27986","27994","28044","28065","28177","28267","28291","28337","28463","28548","28601","28689","28805","28820","28846","28952","28975","29100","29325","29575","29602","30010","30044","30058","30091","30111","30229","30427","30465","30631","30655","30684","30707","30729","30796","30917","31074","31085","31109","31181","31192","31293","31400","31584","31896","31909","31995","32321","32327","32418","32420","32421","32438","32473","32488","32521","32527","32562","32564","32735","32793","33071","33098","33100","33152","33261","33324","33333","33406","33426","33432","33445","33486","33493","33507","33540","33544","33564","33617","33632","33636","33637","33694","33705","33728","33882","34067","34074","34121","34255","34259","34425","34430","34485","34503","34532","34552","34558","34593","34660","34892","34928","34999","35048","35059","35098","35203","35265","35299","35782","35828","35830","35843","35895","35977","36158","36228","36426","36466","36710","36711","36767","36866","36951","37034","37063","37218","37325","38063","38079","38085","38107","38116","38123","38224","38241","38271","38415","38426","38461","38463","38466","38477","38518","38551","38585","38704","38739","38761","38808","39048","39049","39052","39076","39271","39534","39552","39584","39647","39730","39748","40109","40479","40516","40536","40583","40765","40784","40840","40863","_checkPYCh","uni","_mkPYRslt","ignoreMulti","arrRslt","multiLen","strlen","tmpStr","tmpArr","arrResult","defaultComparator","Heap","_items","_size","_comparator","_heapify","elt","lastElt","_sinkDown","_bubbleUp","peek","parentIndex","parentElt","leftChildIndex","rightChildIndex","swapIndex","leftChild","rightChild","LinkHashMap","scope","LRU","limit","tail","_keymap","put","removed","newer","older","returnEntry","node","Int32Array","xs","ceilLog2","PrefixIntervalTree","_half","_heap","getSize","sumUntil","sumTo","inclusiveEnd","begin","greatestLowerBound","leftSum","greatestStrictLowerBound","leastUpperBound","leastStrictUpperBound","uniform","initialValue","Queue","capacity","getElementByIndex","unshift","fromArray","Section","height","width","_indexMap","_indices","addCellIndex","getCellIndices","SECTION_SIZE","SectionManager","sectionSize","_sectionSize","_cellMetadata","_sections","indices","getSections","section","getCellMetadata","sectionXStart","sectionXStop","sectionYStart","sectionYStop","sections","sectionX","sectionY","getTotalSectionCount","registerCell","cellMetadatum","Tree","Node","addNode","newNode","addChild","isRoot","getRoot","initTree","nodes","children","child","_toJSON","getChildren","toJSON","_toJSONWithNode","toJSONWithNode","_traverse","callback","_recursion","route","recursion","inOrderTraverse","_inOrderTraverse","getLeft","getRight","nrInOrderTraverse","preOrderTraverse","_preOrderTraverse","nrPreOrderTraverse","postOrderTraverse","_postOrderTraverse","nrPostOrderTraverse","preNode","isLeaf","getChildrenLength","getFirstChild","getLastChild","setLeft","setRight","setParent","getParent","getChild","getChildIndex","removeChild","removeChildByIndex","behind","removeAllChilds","cur","equals","transformToArrayFormat","pId","newNodes","arrayFormat","transformToTreeFormat","sNodes","tmpMap","treeFormat","traversal","Vector","cross","sqrt","Region","h","isIntersects","isPointInside","vector1","vector2","vector3","getPosition","pos","BI-Multi_Date_Quarter_End","BI-Multi_Date_Month_Begin","BI-Multi_Date_YMD","BI-Custom_Color","BI-Numerical_Interval_Input_Data","BI-Please_Input_Natural_Number","BI-No_More_Data","BI-Basic_Altogether","BI-Basic_Sunday","BI-Widget_Background_Colour","BI-Color_Picker_Error_Text","BI-Multi_Date_Month","BI-No_Selected_Item","BI-Multi_Date_Year_Begin","BI-Quarter_1","BI-Quarter_2","BI-Quarter_3","BI-Quarter_4","BI-Multi_Date_Year_Next","BI-Multi_Date_Month_Prev","BI-Month_Trigger_Error_Text","BI-Less_And_Equal","BI-Year_Trigger_Invalid_Text","BI-Multi_Date_Week_Next","BI-Font_Size","BI-Basic_Total","BI-Already_Selected","BI-Formula_Insert","BI-Select_All","BI-Basic_Tuesday","BI-Multi_Date_Month_End","BI-Load_More","BI-Basic_September","BI-Current_Is_Last_Page","BI-Basic_Auto","BI-Basic_Count","BI-Basic_Value","BI-Basic_Unrestricted","BI-Quarter_Trigger_Error_Text","BI-Basic_More","BI-Basic_Wednesday","BI-Basic_Bold","BI-Basic_Simple_Saturday","BI-Multi_Date_Month_Next","BI-Basic_March","BI-Current_Is_First_Page","BI-Basic_Thursday","BI-Basic_Prompt","BI-Multi_Date_Today","BI-Multi_Date_Quarter_Prev","BI-Row_Header","BI-Date_Trigger_Error_Text","BI-Basic_Cancel","BI-Basic_January","BI-Basic_June","BI-Basic_July","BI-Basic_April","BI-Multi_Date_Quarter_Begin","BI-Multi_Date_Week","BI-Click_Blank_To_Select","BI-Basic_August","BI-Word_Align_Left","BI-Basic_November","BI-Font_Colour","BI-Multi_Date_Day_Prev","BI-Select_Part","BI-Multi_Date_Day_Next","BI-Less_Than","BI-Basic_February","BI-Multi_Date_Year","BI-Number_Index","BI-Multi_Date_Week_Prev","BI-Next_Page","BI-Right_Page","BI-Numerical_Interval_Signal_Value","BI-Basic_December","BI-Basic_Saturday","BI-Basic_Simple_Wednesday","BI-Multi_Date_Quarter_Next","BI-Basic_October","BI-Basic_Simple_Friday","BI-Basic_Save","BI-Numerical_Interval_Number_Value","BI-Previous_Page","BI-No_Select","BI-Basic_Clears","BI-Created_By_Me","BI-Basic_Simple_Tuesday","BI-Word_Align_Right","BI-Summary_Values","BI-Basic_Clear","BI-Upload_File_Size_Error","BI-Up_Page","BI-Basic_Simple_Sunday","BI-Multi_Date_Relative_Current_Time","BI-Selected_Data","BI-Multi_Date_Quarter","BI-Check_Selected","BI-Basic_Search","BI-Basic_May","BI-Continue_Select","BI-Please_Input_Positive_Integer","BI-Upload_File_Type_Error","BI-Upload_File_Error","BI-Basic_Friday","BI-Down_Page","BI-Basic_Monday","BI-Left_Page","BI-Transparent_Color","BI-Basic_Simple_Monday","BI-Multi_Date_Year_End","BI-Time_Interval_Error_Text","BI-Basic_Time","BI-Basic_OK","BI-Basic_Sure","BI-Basic_Simple_Thursday","BI-Multi_Date_Year_Prev","BI-Tiao_Data","BI-Basic_Italic","BI-Basic_Dynamic_Title","BI-Basic_Year","BI-Basic_Single_Quarter","BI-Basic_Month","BI-Basic_Week","BI-Basic_Day","BI-Basic_Work_Day","BI-Basic_Front","BI-Basic_Behind","BI-Basic_Empty","BI-Basic_Month_End","BI-Basic_Month_Begin","BI-Basic_Year_End","BI-Basic_Year_Begin","BI-Basic_Quarter_End","BI-Basic_Quarter_Begin","BI-Basic_Week_End","BI-Basic_Week_Begin","BI-Basic_Current_Day","BI-Basic_Begin_Start","BI-Basic_End_Stop","BI-Basic_Current_Year","BI-Basic_Year_Fen","BI-Basic_Current_Month","BI-Basic_Current_Quarter","BI-Basic_Year_Month","BI-Basic_Year_Quarter","BI-Basic_Input_Can_Not_Null","BI-Basic_Date_Time_Error_Text","BI-Basic_Input_From_To_Number","BI-Basic_Or","BI-Basic_And","BI-Conf_Add_Formula","BI-Conf_Add_Condition","BI-Conf_Formula_And","BI-Conf_Formula_Or","BI-Conf_Condition_And","BI-Conf_Condition_Or","BI-Microsoft_YaHei","BI-Apple_Light","BI-Font_Family","BI-Basic_Please_Input_Content","BI-Word_Align_Center","BI-Basic_Please_Enter_Number_Between","BI-More_Than","BI-More_And_Equal","BI-Please_Enter_SQL","BI-Basic_Click_To_Add_Text","BI-Basic_Please_Select","BI-Basic_Font_Color","BI-Basic_Background_Color","BI-Basic_Underline","BI-Basic_Param_Month","BI-Basic_Param_Day","BI-Basic_Param_Quarter","BI-Basic_Param_Week_Count","BI-Basic_Param_Hour","BI-Basic_Param_Minute","BI-Basic_Param_Second","BI-Basic_Param_Year","BI-Basic_Date_Day","BI-Basic_Hour_Sin","BI-Basic_Seconds","BI-Basic_Minute","BI-Basic_Wan","BI-Basic_Million","BI-Basic_Billion","BI-Basic_Quarter","BI-Basic_No_Select","BI-Basic_Now","_FD","_QN","MODE","BufferPool","_Shared","SharingPool","shared","cat","Req"],"mappings":"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,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,MACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,IACPC,MAAO,KACPC,MAAO,KACPC,MAAO,IACPC,MAAO,KACPC,MAAO,MACPC,MAAO,KACPC,MAAO,KACPC,MAAO,MACPC,MAAO,KACPC,MAAO,IACPC,MAAO,KACPC,MAAO,MACPC,MAAO,IACPC,MAAO,KACPC,MAAO,KACPC,MAAO,IACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,IACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,IACPC,MAAO,IACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,IACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,IACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,MACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,MACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,MACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,MACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,IACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,MACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,MACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KACPC,MAAO,KA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","file":"utils.min.js","sourcesContent":["/**\n * Created by richie on 15/7/8.\n */\n/**\n * 初始化BI对象\n */\nvar _global;\nif (typeof window !== \"undefined\") {\n _global = window;\n} else if (typeof global !== \"undefined\") {\n _global = global;\n} else if (typeof self !== \"undefined\") {\n _global = self;\n} else {\n _global = this;\n}\nif (_global.BI == null) {\n _global.BI = {prepares: []};\n}\nif(_global.BI.prepares == null) {\n _global.BI.prepares = [];\n}/**\n * @license\n * Lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash core plus=\"debounce,throttle,get,set,findIndex,findLastIndex,findKey,findLastKey,isArrayLike,invert,invertBy,uniq,uniqBy,omit,omitBy,zip,unzip,rest,range,random,reject,intersection,drop,countBy,union,zipObject,initial,cloneDeep,clamp,isPlainObject,take,takeRight,without,difference,defaultsDeep,trim,merge,groupBy,uniqBy\"`\n * Copyright JS Foundation and other contributors <https://js.foundation/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n;(function() {\n\n /** Used as a safe reference for `undefined` in pre-ES5 environments. */\n var undefined;\n\n /** Used as the semantic version number. */\n var VERSION = '4.17.5';\n\n /** Used as the size to enable large array optimizations. */\n var LARGE_ARRAY_SIZE = 200;\n\n /** Error message constants. */\n var FUNC_ERROR_TEXT = 'Expected a function';\n\n /** Used to stand-in for `undefined` hash values. */\n var HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n /** Used as the maximum memoize cache size. */\n var MAX_MEMOIZE_SIZE = 500;\n\n /** Used as the internal argument placeholder. */\n var PLACEHOLDER = '__lodash_placeholder__';\n\n /** Used to compose bitmasks for cloning. */\n var CLONE_DEEP_FLAG = 1,\n CLONE_FLAT_FLAG = 2,\n CLONE_SYMBOLS_FLAG = 4;\n\n /** Used to compose bitmasks for value comparisons. */\n var COMPARE_PARTIAL_FLAG = 1,\n COMPARE_UNORDERED_FLAG = 2;\n\n /** Used to compose bitmasks for function metadata. */\n var WRAP_BIND_FLAG = 1,\n WRAP_BIND_KEY_FLAG = 2,\n WRAP_CURRY_BOUND_FLAG = 4,\n WRAP_CURRY_FLAG = 8,\n WRAP_CURRY_RIGHT_FLAG = 16,\n WRAP_PARTIAL_FLAG = 32,\n WRAP_PARTIAL_RIGHT_FLAG = 64,\n WRAP_ARY_FLAG = 128,\n WRAP_REARG_FLAG = 256,\n WRAP_FLIP_FLAG = 512;\n\n /** Used 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\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 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\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 HTML entities and HTML characters. */\n var reUnescapedHtml = /[&<>\"']/g,\n reHasUnescapedHtml = RegExp(reUnescapedHtml.source);\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\n /** Used to match leading and trailing whitespace. */\n var reTrim = /^\\s+|\\s+$/g;\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 backslashes in property paths. */\n var reEscapeChar = /\\\\(\\\\)?/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 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 rsVarRange = '\\\\ufe0e\\\\ufe0f';\n\n /** Used to compose unicode capture groups. */\n var rsAstral = '[' + rsAstralRange + ']',\n rsCombo = '[' + rsComboRange + ']',\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 rsZWJ = '\\\\u200d';\n\n /** Used to compose unicode regexes. */\n var reOptMod = rsModifier + '?',\n rsOptVar = '[' + rsVarRange + ']?',\n rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*',\n rsSeq = rsOptVar + reOptMod + rsOptJoin,\n rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')';\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 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 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 characters to HTML entities. */\n var htmlEscapes = {\n '&': '&',\n '<': '<',\n '>': '>',\n '\"': '"',\n \"'\": '''\n };\n\n /** Built-in method references without a dependency on `root`. */\n var freeParseFloat = parseFloat,\n freeParseInt = parseInt;\n\n /** Detect free variable `global` from Node.js. */\n var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n /** Detect free variable `self`. */\n var freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n /** Used as a reference to the global object. */\n var root = freeGlobal || freeSelf || Function('return this')();\n\n /** Detect free variable `exports`. */\n var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n /** Detect free variable `module`. */\n var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n /** Detect the popular CommonJS extension `module.exports`. */\n var moduleExports = freeModule && freeModule.exports === freeExports;\n\n /** Detect free variable `process` from Node.js. */\n var freeProcess = moduleExports && freeGlobal.process;\n\n /** Used to access faster Node.js helpers. */\n var nodeUtil = (function() {\n try {\n return freeProcess && freeProcess.binding && freeProcess.binding('util');\n } catch (e) {}\n }());\n\n /* Node.js helper references. */\n var 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 `_.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 `_.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 * 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 * 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 `_.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 `_.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 `_.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 `_.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 * 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 * 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 * Gets the value at `key`, unless `key` is \"__proto__\".\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 return key == '__proto__'\n ? undefined\n : object[key];\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 * 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 * 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 * 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\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 = root['__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 ? root.Buffer : undefined,\n Symbol = root.Symbol,\n Uint8Array = root.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 /* 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 = root.isFinite,\n nativeKeys = overArg(Object.keys, Object),\n nativeMax = Math.max,\n nativeMin = Math.min,\n nativeNow = Date.now,\n nativeRandom = Math.random,\n nativeReverse = arrayProto.reverse;\n\n /* Built-in method references that are verified to be native. */\n var DataView = getNative(root, 'DataView'),\n Map = getNative(root, 'Map'),\n Promise = getNative(root, 'Promise'),\n Set = getNative(root, 'Set'),\n WeakMap = getNative(root, '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 // 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 * 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\n return result;\n }\n\n if (isMap(value)) {\n value.forEach(function(subValue, key) {\n result.set(key, baseClone(subValue, bitmask, customizer, key, value, stack));\n });\n\n return result;\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 `_.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 `_.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 `_.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 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 `_.isDate` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a date object, else `false`.\n */\n function baseIsDate(value) {\n return isObjectLike(value) && baseGetTag(value) == dateTag;\n }\n\n /**\n * The base implementation of `_.isEqual` which supports partial comparisons\n * and tracks traversed objects.\n *\n * @private\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @param {boolean} bitmask The bitmask flags.\n * 1 - Unordered comparison\n * 2 - Partial comparison\n * @param {Function} [customizer] The function to customize comparisons.\n * @param {Object} [stack] Tracks traversed `value` and `other` objects.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n */\n function baseIsEqual(value, other, bitmask, customizer, stack) {\n if (value === other) {\n return true;\n }\n if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) {\n return value !== value && other !== other;\n }\n return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);\n }\n\n /**\n * A specialized version of `baseIsEqual` for arrays and objects which performs\n * deep comparisons and tracks traversed objects enabling objects with circular\n * references to be compared.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} [stack] Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\n function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {\n var objIsArr = isArray(object),\n othIsArr = isArray(other),\n objTag = objIsArr ? arrayTag : getTag(object),\n othTag = othIsArr ? arrayTag : getTag(other);\n\n objTag = objTag == argsTag ? objectTag : objTag;\n othTag = othTag == argsTag ? objectTag : othTag;\n\n var objIsObj = objTag == objectTag,\n othIsObj = othTag == objectTag,\n isSameTag = objTag == othTag;\n\n if (isSameTag && isBuffer(object)) {\n if (!isBuffer(other)) {\n return false;\n }\n objIsArr = true;\n objIsObj = false;\n }\n if (isSameTag && !objIsObj) {\n stack || (stack = new Stack);\n return (objIsArr || isTypedArray(object))\n ? equalArrays(object, other, bitmask, customizer, equalFunc, stack)\n : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);\n }\n if (!(bitmask & COMPARE_PARTIAL_FLAG)) {\n var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),\n othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');\n\n if (objIsWrapped || othIsWrapped) {\n var objUnwrapped = objIsWrapped ? object.value() : object,\n othUnwrapped = othIsWrapped ? other.value() : other;\n\n stack || (stack = new Stack);\n return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);\n }\n }\n if (!isSameTag) {\n return false;\n }\n stack || (stack = new Stack);\n return equalObjects(object, other, bitmask, customizer, equalFunc, stack);\n }\n\n /**\n * The base implementation of `_.isMap` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a map, else `false`.\n */\n function baseIsMap(value) {\n return isObjectLike(value) && getTag(value) == mapTag;\n }\n\n /**\n * The base implementation of `_.isMatch` without support for iteratee shorthands.\n *\n * @private\n * @param {Object} object The object to inspect.\n * @param {Object} source The object of property values to match.\n * @param {Array} matchData The property names, values, and compare flags to match.\n * @param {Function} [customizer] The function to customize comparisons.\n * @returns {boolean} Returns `true` if `object` is a match, else `false`.\n */\n function baseIsMatch(object, source, matchData, customizer) {\n var index = matchData.length,\n length = index,\n noCustomizer = !customizer;\n\n if (object == null) {\n return !length;\n }\n object = Object(object);\n while (index--) {\n var data = matchData[index];\n if ((noCustomizer && data[2])\n ? data[1] !== object[data[0]]\n : !(data[0] in object)\n ) {\n return false;\n }\n }\n while (++index < length) {\n data = matchData[index];\n var key = data[0],\n objValue = object[key],\n srcValue = data[1];\n\n if (noCustomizer && data[2]) {\n if (objValue === undefined && !(key in object)) {\n return false;\n }\n } else {\n var stack = new Stack;\n if (customizer) {\n var result = customizer(objValue, srcValue, key, object, source, stack);\n }\n if (!(result === undefined\n ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack)\n : result\n )) {\n return false;\n }\n }\n }\n return true;\n }\n\n /**\n * The base implementation of `_.isNative` without bad shim checks.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a native function,\n * else `false`.\n */\n function baseIsNative(value) {\n if (!isObject(value) || isMasked(value)) {\n return false;\n }\n var pattern = isFunction(value) ? reIsNative : reIsHostCtor;\n return pattern.test(toSource(value));\n }\n\n /**\n * The base implementation of `_.isRegExp` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a regexp, else `false`.\n */\n function baseIsRegExp(value) {\n return isObjectLike(value) && baseGetTag(value) == regexpTag;\n }\n\n /**\n * The base implementation of `_.isSet` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a set, else `false`.\n */\n function baseIsSet(value) {\n return isObjectLike(value) && getTag(value) == setTag;\n }\n\n /**\n * The base implementation of `_.isTypedArray` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n */\n function baseIsTypedArray(value) {\n return isObjectLike(value) &&\n isLength(value.length) && !!typedArrayTags[baseGetTag(value)];\n }\n\n /**\n * The base implementation of `_.iteratee`.\n *\n * @private\n * @param {*} [value=_.identity] The value to convert to an iteratee.\n * @returns {Function} Returns the iteratee.\n */\n function baseIteratee(value) {\n // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9.\n // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details.\n if (typeof value == 'function') {\n return value;\n }\n if (value == null) {\n return identity;\n }\n if (typeof value == 'object') {\n return isArray(value)\n ? baseMatchesProperty(value[0], value[1])\n : baseMatches(value);\n }\n return property(value);\n }\n\n /**\n * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\n function baseKeys(object) {\n if (!isPrototype(object)) {\n return nativeKeys(object);\n }\n var result = [];\n for (var key in Object(object)) {\n if (hasOwnProperty.call(object, key) && key != 'constructor') {\n result.push(key);\n }\n }\n return result;\n }\n\n /**\n * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\n function baseKeysIn(object) {\n if (!isObject(object)) {\n return nativeKeysIn(object);\n }\n var isProto = isPrototype(object),\n result = [];\n\n for (var key in object) {\n if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {\n result.push(key);\n }\n }\n return result;\n }\n\n /**\n * The base implementation of `_.lt` which doesn't coerce arguments.\n *\n * @private\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if `value` is less than `other`,\n * else `false`.\n */\n function baseLt(value, other) {\n return value < other;\n }\n\n /**\n * The base implementation of `_.map` without support for iteratee shorthands.\n *\n * @private\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the new mapped array.\n */\n function baseMap(collection, iteratee) {\n var index = -1,\n result = isArrayLike(collection) ? Array(collection.length) : [];\n\n baseEach(collection, function(value, key, collection) {\n result[++index] = iteratee(value, key, collection);\n });\n return result;\n }\n\n /**\n * The base implementation of `_.matches` which doesn't clone `source`.\n *\n * @private\n * @param {Object} source The object of property values to match.\n * @returns {Function} Returns the new spec function.\n */\n function baseMatches(source) {\n var matchData = getMatchData(source);\n if (matchData.length == 1 && matchData[0][2]) {\n return matchesStrictComparable(matchData[0][0], matchData[0][1]);\n }\n return function(object) {\n return object === source || baseIsMatch(object, source, matchData);\n };\n }\n\n /**\n * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`.\n *\n * @private\n * @param {string} path The path of the property to get.\n * @param {*} srcValue The value to match.\n * @returns {Function} Returns the new spec function.\n */\n function baseMatchesProperty(path, srcValue) {\n if (isKey(path) && isStrictComparable(srcValue)) {\n return matchesStrictComparable(toKey(path), srcValue);\n }\n return function(object) {\n var objValue = get(object, path);\n return (objValue === undefined && objValue === srcValue)\n ? hasIn(object, path)\n : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);\n };\n }\n\n /**\n * The base implementation of `_.merge` without support for multiple sources.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @param {number} srcIndex The index of `source`.\n * @param {Function} [customizer] The function to customize merged values.\n * @param {Object} [stack] Tracks traversed source values and their merged\n * counterparts.\n */\n function baseMerge(object, source, srcIndex, customizer, stack) {\n if (object === source) {\n return;\n }\n baseFor(source, function(srcValue, key) {\n if (isObject(srcValue)) {\n stack || (stack = new Stack);\n baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);\n }\n else {\n var newValue = customizer\n ? customizer(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) || (srcIndex && isFunction(objValue))) {\n newValue = initCloneObject(srcValue);\n }\n }\n else {\n isCommon = false;\n }\n }\n if (isCommon) {\n // Recursively merge objects and arrays (susceptible to call stack limits).\n stack.set(srcValue, newValue);\n mergeFunc(newValue, srcValue, srcIndex, customizer, stack);\n stack['delete'](srcValue);\n }\n assignMergeValue(object, key, newValue);\n }\n\n /**\n * The base implementation of `_.orderBy` without param guards.\n *\n * @private\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function[]|Object[]|string[]} iteratees The iteratees to sort by.\n * @param {string[]} orders The sort orders of `iteratees`.\n * @returns {Array} Returns the new sorted array.\n */\n function baseOrderBy(collection, iteratees, orders) {\n var index = -1;\n iteratees = arrayMap(iteratees.length ? iteratees : [identity], baseUnary(baseIteratee));\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 `_.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 `_.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 `_.set`.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {Array|string} path The path of the property to set.\n * @param {*} value The value to set.\n * @param {Function} [customizer] The function to customize path creation.\n * @returns {Object} Returns `object`.\n */\n function baseSet(object, path, value, customizer) {\n if (!isObject(object)) {\n return object;\n }\n path = castPath(path, object);\n\n var index = -1,\n length = path.length,\n lastIndex = length - 1,\n nested = object;\n\n while (nested != null && ++index < length) {\n var key = toKey(path[index]),\n newValue = value;\n\n if (index != lastIndex) {\n var objValue = nested[key];\n newValue = customizer ? customizer(objValue, key, nested) : undefined;\n if (newValue === undefined) {\n newValue = isObject(objValue)\n ? objValue\n : (isIndex(path[index + 1]) ? [] : {});\n }\n }\n assignValue(nested, key, newValue);\n nested = nested[key];\n }\n return object;\n }\n\n /**\n * The base implementation of `setData` without support for hot loop shorting.\n *\n * @private\n * @param {Function} func The function to associate metadata with.\n * @param {*} data The metadata.\n * @returns {Function} Returns `func`.\n */\n var baseSetData = !metaMap ? identity : function(func, data) {\n metaMap.set(func, data);\n return func;\n };\n\n /**\n * The base implementation of `setToString` without support for hot loop shorting.\n *\n * @private\n * @param {Function} func The function to modify.\n * @param {Function} string The `toString` result.\n * @returns {Function} Returns `func`.\n */\n var baseSetToString = !defineProperty ? identity : function(func, string) {\n return defineProperty(func, 'toString', {\n 'configurable': true,\n 'enumerable': false,\n 'value': constant(string),\n 'writable': true\n });\n };\n\n /**\n * The base implementation of `_.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 `_.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 `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 * 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 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 * 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 * 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, baseIteratee(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 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 = baseIteratee(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 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 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 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 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 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 `_.defaultsDeep` to customize its `_.merge` use to merge source\n * objects into destination objects that are passed thru.\n *\n * @private\n * @param {*} objValue The destination value.\n * @param {*} srcValue The source value.\n * @param {string} key The key of the property to merge.\n * @param {Object} object The parent object of `objValue`.\n * @param {Object} source The parent object of `srcValue`.\n * @param {Object} [stack] Tracks traversed source values and their merged\n * counterparts.\n * @returns {*} Returns the value to assign.\n */\n function customDefaultsMerge(objValue, srcValue, key, object, source, stack) {\n if (isObject(objValue) && isObject(srcValue)) {\n // Recursively merge objects and arrays (susceptible to call stack limits).\n stack.set(srcValue, objValue);\n baseMerge(objValue, srcValue, undefined, customDefaultsMerge, stack);\n stack['delete'](srcValue);\n }\n return objValue;\n }\n\n /**\n * Used by `_.omit` to customize its `_.cloneDeep` use to only clone plain\n * objects.\n *\n * @private\n * @param {*} value The value to inspect.\n * @param {string} key The key of the property to inspect.\n * @returns {*} Returns the uncloned value or `undefined` to defer cloning to `_.cloneDeep`.\n */\n function customOmitClone(value) {\n return isPlainObject(value) ? undefined : value;\n }\n\n /**\n * A specialized version of `baseIsEqualDeep` for arrays with support for\n * partial deep comparisons.\n *\n * @private\n * @param {Array} array The array to compare.\n * @param {Array} other The other array to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `array` and `other` objects.\n * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.\n */\n function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {\n var isPartial = bitmask & COMPARE_PARTIAL_FLAG,\n arrLength = array.length,\n othLength = other.length;\n\n if (arrLength != othLength && !(isPartial && othLength > arrLength)) {\n return false;\n }\n // Assume cyclic values are equal.\n var stacked = stack.get(array);\n if (stacked && stack.get(other)) {\n return stacked == other;\n }\n var index = -1,\n result = true,\n seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined;\n\n stack.set(array, other);\n stack.set(other, array);\n\n // Ignore non-index properties.\n while (++index < arrLength) {\n var arrValue = array[index],\n othValue = other[index];\n\n if (customizer) {\n var compared = isPartial\n ? customizer(othValue, arrValue, index, other, array, stack)\n : customizer(arrValue, othValue, index, array, other, stack);\n }\n if (compared !== undefined) {\n if (compared) {\n continue;\n }\n result = false;\n break;\n }\n // Recursively compare arrays (susceptible to call stack limits).\n if (seen) {\n if (!arraySome(other, function(othValue, othIndex) {\n if (!cacheHas(seen, othIndex) &&\n (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {\n return seen.push(othIndex);\n }\n })) {\n result = false;\n break;\n }\n } else if (!(\n arrValue === othValue ||\n equalFunc(arrValue, othValue, bitmask, customizer, stack)\n )) {\n result = false;\n break;\n }\n }\n stack['delete'](array);\n stack['delete'](other);\n return result;\n }\n\n /**\n * A specialized version of `baseIsEqualDeep` for comparing objects of\n * the same `toStringTag`.\n *\n * **Note:** This function only supports comparing values with tags of\n * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {string} tag The `toStringTag` of the objects to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\n function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {\n switch (tag) {\n case dataViewTag:\n if ((object.byteLength != other.byteLength) ||\n (object.byteOffset != other.byteOffset)) {\n return false;\n }\n object = object.buffer;\n other = other.buffer;\n\n case arrayBufferTag:\n if ((object.byteLength != other.byteLength) ||\n !equalFunc(new Uint8Array(object), new Uint8Array(other))) {\n return false;\n }\n return true;\n\n case boolTag:\n case dateTag:\n case numberTag:\n // Coerce booleans to `1` or `0` and dates to milliseconds.\n // Invalid dates are coerced to `NaN`.\n return eq(+object, +other);\n\n case errorTag:\n return object.name == other.name && object.message == other.message;\n\n case regexpTag:\n case stringTag:\n // Coerce regexes to strings and treat strings, primitives and objects,\n // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring\n // for more details.\n return object == (other + '');\n\n case mapTag:\n var convert = mapToArray;\n\n case setTag:\n var isPartial = bitmask & COMPARE_PARTIAL_FLAG;\n convert || (convert = setToArray);\n\n if (object.size != other.size && !isPartial) {\n return false;\n }\n // Assume cyclic values are equal.\n var stacked = stack.get(object);\n if (stacked) {\n return stacked == other;\n }\n bitmask |= COMPARE_UNORDERED_FLAG;\n\n // Recursively compare objects (susceptible to call stack limits).\n stack.set(object, other);\n var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);\n stack['delete'](object);\n return result;\n\n case symbolTag:\n if (symbolValueOf) {\n return symbolValueOf.call(object) == symbolValueOf.call(other);\n }\n }\n return false;\n }\n\n /**\n * A specialized version of `baseIsEqualDeep` for objects with support for\n * partial deep comparisons.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\n function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {\n var isPartial = bitmask & COMPARE_PARTIAL_FLAG,\n objProps = getAllKeys(object),\n objLength = objProps.length,\n othProps = getAllKeys(other),\n othLength = othProps.length;\n\n if (objLength != othLength && !isPartial) {\n return false;\n }\n var index = objLength;\n while (index--) {\n var key = objProps[index];\n if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {\n return false;\n }\n }\n // Assume cyclic values are equal.\n var stacked = stack.get(object);\n if (stacked && stack.get(other)) {\n return stacked == other;\n }\n var result = true;\n stack.set(object, other);\n stack.set(other, object);\n\n var skipCtor = isPartial;\n while (++index < objLength) {\n key = objProps[index];\n var objValue = object[key],\n othValue = other[key];\n\n if (customizer) {\n var compared = isPartial\n ? customizer(othValue, objValue, key, other, object, stack)\n : customizer(objValue, othValue, key, object, other, stack);\n }\n // Recursively compare objects (susceptible to call stack limits).\n if (!(compared === undefined\n ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack))\n : compared\n )) {\n result = false;\n break;\n }\n skipCtor || (skipCtor = key == 'constructor');\n }\n if (result && !skipCtor) {\n var objCtor = object.constructor,\n othCtor = other.constructor;\n\n // Non `Object` object instances with different constructors are not equal.\n if (objCtor != othCtor &&\n ('constructor' in object && 'constructor' in other) &&\n !(typeof objCtor == 'function' && objCtor instanceof objCtor &&\n typeof othCtor == 'function' && othCtor instanceof othCtor)) {\n result = false;\n }\n }\n stack['delete'](object);\n stack['delete'](other);\n return result;\n }\n\n /**\n * A specialized version of `baseRest` which flattens the rest array.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @returns {Function} Returns the new function.\n */\n function flatRest(func) {\n return setToString(overRest(func, undefined, flatten), func + '');\n }\n\n /**\n * Creates an array of own enumerable property names and symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names and symbols.\n */\n function getAllKeys(object) {\n return baseGetAllKeys(object, keys, getSymbols);\n }\n\n /**\n * Creates an array of own and inherited enumerable property names and\n * symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names and symbols.\n */\n function getAllKeysIn(object) {\n return baseGetAllKeys(object, keysIn, getSymbolsIn);\n }\n\n /**\n * Gets metadata for `func`.\n *\n * @private\n * @param {Function} func The function to query.\n * @returns {*} Returns the metadata for `func`.\n */\n var getData = !metaMap ? noop : function(func) {\n return metaMap.get(func);\n };\n\n /**\n * Gets the name of `func`.\n *\n * @private\n * @param {Function} func The function to query.\n * @returns {string} Returns the function name.\n */\n function getFuncName(func) {\n var result = (func.name + ''),\n array = realNames[result],\n length = hasOwnProperty.call(realNames, result) ? array.length : 0;\n\n while (length--) {\n var data = array[length],\n otherFunc = data.func;\n if (otherFunc == null || otherFunc == func) {\n return data.name;\n }\n }\n return result;\n }\n\n /**\n * Gets the argument placeholder value for `func`.\n *\n * @private\n * @param {Function} func The function to inspect.\n * @returns {*} Returns the placeholder value.\n */\n function getHolder(func) {\n var object = hasOwnProperty.call(lodash, 'placeholder') ? lodash : func;\n return object.placeholder;\n }\n\n /**\n * Gets the 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 `value` is likely a prototype object.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n */\n function isPrototype(value) {\n var Ctor = value && value.constructor,\n proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;\n\n return value === proto;\n }\n\n /**\n * Checks if `value` is suitable for strict equality comparisons, i.e. `===`.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` if suitable for strict\n * equality comparisons, else `false`.\n */\n function isStrictComparable(value) {\n return value === value && !isObject(value);\n }\n\n /**\n * A specialized version of `matchesProperty` for source values suitable\n * for strict equality comparisons, i.e. `===`.\n *\n * @private\n * @param {string} key The key of the property to get.\n * @param {*} srcValue The value to match.\n * @returns {Function} Returns the new spec function.\n */\n function matchesStrictComparable(key, srcValue) {\n return function(object) {\n if (object == null) {\n return false;\n }\n return object[key] === srcValue &&\n (srcValue !== undefined || (key in Object(object)));\n };\n }\n\n /**\n * A specialized version of `_.memoize` which clears the memoized function's\n * cache when it exceeds `MAX_MEMOIZE_SIZE`.\n *\n * @private\n * @param {Function} func The function to have its output memoized.\n * @returns {Function} Returns the new memoized function.\n */\n function memoizeCapped(func) {\n var result = memoize(func, function(key) {\n if (cache.size === MAX_MEMOIZE_SIZE) {\n cache.clear();\n }\n return key;\n });\n\n var cache = result.cache;\n return result;\n }\n\n /**\n * Merges the function metadata of `source` into `data`.\n *\n * Merging metadata reduces the number of wrappers used to invoke a function.\n * This is possible because methods like `_.bind`, `_.curry`, and `_.partial`\n * may be applied regardless of execution order. Methods like `_.ary` and\n * `_.rearg` modify function arguments, making the order in which they are\n * executed important, preventing the merging of metadata. However, we make\n * an exception for a safe combined case where curried functions have `_.ary`\n * and or `_.rearg` applied.\n *\n * @private\n * @param {Array} data The destination metadata.\n * @param {Array} source The source metadata.\n * @returns {Array} Returns `data`.\n */\n function mergeData(data, source) {\n var bitmask = data[1],\n srcBitmask = source[1],\n newBitmask = bitmask | srcBitmask,\n isCommon = newBitmask < (WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG | WRAP_ARY_FLAG);\n\n var isCombo =\n ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_CURRY_FLAG)) ||\n ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_REARG_FLAG) && (data[7].length <= source[8])) ||\n ((srcBitmask == (WRAP_ARY_FLAG | WRAP_REARG_FLAG)) && (source[7].length <= source[8]) && (bitmask == WRAP_CURRY_FLAG));\n\n // Exit early if metadata can't be merged.\n if (!(isCommon || isCombo)) {\n return data;\n }\n // Use source `thisArg` if available.\n if (srcBitmask & WRAP_BIND_FLAG) {\n data[2] = source[2];\n // Set when currying a bound function.\n newBitmask |= bitmask & WRAP_BIND_FLAG ? 0 : WRAP_CURRY_BOUND_FLAG;\n }\n // Compose partial arguments.\n var value = source[3];\n if (value) {\n var partials = data[3];\n data[3] = partials ? composeArgs(partials, value, source[4]) : value;\n data[4] = partials ? replaceHolders(data[3], PLACEHOLDER) : source[4];\n }\n // Compose partial right arguments.\n value = source[5];\n if (value) {\n partials = data[5];\n data[5] = partials ? composeArgsRight(partials, value, source[6]) : value;\n data[6] = partials ? replaceHolders(data[5], PLACEHOLDER) : source[6];\n }\n // Use source `argPos` if available.\n value = source[7];\n if (value) {\n data[7] = value;\n }\n // Use source `ary` if it's smaller.\n if (srcBitmask & WRAP_ARY_FLAG) {\n data[8] = data[8] == null ? source[8] : nativeMin(data[8], source[8]);\n }\n // Use source `arity` if one is not provided.\n if (data[9] == null) {\n data[9] = source[9];\n }\n // Use source `func` and merge bitmasks.\n data[0] = source[0];\n data[1] = newBitmask;\n\n return data;\n }\n\n /**\n * This function is like\n * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * except that it includes inherited enumerable properties.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\n function nativeKeysIn(object) {\n var result = [];\n if (object != null) {\n for (var key in Object(object)) {\n result.push(key);\n }\n }\n return result;\n }\n\n /**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\n function objectToString(value) {\n return nativeObjectToString.call(value);\n }\n\n /**\n * A specialized version of `baseRest` which transforms the rest array.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @param {Function} transform The rest array transform.\n * @returns {Function} Returns the new function.\n */\n function overRest(func, start, transform) {\n start = nativeMax(start === undefined ? (func.length - 1) : start, 0);\n return function() {\n var args = arguments,\n index = -1,\n length = nativeMax(args.length - start, 0),\n array = Array(length);\n\n while (++index < length) {\n array[index] = args[start + index];\n }\n index = -1;\n var otherArgs = Array(start + 1);\n while (++index < start) {\n otherArgs[index] = args[index];\n }\n otherArgs[start] = transform(array);\n return apply(func, this, otherArgs);\n };\n }\n\n /**\n * Gets the parent value at `path` of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Array} path The path to get the parent value of.\n * @returns {*} Returns the parent value.\n */\n function parent(object, path) {\n return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1));\n }\n\n /**\n * Reorder `array` according to the specified indexes where the element at\n * the first index is assigned as the first element, the element at\n * the second index is assigned as the second element, and so on.\n *\n * @private\n * @param {Array} array The array to reorder.\n * @param {Array} indexes The arranged array indexes.\n * @returns {Array} Returns `array`.\n */\n function reorder(array, indexes) {\n var arrLength = array.length,\n length = nativeMin(indexes.length, arrLength),\n oldArray = copyArray(array);\n\n while (length--) {\n var index = indexes[length];\n array[length] = isIndex(index, arrLength) ? oldArray[index] : undefined;\n }\n return array;\n }\n\n /**\n * Sets metadata for `func`.\n *\n * **Note:** If this function becomes hot, i.e. is invoked a lot in a short\n * period of time, it will trip its breaker and transition to an identity\n * function to avoid garbage collection pauses in V8. See\n * [V8 issue 2070](https://bugs.chromium.org/p/v8/issues/detail?id=2070)\n * for more details.\n *\n * @private\n * @param {Function} func The function to associate metadata with.\n * @param {*} data The metadata.\n * @returns {Function} Returns `func`.\n */\n var setData = shortOut(baseSetData);\n\n /**\n * 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 * 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 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 * 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 * 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, baseIteratee(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, baseIteratee(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 * 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 * 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 * 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 * 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 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 * 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, baseIteratee(iteratee, 2)) : [];\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 * 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 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\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, baseIteratee(predicate, 3));\n }\n\n /**\n * Iterates over elements of `collection`, returning an array of all elements\n * `predicate` returns truthy for. The predicate is invoked with three\n * arguments: (value, index|key, collection).\n *\n * **Note:** Unlike `_.remove`, this method returns a new array.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} [predicate=_.identity] The function invoked per iteration.\n * @returns {Array} Returns the new filtered array.\n * @see _.reject\n * @example\n *\n * var users = [\n * { 'user': 'barney', 'age': 36, 'active': true },\n * { 'user': 'fred', 'age': 40, 'active': false }\n * ];\n *\n * _.filter(users, function(o) { return !o.active; });\n * // => objects for ['fred']\n *\n * // The `_.matches` iteratee shorthand.\n * _.filter(users, { 'age': 36, 'active': true });\n * // => objects for ['barney']\n *\n * // The `_.matchesProperty` iteratee shorthand.\n * _.filter(users, ['active', false]);\n * // => objects for ['fred']\n *\n * // The `_.property` iteratee shorthand.\n * _.filter(users, 'active');\n * // => objects for ['barney']\n */\n function filter(collection, predicate) {\n var func = isArray(collection) ? arrayFilter : baseFilter;\n return func(collection, baseIteratee(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 * 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, baseIteratee(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 * 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, baseIteratee(iteratee, 3));\n }\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, baseIteratee(iteratee, 4), accumulator, initAccum, baseEach);\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(baseIteratee(predicate, 3)));\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, baseIteratee(predicate, 3));\n }\n\n /**\n * Creates an array of elements, sorted in ascending order by the results of\n * running each element in a collection thru each iteratee. This method\n * performs a stable sort, that is, it preserves the original sort order of\n * equal elements. The iteratees are invoked with one argument: (value).\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {...(Function|Function[])} [iteratees=[_.identity]]\n * The iteratees to sort by.\n * @returns {Array} Returns the new sorted array.\n * @example\n *\n * var users = [\n * { 'user': 'fred', 'age': 48 },\n * { 'user': 'barney', 'age': 36 },\n * { 'user': 'fred', 'age': 40 },\n * { 'user': 'barney', 'age': 34 }\n * ];\n *\n * _.sortBy(users, [function(o) { return o.user; }]);\n * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]\n *\n * _.sortBy(users, ['user', 'age']);\n * // => objects for [['barney', 34], ['barney', 36], ['fred', 40], ['fred', 48]]\n */\n var sortBy = baseRest(function(collection, iteratees) {\n if (collection == null) {\n return [];\n }\n var length = iteratees.length;\n if (length > 1 && isIterateeCall(collection, iteratees[0], iteratees[1])) {\n iteratees = [];\n } else if (length > 2 && isIterateeCall(iteratees[0], iteratees[1], iteratees[2])) {\n iteratees = [iteratees[0]];\n }\n return baseOrderBy(collection, baseFlatten(iteratees, 1), []);\n });\n\n /*------------------------------------------------------------------------*/\n\n /**\n * Gets the timestamp of the number of milliseconds that have elapsed since\n * the Unix epoch (1 January 1970 00:00:00 UTC).\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Date\n * @returns {number} Returns the timestamp.\n * @example\n *\n * _.defer(function(stamp) {\n * console.log(_.now() - stamp);\n * }, _.now());\n * // => Logs the number of milliseconds it took for the deferred invocation.\n */\n var now = function() {\n return root.Date.now();\n };\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 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 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 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 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 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\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 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 * 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 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 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 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 * 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 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 * 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 `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 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 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 * 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 a number.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3.2);\n * // => 3.2\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3.2');\n * // => 3.2\n */\n function toNumber(value) {\n if (typeof value == 'number') {\n return value;\n }\n if (isSymbol(value)) {\n return NAN;\n }\n if (isObject(value)) {\n var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n value = isObject(other) ? (other + '') : other;\n }\n if (typeof value != 'string') {\n return value === 0 ? value : +value;\n }\n value = value.replace(reTrim, '');\n var isBinary = reIsBinary.test(value);\n return (isBinary || reIsOctal.test(value))\n ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n : (reIsBadHex.test(value) ? NAN : +value);\n }\n\n /**\n * Converts `value` to a plain object flattening inherited enumerable string\n * keyed properties of `value` to own properties of the plain object.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {Object} Returns the converted plain object.\n * @example\n *\n * function Foo() {\n * this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.assign({ 'a': 1 }, new Foo);\n * // => { 'a': 1, 'b': 2 }\n *\n * _.assign({ 'a': 1 }, _.toPlainObject(new Foo));\n * // => { 'a': 1, 'b': 2, 'c': 3 }\n */\n function toPlainObject(value) {\n return copyObject(value, keysIn(value));\n }\n\n /**\n * Converts `value` to a 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 * 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 * 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, baseIteratee(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, baseIteratee(predicate, 3), baseForOwnRight);\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 }, baseIteratee);\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 * 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(baseIteratee(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 = baseIteratee(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 * 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\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 * 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 the characters \"&\", \"<\", \">\", '\"', and \"'\" in `string` to their\n * corresponding HTML entities.\n *\n * **Note:** No other characters are escaped. To escape additional\n * characters use a third-party library like [_he_](https://mths.be/he).\n *\n * Though the \">\" character is escaped for symmetry, characters like\n * \">\" and \"/\" don't need escaping in HTML and have no special meaning\n * unless they're part of a tag or unquoted attribute value. See\n * [Mathias Bynens's article](https://mathiasbynens.be/notes/ambiguous-ampersands)\n * (under \"semi-related fun fact\") for more details.\n *\n * When working with HTML you should always\n * [quote attribute values](http://wonko.com/post/html-escaping) to reduce\n * XSS vectors.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category String\n * @param {string} [string=''] The string to escape.\n * @returns {string} Returns the escaped string.\n * @example\n *\n * _.escape('fred, barney, & pebbles');\n * // => 'fred, barney, & pebbles'\n */\n function escape(string) {\n string = toString(string);\n return (string && reHasUnescapedHtml.test(string))\n ? string.replace(reUnescapedHtml, escapeHtmlChar)\n : string;\n }\n\n /**\n * Removes leading and trailing whitespace or specified characters from `string`.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category String\n * @param {string} [string=''] The string to trim.\n * @param {string} [chars=whitespace] The characters to trim.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {string} Returns the trimmed string.\n * @example\n *\n * _.trim(' abc ');\n * // => 'abc'\n *\n * _.trim('-_-abc-_-', '_-');\n * // => 'abc'\n *\n * _.map([' foo ', ' bar '], _.trim);\n * // => ['foo', 'bar']\n */\n function trim(string, chars, guard) {\n string = toString(string);\n if (string && (guard || chars === undefined)) {\n return string.replace(reTrim, '');\n }\n if (!string || !(chars = baseToString(chars))) {\n return string;\n }\n var strSymbols = stringToArray(string),\n chrSymbols = stringToArray(chars),\n start = charsStartIndex(strSymbols, chrSymbols),\n end = charsEndIndex(strSymbols, chrSymbols) + 1;\n\n return castSlice(strSymbols, start, end).join('');\n }\n\n /*------------------------------------------------------------------------*/\n\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 * This method returns the first argument it receives.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Util\n * @param {*} value Any value.\n * @returns {*} Returns `value`.\n * @example\n *\n * var object = { 'a': 1 };\n *\n * console.log(_.identity(object) === object);\n * // => true\n */\n function identity(value) {\n return value;\n }\n\n /**\n * Creates a function that invokes `func` with the arguments of the created\n * function. If `func` is a property name, the created function returns the\n * property value for a given element. If `func` is an array or object, the\n * created function returns `true` for elements that contain the equivalent\n * source properties, otherwise it returns `false`.\n *\n * @static\n * @since 4.0.0\n * @memberOf _\n * @category Util\n * @param {*} [func=_.identity] The value to convert to a callback.\n * @returns {Function} Returns the callback.\n * @example\n *\n * var users = [\n * { 'user': 'barney', 'age': 36, 'active': true },\n * { 'user': 'fred', 'age': 40, 'active': false }\n * ];\n *\n * // The `_.matches` iteratee shorthand.\n * _.filter(users, _.iteratee({ 'user': 'barney', 'active': true }));\n * // => [{ 'user': 'barney', 'age': 36, 'active': true }]\n *\n * // The `_.matchesProperty` iteratee shorthand.\n * _.filter(users, _.iteratee(['user', 'fred']));\n * // => [{ 'user': 'fred', 'age': 40 }]\n *\n * // The `_.property` iteratee shorthand.\n * _.map(users, _.iteratee('user'));\n * // => ['barney', 'fred']\n *\n * // Create custom iteratee shorthands.\n * _.iteratee = _.wrap(_.iteratee, function(iteratee, func) {\n * return !_.isRegExp(func) ? iteratee(func) : function(string) {\n * return func.test(string);\n * };\n * });\n *\n * _.filter(['abc', 'def'], /ef/);\n * // => ['def']\n */\n function iteratee(func) {\n return baseIteratee(typeof func == 'function' ? func : baseClone(func, CLONE_DEEP_FLAG));\n }\n\n /**\n * Creates a function that performs a partial deep comparison between a given\n * object and `source`, returning `true` if the given object has equivalent\n * property values, else `false`.\n *\n * **Note:** The created function is equivalent to `_.isMatch` with `source`\n * partially applied.\n *\n * Partial comparisons will match empty array and empty object `source`\n * values against any array or object value, respectively. See `_.isEqual`\n * for a list of supported value comparisons.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Util\n * @param {Object} source The object of property values to match.\n * @returns {Function} Returns the new spec function.\n * @example\n *\n * var objects = [\n * { 'a': 1, 'b': 2, 'c': 3 },\n * { 'a': 4, 'b': 5, 'c': 6 }\n * ];\n *\n * _.filter(objects, _.matches({ 'a': 4, 'c': 6 }));\n * // => [{ 'a': 4, 'b': 5, 'c': 6 }]\n */\n function matches(source) {\n return baseMatches(baseClone(source, CLONE_DEEP_FLAG));\n }\n\n /**\n * 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 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 * 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 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 * 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 * 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 * 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\n // Add methods that return wrapped values in chain sequences.\n lodash.assignIn = assignIn;\n lodash.before = before;\n lodash.bind = bind;\n lodash.chain = chain;\n lodash.compact = compact;\n lodash.concat = concat;\n lodash.countBy = countBy;\n lodash.create = create;\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.drop = drop;\n lodash.filter = filter;\n lodash.flatten = flatten;\n lodash.flattenDeep = flattenDeep;\n lodash.groupBy = groupBy;\n lodash.initial = initial;\n lodash.intersection = intersection;\n lodash.invert = invert;\n lodash.invertBy = invertBy;\n lodash.iteratee = iteratee;\n lodash.keys = keys;\n lodash.map = map;\n lodash.matches = matches;\n lodash.merge = merge;\n lodash.mixin = mixin;\n lodash.negate = negate;\n lodash.omit = omit;\n lodash.omitBy = omitBy;\n lodash.once = once;\n lodash.pick = pick;\n lodash.range = range;\n lodash.reject = reject;\n lodash.rest = rest;\n lodash.set = set;\n lodash.slice = slice;\n lodash.sortBy = sortBy;\n lodash.take = take;\n lodash.takeRight = takeRight;\n lodash.tap = tap;\n lodash.throttle = throttle;\n lodash.thru = thru;\n lodash.toArray = toArray;\n lodash.union = union;\n lodash.uniq = uniq;\n lodash.uniqBy = uniqBy;\n lodash.unzip = unzip;\n lodash.values = values;\n lodash.without = without;\n lodash.zip = zip;\n lodash.zipObject = zipObject;\n\n // Add aliases.\n lodash.extend = assignIn;\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.clamp = clamp;\n lodash.clone = clone;\n lodash.cloneDeep = cloneDeep;\n lodash.escape = escape;\n lodash.every = every;\n lodash.find = find;\n lodash.findIndex = findIndex;\n lodash.findKey = findKey;\n lodash.findLastIndex = findLastIndex;\n lodash.findLastKey = findLastKey;\n lodash.forEach = forEach;\n lodash.get = get;\n lodash.has = has;\n lodash.head = head;\n lodash.identity = identity;\n lodash.indexOf = indexOf;\n lodash.isArguments = isArguments;\n lodash.isArray = isArray;\n lodash.isArrayLike = isArrayLike;\n lodash.isBoolean = isBoolean;\n lodash.isDate = isDate;\n lodash.isEmpty = isEmpty;\n lodash.isEqual = isEqual;\n lodash.isFinite = isFinite;\n lodash.isFunction = isFunction;\n lodash.isNaN = isNaN;\n lodash.isNull = isNull;\n lodash.isNumber = isNumber;\n lodash.isObject = isObject;\n lodash.isPlainObject = isPlainObject;\n lodash.isRegExp = isRegExp;\n lodash.isString = isString;\n lodash.isUndefined = isUndefined;\n lodash.last = last;\n lodash.max = max;\n lodash.min = min;\n lodash.noConflict = noConflict;\n lodash.noop = noop;\n lodash.random = random;\n lodash.reduce = reduce;\n lodash.result = result;\n lodash.size = size;\n lodash.some = some;\n lodash.trim = trim;\n lodash.uniqueId = uniqueId;\n\n // Add aliases.\n lodash.each = forEach;\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 // Add `LazyWrapper` methods for `_.drop` and `_.take` variants.\n arrayEach(['drop', 'take'], function(methodName, index) {\n LazyWrapper.prototype[methodName] = function(n) {\n n = n === undefined ? 1 : nativeMax(toInteger(n), 0);\n\n var result = (this.__filtered__ && !index)\n ? new LazyWrapper(this)\n : this.clone();\n\n if (result.__filtered__) {\n result.__takeCount__ = nativeMin(n, result.__takeCount__);\n } else {\n result.__views__.push({\n 'size': nativeMin(n, MAX_ARRAY_LENGTH),\n 'type': methodName + (result.__dir__ < 0 ? 'Right' : '')\n });\n }\n return result;\n };\n\n LazyWrapper.prototype[methodName + 'Right'] = function(n) {\n return this.reverse()[methodName](n).reverse();\n };\n });\n\n // Add `LazyWrapper` methods that accept an `iteratee` value.\n arrayEach(['filter', 'map', 'takeWhile'], function(methodName, index) {\n var type = index + 1,\n isFilter = type == LAZY_FILTER_FLAG || type == LAZY_WHILE_FLAG;\n\n LazyWrapper.prototype[methodName] = function(iteratee) {\n var result = this.clone();\n result.__iteratees__.push({\n 'iteratee': getIteratee(iteratee, 3),\n 'type': type\n });\n result.__filtered__ = result.__filtered__ || isFilter;\n return result;\n };\n });\n\n // Add `LazyWrapper` methods for `_.head` and `_.last`.\n arrayEach(['head', 'last'], function(methodName, index) {\n var takeName = 'take' + (index ? 'Right' : '');\n\n LazyWrapper.prototype[methodName] = function() {\n return this[takeName](1).value()[0];\n };\n });\n\n // Add `LazyWrapper` methods for `_.initial` and `_.tail`.\n arrayEach(['initial', 'tail'], function(methodName, index) {\n var dropName = 'drop' + (index ? '' : 'Right');\n\n LazyWrapper.prototype[methodName] = function() {\n return this.__filtered__ ? new LazyWrapper(this) : this[dropName](1);\n };\n });\n\n LazyWrapper.prototype.compact = function() {\n return this.filter(identity);\n };\n\n LazyWrapper.prototype.find = function(predicate) {\n return this.filter(predicate).head();\n };\n\n LazyWrapper.prototype.findLast = function(predicate) {\n return this.reverse().find(predicate);\n };\n\n LazyWrapper.prototype.invokeMap = baseRest(function(path, args) {\n if (typeof path == 'function') {\n return new LazyWrapper(this);\n }\n return this.map(function(value) {\n return baseInvoke(value, path, args);\n });\n });\n\n LazyWrapper.prototype.reject = function(predicate) {\n return this.filter(negate(getIteratee(predicate)));\n };\n\n LazyWrapper.prototype.slice = function(start, end) {\n start = toInteger(start);\n\n var result = this;\n if (result.__filtered__ && (start > 0 || end < 0)) {\n return new LazyWrapper(result);\n }\n if (start < 0) {\n result = result.takeRight(-start);\n } else if (start) {\n result = result.drop(start);\n }\n if (end !== undefined) {\n end = toInteger(end);\n result = end < 0 ? result.dropRight(-end) : result.take(end - start);\n }\n return result;\n };\n\n LazyWrapper.prototype.takeRightWhile = function(predicate) {\n return this.reverse().takeWhile(predicate).reverse();\n };\n\n LazyWrapper.prototype.toArray = function() {\n return this.take(MAX_ARRAY_LENGTH);\n };\n\n // Add `LazyWrapper` methods to `lodash.prototype`.\n baseForOwn(LazyWrapper.prototype, function(func, methodName) {\n var checkIteratee = /^(?:filter|find|map|reject)|While$/.test(methodName),\n isTaker = /^(?:head|last)$/.test(methodName),\n lodashFunc = lodash[isTaker ? ('take' + (methodName == 'last' ? 'Right' : '')) : methodName],\n retUnwrapped = isTaker || /^find/.test(methodName);\n\n if (!lodashFunc) {\n return;\n }\n lodash.prototype[methodName] = function() {\n var value = this.__wrapped__,\n args = isTaker ? [1] : arguments,\n isLazy = value instanceof LazyWrapper,\n iteratee = args[0],\n useLazy = isLazy || isArray(value);\n\n var interceptor = function(value) {\n var result = lodashFunc.apply(lodash, arrayPush([value], args));\n return (isTaker && chainAll) ? result[0] : result;\n };\n\n if (useLazy && checkIteratee && typeof iteratee == 'function' && iteratee.length != 1) {\n // Avoid lazy use if the iteratee has a \"length\" value other than `1`.\n isLazy = useLazy = false;\n }\n var chainAll = this.__chain__,\n isHybrid = !!this.__actions__.length,\n isUnwrapped = retUnwrapped && !chainAll,\n onlyLazy = isLazy && !isHybrid;\n\n if (!retUnwrapped && useLazy) {\n value = onlyLazy ? value : new LazyWrapper(this);\n var result = func.apply(value, args);\n result.__actions__.push({ 'func': thru, 'args': [interceptor], 'thisArg': undefined });\n return new LodashWrapper(result, chainAll);\n }\n if (isUnwrapped && onlyLazy) {\n return func.apply(this, args);\n }\n result = this.thru(interceptor);\n return isUnwrapped ? (isTaker ? result.value()[0] : result.value()) : result;\n };\n });\n\n // Add `Array` methods to `lodash.prototype`.\n arrayEach(['pop', 'push', 'shift', 'sort', 'splice', 'unshift'], function(methodName) {\n var func = arrayProto[methodName],\n chainName = /^(?:push|sort|unshift)$/.test(methodName) ? 'tap' : 'thru',\n retUnwrapped = /^(?:pop|shift)$/.test(methodName);\n\n lodash.prototype[methodName] = function() {\n var args = arguments;\n if (retUnwrapped && !this.__chain__) {\n var value = this.value();\n return func.apply(isArray(value) ? value : [], args);\n }\n return this[chainName](function(value) {\n return func.apply(isArray(value) ? value : [], args);\n });\n };\n });\n\n // Map minified method names to their real names.\n baseForOwn(LazyWrapper.prototype, function(func, methodName) {\n var lodashFunc = lodash[methodName];\n if (lodashFunc) {\n var key = (lodashFunc.name + ''),\n names = realNames[key] || (realNames[key] = []);\n\n names.push({ 'name': methodName, 'func': lodashFunc });\n }\n });\n\n realNames[createHybrid(undefined, WRAP_BIND_KEY_FLAG).name] = [{\n 'name': 'wrapper',\n 'func': undefined\n }];\n\n // Add methods to `LazyWrapper`.\n LazyWrapper.prototype.clone = lazyClone;\n LazyWrapper.prototype.reverse = lazyReverse;\n LazyWrapper.prototype.value = lazyValue;\n\n // Add lazy aliases.\n lodash.prototype.first = lodash.prototype.head;\n\n if (symIterator) {\n lodash.prototype[symIterator] = wrapperToIterator;\n }\n\n /*--------------------------------------------------------------------------*/\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._ = lodash;\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 lodash;\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 = lodash)._ = lodash;\n // Export for CommonJS support.\n freeExports._ = lodash;\n }\n else {\n // Export to the global object.\n root._ = lodash;\n }\n}.call(this));\n/**\n * 常量\n */\n\n_.extend(BI, {\n MAX: 0xfffffffffffffff,\n MIN: -0xfffffffffffffff,\n EVENT_RESPONSE_TIME: 200,\n zIndex_layer: 1e5,\n zIndex_popover: 1e6,\n zIndex_popup: 1e7,\n zIndex_masker: 1e8,\n zIndex_tip: 1e9,\n emptyStr: \"\",\n emptyFn: function () {\n },\n empty: null,\n Key: {\n 48: \"0\",\n 49: \"1\",\n 50: \"2\",\n 51: \"3\",\n 52: \"4\",\n 53: \"5\",\n 54: \"6\",\n 55: \"7\",\n 56: \"8\",\n 57: \"9\",\n 65: \"a\",\n 66: \"b\",\n 67: \"c\",\n 68: \"d\",\n 69: \"e\",\n 70: \"f\",\n 71: \"g\",\n 72: \"h\",\n 73: \"i\",\n 74: \"j\",\n 75: \"k\",\n 76: \"l\",\n 77: \"m\",\n 78: \"n\",\n 79: \"o\",\n 80: \"p\",\n 81: \"q\",\n 82: \"r\",\n 83: \"s\",\n 84: \"t\",\n 85: \"u\",\n 86: \"v\",\n 87: \"w\",\n 88: \"x\",\n 89: \"y\",\n 90: \"z\",\n 96: \"0\",\n 97: \"1\",\n 98: \"2\",\n 99: \"3\",\n 100: \"4\",\n 101: \"5\",\n 102: \"6\",\n 103: \"7\",\n 104: \"8\",\n 105: \"9\",\n 106: \"*\",\n 107: \"+\",\n 109: \"-\",\n 110: \".\",\n 111: \"/\"\n },\n KeyCode: {\n BACKSPACE: 8,\n COMMA: 188,\n DELETE: 46,\n DOWN: 40,\n END: 35,\n ENTER: 13,\n ESCAPE: 27,\n HOME: 36,\n LEFT: 37,\n NUMPAD_ADD: 107,\n NUMPAD_DECIMAL: 110,\n NUMPAD_DIVIDE: 111,\n NUMPAD_ENTER: 108,\n NUMPAD_MULTIPLY: 106,\n NUMPAD_SUBTRACT: 109,\n PAGE_DOWN: 34,\n PAGE_UP: 33,\n PERIOD: 190,\n RIGHT: 39,\n SPACE: 32,\n TAB: 9,\n UP: 38\n },\n Status: {\n SUCCESS: 1,\n WRONG: 2,\n START: 3,\n END: 4,\n WAITING: 5,\n READY: 6,\n RUNNING: 7,\n OUTOFBOUNDS: 8,\n NULL: -1\n },\n Direction: {\n Top: \"top\",\n Bottom: \"bottom\",\n Left: \"left\",\n Right: \"right\",\n Custom: \"custom\"\n },\n Axis: {\n Vertical: \"vertical\",\n Horizontal: \"horizontal\"\n },\n Selection: {\n Default: -2,\n None: -1,\n Single: 0,\n Multi: 1,\n All: 2\n },\n HorizontalAlign: {\n Left: \"left\",\n Right: \"right\",\n Center: \"center\",\n Stretch: \"stretch\"\n },\n VerticalAlign: {\n Middle: \"middle\",\n Top: \"top\",\n Bottom: \"bottom\",\n Stretch: \"stretch\"\n },\n StartOfWeek: 1\n});/**\n * 对数组对象的扩展\n * @class Array\n */\n_.extend(BI, {\n\n pushArray: function (sArray, array) {\n for (var i = 0; i < array.length; i++) {\n sArray.push(array[i]);\n }\n },\n pushDistinct: function (sArray, obj) {\n if (!BI.contains(sArray, obj)) {\n sArray.push(obj);\n }\n },\n pushDistinctArray: function (sArray, array) {\n for (var i = 0, len = array.length; i < len; i++) {\n BI.pushDistinct(sArray, array[i]);\n }\n }\n});\n_.extend(BI, {\n // 给Number类型增加一个add方法，调用起来更加方便。\n add: function (num, arg) {\n return accAdd(arg, num);\n\n /**\n ** 加法函数，用来得到精确的加法结果\n ** 说明：javascript的加法结果会有误差，在两个浮点数相加的时候会比较明显。这个函数返回较为精确的加法结果。\n ** 调用：accAdd(arg1,arg2)\n ** 返回值：arg1加上arg2的精确结果\n **/\n function accAdd (arg1, arg2) {\n var r1, r2, m, c;\n try {\n r1 = arg1.toString().split(\".\")[1].length;\n } catch (e) {\n r1 = 0;\n }\n try {\n r2 = arg2.toString().split(\".\")[1].length;\n } catch (e) {\n r2 = 0;\n }\n c = Math.abs(r1 - r2);\n m = Math.pow(10, Math.max(r1, r2));\n if (c > 0) {\n var cm = Math.pow(10, c);\n if (r1 > r2) {\n arg1 = Number(arg1.toString().replace(\".\", \"\"));\n arg2 = Number(arg2.toString().replace(\".\", \"\")) * cm;\n } else {\n arg1 = Number(arg1.toString().replace(\".\", \"\")) * cm;\n arg2 = Number(arg2.toString().replace(\".\", \"\"));\n }\n } else {\n arg1 = Number(arg1.toString().replace(\".\", \"\"));\n arg2 = Number(arg2.toString().replace(\".\", \"\"));\n }\n return (arg1 + arg2) / m;\n }\n },\n\n // 给Number类型增加一个sub方法，调用起来更加方便。\n sub: function (num, arg) {\n return accSub(num, arg);\n\n /**\n ** 减法函数，用来得到精确的减法结果\n ** 说明：javascript的减法结果会有误差，在两个浮点数相减的时候会比较明显。这个函数返回较为精确的减法结果。\n ** 调用：accSub(arg1,arg2)\n ** 返回值：arg1加上arg2的精确结果\n **/\n function accSub (arg1, arg2) {\n var r1, r2, m, n;\n try {\n r1 = arg1.toString().split(\".\")[1].length;\n } catch (e) {\n r1 = 0;\n }\n try {\n r2 = arg2.toString().split(\".\")[1].length;\n } catch (e) {\n r2 = 0;\n }\n m = Math.pow(10, Math.max(r1, r2)); // last modify by deeka //动态控制精度长度\n n = (r1 >= r2) ? r1 : r2;\n return ((arg1 * m - arg2 * m) / m).toFixed(n);\n }\n },\n\n // 给Number类型增加一个mul方法，调用起来更加方便。\n mul: function (num, arg) {\n return accMul(arg, num);\n\n /**\n ** 乘法函数，用来得到精确的乘法结果\n ** 说明：javascript的乘法结果会有误差，在两个浮点数相乘的时候会比较明显。这个函数返回较为精确的乘法结果。\n ** 调用：accMul(arg1,arg2)\n ** 返回值：arg1乘以 arg2的精确结果\n **/\n function accMul (arg1, arg2) {\n var m = 0, s1 = arg1.toString(), s2 = arg2.toString();\n try {\n m += s1.split(\".\")[1].length;\n } catch (e) {\n }\n try {\n m += s2.split(\".\")[1].length;\n } catch (e) {\n }\n return Number(s1.replace(\".\", \"\")) * Number(s2.replace(\".\", \"\")) / Math.pow(10, m);\n }\n },\n \n // 给Number类型增加一个div方法，调用起来更加方便。\n div: function (num, arg) {\n return accDivide(num, arg);\n\n /**\n * Return digits length of a number\n * @param {*number} num Input number\n */\n function digitLength (num) {\n // Get digit length of e\n var eSplit = num.toString().split(/[eE]/);\n var len = (eSplit[0].split(\".\")[1] || \"\").length - (+(eSplit[1] || 0));\n return len > 0 ? len : 0;\n }\n /**\n * 把小数转成整数，支持科学计数法。如果是小数则放大成整数\n * @param {*number} num 输入数\n */\n function float2Fixed (num) {\n if (num.toString().indexOf(\"e\") === -1) {\n return Number(num.toString().replace(\".\", \"\"));\n }\n var dLen = digitLength(num);\n return dLen > 0 ? num * Math.pow(10, dLen) : num;\n }\n\n /**\n * 精确乘法\n */\n function times (num1, num2) {\n var others = [];\n for (var _i = 2; _i < arguments.length; _i++) {\n others[_i - 2] = arguments[_i];\n }\n if (others.length > 0) {\n return times.apply(void 0, [times(num1, num2), others[0]].concat(others.slice(1)));\n }\n var num1Changed = float2Fixed(num1);\n var num2Changed = float2Fixed(num2);\n var baseNum = digitLength(num1) + digitLength(num2);\n var leftValue = num1Changed * num2Changed;\n return leftValue / Math.pow(10, baseNum);\n }\n\n /**\n * 精确除法\n */\n function accDivide (num1, num2) {\n var others = [];\n for (var _i = 2; _i < arguments.length; _i++) {\n others[_i - 2] = arguments[_i];\n }\n if (others.length > 0) {\n return accDivide.apply(void 0, [accDivide(num1, num2), others[0]].concat(others.slice(1)));\n }\n var num1Changed = float2Fixed(num1);\n var num2Changed = float2Fixed(num2);\n return times((num1Changed / num2Changed), Math.pow(10, digitLength(num2) - digitLength(num1)));\n }\n }\n\n});/**\n * 对字符串对象的扩展\n * @class String\n */\n_.extend(BI, {\n\n /**\n * 判断字符串是否已指定的字符串开始\n * @param str source字符串\n * @param {String} startTag 指定的开始字符串\n * @return {Boolean} 如果字符串以指定字符串开始则返回true，否则返回false\n */\n startWith: function (str, startTag) {\n str = str || \"\";\n if (startTag == null || startTag == \"\" || str.length === 0 || startTag.length > str.length) {\n return false;\n }\n return str.substr(0, startTag.length) == startTag;\n },\n /**\n * 判断字符串是否以指定的字符串结束\n * @param str source字符串\n * @param {String} endTag 指定的字符串\n * @return {Boolean} 如果字符串以指定字符串结束则返回true，否则返回false\n */\n endWith: function (str, endTag) {\n if (endTag == null || endTag == \"\" || str.length === 0 || endTag.length > str.length) {\n return false;\n }\n return str.substring(str.length - endTag.length) == endTag;\n },\n\n /**\n * 获取url中指定名字的参数\n * @param str source字符串\n * @param {String} name 参数的名字\n * @return {String} 参数的值\n */\n getQuery: function (str, name) {\n var reg = new RegExp(\"(^|&)\" + name + \"=([^&]*)(&|$)\");\n var r = str.substr(str.indexOf(\"?\") + 1).match(reg);\n if (r) {\n return unescape(r[2]);\n }\n return null;\n },\n\n /**\n * 给url加上给定的参数\n * @param str source字符串\n * @param {Object} paras 参数对象，是一个键值对对象\n * @return {String} 添加了给定参数的url\n */\n appendQuery: function (str, paras) {\n if (!paras) {\n return str;\n }\n var src = str;\n // 没有问号说明还没有参数\n if (src.indexOf(\"?\") === -1) {\n src += \"?\";\n }\n // 如果以问号结尾，说明没有其他参数\n if (src.endWith(\"?\") !== false) {\n } else {\n src += \"&\";\n }\n _.each(paras, function (value, name) {\n if (typeof(name) === \"string\") {\n src += name + \"=\" + value + \"&\";\n }\n });\n src = src.substr(0, src.length - 1);\n return src;\n },\n /**\n * 将所有符合第一个字符串所表示的字符串替换成为第二个字符串\n * @param str source字符串\n * @param {String} s1 要替换的字符串的正则表达式\n * @param {String} s2 替换的结果字符串\n * @returns {String} 替换后的字符串\n */\n replaceAll: function (str, s1, s2) {\n return str.replace(new RegExp(s1, \"gm\"), s2);\n },\n /**\n * 总是让字符串以指定的字符开头\n * @param str source字符串\n * @param {String} start 指定的字符\n * @returns {String} 以指定字符开头的字符串\n */\n perfectStart: function (str, start) {\n if (str.startWith(start)) {\n return str;\n }\n return start + str;\n\n },\n\n /**\n * 获取字符串中某字符串的所有项位置数组\n * @param str source字符串\n * @param {String} sub 子字符串\n * @return {Number[]} 子字符串在父字符串中出现的所有位置组成的数组\n */\n allIndexOf: function (str, sub) {\n if (typeof sub !== \"string\") {\n return [];\n }\n var location = [];\n var offset = 0;\n while (str.length > 0) {\n var loc = str.indexOf(sub);\n if (loc === -1) {\n break;\n }\n location.push(offset + loc);\n str = str.substring(loc + sub.length, str.length);\n offset += loc + sub.length;\n }\n return location;\n }\n});/** Constants used for time computations */\nBI.Date = BI.Date || {};\nBI.Date.SECOND = 1000;\nBI.Date.MINUTE = 60 * BI.Date.SECOND;\nBI.Date.HOUR = 60 * BI.Date.MINUTE;\nBI.Date.DAY = 24 * BI.Date.HOUR;\nBI.Date.WEEK = 7 * BI.Date.DAY;\n\n_.extend(BI, {\n /**\n * 获取时区\n * @returns {String}\n */\n getTimezone: function (date) {\n return date.toString().replace(/^.* (?:\\((.*)\\)|([A-Z]{1,4})(?:[\\-+][0-9]{4})?(?: -?\\d+)?)$/, \"$1$2\").replace(/[^A-Z]/g, \"\");\n },\n\n /** Returns the number of days in the current month */\n getMonthDays: function (date, month) {\n var year = date.getFullYear();\n if (typeof month === \"undefined\") {\n month = date.getMonth();\n }\n if (((0 == (year % 4)) && ((0 != (year % 100)) || (0 == (year % 400)))) && month == 1) {\n return 29;\n }\n return BI.Date._MD[month];\n\n },\n\n /**\n * 获取每月的最后一天\n * @returns {Date}\n */\n getLastDateOfMonth: function (date) {\n return BI.getDate(date.getFullYear(), date.getMonth(), BI.getMonthDays(date));\n },\n\n /** Returns the number of day in the year. */\n getDayOfYear: function (date) {\n var now = BI.getDate(date.getFullYear(), date.getMonth(), date.getDate(), 0, 0, 0);\n var then = BI.getDate(date.getFullYear(), 0, 0, 0, 0, 0);\n var time = now - then;\n return Math.floor(time / BI.Date.DAY);\n },\n\n /** Returns the number of the week in year, as defined in ISO 8601. */\n getWeekNumber: function (date) {\n var d = BI.getDate(date.getFullYear(), date.getMonth(), date.getDate(), 0, 0, 0);\n var week = d.getDay();\n var startOfWeek = BI.StartOfWeek % 7;\n var middleDay = (startOfWeek + 3) % 7;\n middleDay = middleDay || 7;\n // 偏移到周周首之前需要多少天\n var offsetWeekStartCount = week < startOfWeek ? (7 + week - startOfWeek) : (week - startOfWeek);\n var offsetWeekMiddleCount = middleDay < startOfWeek ? (7 + middleDay - startOfWeek) : (middleDay - startOfWeek);\n d.setDate(d.getDate() - offsetWeekStartCount + offsetWeekMiddleCount);\n var ms = d.valueOf();\n d.setMonth(0);\n d.setDate(1);\n return Math.floor((ms - d.valueOf()) / (7 * 864e5)) + 1;\n },\n\n getQuarter: function (date) {\n return Math.floor(date.getMonth() / 3) + 1;\n },\n\n // 离当前时间多少天的时间\n getOffsetDate: function (date, offset) {\n return BI.getDate(BI.getTime(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), date.getSeconds()) + offset * 864e5);\n },\n\n getOffsetQuarter: function (date, n) {\n var dt = BI.getDate(BI.getTime(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), date.getSeconds()));\n var day = dt.getDate();\n var monthDay = BI.getMonthDays(BI.getDate(dt.getFullYear(), dt.getMonth() + BI.parseInt(n) * 3, 1));\n if (day > monthDay) {\n day = monthDay;\n }\n dt.setDate(day);\n dt.setMonth(dt.getMonth() + parseInt(n) * 3);\n return dt;\n },\n\n // 得到本季度的起始月份\n getQuarterStartMonth: function (date) {\n var quarterStartMonth = 0;\n var nowMonth = date.getMonth();\n if (nowMonth < 3) {\n quarterStartMonth = 0;\n }\n if (2 < nowMonth && nowMonth < 6) {\n quarterStartMonth = 3;\n }\n if (5 < nowMonth && nowMonth < 9) {\n quarterStartMonth = 6;\n }\n if (nowMonth > 8) {\n quarterStartMonth = 9;\n }\n return quarterStartMonth;\n },\n // 获得本季度的起始日期\n getQuarterStartDate: function (date) {\n return BI.getDate(date.getFullYear(), BI.getQuarterStartMonth(date), 1);\n },\n // 得到本季度的结束日期\n getQuarterEndDate: function (date) {\n var quarterEndMonth = BI.getQuarterStartMonth(date) + 2;\n return BI.getDate(date.getFullYear(), quarterEndMonth, BI.getMonthDays(date, quarterEndMonth));\n },\n\n // 指定日期n个月之前或之后的日期\n getOffsetMonth: function (date, n) {\n var dt = BI.getDate(BI.getTime(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), date.getSeconds()));\n var day = dt.getDate();\n var monthDay = BI.getMonthDays(BI.getDate(dt.getFullYear(), dt.getMonth() + parseInt(n), 1));\n if (day > monthDay) {\n day = monthDay;\n }\n dt.setDate(day);\n dt.setMonth(dt.getMonth() + parseInt(n));\n return dt;\n },\n\n // 获得本周的起始日期\n getWeekStartDate: function (date) {\n var w = date.getDay();\n var startOfWeek = BI.StartOfWeek % 7;\n return BI.getOffsetDate(date, BI.Date._OFFSET[w < startOfWeek ? (7 + w - startOfWeek) : (w - startOfWeek)]);\n },\n // 得到本周的结束日期\n getWeekEndDate: function (date) {\n var w = date.getDay();\n var startOfWeek = BI.StartOfWeek % 7;\n return BI.getOffsetDate(date, BI.Date._OFFSET[w < startOfWeek ? (7 + w - startOfWeek) : (w - startOfWeek)] + 6);\n },\n\n // 格式化打印日期\n print: function (date, str) {\n var m = date.getMonth();\n var d = date.getDate();\n var y = date.getFullYear();\n var yWith4number = y + \"\";\n while (yWith4number.length < 4) {\n yWith4number = \"0\" + yWith4number;\n }\n var wn = BI.getWeekNumber(date);\n var qr = BI.getQuarter(date);\n var w = date.getDay();\n var s = {};\n var hr = date.getHours();\n var pm = (hr >= 12);\n var ir = (pm) ? (hr - 12) : hr;\n var dy = BI.getDayOfYear(date);\n if (ir == 0) {\n ir = 12;\n }\n var min = date.getMinutes();\n var sec = date.getSeconds();\n s[\"%a\"] = BI.Date._SDN[w]; // abbreviated weekday name [FIXME: I18N]\n s[\"%A\"] = BI.Date._DN[w]; // full weekday name\n s[\"%b\"] = BI.Date._SMN[m]; // abbreviated month name [FIXME: I18N]\n s[\"%B\"] = BI.Date._MN[m]; // full month name\n // FIXME: %c : preferred date and time representation for the current locale\n s[\"%C\"] = 1 + Math.floor(y / 100); // the century number\n s[\"%d\"] = (d < 10) ? (\"0\" + d) : d; // the day of the month (range 01 to 31)\n s[\"%e\"] = d; // the day of the month (range 1 to 31)\n // FIXME: %D : american date style: %m/%d/%y\n // FIXME: %E, %F, %G, %g, %h (man strftime)\n s[\"%H\"] = (hr < 10) ? (\"0\" + hr) : hr; // hour, range 00 to 23 (24h format)\n s[\"%I\"] = (ir < 10) ? (\"0\" + ir) : ir; // hour, range 01 to 12 (12h format)\n s[\"%j\"] = (dy < 100) ? ((dy < 10) ? (\"00\" + dy) : (\"0\" + dy)) : dy; // day of the year (range 001 to 366)\n s[\"%k\"] = hr + \"\";\t\t// hour, range 0 to 23 (24h format)\n s[\"%l\"] = ir + \"\";\t\t// hour, range 1 to 12 (12h format)\n s[\"%X\"] = (m < 9) ? (\"0\" + (1 + m)) : (1 + m); // month, range 01 to 12\n s[\"%x\"] = m + 1; // month, range 1 to 12\n s[\"%M\"] = (min < 10) ? (\"0\" + min) : min; // minute, range 00 to 59\n s[\"%n\"] = \"\\n\";\t\t// a newline character\n s[\"%p\"] = pm ? \"PM\" : \"AM\";\n s[\"%P\"] = pm ? \"pm\" : \"am\";\n // FIXME: %r : the time in am/pm notation %I:%M:%S %p\n // FIXME: %R : the time in 24-hour notation %H:%M\n s[\"%s\"] = Math.floor(date.getTime() / 1000);\n s[\"%S\"] = (sec < 10) ? (\"0\" + sec) : sec; // seconds, range 00 to 59\n s[\"%t\"] = \"\\t\";\t\t// a tab character\n // FIXME: %T : the time in 24-hour notation (%H:%M:%S)\n s[\"%U\"] = s[\"%W\"] = s[\"%V\"] = (wn < 10) ? (\"0\" + wn) : wn;\n s[\"%u\"] = w + 1;\t// the day of the week (range 1 to 7, 1 = MON)\n s[\"%w\"] = w;\t\t// the day of the week (range 0 to 6, 0 = SUN)\n // FIXME: %x : preferred date representation for the current locale without the time\n // FIXME: %X : preferred time representation for the current locale without the date\n s[\"%y\"] = yWith4number.substr(2, 2); // year without the century (range 00 to 99)\n s[\"%Y\"] = yWith4number;\t\t// year with the century\n s[\"%%\"] = \"%\";\t\t// a literal '%' character\n s[\"%Q\"] = qr;\n\n var re = /%./g;\n BI.isKhtml = BI.isKhtml || function () {\n if(!_global.navigator) {\n return false;\n }\n return /Konqueror|Safari|KHTML/i.test(navigator.userAgent);\n };\n\n // 包含年周的格式化，ISO8601标准周的计数会影响年\n if ((str.indexOf(\"%Y\") !== -1 || str.indexOf(\"%y\") !== -1) && (str.indexOf(\"%W\") !== -1 || str.indexOf(\"%U\") !== -1 || str.indexOf(\"%V\") !== -1)) {\n switch (wn) {\n // 如果周数是1，但是当前却在12月，表示此周数为下一年的\n case 1:\n if (m === 11) {\n s[\"%y\"] = parseInt(s[\"%y\"]) + 1;\n s[\"%Y\"] = parseInt(s[\"%Y\"]) + 1;\n }\n break;\n // 如果周数是53，但是当前却在1月，表示此周数为上一年的\n case 53:\n if (m === 0) {\n s[\"%y\"] = parseInt(s[\"%y\"]) - 1;\n s[\"%Y\"] = parseInt(s[\"%Y\"]) - 1;\n }\n break;\n default:\n break;\n }\n }\n\n if (!BI.isKhtml()) {\n return str.replace(re, function (par) {\n return s[par] || par;\n });\n }\n var a = str.match(re);\n for (var i = 0; i < a.length; i++) {\n var tmp = s[a[i]];\n if (tmp) {\n re = new RegExp(a[i], \"g\");\n str = str.replace(re, tmp);\n }\n }\n\n return str;\n }\n});\n/**\n * 基本的函数\n * Created by GUY on 2015/6/24.\n */\nBI.Func = {};\n_.extend(BI.Func, {\n /**\n * 创建唯一的名字\n * @param array\n * @param name\n * @returns {*}\n */\n createDistinctName: function (array, name) {\n var src = name, idx = 1;\n name = name || \"\";\n while (true) {\n if (BI.every(array, function (i, item) {\n return BI.isKey(item) ? item !== name : item.name !== name;\n })) {\n break;\n }\n name = src + (idx++);\n }\n return name;\n },\n\n /**\n * 获取字符宽度\n * @param str\n * @return {number}\n */\n getGBWidth: function (str) {\n str = str + \"\";\n str = str.replace(/[^\\x00-\\xff]/g, \"xx\");\n return Math.ceil(str.length / 2);\n },\n\n /**\n * 获取搜索结果\n * @param items\n * @param keyword\n * @param param 搜索哪个属性\n */\n getSearchResult: function (items, keyword, param) {\n var isArray = BI.isArray(items);\n items = isArray ? BI.flatten(items) : items;\n param || (param = \"text\");\n if (!BI.isKey(keyword)) {\n return {\n find: BI.deepClone(items),\n match: isArray ? [] : {}\n };\n }\n var t, text, py;\n keyword = BI.toUpperCase(keyword);\n var matched = isArray ? [] : {}, find = isArray ? [] : {};\n BI.each(items, function (i, item) {\n // 兼容item为null的处理\n if (BI.isNull(item)) {\n return;\n }\n item = BI.deepClone(item);\n t = BI.stripEL(item);\n text = BI.find([t[param], t.text, t.value, t.name, t], function (index, val) {\n return BI.isNotNull(val);\n });\n\n if (BI.isNull(text) || BI.isObject(text)) return;\n\n py = BI.makeFirstPY(text, {\n splitChar: \"\\u200b\"\n });\n text = BI.toUpperCase(text);\n py = BI.toUpperCase(py);\n var pidx;\n if (text.indexOf(keyword) > -1) {\n if (text === keyword) {\n isArray ? matched.push(item) : (matched[i] = item);\n } else {\n isArray ? find.push(item) : (find[i] = item);\n }\n // BI-56386 这边两个pid / text.length是为了防止截取的首字符串不是完整的，但光这样做还不够，即时错位了，也不能说明就不符合条件\n } else if (pidx = py.indexOf(keyword), (pidx > -1)) {\n if (text === keyword || keyword.length === text.length) {\n isArray ? matched.push(item) : (matched[i] = item);\n } else {\n isArray ? find.push(item) : (find[i] = item);\n }\n }\n });\n return {\n match: matched,\n find: find\n };\n }\n});\n\n_.extend(BI, {\n beforeFunc: function (sFunc, func) {\n var __self = sFunc;\n return function () {\n if (func.apply(sFunc, arguments) === false) {\n return false;\n }\n return __self.apply(sFunc, arguments);\n };\n },\n\n afterFunc: function (sFunc, func) {\n var __self = sFunc;\n return function () {\n var ret = __self.apply(sFunc, arguments);\n if (ret === false) {\n return false;\n }\n func.apply(sFunc, arguments);\n return ret;\n };\n }\n});/**\n * 基本函数\n * Create By GUY 2014\\11\\17\n *\n */\nvar _global;\nif (typeof window !== \"undefined\") {\n _global = window;\n} else if (typeof global !== \"undefined\") {\n _global = global;\n} else if (typeof self !== \"undefined\") {\n _global = self;\n} else {\n _global = this;\n}\nif (!_global.BI) {\n _global.BI = {};\n}\n\n!(function (undefined) {\n var traverse = function (func, context) {\n return function (value, key, obj) {\n return func.call(context, key, value, obj);\n };\n };\n var _apply = function (name) {\n return function () {\n return _[name].apply(_, arguments);\n };\n };\n var _applyFunc = function (name) {\n return function () {\n var args = Array.prototype.slice.call(arguments, 0);\n args[1] = _.isFunction(args[1]) ? traverse(args[1], args[2]) : args[1];\n return _[name].apply(_, args);\n };\n };\n\n // Utility\n _.extend(BI, {\n assert: function (v, is) {\n if (this.isFunction(is)) {\n if (!is(v)) {\n throw new Error(v + \" error\");\n } else {\n return true;\n }\n }\n if (!this.isArray(is)) {\n is = [is];\n }\n if (!this.deepContains(is, v)) {\n throw new Error(v + \" error\");\n }\n },\n\n warn: function (message) {\n console.warn(message);\n },\n\n UUID: function () {\n var f = [\"0\", \"1\", \"2\", \"3\", \"4\", \"5\", \"6\", \"7\", \"8\", \"9\", \"a\", \"b\", \"c\", \"d\", \"e\", \"f\"];\n var str = \"\";\n for (var i = 0; i < 16; i++) {\n var r = parseInt(f.length * Math.random(), 10);\n str += f[r];\n }\n return str;\n },\n\n isWidget: function (widget) {\n return widget instanceof BI.Widget || (BI.View && widget instanceof BI.View);\n },\n\n createWidgets: function (items, options, context) {\n if (!BI.isArray(items)) {\n throw new Error(\"cannot create Widgets\");\n }\n if (BI.isWidget(options)) {\n context = options;\n options = {};\n } else {\n options || (options = {});\n }\n return BI.map(BI.flatten(items), function (i, item) {\n return BI.createWidget(item, BI.deepClone(options));\n });\n },\n\n createItems: function (data, innerAttr, outerAttr) {\n innerAttr = BI.isArray(innerAttr) ? innerAttr : BI.makeArray(BI.flatten(data).length, innerAttr || {});\n outerAttr = BI.isArray(outerAttr) ? outerAttr : BI.makeArray(BI.flatten(data).length, outerAttr || {});\n return BI.map(data, function (i, item) {\n if (BI.isArray(item)) {\n return BI.createItems(item, innerAttr, outerAttr);\n }\n if (item instanceof BI.Widget) {\n return BI.extend({}, innerAttr.shift(), outerAttr.shift(), {\n type: null,\n el: item\n });\n }\n if (innerAttr[0] instanceof BI.Widget) {\n outerAttr.shift();\n return BI.extend({}, item, {\n el: innerAttr.shift()\n });\n }\n if (item.el instanceof BI.Widget || (BI.View && item.el instanceof BI.View)) {\n innerAttr.shift();\n return BI.extend({}, outerAttr.shift(), {type: null}, item);\n }\n if (item.el) {\n return BI.extend({}, outerAttr.shift(), item, {\n el: BI.extend({}, innerAttr.shift(), item.el)\n });\n }\n return BI.extend({}, outerAttr.shift(), {\n el: BI.extend({}, innerAttr.shift(), item)\n });\n });\n },\n\n // 用容器包装items\n packageItems: function (items, layouts) {\n for (var i = layouts.length - 1; i >= 0; i--) {\n items = BI.map(items, function (k, it) {\n return BI.extend({}, layouts[i], {\n items: [\n BI.extend({}, layouts[i].el, {\n el: it\n })\n ]\n });\n });\n }\n return items;\n },\n\n formatEL: function (obj) {\n if (obj && !obj.type && obj.el) {\n return obj;\n }\n return {\n el: obj\n };\n },\n\n // 剥开EL\n stripEL: function (obj) {\n return obj.type && obj || obj.el || obj;\n },\n\n trans2Element: function (widgets) {\n return BI.map(widgets, function (i, wi) {\n return wi.element;\n });\n }\n });\n\n // 集合相关方法\n _.each([\"where\", \"findWhere\", \"invoke\", \"pluck\", \"shuffle\", \"sample\", \"toArray\", \"size\"], function (name) {\n BI[name] = _apply(name);\n });\n _.each([\"get\", \"set\", \"each\", \"map\", \"reduce\", \"reduceRight\", \"find\", \"filter\", \"reject\", \"every\", \"all\", \"some\", \"any\", \"max\", \"min\",\n \"sortBy\", \"groupBy\", \"indexBy\", \"countBy\", \"partition\", \"clamp\"], function (name) {\n if (name === \"any\") {\n BI[name] = _applyFunc(\"some\");\n } else {\n BI[name] = _applyFunc(name);\n }\n });\n _.extend(BI, {\n // 数数\n count: function (from, to, predicate) {\n var t;\n if (predicate) {\n for (t = from; t < to; t++) {\n predicate(t);\n }\n }\n return to - from;\n },\n\n // 倒数\n inverse: function (from, to, predicate) {\n return BI.count(to, from, predicate);\n },\n\n firstKey: function (obj) {\n var res = undefined;\n BI.any(obj, function (key, value) {\n res = key;\n return true;\n });\n return res;\n },\n\n lastKey: function (obj) {\n var res = undefined;\n BI.each(obj, function (key, value) {\n res = key;\n return true;\n });\n return res;\n },\n\n firstObject: function (obj) {\n var res = undefined;\n BI.any(obj, function (key, value) {\n res = value;\n return true;\n });\n return res;\n },\n\n lastObject: function (obj) {\n var res = undefined;\n BI.each(obj, function (key, value) {\n res = value;\n return true;\n });\n return res;\n },\n\n concat: function (obj1, obj2) {\n if (BI.isKey(obj1)) {\n return obj1 + \"\" + obj2;\n }\n if (BI.isArray(obj1)) {\n return obj1.concat(obj2);\n }\n if (BI.isObject(obj1)) {\n return _.extend({}, obj1, obj2);\n }\n },\n\n backEach: function (obj, predicate, context) {\n predicate = BI.iteratee(predicate, context);\n for (var index = obj.length - 1; index >= 0; index--) {\n predicate(index, obj[index], obj);\n }\n return false;\n },\n\n backAny: function (obj, predicate, context) {\n predicate = BI.iteratee(predicate, context);\n for (var index = obj.length - 1; index >= 0; index--) {\n if (predicate(index, obj[index], obj)) {\n return true;\n }\n }\n return false;\n },\n\n backEvery: function (obj, predicate, context) {\n predicate = BI.iteratee(predicate, context);\n for (var index = obj.length - 1; index >= 0; index--) {\n if (!predicate(index, obj[index], obj)) {\n return false;\n }\n }\n return true;\n },\n\n backFindKey: function (obj, predicate, context) {\n predicate = BI.iteratee(predicate, context);\n var keys = _.keys(obj), key;\n for (var i = keys.length - 1; i >= 0; i--) {\n key = keys[i];\n if (predicate(obj[key], key, obj)) {\n return key;\n }\n }\n },\n\n backFind: function (obj, predicate, context) {\n var key;\n if (BI.isArray(obj)) {\n key = BI.findLastIndex(obj, predicate, context);\n } else {\n key = BI.backFindKey(obj, predicate, context);\n }\n if (key !== void 0 && key !== -1) {\n return obj[key];\n }\n },\n\n remove: function (obj, target, context) {\n var isFunction = BI.isFunction(target);\n target = isFunction || BI.isArray(target) ? target : [target];\n var i;\n if (BI.isArray(obj)) {\n for (i = 0; i < obj.length; i++) {\n if ((isFunction && target.apply(context, [i, obj[i]]) === true) || (!isFunction && BI.contains(target, obj[i]))) {\n obj.splice(i--, 1);\n }\n }\n } else {\n BI.each(obj, function (i, v) {\n if ((isFunction && target.apply(context, [i, obj[i]]) === true) || (!isFunction && BI.contains(target, obj[i]))) {\n delete obj[i];\n }\n });\n }\n },\n\n removeAt: function (obj, index) {\n index = BI.isArray(index) ? index : [index];\n var isArray = BI.isArray(obj), i;\n for (i = 0; i < index.length; i++) {\n if (isArray) {\n obj[index[i]] = \"$deleteIndex\";\n } else {\n delete obj[index[i]];\n }\n }\n if (isArray) {\n BI.remove(obj, \"$deleteIndex\");\n }\n },\n\n string2Array: function (str) {\n return str.split(\"&-&\");\n },\n\n array2String: function (array) {\n return array.join(\"&-&\");\n },\n\n abc2Int: function (str) {\n var idx = 0, start = \"A\", str = str.toUpperCase();\n for (var i = 0, len = str.length; i < len; ++i) {\n idx = str.charAt(i).charCodeAt(0) - start.charCodeAt(0) + 26 * idx + 1;\n if (idx > (2147483646 - str.charAt(i).charCodeAt(0) + start.charCodeAt(0)) / 26) {\n return 0;\n }\n }\n return idx;\n },\n\n int2Abc: function (num) {\n var DIGITS = [\"A\", \"B\", \"C\", \"D\", \"E\", \"F\", \"G\", \"H\", \"I\", \"J\", \"K\", \"L\", \"M\", \"N\", \"O\", \"P\", \"Q\", \"R\", \"S\", \"T\", \"U\", \"V\", \"W\", \"X\", \"Y\", \"Z\"];\n var idx = num, str = \"\";\n if (num === 0) {\n return \"\";\n }\n while (idx !== 0) {\n var t = idx % 26;\n if (t === 0) {\n t = 26;\n }\n str = DIGITS[t - 1] + str;\n idx = (idx - t) / 26;\n }\n return str;\n }\n });\n\n // 数组相关的方法\n _.each([\"first\", \"initial\", \"last\", \"rest\", \"compact\", \"flatten\", \"without\", \"union\", \"intersection\",\n \"difference\", \"zip\", \"unzip\", \"object\", \"indexOf\", \"lastIndexOf\", \"sortedIndex\", \"range\", \"take\", \"takeRight\", \"uniqBy\"], function (name) {\n BI[name] = _apply(name);\n });\n _.each([\"findIndex\", \"findLastIndex\"], function (name) {\n BI[name] = _applyFunc(name);\n });\n _.extend(BI, {\n // 构建一个长度为length的数组\n makeArray: function (length, value) {\n var res = [];\n for (var i = 0; i < length; i++) {\n if (BI.isNull(value)) {\n res.push(i);\n } else {\n res.push(BI.deepClone(value));\n }\n }\n return res;\n },\n\n makeObject: function (array, value) {\n var map = {};\n for (var i = 0; i < array.length; i++) {\n if (BI.isNull(value)) {\n map[array[i]] = array[i];\n } else {\n map[array[i]] = BI.deepClone(value);\n }\n }\n return map;\n },\n\n makeArrayByArray: function (array, value) {\n var res = [];\n if (!array) {\n return res;\n }\n for (var i = 0, len = array.length; i < len; i++) {\n if (BI.isArray(array[i])) {\n res.push(arguments.callee(array[i], value));\n } else {\n res.push(BI.deepClone(value));\n }\n }\n return res;\n },\n\n uniq: function (array, isSorted, iteratee, context) {\n if (array == null) {\n return [];\n }\n if (!_.isBoolean(isSorted)) {\n context = iteratee;\n iteratee = isSorted;\n isSorted = false;\n }\n iteratee && (iteratee = traverse(iteratee, context));\n return _.uniq.call(_, array, isSorted, iteratee, context);\n }\n });\n\n // 对象相关方法\n _.each([\"keys\", \"allKeys\", \"values\", \"pairs\", \"invert\", \"create\", \"functions\", \"extend\", \"extendOwn\",\n \"defaults\", \"clone\", \"property\", \"propertyOf\", \"matcher\", \"isEqual\", \"isMatch\", \"isEmpty\",\n \"isElement\", \"isNumber\", \"isString\", \"isArray\", \"isObject\", \"isPlainObject\", \"isArguments\", \"isFunction\", \"isFinite\",\n \"isBoolean\", \"isDate\", \"isRegExp\", \"isError\", \"isNaN\", \"isUndefined\", \"zipObject\", \"cloneDeep\"], function (name) {\n BI[name] = _apply(name);\n });\n _.each([\"mapObject\", \"findKey\", \"pick\", \"omit\", \"tap\"], function (name) {\n BI[name] = _applyFunc(name);\n });\n _.extend(BI, {\n\n inherit: function (sb, sp, overrides) {\n if (typeof sp === \"object\") {\n overrides = sp;\n sp = sb;\n sb = function () {\n return sp.apply(this, arguments);\n };\n }\n var F = function () {\n }, spp = sp.prototype;\n F.prototype = spp;\n sb.prototype = new F();\n sb.superclass = spp;\n _.extend(sb.prototype, overrides, {\n superclass: sp\n });\n return sb;\n },\n\n init: function () {\n // 先把准备环境准备好\n while (BI.prepares && BI.prepares.length > 0) {\n BI.prepares.shift()();\n }\n BI.initialized = true;\n },\n\n has: function (obj, keys) {\n if (BI.isArray(keys)) {\n if (keys.length === 0) {\n return false;\n }\n return BI.every(keys, function (i, key) {\n return _.has(obj, key);\n });\n }\n return _.has.apply(_, arguments);\n },\n\n freeze: function (value) {\n // 在ES5中，如果这个方法的参数不是一个对象（一个原始值），那么它会导致 TypeError\n // 在ES2015中，非对象参数将被视为要被冻结的普通对象，并被简单地返回\n if (Object.freeze && BI.isObject(value)) {\n return Object.freeze(value);\n }\n return value;\n },\n\n // 数字和字符串可以作为key\n isKey: function (key) {\n return BI.isNumber(key) || (BI.isString(key) && key.length > 0);\n },\n\n // 忽略大小写的等于\n isCapitalEqual: function (a, b) {\n a = BI.isNull(a) ? a : (\"\" + a).toLowerCase();\n b = BI.isNull(b) ? b : (\"\" + b).toLowerCase();\n return BI.isEqual(a, b);\n },\n\n isWidthOrHeight: function (w) {\n if (typeof w === \"number\") {\n return w >= 0;\n } else if (typeof w === \"string\") {\n return /^\\d{1,3}%$/.exec(w) || w == \"auto\" || /^\\d+px$/.exec(w);\n }\n },\n\n isNotNull: function (obj) {\n return !BI.isNull(obj);\n },\n\n isNull: function (obj) {\n return typeof obj === \"undefined\" || obj === null;\n },\n\n isEmptyArray: function (arr) {\n return BI.isArray(arr) && BI.isEmpty(arr);\n },\n\n isNotEmptyArray: function (arr) {\n return BI.isArray(arr) && !BI.isEmpty(arr);\n },\n\n isEmptyObject: function (obj) {\n return BI.isEqual(obj, {});\n },\n\n isNotEmptyObject: function (obj) {\n return BI.isPlainObject(obj) && !BI.isEmptyObject(obj);\n },\n\n isEmptyString: function (obj) {\n return BI.isString(obj) && obj.length === 0;\n },\n\n isNotEmptyString: function (obj) {\n return BI.isString(obj) && !BI.isEmptyString(obj);\n },\n\n isWindow: function (obj) {\n return obj != null && obj == obj.window;\n }\n });\n\n // deep方法\n _.extend(BI, {\n deepClone: _.cloneDeep,\n deepExtend: _.merge,\n\n isDeepMatch: function (object, attrs) {\n var keys = BI.keys(attrs), length = keys.length;\n if (object == null) {\n return !length;\n }\n var obj = Object(object);\n for (var i = 0; i < length; i++) {\n var key = keys[i];\n if (!BI.isEqual(attrs[key], obj[key]) || !(key in obj)) {\n return false;\n }\n }\n return true;\n },\n\n contains: function (obj, target, fromIndex) {\n if (!_.isArrayLike(obj)) obj = _.values(obj);\n return _.indexOf(obj, target, typeof fromIndex === \"number\" && fromIndex) >= 0;\n },\n\n deepContains: function (obj, copy) {\n if (BI.isObject(copy)) {\n return BI.any(obj, function (i, v) {\n if (BI.isEqual(v, copy)) {\n return true;\n }\n });\n }\n return BI.contains(obj, copy);\n },\n\n deepIndexOf: function (obj, target) {\n for (var i = 0; i < obj.length; i++) {\n if (BI.isEqual(target, obj[i])) {\n return i;\n }\n }\n return -1;\n },\n\n deepRemove: function (obj, target) {\n var done = false;\n var i;\n if (BI.isArray(obj)) {\n for (i = 0; i < obj.length; i++) {\n if (BI.isEqual(target, obj[i])) {\n obj.splice(i--, 1);\n done = true;\n }\n }\n } else {\n BI.each(obj, function (i, v) {\n if (BI.isEqual(target, obj[i])) {\n delete obj[i];\n done = true;\n }\n });\n }\n return done;\n },\n\n deepWithout: function (obj, target) {\n if (BI.isArray(obj)) {\n var result = [];\n for (var i = 0; i < obj.length; i++) {\n if (!BI.isEqual(target, obj[i])) {\n result.push(obj[i]);\n }\n }\n return result;\n }\n var result = {};\n BI.each(obj, function (i, v) {\n if (!BI.isEqual(target, obj[i])) {\n result[i] = v;\n }\n });\n return result;\n\n },\n\n deepUnique: function (array) {\n var result = [];\n BI.each(array, function (i, item) {\n if (!BI.deepContains(result, item)) {\n result.push(item);\n }\n });\n return result;\n },\n\n // 比较两个对象得出不一样的key值\n deepDiff: function (object, other) {\n object || (object = {});\n other || (other = {});\n var result = [];\n var used = [];\n for (var b in object) {\n if (this.has(object, b)) {\n if (!this.isEqual(object[b], other[b])) {\n result.push(b);\n }\n used.push(b);\n }\n }\n for (var b in other) {\n if (this.has(other, b) && !BI.contains(used, b)) {\n result.push(b);\n }\n }\n return result;\n }\n });\n\n // 通用方法\n _.each([\"uniqueId\", \"result\", \"chain\", \"iteratee\", \"escape\", \"unescape\"], function (name) {\n BI[name] = function () {\n return _[name].apply(_, arguments);\n };\n });\n\n // 事件相关方法\n _.each([\"bind\", \"once\", \"partial\", \"debounce\", \"throttle\", \"delay\", \"defer\", \"wrap\"], function (name) {\n BI[name] = function () {\n return _[name].apply(_, arguments);\n };\n });\n\n _.extend(BI, {\n nextTick: (function () {\n var callbacks = [];\n var pending = false;\n var timerFunc;\n\n function nextTickHandler () {\n pending = false;\n var copies = callbacks.slice(0);\n callbacks = [];\n for (var i = 0; i < copies.length; i++) {\n copies[i]();\n }\n }\n\n if (typeof Promise !== \"undefined\") {\n var p = Promise.resolve();\n timerFunc = function () {\n p.then(nextTickHandler);\n };\n } else\n\n /* istanbul ignore if */\n if (typeof MutationObserver !== \"undefined\") {\n var counter = 1;\n var observer = new MutationObserver(nextTickHandler);\n var textNode = document.createTextNode(counter + \"\");\n observer.observe(textNode, {\n characterData: true\n });\n timerFunc = function () {\n counter = (counter + 1) % 2;\n textNode.data = counter + \"\";\n };\n } else {\n timerFunc = function () {\n setTimeout(nextTickHandler, 0);\n };\n }\n return function queueNextTick (cb) {\n var _resolve;\n var args = [].slice.call(arguments, 1);\n callbacks.push(function () {\n if (cb) {\n cb.apply(null, args);\n }\n if (_resolve) {\n _resolve.apply(null, args);\n }\n });\n if (!pending) {\n pending = true;\n timerFunc();\n }\n if (!cb && typeof Promise !== \"undefined\") {\n return new Promise(function (resolve) {\n _resolve = resolve;\n });\n }\n };\n })()\n });\n\n // 数字相关方法\n _.each([\"random\"], function (name) {\n BI[name] = _apply(name);\n });\n _.extend(BI, {\n getTime: function () {\n if (_global.performance && _global.performance.now) {\n return _global.performance.now();\n }\n if (_global.performance && _global.performance.webkitNow) {\n return _global.performance.webkitNow();\n }\n if (Date.now) {\n return Date.now();\n }\n return BI.getDate().getTime();\n\n\n },\n\n parseInt: function (number) {\n var radix = 10;\n if (/^0x/g.test(number)) {\n radix = 16;\n }\n try {\n return parseInt(number, radix);\n } catch (e) {\n throw new Error(number + \"parse int error\");\n return NaN;\n }\n },\n\n parseSafeInt: function (value) {\n var MAX_SAFE_INTEGER = 9007199254740991;\n return value\n ? this.clamp(this.parseInt(value), -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER)\n : (value === 0 ? value : 0);\n },\n\n parseFloat: function (number) {\n try {\n return parseFloat(number);\n } catch (e) {\n throw new Error(number + \"parse float error\");\n return NaN;\n }\n },\n\n isNaturalNumber: function (number) {\n if (/^\\d+$/.test(number)) {\n return true;\n }\n return false;\n },\n\n isPositiveInteger: function (number) {\n if (/^\\+?[1-9][0-9]*$/.test(number)) {\n return true;\n }\n return false;\n },\n\n isNegativeInteger: function (number) {\n if (/^\\-[1-9][0-9]*$/.test(number)) {\n return true;\n }\n return false;\n },\n\n isInteger: function (number) {\n if (/^\\-?\\d+$/.test(number)) {\n return true;\n }\n return false;\n },\n\n isNumeric: function (number) {\n return !isNaN(parseFloat(number)) && isFinite(number);\n },\n\n isFloat: function (number) {\n if (/^([+-]?)\\\\d*\\\\.\\\\d+$/.test(number)) {\n return true;\n }\n return false;\n },\n\n isOdd: function (number) {\n if (!BI.isInteger(number)) {\n return false;\n }\n return (number & 1) === 1;\n },\n\n isEven: function (number) {\n if (!BI.isInteger(number)) {\n return false;\n }\n return (number & 1) === 0;\n },\n\n sum: function (array, iteratee, context) {\n var sum = 0;\n BI.each(array, function (i, item) {\n if (iteratee) {\n sum += Number(iteratee.apply(context, [i, item]));\n } else {\n sum += Number(item);\n }\n });\n return sum;\n },\n\n average: function (array, iteratee, context) {\n var sum = BI.sum(array, iteratee, context);\n return sum / array.length;\n }\n });\n\n // 字符串相关方法\n _.extend(BI, {\n trim: function () {\n return _.trim.apply(_, arguments);\n },\n\n toUpperCase: function (string) {\n return (string + \"\").toLocaleUpperCase();\n },\n\n toLowerCase: function (string) {\n return (string + \"\").toLocaleLowerCase();\n },\n\n isEndWithBlank: function (string) {\n return /(\\s|\\u00A0)$/.test(string);\n },\n\n isLiteral: function (exp) {\n var literalValueRE = /^\\s?(true|false|-?[\\d\\.]+|'[^']*'|\"[^\"]*\")\\s?$/;\n return literalValueRE.test(exp);\n },\n\n stripQuotes: function (str) {\n var a = str.charCodeAt(0);\n var b = str.charCodeAt(str.length - 1);\n return a === b && (a === 0x22 || a === 0x27)\n ? str.slice(1, -1)\n : str;\n },\n\n // background-color => backgroundColor\n camelize: function (str) {\n return str.replace(/-(.)/g, function (_, character) {\n return character.toUpperCase();\n });\n },\n\n // backgroundColor => background-color\n hyphenate: function (str) {\n return str.replace(/([A-Z])/g, \"-$1\").toLowerCase();\n },\n\n isNotEmptyString: function (str) {\n return BI.isString(str) && !BI.isEmpty(str);\n },\n\n isEmptyString: function (str) {\n return BI.isString(str) && BI.isEmpty(str);\n },\n\n /**\n * 通用加密方法\n */\n encrypt: function (type, text, key) {\n switch (type) {\n case BI.CRYPT_TYPE.AES:\n default:\n return BI.aesEncrypt(text, key);\n }\n },\n\n /**\n * 对字符串中的'和\\做编码处理\n * @static\n * @param {String} string 要做编码处理的字符串\n * @return {String} 编码后的字符串\n */\n escape: function (string) {\n return string.replace(/('|\\\\)/g, \"\\\\$1\");\n },\n\n /**\n * 让字符串通过指定字符做补齐的函数\n *\n * var s = BI.leftPad('123', 5, '0');//s的值为：'00123'\n *\n * @static\n * @param {String} val 原始值\n * @param {Number} size 总共需要的位数\n * @param {String} ch 用于补齐的字符\n * @return {String} 补齐后的字符串\n */\n leftPad: function (val, size, ch) {\n var result = String(val);\n if (!ch) {\n ch = \" \";\n }\n while (result.length < size) {\n result = ch + result;\n }\n return result.toString();\n },\n\n /**\n * 对字符串做替换的函数\n *\n * var cls = 'my-class', text = 'Some text';\n * var res = BI.format('<div class=\"{0}>{1}</div>\"', cls, text);\n * //res的值为：'<div class=\"my-class\">Some text</div>';\n *\n * @static\n * @param {String} format 要做替换的字符串，替换字符串1，替换字符串2...\n * @return {String} 做了替换后的字符串\n */\n format: function (format) {\n var args = Array.prototype.slice.call(arguments, 1);\n return format.replace(/\\{(\\d+)\\}/g, function (m, i) {\n return args[i];\n });\n }\n });\n\n // 日期相关方法\n _.extend(BI, {\n /**\n * 是否是闰年\n * @param year\n * @returns {boolean}\n */\n isLeapYear: function (year) {\n return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;\n },\n\n /**\n * 检测是否在有效期\n *\n * @param YY 年\n * @param MM 月\n * @param DD 日\n * @param minDate '1900-01-01'\n * @param maxDate '2099-12-31'\n * @returns {Array} 若无效返回无效状态\n */\n checkDateVoid: function (YY, MM, DD, minDate, maxDate) {\n var back = [];\n YY = YY | 0;\n MM = MM | 0;\n DD = DD | 0;\n minDate = BI.isString(minDate) ? minDate.match(/\\d+/g) : minDate;\n maxDate = BI.isString(maxDate) ? maxDate.match(/\\d+/g) : maxDate;\n if (YY < minDate[0]) {\n back = [\"y\"];\n } else if (YY > maxDate[0]) {\n back = [\"y\", 1];\n } else if (YY >= minDate[0] && YY <= maxDate[0]) {\n if (YY == minDate[0]) {\n if (MM < minDate[1]) {\n back = [\"m\"];\n } else if (MM == minDate[1]) {\n if (DD < minDate[2]) {\n back = [\"d\"];\n }\n }\n }\n if (YY == maxDate[0]) {\n if (MM > maxDate[1]) {\n back = [\"m\", 1];\n } else if (MM == maxDate[1]) {\n if (DD > maxDate[2]) {\n back = [\"d\", 1];\n }\n }\n }\n }\n return back;\n },\n\n checkDateLegal: function (str) {\n var ar = str.match(/\\d+/g);\n var YY = ar[0] | 0, MM = ar[1] | 0, DD = ar[2] | 0;\n if (ar.length <= 1) {\n return true;\n }\n if (ar.length <= 2) {\n return MM >= 1 && MM <= 12;\n }\n var MD = BI.Date._MD.slice(0);\n MD[1] = BI.isLeapYear(YY) ? 29 : 28;\n return MM >= 1 && MM <= 12 && DD <= MD[MM - 1];\n },\n\n parseDateTime: function (str, fmt) {\n var today = BI.getDate();\n var y = 0;\n var m = 0;\n var d = 1;\n // wei : 对于fmt为‘YYYYMM’或者‘YYYYMMdd’的格式，str的值为类似'201111'的形式，因为年月之间没有分隔符，所以正则表达式分割无效，导致bug7376。\n var a = str.split(/\\W+/);\n if (fmt.toLowerCase() == \"%y%x\" || fmt.toLowerCase() == \"%y%x%d\") {\n var yearlength = 4;\n var otherlength = 2;\n a[0] = str.substring(0, yearlength);\n a[1] = str.substring(yearlength, yearlength + otherlength);\n a[2] = str.substring(yearlength + otherlength, yearlength + otherlength * 2);\n }\n var b = fmt.match(/%./g);\n var i = 0, j = 0;\n var hr = 0;\n var min = 0;\n var sec = 0;\n for (i = 0; i < a.length; ++i) {\n switch (b[i]) {\n case \"%d\":\n case \"%e\":\n d = parseInt(a[i], 10);\n break;\n\n case \"%X\":\n m = parseInt(a[i], 10) - 1;\n break;\n case \"%x\":\n m = parseInt(a[i], 10) - 1;\n break;\n\n case \"%Y\":\n case \"%y\":\n y = parseInt(a[i], 10);\n (y < 100) && (y += (y > 29) ? 1900 : 2000);\n break;\n\n case \"%b\":\n case \"%B\":\n for (j = 0; j < 12; ++j) {\n if (BI.Date._MN[j].substr(0, a[i].length).toLowerCase() == a[i].toLowerCase()) {\n m = j;\n break;\n }\n }\n break;\n\n case \"%H\":\n case \"%I\":\n case \"%k\":\n case \"%l\":\n hr = parseInt(a[i], 10);\n break;\n\n case \"%P\":\n case \"%p\":\n if (/pm/i.test(a[i]) && hr < 12) {\n hr += 12;\n } else if (/am/i.test(a[i]) && hr >= 12) {\n hr -= 12;\n }\n break;\n\n case \"%M\":\n min = parseInt(a[i], 10);\n case \"%S\":\n sec = parseInt(a[i], 10);\n break;\n }\n }\n // if (!a[i]) {\n // continue;\n //\t}\n if (isNaN(y)) {\n y = today.getFullYear();\n }\n if (isNaN(m)) {\n m = today.getMonth();\n }\n if (isNaN(d)) {\n d = today.getDate();\n }\n if (isNaN(hr)) {\n hr = today.getHours();\n }\n if (isNaN(min)) {\n min = today.getMinutes();\n }\n if (isNaN(sec)) {\n sec = today.getSeconds();\n }\n if (y != 0) {\n return BI.getDate(y, m, d, hr, min, sec);\n }\n y = 0;\n m = -1;\n d = 0;\n for (i = 0; i < a.length; ++i) {\n if (a[i].search(/[a-zA-Z]+/) != -1) {\n var t = -1;\n for (j = 0; j < 12; ++j) {\n if (BI.Date._MN[j].substr(0, a[i].length).toLowerCase() == a[i].toLowerCase()) {\n t = j;\n break;\n }\n }\n if (t != -1) {\n if (m != -1) {\n d = m + 1;\n }\n m = t;\n }\n } else if (parseInt(a[i], 10) <= 12 && m == -1) {\n m = a[i] - 1;\n } else if (parseInt(a[i], 10) > 31 && y == 0) {\n y = parseInt(a[i], 10);\n (y < 100) && (y += (y > 29) ? 1900 : 2000);\n } else if (d == 0) {\n d = a[i];\n }\n }\n if (y == 0) {\n y = today.getFullYear();\n }\n if (m != -1 && d != 0) {\n return BI.getDate(y, m, d, hr, min, sec);\n }\n return today;\n },\n\n getDate: function () {\n var length = arguments.length;\n var args = arguments;\n var dt;\n switch (length) {\n // new Date()\n case 0:\n dt = new Date();\n break;\n // new Date(long)\n case 1:\n dt = new Date(args[0]);\n break;\n // new Date(year, month)\n case 2:\n dt = new Date(args[0], args[1]);\n break;\n // new Date(year, month, day)\n case 3:\n dt = new Date(args[0], args[1], args[2]);\n break;\n // new Date(year, month, day, hour)\n case 4:\n dt = new Date(args[0], args[1], args[2], args[3]);\n break;\n // new Date(year, month, day, hour, minute)\n case 5:\n dt = new Date(args[0], args[1], args[2], args[3], args[4]);\n break;\n // new Date(year, month, day, hour, minute, second)\n case 6:\n dt = new Date(args[0], args[1], args[2], args[3], args[4], args[5]);\n break;\n // new Date(year, month, day, hour, minute, second, millisecond)\n case 7:\n dt = new Date(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);\n break;\n default:\n dt = new Date();\n break;\n }\n if (BI.isNotNull(BI.timeZone) && (arguments.length === 0 || (arguments.length === 1 && BI.isNumber(arguments[0])))) {\n var localTime = dt.getTime();\n // BI-33791 1901年以前的东8区标准是GMT+0805, 统一无论是什么时间，都以整的0800这样的为基准\n var localOffset = dt.getTimezoneOffset() * 60000; // 获得当地时间偏移的毫秒数\n var utc = localTime + localOffset; // utc即GMT时间标准时区\n return new Date(utc + BI.timeZone);// + Pool.timeZone.offset);\n }\n return dt;\n\n },\n\n getTime: function () {\n var length = arguments.length;\n var args = arguments;\n var dt;\n switch (length) {\n // new Date()\n case 0:\n dt = new Date();\n break;\n // new Date(long)\n case 1:\n dt = new Date(args[0]);\n break;\n // new Date(year, month)\n case 2:\n dt = new Date(args[0], args[1]);\n break;\n // new Date(year, month, day)\n case 3:\n dt = new Date(args[0], args[1], args[2]);\n break;\n // new Date(year, month, day, hour)\n case 4:\n dt = new Date(args[0], args[1], args[2], args[3]);\n break;\n // new Date(year, month, day, hour, minute)\n case 5:\n dt = new Date(args[0], args[1], args[2], args[3], args[4]);\n break;\n // new Date(year, month, day, hour, minute, second)\n case 6:\n dt = new Date(args[0], args[1], args[2], args[3], args[4], args[5]);\n break;\n // new Date(year, month, day, hour, minute, second, millisecond)\n case 7:\n dt = new Date(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);\n break;\n default:\n dt = new Date();\n break;\n }\n if (BI.isNotNull(BI.timeZone)) {\n // BI-33791 1901年以前的东8区标准是GMT+0805, 统一无论是什么时间，都以整的0800这样的为基准\n return dt.getTime() - BI.timeZone - new Date().getTimezoneOffset() * 60000;\n }\n return dt.getTime();\n\n }\n });\n})();\n!(function () {\n function extend () {\n var target = arguments[0] || {}, length = arguments.length, i = 1, options, name, src, copy;\n for (; i < length; i++) {\n // Only deal with non-null/undefined values\n if ((options = arguments[i]) != null) {\n // Extend the base object\n for (name in options) {\n src = target[name];\n copy = options[name];\n\n // Prevent never-ending loop\n if (target === copy) {\n continue;\n }\n\n if (copy !== undefined) {\n target[name] = copy;\n }\n }\n }\n }\n return target;\n }\n\n /**\n * 客户端观察者，主要处理事件的添加、删除、执行等\n * @class BI.OB\n * @abstract\n */\n BI.OB = function (config) {\n this._constructor(config);\n };\n _.extend(BI.OB.prototype, {\n props: {},\n init: null,\n destroyed: null,\n\n _constructor: function (config) {\n this._initProps(config);\n this._init();\n this._initRef();\n },\n\n _defaultConfig: function (config) {\n return {};\n },\n\n _initProps: function (config) {\n var props = this.props;\n if (BI.isFunction(this.props)) {\n props = this.props(config);\n }\n this.options = extend(this._defaultConfig(config), props, config);\n },\n\n _init: function () {\n this._initListeners();\n this.init && this.init();\n },\n\n _initListeners: function () {\n var self = this;\n if (this.options.listeners != null) {\n _.each(this.options.listeners, function (lis) {\n (lis.target ? lis.target : self)[lis.once ? \"once\" : \"on\"]\n (lis.eventName, _.bind(lis.action, self));\n });\n delete this.options.listeners;\n }\n },\n\n // 获得一个当前对象的引用\n _initRef: function () {\n if (this.options.ref) {\n this.options.ref.call(this, this);\n }\n },\n\n //释放当前对象\n _purgeRef: function () {\n if (this.options.ref) {\n this.options.ref.call(null);\n }\n },\n\n _getEvents: function () {\n if (!_.isArray(this.events)) {\n this.events = [];\n }\n return this.events;\n },\n\n /**\n * 给观察者绑定一个事件\n * @param {String} eventName 事件的名字\n * @param {Function} fn 事件对应的执行函数\n */\n on: function (eventName, fn) {\n eventName = eventName.toLowerCase();\n var fns = this._getEvents()[eventName];\n if (!_.isArray(fns)) {\n fns = [];\n this._getEvents()[eventName] = fns;\n }\n fns.push(fn);\n },\n\n /**\n * 给观察者绑定一个只执行一次的事件\n * @param {String} eventName 事件的名字\n * @param {Function} fn 事件对应的执行函数\n */\n once: function (eventName, fn) {\n var proxy = function () {\n fn.apply(this, arguments);\n this.un(eventName, proxy);\n };\n this.on(eventName, proxy);\n },\n /**\n * 解除观察者绑定的指定事件\n * @param {String} eventName 要解除绑定事件的名字\n * @param {Function} fn 事件对应的执行函数，该参数是可选的，没有该参数时，将解除绑定所有同名字的事件\n */\n un: function (eventName, fn) {\n eventName = eventName.toLowerCase();\n\n /* alex:如果fn是null,就是把eventName上面所有方法都un掉*/\n if (fn == null) {\n delete this._getEvents()[eventName];\n } else {\n var fns = this._getEvents()[eventName];\n if (_.isArray(fns)) {\n var newFns = [];\n _.each(fns, function (ifn) {\n if (ifn != fn) {\n newFns.push(ifn);\n }\n });\n this._getEvents()[eventName] = newFns;\n }\n }\n },\n /**\n * 清除观察者的所有事件绑定\n */\n purgeListeners: function () {\n /* alex:清空events*/\n this.events = [];\n },\n /**\n * 触发绑定过的事件\n *\n * @param {String} eventName 要触发的事件的名字\n * @returns {Boolean} 如果事件函数返回false，则返回false并中断其他同名事件的执行，否则执行所有的同名事件并返回true\n */\n fireEvent: function () {\n var eventName = arguments[0].toLowerCase();\n var fns = this._getEvents()[eventName];\n if (BI.isArray(fns)) {\n if (BI.isArguments(arguments[1])) {\n for (var i = 0; i < fns.length; i++) {\n if (fns[i].apply(this, arguments[1]) === false) {\n return false;\n }\n }\n } else {\n var args = Array.prototype.slice.call(arguments, 1);\n for (var i = 0; i < fns.length; i++) {\n if (fns[i].apply(this, args) === false) {\n return false;\n }\n }\n }\n }\n return true;\n },\n\n destroy: function () {\n this.destroyed && this.destroyed();\n this._purgeRef();\n this.purgeListeners();\n }\n });\n})();(function () {\n var _global;\n if (typeof window !== \"undefined\") {\n _global = window;\n } else if (typeof global !== \"undefined\") {\n _global = global;\n } else if (typeof self !== \"undefined\") {\n _global = self;\n } else {\n _global = this;\n }\n if (!_global.BI) {\n _global.BI = {};\n }\n\n function isEmpty (value) {\n // 判断是否为空值\n var result = value === \"\" || value === null || value === undefined;\n return result;\n }\n\n // 判断是否是无效的日期\n function isInvalidDate (date) {\n return date == \"Invalid Date\" || date == \"NaN\";\n }\n\n /**\n * CHART-1400\n * 使用数值计算的方式来获取任意数值的科学技术表示值。\n * 科学计数格式\n */\n function _eFormat (text, fmt) {\n text = +text;\n\n return eFormat(text, fmt);\n\n /**\n * 科学计数格式具体计算过程\n * @param num\n * @param format {String}有两种形式，\n * 1、\"0.00E00\"这样的字符串表示正常的科学计数表示，只不过规定了数值精确到百分位，\n * 而数量级的绝对值如果是10以下的时候在前面补零。\n * 2、 \"##0.0E0\"这样的字符串则规定用科学计数法表示之后的数值的整数部分是三位，精确到十分位，\n * 数量级没有规定，因为没见过实数里有用科学计数法表示之后E的后面会小于一位的情况（0无所谓）。\n * @returns {*}\n */\n function eFormat (num, format) {\n var neg = num < 0 ? (num *= -1, \"-\") : \"\",\n magnitudeNeg = \"\";\n\n var funcName = num > 0 && num < 1 ? \"floor\" : \"ceil\"; // -0.9999->-1\n // 数量级\n var magnitude = Math[funcName](Math.log(num) / Math.log(10));\n\n if (!isFinite(magnitude)) {\n return format.replace(/#/ig, \"\").replace(/\\.e/ig, \"E\");\n }\n\n num = num / Math.pow(10, magnitude);\n\n // 让num转化成[1, 10)区间上的数\n if (num > 0 && num < 1) {\n num *= 10;\n magnitude -= 1;\n }\n\n // 计算出format中需要显示的整数部分的位数，然后更新这个数值，也更新数量级\n var integerLen = getInteger(magnitude, format);\n integerLen > 1 && (magnitude -= integerLen - 1, num *= Math.pow(10, integerLen - 1));\n\n magnitude < 0 && (magnitudeNeg = \"-\", magnitude *= -1);\n\n // 获取科学计数法精确到的位数\n var precision = getPrecision(format);\n // 判断num经过四舍五入之后是否有进位\n var isValueCarry = isValueCarried(num);\n\n num *= Math.pow(10, precision);\n num = Math.round(num);\n // 如果出现进位的情况，将num除以10\n isValueCarry && (num /= 10, magnitude += magnitudeNeg === \"-\" ? -1 : 1);\n num /= Math.pow(10, precision);\n\n // 小数部分保留precision位\n num = num.toFixed(precision);\n // 格式化指数的部分\n magnitude = formatExponential(format, magnitude, magnitudeNeg);\n\n return neg + num + \"E\" + magnitude;\n }\n\n // 获取format格式规定的数量级的形式\n function formatExponential (format, num, magnitudeNeg) {\n num += \"\";\n if (!/e/ig.test(format)) {\n return num;\n }\n format = format.split(/e/ig)[1];\n\n while (num.length < format.length) {\n num = \"0\" + num;\n }\n\n // 如果magnitudeNeg是一个\"-\"，而且num正好全是0，那么就别显示负号了\n var isAllZero = true;\n for (var i = 0, len = num.length; i < len; i++) {\n if (!isAllZero) {\n continue;\n }\n isAllZero = num.charAt(i) === \"0\";\n }\n magnitudeNeg = isAllZero ? \"\" : magnitudeNeg;\n\n return magnitudeNeg + num;\n }\n\n // 获取format规定的科学计数法精确到的位数\n function getPrecision (format) {\n if (!/e/ig.test(format)) {\n return 0;\n }\n var arr = format.split(/e/ig)[0].split(\".\");\n\n return arr.length > 1 ? arr[1].length : 0;\n }\n\n // 获取数值科学计数法表示之后整数的位数\n // 这边我们还需要考虑#和0的问题\n function getInteger (magnitude, format) {\n if (!/e/ig.test(format)) {\n return 0;\n }\n // return format.split(/e/ig)[0].split(\".\")[0].length;\n\n var formatLeft = format.split(/e/ig)[0].split(\".\")[0], i, f, len = formatLeft.length;\n var valueLeftLen = 0;\n\n for (i = 0; i < len; i++) {\n f = formatLeft.charAt(i);\n // \"#\"所在的位置到末尾长度小于等于值的整数部分长度，那么这个#才可以占位\n if (f == 0 || (f == \"#\" && (len - i <= magnitude + 1))) {\n valueLeftLen++;\n }\n }\n\n return valueLeftLen;\n }\n\n // 判断num通过round函数之后是否有进位\n function isValueCarried (num) {\n var roundNum = Math.round(num);\n num = (num + \"\").split(\".\")[0];\n roundNum = (roundNum + \"\").split(\".\")[0];\n return num.length !== roundNum.length;\n }\n }\n\n //'#.##'之类的格式处理 1.324e-18 这种的科学数字\n function _dealNumberPrecision (text, fright) {\n if (/[eE]/.test(text)) {\n var precision = 0, i = 0, ch;\n\n if (/[%‰]$/.test(fright)) {\n precision = /[%]$/.test(fright) ? 2 : 3;\n }\n\n for (var len = fright.length; i < len; i++) {\n if ((ch = fright.charAt(i)) == \"0\" || ch == \"#\") {\n precision++;\n }\n }\n return Number(text).toFixed(precision);\n }\n\n return text;\n }\n\n /**\n * 数字格式\n */\n function _numberFormat (text, format) {\n var text = text + \"\";\n\n //在调用数字格式的时候如果text里没有任何数字则不处理\n if (!(/[0-9]/.test(text)) || !format) {\n return text;\n }\n\n // 数字格式，区分正负数\n var numMod = format.indexOf(\";\");\n if (numMod > -1) {\n if (text >= 0) {\n return _numberFormat(text + \"\", format.substring(0, numMod));\n }\n return _numberFormat((-text) + \"\", format.substr(numMod + 1));\n\n } else {\n // 兼容格式处理负数的情况(copy:fr-jquery.format.js)\n if (+text < 0 && format.charAt(0) !== \"-\") {\n return _numberFormat((-text) + \"\", \"-\" + format);\n }\n }\n\n var fp = format.split(\".\"), fleft = fp[0] || \"\", fright = fp[1] || \"\";\n text = _dealNumberPrecision(text, fright);\n var tp = text.split(\".\"), tleft = tp[0] || \"\", tright = tp[1] || \"\";\n\n // 百分比,千分比的小数点移位处理\n if (/[%‰]$/.test(format)) {\n var paddingZero = /[%]$/.test(format) ? \"00\" : \"000\";\n tright += paddingZero;\n tleft += tright.substr(0, paddingZero.length);\n tleft = tleft.replace(/^0+/gi, \"\");\n tright = tright.substr(paddingZero.length).replace(/0+$/gi, \"\");\n }\n var right = _dealWithRight(tright, fright);\n if (right.leftPlus) {\n // 小数点后有进位\n tleft = parseInt(tleft) + 1 + \"\";\n\n tleft = isNaN(tleft) ? \"1\" : tleft;\n }\n right = right.num;\n var left = _dealWithLeft(tleft, fleft);\n if (!(/[0-9]/.test(left))) {\n left = left + \"0\";\n }\n if (!(/[0-9]/.test(right))) {\n return left + right;\n } else {\n return left + \".\" + right;\n }\n }\n\n /**\n * 处理小数点右边小数部分\n * @param tright 右边内容\n * @param fright 右边格式\n * @returns {JSON} 返回处理结果和整数部分是否需要进位\n * @private\n */\n function _dealWithRight (tright, fright) {\n var right = \"\", j = 0, i = 0;\n for (var len = fright.length; i < len; i++) {\n var ch = fright.charAt(i);\n var c = tright.charAt(j);\n switch (ch) {\n case \"0\":\n if (isEmpty(c)) {\n c = \"0\";\n }\n right += c;\n j++;\n break;\n case \"#\":\n right += c;\n j++;\n break;\n default :\n right += ch;\n break;\n }\n }\n var rll = tright.substr(j);\n var result = {};\n if (!isEmpty(rll) && rll.charAt(0) > 4) {\n // 有多余字符，需要四舍五入\n result.leftPlus = true;\n var numReg = right.match(/^[0-9]+/);\n if (numReg) {\n var num = numReg[0];\n var orilen = num.length;\n var newnum = parseInt(num) + 1 + \"\";\n // 进位到整数部分\n if (newnum.length > orilen) {\n newnum = newnum.substr(1);\n } else {\n newnum = BI.leftPad(newnum, orilen, \"0\");\n result.leftPlus = false;\n }\n right = right.replace(/^[0-9]+/, newnum);\n }\n }\n result.num = right;\n return result;\n }\n\n /**\n * 处理小数点左边整数部分\n * @param tleft 左边内容\n * @param fleft 左边格式\n * @returns {string} 返回处理结果\n * @private\n */\n function _dealWithLeft (tleft, fleft) {\n var left = \"\";\n var j = tleft.length - 1;\n var combo = -1, last = -1;\n var i = fleft.length - 1;\n for (; i >= 0; i--) {\n var ch = fleft.charAt(i);\n var c = tleft.charAt(j);\n switch (ch) {\n case \"0\":\n if (isEmpty(c)) {\n c = \"0\";\n }\n last = -1;\n left = c + left;\n j--;\n break;\n case \"#\":\n last = i;\n left = c + left;\n j--;\n break;\n case \",\":\n if (!isEmpty(c)) {\n // 计算一个,分隔区间的长度\n var com = fleft.match(/,[#0]+/);\n if (com) {\n combo = com[0].length - 1;\n }\n left = \",\" + left;\n }\n break;\n default :\n left = ch + left;\n break;\n }\n }\n if (last > -1) {\n // 处理剩余字符\n var tll = tleft.substr(0, j + 1);\n left = left.substr(0, last) + tll + left.substr(last);\n }\n if (combo > 0) {\n // 处理,分隔区间\n var res = left.match(/[0-9]+,/);\n if (res) {\n res = res[0];\n var newstr = \"\", n = res.length - 1 - combo;\n for (; n >= 0; n = n - combo) {\n newstr = res.substr(n, combo) + \",\" + newstr;\n }\n var lres = res.substr(0, n + combo);\n if (!isEmpty(lres)) {\n newstr = lres + \",\" + newstr;\n }\n }\n left = left.replace(/[0-9]+,/, newstr);\n }\n return left;\n }\n\n\n BI.cjkEncode = function (text) {\n // alex:如果非字符串,返回其本身(cjkEncode(234) 返回 \"\"是不对的)\n if (typeof text !== \"string\") {\n return text;\n }\n\n var newText = \"\";\n for (var i = 0; i < text.length; i++) {\n var code = text.charCodeAt(i);\n if (code >= 128 || code === 91 || code === 93) {// 91 is \"[\", 93 is \"]\".\n newText += \"[\" + code.toString(16) + \"]\";\n } else {\n newText += text.charAt(i);\n }\n }\n\n return newText;\n };\n\n /**\n * 将cjkEncode处理过的字符串转化为原始字符串\n *\n * @static\n * @param text 需要做解码的字符串\n * @return {String} 解码后的字符串\n */\n BI.cjkDecode = function (text) {\n if (text == null) {\n return \"\";\n }\n // 查找没有 \"[\", 直接返回. kunsnat:数字的时候, 不支持indexOf方法, 也是直接返回.\n if (!isNaN(text) || text.indexOf(\"[\") == -1) {\n return text;\n }\n\n var newText = \"\";\n for (var i = 0; i < text.length; i++) {\n var ch = text.charAt(i);\n if (ch == \"[\") {\n var rightIdx = text.indexOf(\"]\", i + 1);\n if (rightIdx > i + 1) {\n var subText = text.substring(i + 1, rightIdx);\n // james：主要是考虑[CDATA[]]这样的值的出现\n if (subText.length > 0) {\n ch = String.fromCharCode(eval(\"0x\" + subText));\n }\n\n i = rightIdx;\n }\n }\n\n newText += ch;\n }\n\n return newText;\n };\n\n // replace the html special tags\n var SPECIAL_TAGS = {\n \"&\": \"&\",\n \"\\\"\": \""\",\n \"<\": \"<\",\n \">\": \">\",\n \" \": \" \"\n };\n BI.htmlEncode = function (text) {\n return BI.isNull(text) ? \"\" : BI.replaceAll(text + \"\", \"&|\\\"|<|>|\\\\s\", function (v) {\n return SPECIAL_TAGS[v] ? SPECIAL_TAGS[v] : \" \";\n });\n };\n // html decode\n BI.htmlDecode = function (text) {\n return BI.isNull(text) ? \"\" : BI.replaceAll(text + \"\", \"&|"|<|>| \", function (v) {\n switch (v) {\n case \"&\":\n return \"&\";\n case \""\":\n return \"\\\"\";\n case \"<\":\n return \"<\";\n case \">\":\n return \">\";\n case \" \":\n default:\n return \" \";\n }\n });\n };\n\n BI.cjkEncodeDO = function (o) {\n if (BI.isPlainObject(o)) {\n var result = {};\n _.each(o, function (v, k) {\n if (!(typeof v === \"string\")) {\n v = BI.jsonEncode(v);\n }\n // wei:bug 43338，如果key是中文，cjkencode后o的长度就加了1，ie9以下版本死循环，所以新建对象result。\n k = BI.cjkEncode(k);\n result[k] = BI.cjkEncode(v);\n });\n return result;\n }\n return o;\n };\n\n BI.jsonEncode = function (o) {\n // james:这个Encode是抄的EXT的\n var useHasOwn = !!{}.hasOwnProperty;\n\n // crashes Safari in some instances\n // var validRE = /^(\"(\\\\.|[^\"\\\\\\n\\r])*?\"|[,:{}\\[\\]0-9.\\-+Eaeflnr-u \\n\\r\\t])+?$/;\n\n var m = {\n \"\\b\": \"\\\\b\",\n \"\\t\": \"\\\\t\",\n \"\\n\": \"\\\\n\",\n \"\\f\": \"\\\\f\",\n \"\\r\": \"\\\\r\",\n \"\\\"\": \"\\\\\\\"\",\n \"\\\\\": \"\\\\\\\\\"\n };\n\n var encodeString = function (s) {\n if (/[\"\\\\\\x00-\\x1f]/.test(s)) {\n return \"\\\"\" + s.replace(/([\\x00-\\x1f\\\\\"])/g, function (a, b) {\n var c = m[b];\n if (c) {\n return c;\n }\n c = b.charCodeAt();\n return \"\\\\u00\" +\n Math.floor(c / 16).toString(16) +\n (c % 16).toString(16);\n }) + \"\\\"\";\n }\n return \"\\\"\" + s + \"\\\"\";\n };\n\n var encodeArray = function (o) {\n var a = [\"[\"], b, i, l = o.length, v;\n for (i = 0; i < l; i += 1) {\n v = o[i];\n switch (typeof v) {\n case \"undefined\":\n case \"function\":\n case \"unknown\":\n break;\n default:\n if (b) {\n a.push(\",\");\n }\n a.push(v === null ? \"null\" : BI.jsonEncode(v));\n b = true;\n }\n }\n a.push(\"]\");\n return a.join(\"\");\n };\n\n if (typeof o === \"undefined\" || o === null) {\n return \"null\";\n } else if (BI.isArray(o)) {\n return encodeArray(o);\n } else if (o instanceof Date) {\n /*\n * alex:原来只是把年月日时分秒简单地拼成一个String,无法decode\n * 现在这么处理就可以decode了,但是JS.jsonDecode和Java.JSONObject也要跟着改一下\n */\n return BI.jsonEncode({\n __time__: o.getTime()\n });\n } else if (typeof o === \"string\") {\n return encodeString(o);\n } else if (typeof o === \"number\") {\n return isFinite(o) ? String(o) : \"null\";\n } else if (typeof o === \"boolean\") {\n return String(o);\n } else if (BI.isFunction(o)) {\n return String(o);\n }\n var a = [\"{\"], b, i, v;\n for (i in o) {\n if (!useHasOwn || o.hasOwnProperty(i)) {\n v = o[i];\n switch (typeof v) {\n case \"undefined\":\n case \"unknown\":\n break;\n default:\n if (b) {\n a.push(\",\");\n }\n a.push(BI.jsonEncode(i), \":\",\n v === null ? \"null\" : BI.jsonEncode(v));\n b = true;\n }\n }\n }\n a.push(\"}\");\n return a.join(\"\");\n\n };\n\n BI.jsonDecode = function (text) {\n\n try {\n // 注意0啊\n // var jo = $.parseJSON(text) || {};\n var jo = BI.$ ? BI.$.parseJSON(text) : _global.JSON.parse(text);\n if (jo == null) {\n jo = {};\n }\n } catch (e) {\n /*\n * richie:浏览器只支持标准的JSON字符串转换，而jQuery会默认调用浏览器的window.JSON.parse()函数进行解析\n * 比如：var str = \"{'a':'b'}\",这种形式的字符串转换为JSON就会抛异常\n */\n try {\n jo = new Function(\"return \" + text)() || {};\n } catch (e) {\n // do nothing\n }\n if (jo == null) {\n jo = [];\n }\n }\n if (!_hasDateInJson(text)) {\n return jo;\n }\n\n function _hasDateInJson (json) {\n if (!json || typeof json !== \"string\") {\n return false;\n }\n return json.indexOf(\"__time__\") != -1;\n }\n\n return (function (o) {\n if (typeof o === \"string\") {\n return o;\n }\n if (o && o.__time__ != null) {\n return new Date(o.__time__);\n }\n for (var a in o) {\n if (o[a] == o || typeof o[a] === \"object\" || _.isFunction(o[a])) {\n break;\n }\n o[a] = arguments.callee(o[a]);\n }\n\n return o;\n })(jo);\n };\n\n /**\n * 获取编码后的url\n * @param urlTemplate url模板\n * @param param 参数\n * @returns {*|String}\n * @example\n * BI.getEncodeURL(\"design/{tableName}/{fieldName}\",{tableName: \"A\", fieldName: \"a\"}) // design/A/a\n */\n BI.getEncodeURL = function (urlTemplate, param) {\n return urlTemplate.replaceAll(\"\\\\{(.*?)\\\\}\", function (ori, str) {\n return BI.encodeURIComponent(BI.isObject(param) ? param[str] : param);\n });\n };\n\n BI.encodeURIComponent = function (url) {\n BI.specialCharsMap = BI.specialCharsMap || {};\n url = url || \"\";\n url = BI.replaceAll(url + \"\", BI.keys(BI.specialCharsMap || []).join(\"|\"), function (str) {\n switch (str) {\n case \"\\\\\":\n return BI.specialCharsMap[\"\\\\\\\\\"] || str;\n default:\n return BI.specialCharsMap[str] || str;\n }\n });\n return _global.encodeURIComponent(url);\n };\n\n BI.decodeURIComponent = function (url) {\n var reserveSpecialCharsMap = {};\n BI.each(BI.specialCharsMap, function (initialChar, encodeChar) {\n reserveSpecialCharsMap[encodeChar] = initialChar === \"\\\\\\\\\" ? \"\\\\\" : initialChar;\n });\n url = url || \"\";\n url = BI.replaceAll(url + \"\", BI.keys(reserveSpecialCharsMap || []).join(\"|\"), function (str) {\n return reserveSpecialCharsMap[str] || str;\n });\n return _global.decodeURIComponent(url);\n };\n\n BI.contentFormat = function (cv, fmt) {\n if (isEmpty(cv)) {\n // 原值为空，返回空字符\n return \"\";\n }\n var text = cv.toString();\n if (isEmpty(fmt)) {\n // 格式为空，返回原字符\n return text;\n }\n if (fmt.match(/^T/)) {\n // T - 文本格式\n return text;\n } else if (fmt.match(/^D/)) {\n // D - 日期(时间)格式\n if (!(cv instanceof Date)) {\n if (typeof cv === \"number\") {\n // 毫秒数类型\n cv = new Date(cv);\n } else {\n //字符串类型转化为date类型\n cv = new Date(Date.parse((\"\" + cv).replace(/-|\\./g, \"/\")));\n }\n }\n if (!isInvalidDate(cv) && !BI.isNull(cv)) {\n var needTrim = fmt.match(/^DT/);\n text = BI.date2Str(cv, fmt.substring(needTrim ? 2 : 1));\n }\n } else if (fmt.match(/E/)) {\n // 科学计数格式\n text = _eFormat(text, fmt);\n } else {\n // 数字格式\n text = _numberFormat(text, fmt);\n }\n // ¤ - 货币格式\n text = text.replace(/¤/g, \"￥\");\n return text;\n };\n\n /**\n * 将Java提供的日期格式字符串装换为JS识别的日期格式字符串\n * @class FR.parseFmt\n * @param fmt 日期格式\n * @returns {String}\n */\n BI.parseFmt = function (fmt) {\n if (!fmt) {\n return \"\";\n }\n //日期\n fmt = String(fmt)\n //年\n .replace(/y{4,}/g, \"%Y\")//yyyy的时候替换为Y\n .replace(/y{2}/g, \"%y\")//yy的时候替换为y\n //月\n .replace(/M{4,}/g, \"%b\")//MMMM的时候替换为b，八\n .replace(/M{3}/g, \"%B\")//MMM的时候替换为M，八月\n .replace(/M{2}/g, \"%X\")//MM的时候替换为X，08\n .replace(/M{1}/g, \"%x\")//M的时候替换为x，8\n .replace(/a{1}/g, \"%p\");\n //天\n if (new RegExp(\"d{2,}\", \"g\").test(fmt)) {\n fmt = fmt.replace(/d{2,}/g, \"%d\");//dd的时候替换为d\n } else {\n fmt = fmt.replace(/d{1}/g, \"%e\");//d的时候替换为j\n }\n //时\n if (new RegExp(\"h{2,}\", \"g\").test(fmt)) {//12小时制\n fmt = fmt.replace(/h{2,}/g, \"%I\");\n } else {\n fmt = fmt.replace(/h{1}/g, \"%I\");\n }\n if (new RegExp(\"H{2,}\", \"g\").test(fmt)) {//24小时制\n fmt = fmt.replace(/H{2,}/g, \"%H\");\n } else {\n fmt = fmt.replace(/H{1}/g, \"%H\");\n }\n fmt = fmt.replace(/m{2,}/g, \"%M\")//分\n //秒\n .replace(/s{2,}/g, \"%S\");\n\n return fmt;\n };\n\n /**\n * 把字符串按照对应的格式转化成日期对象\n *\n * @example\n * var result = BI.str2Date('2013-12-12', 'yyyy-MM-dd');//Thu Dec 12 2013 00:00:00 GMT+0800\n *\n * @class BI.str2Date\n * @param str 字符串\n * @param format 日期格式\n * @returns {*}\n */\n BI.str2Date = function (str, format) {\n if (typeof str != \"string\" || typeof format != \"string\") {\n return null;\n }\n var fmt = BI.parseFmt(format);\n return BI.parseDateTime(str, fmt);\n };\n\n /**\n * 把日期对象按照指定格式转化成字符串\n *\n * @example\n * var date = new Date('Thu Dec 12 2013 00:00:00 GMT+0800');\n * var result = BI.date2Str(date, 'yyyy-MM-dd');//2013-12-12\n *\n * @class BI.date2Str\n * @param date 日期\n * @param format 日期格式\n * @returns {String}\n */\n BI.date2Str = function (date, format) {\n if (!date) {\n return \"\";\n }\n // O(len(format))\n var len = format.length, result = \"\";\n if (len > 0) {\n var flagch = format.charAt(0), start = 0, str = flagch;\n for (var i = 1; i < len; i++) {\n var ch = format.charAt(i);\n if (flagch !== ch) {\n result += compileJFmt({\n char: flagch,\n str: str,\n len: i - start\n }, date);\n flagch = ch;\n start = i;\n str = flagch;\n } else {\n str += ch;\n }\n }\n result += compileJFmt({\n char: flagch,\n str: str,\n len: len - start\n }, date);\n }\n return result;\n\n function compileJFmt (jfmt, date) {\n var str = jfmt.str, len = jfmt.len, ch = jfmt[\"char\"];\n switch (ch) {\n case \"E\": // 星期\n str = BI.Date._DN[date.getDay()];\n break;\n case \"y\": // 年\n if (len <= 3) {\n str = (date.getFullYear() + \"\").slice(2, 4);\n } else {\n str = date.getFullYear();\n }\n break;\n case \"M\": // 月\n if (len > 2) {\n str = BI.Date._MN[date.getMonth()];\n } else if (len < 2) {\n str = date.getMonth() + 1;\n } else {\n str = BI.leftPad(date.getMonth() + 1 + \"\", 2, \"0\");\n }\n break;\n case \"d\": // 日\n if (len > 1) {\n str = BI.leftPad(date.getDate() + \"\", 2, \"0\");\n } else {\n str = date.getDate();\n }\n break;\n case \"h\": // 时(12)\n var hour = date.getHours() % 12;\n if (hour === 0) {\n hour = 12;\n }\n if (len > 1) {\n str = BI.leftPad(hour + \"\", 2, \"0\");\n } else {\n str = hour;\n }\n break;\n case \"H\": // 时(24)\n if (len > 1) {\n str = BI.leftPad(date.getHours() + \"\", 2, \"0\");\n } else {\n str = date.getHours();\n }\n break;\n case \"m\":\n if (len > 1) {\n str = BI.leftPad(date.getMinutes() + \"\", 2, \"0\");\n } else {\n str = date.getMinutes();\n }\n break;\n case \"s\":\n if (len > 1) {\n str = BI.leftPad(date.getSeconds() + \"\", 2, \"0\");\n } else {\n str = date.getSeconds();\n }\n break;\n case \"a\":\n str = date.getHours() < 12 ? \"am\" : \"pm\";\n break;\n case \"z\":\n str = BI.getTimezone(date);\n break;\n default:\n str = jfmt.str;\n break;\n }\n return str;\n }\n };\n\n BI.object2Number = function (value) {\n if (value == null) {\n return 0;\n }\n if (typeof value === \"number\") {\n return value;\n }\n var str = value + \"\";\n if (str.indexOf(\".\") === -1) {\n return parseInt(str);\n }\n return parseFloat(str);\n };\n\n BI.object2Date = function (obj) {\n if (obj == null) {\n return new Date();\n }\n if (obj instanceof Date) {\n return obj;\n } else if (typeof obj === \"number\") {\n return new Date(obj);\n }\n var str = obj + \"\";\n str = str.replace(/-/g, \"/\");\n var dt = new Date(str);\n if (!isInvalidDate(dt)) {\n return dt;\n }\n\n return new Date();\n\n };\n\n BI.object2Time = function (obj) {\n if (obj == null) {\n return new Date();\n }\n if (obj instanceof Date) {\n return obj;\n }\n var str = obj + \"\";\n str = str.replace(/-/g, \"/\");\n var dt = new Date(str);\n if (!isInvalidDate(dt)) {\n return dt;\n }\n if (str.indexOf(\"/\") === -1 && str.indexOf(\":\") !== -1) {\n dt = new Date(\"1970/01/01 \" + str);\n if (!isInvalidDate(dt)) {\n return dt;\n }\n }\n dt = BI.parseDateTime(str, \"HH:mm:ss\");\n if (!isInvalidDate(dt)) {\n return dt;\n }\n return new Date();\n\n };\n})();\n(function () {\n var moduleInjection = {};\n BI.module = function (xtype, cls) {\n if (moduleInjection[xtype] != null) {\n _global.console && console.error(\"module:[\" + xtype + \"] has been registed\");\n }\n moduleInjection[xtype] = cls;\n };\n\n var constantInjection = {};\n BI.constant = function (xtype, cls) {\n if (constantInjection[xtype] != null) {\n _global.console && console.error(\"constant:[\" + xtype + \"] has been registed\");\n }\n constantInjection[xtype] = cls;\n };\n\n var modelInjection = {};\n BI.model = function (xtype, cls) {\n if (modelInjection[xtype] != null) {\n _global.console && console.error(\"model:[\" + xtype + \"] has been registed\");\n }\n modelInjection[xtype] = cls;\n };\n\n var storeInjection = {};\n BI.store = function (xtype, cls) {\n if (storeInjection[xtype] != null) {\n _global.console && console.error(\"store:[\" + xtype + \"] has been registed\");\n }\n storeInjection[xtype] = cls;\n };\n\n var serviceInjection = {};\n BI.service = function (xtype, cls) {\n if (serviceInjection[xtype] != null) {\n _global.console && console.error(\"service:[\" + xtype + \"] has been registed\");\n }\n serviceInjection[xtype] = cls;\n };\n\n var providerInjection = {};\n BI.provider = function (xtype, cls) {\n if (providerInjection[xtype] != null) {\n _global.console && console.error(\"provider:[\" + xtype + \"] has been registed\");\n }\n providerInjection[xtype] = cls;\n };\n\n var configFunctions = {};\n BI.config = function (type, configFn) {\n if (BI.initialized) {\n if (constantInjection[type]) {\n return (constantInjection[type] = configFn(constantInjection[type]));\n }\n if (providerInjection[type]) {\n if (!providers[type]) {\n providers[type] = new providerInjection[type]();\n }\n return configFn(providers[type]);\n }\n return BI.Plugin.configWidget(type, configFn);\n }\n if (!configFunctions[type]) {\n configFunctions[type] = [];\n BI.prepares.push(function () {\n var queue = configFunctions[type];\n for (var i = 0; i < queue.length; i++) {\n if (constantInjection[type]) {\n constantInjection[type] = queue[i](constantInjection[type]);\n continue;\n }\n if (providerInjection[type]) {\n if (!providers[type]) {\n providers[type] = new providerInjection[type]();\n }\n queue[i](providers[type]);\n continue;\n }\n BI.Plugin.configWidget(type, queue[i]);\n }\n configFunctions[type] = null;\n });\n }\n configFunctions[type].push(configFn);\n };\n\n var actions = {};\n var globalAction = [];\n BI.action = function (type, actionFn) {\n if (BI.isFunction(type)) {\n globalAction.push(type);\n return function () {\n BI.remove(globalAction, function (idx) {\n return globalAction.indexOf(actionFn) === idx;\n });\n };\n }\n if (!actions[type]) {\n actions[type] = [];\n }\n actions[type].push(actionFn);\n return function () {\n BI.remove(actions[type], function (idx) {\n return actions[type].indexOf(actionFn) === idx;\n });\n if (actions[type].length === 0) {\n delete actions[type];\n }\n };\n };\n\n var points = {};\n BI.point = function (type, action, pointFn, after) {\n if (!points[type]) {\n points[type] = {};\n }\n if (!points[type][action]) {\n points[type][action] = {};\n }\n if (!points[type][action][after ? \"after\" : \"before\"]) {\n points[type][action][after ? \"after\" : \"before\"] = [];\n }\n points[type][action][after ? \"after\" : \"before\"].push(pointFn);\n };\n\n BI.Modules = {\n getModule: function (type) {\n if (!moduleInjection[type]) {\n _global.console && console.error(\"module:[\" + type + \"] does not exists\");\n return false;\n }\n return moduleInjection[type];\n },\n getAllModules: function () {\n return moduleInjection;\n }\n };\n\n BI.Constants = {\n getConstant: function (type) {\n return constantInjection[type];\n }\n };\n\n var callPoint = function (inst, type) {\n if (points[type]) {\n for (var action in points[type]) {\n var bfns = points[type][action].before;\n if (bfns) {\n BI.aspect.before(inst, action, function (bfns) {\n return function () {\n for (var i = 0, len = bfns.length; i < len; i++) {\n try {\n bfns[i].apply(inst, arguments);\n } catch (e) {\n _global.console && console.error(e);\n }\n }\n };\n }(bfns));\n }\n var afns = points[type][action].after;\n if (afns) {\n BI.aspect.after(inst, action, function (afns) {\n return function () {\n for (var i = 0, len = afns.length; i < len; i++) {\n try {\n afns[i].apply(inst, arguments);\n } catch (e) {\n _global.console && console.error(e);\n }\n }\n };\n }(afns));\n }\n }\n }\n };\n\n BI.Models = {\n getModel: function (type, config) {\n var inst = new modelInjection[type](config);\n inst._constructor && inst._constructor(config);\n callPoint(inst, type);\n return inst;\n }\n };\n\n var stores = {};\n\n BI.Stores = {\n getStore: function (type, config) {\n if (stores[type]) {\n return stores[type];\n }\n var inst = stores[type] = new storeInjection[type](config);\n inst._constructor && inst._constructor(config);\n callPoint(inst, type);\n return inst;\n }\n };\n\n var services = {};\n\n BI.Services = {\n getService: function (type, config) {\n if (services[type]) {\n return services[type];\n }\n services[type] = new serviceInjection[type](config);\n callPoint(services[type], type);\n return services[type];\n }\n };\n\n var providers = {},\n providerInstance = {};\n\n BI.Providers = {\n getProvider: function (type, config) {\n if (!providers[type]) {\n providers[type] = new providerInjection[type]();\n }\n if (!providerInstance[type]) {\n providerInstance[type] = new (providers[type].$get())(config);\n }\n return providerInstance[type];\n }\n };\n\n BI.Actions = {\n runAction: function (type, event, config) {\n BI.each(actions[type], function (i, act) {\n try {\n act(event, config);\n } catch (e) {\n _global.console && console.error(e);\n }\n });\n },\n runGlobalAction: function () {\n var args = [].slice.call(arguments);\n BI.each(globalAction, function (i, act) {\n try {\n act.apply(null, args);\n } catch (e) {\n _global.console && console.error(e);\n }\n });\n }\n };\n\n BI.getContext = function (type, config) {\n if (constantInjection[type]) {\n return BI.Constants.getConstant(type);\n }\n if (modelInjection[type]) {\n return BI.Models.getModel(type, config);\n }\n if (storeInjection[type]) {\n return BI.Stores.getStore(type, config);\n }\n if (serviceInjection[type]) {\n return BI.Services.getService(type, config);\n }\n if (providerInjection[type]) {\n return BI.Providers.getProvider(type, config);\n }\n };\n})();!(function () {\n var i18nStore = {};\n _.extend(BI, {\n addI18n: function (i18n) {\n BI.extend(i18nStore, i18n);\n },\n i18nText: function (key) {\n var localeText = i18nStore[key] || (BI.i18n && BI.i18n[key]) || \"\";\n if (!localeText) {\n localeText = key;\n }\n var len = arguments.length;\n if (len > 1) {\n if (localeText.indexOf(\"{R1}\") > -1) {\n for (var i = 1; i < len; i++) {\n var key = \"{R\" + i + \"}\";\n localeText = BI.replaceAll(localeText, key, arguments[i] + \"\");\n }\n } else {\n var args = Array.prototype.slice.call(arguments);\n var count = 1;\n return BI.replaceAll(localeText, \"\\\\{\\\\s*\\\\}\", function () {\n return args[count++] + \"\";\n });\n }\n }\n return localeText;\n }\n });\n})();!(function () {\n /*\n CryptoJS v3.1.2\n code.google.com/p/crypto-js\n (c) 2009-2013 by Jeff Mott. All rights reserved.\n code.google.com/p/crypto-js/wiki/License\n */\n /**\n * CryptoJS core components.\n */\n BI.CRYPT_TYPE = BI.CRYPT_TYPE || {};\n BI.CRYPT_TYPE.AES = \"aes\";\n\n var CryptoJS = CryptoJS || (function (Math, undefined) {\n /**\n * CryptoJS namespace.\n */\n var C = {};\n\n /**\n * Library namespace.\n */\n var C_lib = C.lib = {};\n\n /**\n * Base object for prototypal inheritance.\n */\n var Base = C_lib.Base = (function () {\n function F () {\n }\n\n return {\n /**\n * Creates a new object that inherits from this object.\n *\n * @param {Object} overrides Properties to copy into the new object.\n *\n * @return {Object} The new object.\n *\n * @static\n *\n * @example\n *\n * var MyType = CryptoJS.lib.Base.extend({\n * field: 'value',\n *\n * method: function () {\n * }\n * });\n */\n extend: function (overrides) {\n // Spawn\n F.prototype = this;\n var subtype = new F();\n\n // Augment\n if (overrides) {\n subtype.mixIn(overrides);\n }\n\n // Create default initializer\n if (!subtype.hasOwnProperty('init')) {\n subtype.init = function () {\n subtype.$super.init.apply(this, arguments);\n };\n }\n\n // Initializer's prototype is the subtype object\n subtype.init.prototype = subtype;\n\n // Reference supertype\n subtype.$super = this;\n\n return subtype;\n },\n\n /**\n * Extends this object and runs the init method.\n * Arguments to create() will be passed to init().\n *\n * @return {Object} The new object.\n *\n * @static\n *\n * @example\n *\n * var instance = MyType.create();\n */\n create: function () {\n var instance = this.extend();\n instance.init.apply(instance, arguments);\n\n return instance;\n },\n\n /**\n * Initializes a newly created object.\n * Override this method to add some logic when your objects are created.\n *\n * @example\n *\n * var MyType = CryptoJS.lib.Base.extend({\n * init: function () {\n * // ...\n * }\n * });\n */\n init: function () {\n },\n\n /**\n * Copies properties into this object.\n *\n * @param {Object} properties The properties to mix in.\n *\n * @example\n *\n * MyType.mixIn({\n * field: 'value'\n * });\n */\n mixIn: function (properties) {\n for (var propertyName in properties) {\n if (properties.hasOwnProperty(propertyName)) {\n this[propertyName] = properties[propertyName];\n }\n }\n\n // IE won't copy toString using the loop above\n if (properties.hasOwnProperty('toString')) {\n this.toString = properties.toString;\n }\n },\n\n /**\n * Creates a copy of this object.\n *\n * @return {Object} The clone.\n *\n * @example\n *\n * var clone = instance.clone();\n */\n clone: function () {\n return this.init.prototype.extend(this);\n }\n };\n }());\n\n /**\n * An array of 32-bit words.\n *\n * @property {Array} words The array of 32-bit words.\n * @property {number} sigBytes The number of significant bytes in this word array.\n */\n var WordArray = C_lib.WordArray = Base.extend({\n /**\n * Initializes a newly created word array.\n *\n * @param {Array} words (Optional) An array of 32-bit words.\n * @param {number} sigBytes (Optional) The number of significant bytes in the words.\n *\n * @example\n *\n * var wordArray = CryptoJS.lib.WordArray.create();\n * var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607]);\n * var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607], 6);\n */\n init: function (words, sigBytes) {\n words = this.words = words || [];\n\n if (sigBytes != undefined) {\n this.sigBytes = sigBytes;\n } else {\n this.sigBytes = words.length * 4;\n }\n },\n\n /**\n * Converts this word array to a string.\n *\n * @param {Encoder} encoder (Optional) The encoding strategy to use. Default: CryptoJS.enc.Hex\n *\n * @return {string} The stringified word array.\n *\n * @example\n *\n * var string = wordArray + '';\n * var string = wordArray.toString();\n * var string = wordArray.toString(CryptoJS.enc.Utf8);\n */\n toString: function (encoder) {\n return (encoder || Hex).stringify(this);\n },\n\n /**\n * Concatenates a word array to this word array.\n *\n * @param {WordArray} wordArray The word array to append.\n *\n * @return {WordArray} This word array.\n *\n * @example\n *\n * wordArray1.concat(wordArray2);\n */\n concat: function (wordArray) {\n // Shortcuts\n var thisWords = this.words;\n var thatWords = wordArray.words;\n var thisSigBytes = this.sigBytes;\n var thatSigBytes = wordArray.sigBytes;\n\n // Clamp excess bits\n this.clamp();\n\n // Concat\n if (thisSigBytes % 4) {\n // Copy one byte at a time\n for (var i = 0; i < thatSigBytes; i++) {\n var thatByte = (thatWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;\n thisWords[(thisSigBytes + i) >>> 2] |= thatByte << (24 - ((thisSigBytes + i) % 4) * 8);\n }\n } else if (thatWords.length > 0xffff) {\n // Copy one word at a time\n for (var i = 0; i < thatSigBytes; i += 4) {\n thisWords[(thisSigBytes + i) >>> 2] = thatWords[i >>> 2];\n }\n } else {\n // Copy all words at once\n thisWords.push.apply(thisWords, thatWords);\n }\n this.sigBytes += thatSigBytes;\n\n // Chainable\n return this;\n },\n\n /**\n * Removes insignificant bits.\n *\n * @example\n *\n * wordArray.clamp();\n */\n clamp: function () {\n // Shortcuts\n var words = this.words;\n var sigBytes = this.sigBytes;\n\n // Clamp\n words[sigBytes >>> 2] &= 0xffffffff << (32 - (sigBytes % 4) * 8);\n words.length = Math.ceil(sigBytes / 4);\n },\n\n /**\n * Creates a copy of this word array.\n *\n * @return {WordArray} The clone.\n *\n * @example\n *\n * var clone = wordArray.clone();\n */\n clone: function () {\n var clone = Base.clone.call(this);\n clone.words = this.words.slice(0);\n\n return clone;\n },\n\n /**\n * Creates a word array filled with random bytes.\n *\n * @param {number} nBytes The number of random bytes to generate.\n *\n * @return {WordArray} The random word array.\n *\n * @static\n *\n * @example\n *\n * var wordArray = CryptoJS.lib.WordArray.random(16);\n */\n random: function (nBytes) {\n var words = [];\n for (var i = 0; i < nBytes; i += 4) {\n words.push((Math.random() * 0x100000000) | 0);\n }\n\n return new WordArray.init(words, nBytes);\n }\n });\n\n /**\n * Encoder namespace.\n */\n var C_enc = C.enc = {};\n\n /**\n * Hex encoding strategy.\n */\n var Hex = C_enc.Hex = {\n /**\n * Converts a word array to a hex string.\n *\n * @param {WordArray} wordArray The word array.\n *\n * @return {string} The hex string.\n *\n * @static\n *\n * @example\n *\n * var hexString = CryptoJS.enc.Hex.stringify(wordArray);\n */\n stringify: function (wordArray) {\n // Shortcuts\n var words = wordArray.words;\n var sigBytes = wordArray.sigBytes;\n\n // Convert\n var hexChars = [];\n for (var i = 0; i < sigBytes; i++) {\n var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;\n hexChars.push((bite >>> 4).toString(16));\n hexChars.push((bite & 0x0f).toString(16));\n }\n\n return hexChars.join('');\n },\n\n /**\n * Converts a hex string to a word array.\n *\n * @param {string} hexStr The hex string.\n *\n * @return {WordArray} The word array.\n *\n * @static\n *\n * @example\n *\n * var wordArray = CryptoJS.enc.Hex.parse(hexString);\n */\n parse: function (hexStr) {\n // Shortcut\n var hexStrLength = hexStr.length;\n\n // Convert\n var words = [];\n for (var i = 0; i < hexStrLength; i += 2) {\n words[i >>> 3] |= parseInt(hexStr.substr(i, 2), 16) << (24 - (i % 8) * 4);\n }\n\n return new WordArray.init(words, hexStrLength / 2);\n }\n };\n\n /**\n * Latin1 encoding strategy.\n */\n var Latin1 = C_enc.Latin1 = {\n /**\n * Converts a word array to a Latin1 string.\n *\n * @param {WordArray} wordArray The word array.\n *\n * @return {string} The Latin1 string.\n *\n * @static\n *\n * @example\n *\n * var latin1String = CryptoJS.enc.Latin1.stringify(wordArray);\n */\n stringify: function (wordArray) {\n // Shortcuts\n var words = wordArray.words;\n var sigBytes = wordArray.sigBytes;\n\n // Convert\n var latin1Chars = [];\n for (var i = 0; i < sigBytes; i++) {\n var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;\n latin1Chars.push(String.fromCharCode(bite));\n }\n\n return latin1Chars.join('');\n },\n\n /**\n * Converts a Latin1 string to a word array.\n *\n * @param {string} latin1Str The Latin1 string.\n *\n * @return {WordArray} The word array.\n *\n * @static\n *\n * @example\n *\n * var wordArray = CryptoJS.enc.Latin1.parse(latin1String);\n */\n parse: function (latin1Str) {\n // Shortcut\n var latin1StrLength = latin1Str.length;\n\n // Convert\n var words = [];\n for (var i = 0; i < latin1StrLength; i++) {\n words[i >>> 2] |= (latin1Str.charCodeAt(i) & 0xff) << (24 - (i % 4) * 8);\n }\n\n return new WordArray.init(words, latin1StrLength);\n }\n };\n\n /**\n * UTF-8 encoding strategy.\n */\n var Utf8 = C_enc.Utf8 = {\n /**\n * Converts a word array to a UTF-8 string.\n *\n * @param {WordArray} wordArray The word array.\n *\n * @return {string} The UTF-8 string.\n *\n * @static\n *\n * @example\n *\n * var utf8String = CryptoJS.enc.Utf8.stringify(wordArray);\n */\n stringify: function (wordArray) {\n try {\n return decodeURIComponent(escape(Latin1.stringify(wordArray)));\n } catch (e) {\n throw new Error('Malformed UTF-8 data');\n }\n },\n\n /**\n * Converts a UTF-8 string to a word array.\n *\n * @param {string} utf8Str The UTF-8 string.\n *\n * @return {WordArray} The word array.\n *\n * @static\n *\n * @example\n *\n * var wordArray = CryptoJS.enc.Utf8.parse(utf8String);\n */\n parse: function (utf8Str) {\n return Latin1.parse(unescape(encodeURIComponent(utf8Str)));\n }\n };\n\n /**\n * Abstract buffered block algorithm template.\n *\n * The property blockSize must be implemented in a concrete subtype.\n *\n * @property {number} _minBufferSize The number of blocks that should be kept unprocessed in the buffer. Default: 0\n */\n var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({\n /**\n * Resets this block algorithm's data buffer to its initial state.\n *\n * @example\n *\n * bufferedBlockAlgorithm.reset();\n */\n reset: function () {\n // Initial values\n this._data = new WordArray.init();\n this._nDataBytes = 0;\n },\n\n /**\n * Adds new data to this block algorithm's buffer.\n *\n * @param {WordArray|string} data The data to append. Strings are converted to a WordArray using UTF-8.\n *\n * @example\n *\n * bufferedBlockAlgorithm._append('data');\n * bufferedBlockAlgorithm._append(wordArray);\n */\n _append: function (data) {\n // Convert string to WordArray, else assume WordArray already\n if (typeof data == 'string') {\n data = Utf8.parse(data);\n }\n\n // Append\n this._data.concat(data);\n this._nDataBytes += data.sigBytes;\n },\n\n /**\n * Processes available data blocks.\n *\n * This method invokes _doProcessBlock(offset), which must be implemented by a concrete subtype.\n *\n * @param {boolean} doFlush Whether all blocks and partial blocks should be processed.\n *\n * @return {WordArray} The processed data.\n *\n * @example\n *\n * var processedData = bufferedBlockAlgorithm._process();\n * var processedData = bufferedBlockAlgorithm._process(!!'flush');\n */\n _process: function (doFlush) {\n // Shortcuts\n var data = this._data;\n var dataWords = data.words;\n var dataSigBytes = data.sigBytes;\n var blockSize = this.blockSize;\n var blockSizeBytes = blockSize * 4;\n\n // Count blocks ready\n var nBlocksReady = dataSigBytes / blockSizeBytes;\n if (doFlush) {\n // Round up to include partial blocks\n nBlocksReady = Math.ceil(nBlocksReady);\n } else {\n // Round down to include only full blocks,\n // less the number of blocks that must remain in the buffer\n nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0);\n }\n\n // Count words ready\n var nWordsReady = nBlocksReady * blockSize;\n\n // Count bytes ready\n var nBytesReady = Math.min(nWordsReady * 4, dataSigBytes);\n\n // Process blocks\n if (nWordsReady) {\n for (var offset = 0; offset < nWordsReady; offset += blockSize) {\n // Perform concrete-algorithm logic\n this._doProcessBlock(dataWords, offset);\n }\n\n // Remove processed words\n var processedWords = dataWords.splice(0, nWordsReady);\n data.sigBytes -= nBytesReady;\n }\n\n // Return processed words\n return new WordArray.init(processedWords, nBytesReady);\n },\n\n /**\n * Creates a copy of this object.\n *\n * @return {Object} The clone.\n *\n * @example\n *\n * var clone = bufferedBlockAlgorithm.clone();\n */\n clone: function () {\n var clone = Base.clone.call(this);\n clone._data = this._data.clone();\n\n return clone;\n },\n\n _minBufferSize: 0\n });\n\n /**\n * Abstract hasher template.\n *\n * @property {number} blockSize The number of 32-bit words this hasher operates on. Default: 16 (512 bits)\n */\n var Hasher = C_lib.Hasher = BufferedBlockAlgorithm.extend({\n /**\n * Configuration options.\n */\n cfg: Base.extend(),\n\n /**\n * Initializes a newly created hasher.\n *\n * @param {Object} cfg (Optional) The configuration options to use for this hash computation.\n *\n * @example\n *\n * var hasher = CryptoJS.algo.SHA256.create();\n */\n init: function (cfg) {\n // Apply config defaults\n this.cfg = this.cfg.extend(cfg);\n\n // Set initial values\n this.reset();\n },\n\n /**\n * Resets this hasher to its initial state.\n *\n * @example\n *\n * hasher.reset();\n */\n reset: function () {\n // Reset data buffer\n BufferedBlockAlgorithm.reset.call(this);\n\n // Perform concrete-hasher logic\n this._doReset();\n },\n\n /**\n * Updates this hasher with a message.\n *\n * @param {WordArray|string} messageUpdate The message to append.\n *\n * @return {Hasher} This hasher.\n *\n * @example\n *\n * hasher.update('message');\n * hasher.update(wordArray);\n */\n update: function (messageUpdate) {\n // Append\n this._append(messageUpdate);\n\n // Update the hash\n this._process();\n\n // Chainable\n return this;\n },\n\n /**\n * Finalizes the hash computation.\n * Note that the finalize operation is effectively a destructive, read-once operation.\n *\n * @param {WordArray|string} messageUpdate (Optional) A final message update.\n *\n * @return {WordArray} The hash.\n *\n * @example\n *\n * var hash = hasher.finalize();\n * var hash = hasher.finalize('message');\n * var hash = hasher.finalize(wordArray);\n */\n finalize: function (messageUpdate) {\n // Final message update\n if (messageUpdate) {\n this._append(messageUpdate);\n }\n\n // Perform concrete-hasher logic\n var hash = this._doFinalize();\n\n return hash;\n },\n\n blockSize: 512 / 32,\n\n /**\n * Creates a shortcut function to a hasher's object interface.\n *\n * @param {Hasher} hasher The hasher to create a helper for.\n *\n * @return {Function} The shortcut function.\n *\n * @static\n *\n * @example\n *\n * var SHA256 = CryptoJS.lib.Hasher._createHelper(CryptoJS.algo.SHA256);\n */\n _createHelper: function (hasher) {\n return function (message, cfg) {\n return new hasher.init(cfg).finalize(message);\n };\n },\n\n /**\n * Creates a shortcut function to the HMAC's object interface.\n *\n * @param {Hasher} hasher The hasher to use in this HMAC helper.\n *\n * @return {Function} The shortcut function.\n *\n * @static\n *\n * @example\n *\n * var HmacSHA256 = CryptoJS.lib.Hasher._createHmacHelper(CryptoJS.algo.SHA256);\n */\n _createHmacHelper: function (hasher) {\n return function (message, key) {\n return new C_algo.HMAC.init(hasher, key).finalize(message);\n };\n }\n });\n\n /**\n * Algorithm namespace.\n */\n var C_algo = C.algo = {};\n\n return C;\n }(Math));\n\n /*\n CryptoJS v3.1.2\n code.google.com/p/crypto-js\n (c) 2009-2013 by Jeff Mott. All rights reserved.\n code.google.com/p/crypto-js/wiki/License\n */\n (function () {\n // Shortcuts\n var C = CryptoJS;\n var C_lib = C.lib;\n var WordArray = C_lib.WordArray;\n var C_enc = C.enc;\n\n /**\n * Base64 encoding strategy.\n */\n var Base64 = C_enc.Base64 = {\n /**\n * Converts a word array to a Base64 string.\n *\n * @param {WordArray} wordArray The word array.\n *\n * @return {string} The Base64 string.\n *\n * @static\n *\n * @example\n *\n * var base64String = CryptoJS.enc.Base64.stringify(wordArray);\n */\n stringify: function (wordArray) {\n // Shortcuts\n var words = wordArray.words;\n var sigBytes = wordArray.sigBytes;\n var map = this._map;\n\n // Clamp excess bits\n wordArray.clamp();\n\n // Convert\n var base64Chars = [];\n for (var i = 0; i < sigBytes; i += 3) {\n var byte1 = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;\n var byte2 = (words[(i + 1) >>> 2] >>> (24 - ((i + 1) % 4) * 8)) & 0xff;\n var byte3 = (words[(i + 2) >>> 2] >>> (24 - ((i + 2) % 4) * 8)) & 0xff;\n\n var triplet = (byte1 << 16) | (byte2 << 8) | byte3;\n\n for (var j = 0; (j < 4) && (i + j * 0.75 < sigBytes); j++) {\n base64Chars.push(map.charAt((triplet >>> (6 * (3 - j))) & 0x3f));\n }\n }\n\n // Add padding\n var paddingChar = map.charAt(64);\n if (paddingChar) {\n while (base64Chars.length % 4) {\n base64Chars.push(paddingChar);\n }\n }\n\n return base64Chars.join('');\n },\n\n /**\n * Converts a Base64 string to a word array.\n *\n * @param {string} base64Str The Base64 string.\n *\n * @return {WordArray} The word array.\n *\n * @static\n *\n * @example\n *\n * var wordArray = CryptoJS.enc.Base64.parse(base64String);\n */\n parse: function (base64Str) {\n // Shortcuts\n var base64StrLength = base64Str.length;\n var map = this._map;\n\n // Ignore padding\n var paddingChar = map.charAt(64);\n if (paddingChar) {\n var paddingIndex = base64Str.indexOf(paddingChar);\n if (paddingIndex != -1) {\n base64StrLength = paddingIndex;\n }\n }\n\n // Convert\n var words = [];\n var nBytes = 0;\n for (var i = 0; i < base64StrLength; i++) {\n if (i % 4) {\n var bits1 = map.indexOf(base64Str.charAt(i - 1)) << ((i % 4) * 2);\n var bits2 = map.indexOf(base64Str.charAt(i)) >>> (6 - (i % 4) * 2);\n words[nBytes >>> 2] |= (bits1 | bits2) << (24 - (nBytes % 4) * 8);\n nBytes++;\n }\n }\n\n return WordArray.create(words, nBytes);\n },\n\n _map: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='\n };\n }());\n\n /*\n CryptoJS v3.1.2\n code.google.com/p/crypto-js\n (c) 2009-2013 by Jeff Mott. All rights reserved.\n code.google.com/p/crypto-js/wiki/License\n */\n (function (Math) {\n // Shortcuts\n var C = CryptoJS;\n var C_lib = C.lib;\n var WordArray = C_lib.WordArray;\n var Hasher = C_lib.Hasher;\n var C_algo = C.algo;\n\n // Constants table\n var T = [];\n\n // Compute constants\n (function () {\n for (var i = 0; i < 64; i++) {\n T[i] = (Math.abs(Math.sin(i + 1)) * 0x100000000) | 0;\n }\n }());\n\n /**\n * MD5 hash algorithm.\n */\n var MD5 = C_algo.MD5 = Hasher.extend({\n _doReset: function () {\n this._hash = new WordArray.init([\n 0x67452301, 0xefcdab89,\n 0x98badcfe, 0x10325476\n ]);\n },\n\n _doProcessBlock: function (M, offset) {\n // Swap endian\n for (var i = 0; i < 16; i++) {\n // Shortcuts\n var offset_i = offset + i;\n var M_offset_i = M[offset_i];\n\n M[offset_i] = (\n (((M_offset_i << 8) | (M_offset_i >>> 24)) & 0x00ff00ff) |\n (((M_offset_i << 24) | (M_offset_i >>> 8)) & 0xff00ff00)\n );\n }\n\n // Shortcuts\n var H = this._hash.words;\n\n var M_offset_0 = M[offset + 0];\n var M_offset_1 = M[offset + 1];\n var M_offset_2 = M[offset + 2];\n var M_offset_3 = M[offset + 3];\n var M_offset_4 = M[offset + 4];\n var M_offset_5 = M[offset + 5];\n var M_offset_6 = M[offset + 6];\n var M_offset_7 = M[offset + 7];\n var M_offset_8 = M[offset + 8];\n var M_offset_9 = M[offset + 9];\n var M_offset_10 = M[offset + 10];\n var M_offset_11 = M[offset + 11];\n var M_offset_12 = M[offset + 12];\n var M_offset_13 = M[offset + 13];\n var M_offset_14 = M[offset + 14];\n var M_offset_15 = M[offset + 15];\n\n // Working varialbes\n var a = H[0];\n var b = H[1];\n var c = H[2];\n var d = H[3];\n\n // Computation\n a = FF(a, b, c, d, M_offset_0, 7, T[0]);\n d = FF(d, a, b, c, M_offset_1, 12, T[1]);\n c = FF(c, d, a, b, M_offset_2, 17, T[2]);\n b = FF(b, c, d, a, M_offset_3, 22, T[3]);\n a = FF(a, b, c, d, M_offset_4, 7, T[4]);\n d = FF(d, a, b, c, M_offset_5, 12, T[5]);\n c = FF(c, d, a, b, M_offset_6, 17, T[6]);\n b = FF(b, c, d, a, M_offset_7, 22, T[7]);\n a = FF(a, b, c, d, M_offset_8, 7, T[8]);\n d = FF(d, a, b, c, M_offset_9, 12, T[9]);\n c = FF(c, d, a, b, M_offset_10, 17, T[10]);\n b = FF(b, c, d, a, M_offset_11, 22, T[11]);\n a = FF(a, b, c, d, M_offset_12, 7, T[12]);\n d = FF(d, a, b, c, M_offset_13, 12, T[13]);\n c = FF(c, d, a, b, M_offset_14, 17, T[14]);\n b = FF(b, c, d, a, M_offset_15, 22, T[15]);\n\n a = GG(a, b, c, d, M_offset_1, 5, T[16]);\n d = GG(d, a, b, c, M_offset_6, 9, T[17]);\n c = GG(c, d, a, b, M_offset_11, 14, T[18]);\n b = GG(b, c, d, a, M_offset_0, 20, T[19]);\n a = GG(a, b, c, d, M_offset_5, 5, T[20]);\n d = GG(d, a, b, c, M_offset_10, 9, T[21]);\n c = GG(c, d, a, b, M_offset_15, 14, T[22]);\n b = GG(b, c, d, a, M_offset_4, 20, T[23]);\n a = GG(a, b, c, d, M_offset_9, 5, T[24]);\n d = GG(d, a, b, c, M_offset_14, 9, T[25]);\n c = GG(c, d, a, b, M_offset_3, 14, T[26]);\n b = GG(b, c, d, a, M_offset_8, 20, T[27]);\n a = GG(a, b, c, d, M_offset_13, 5, T[28]);\n d = GG(d, a, b, c, M_offset_2, 9, T[29]);\n c = GG(c, d, a, b, M_offset_7, 14, T[30]);\n b = GG(b, c, d, a, M_offset_12, 20, T[31]);\n\n a = HH(a, b, c, d, M_offset_5, 4, T[32]);\n d = HH(d, a, b, c, M_offset_8, 11, T[33]);\n c = HH(c, d, a, b, M_offset_11, 16, T[34]);\n b = HH(b, c, d, a, M_offset_14, 23, T[35]);\n a = HH(a, b, c, d, M_offset_1, 4, T[36]);\n d = HH(d, a, b, c, M_offset_4, 11, T[37]);\n c = HH(c, d, a, b, M_offset_7, 16, T[38]);\n b = HH(b, c, d, a, M_offset_10, 23, T[39]);\n a = HH(a, b, c, d, M_offset_13, 4, T[40]);\n d = HH(d, a, b, c, M_offset_0, 11, T[41]);\n c = HH(c, d, a, b, M_offset_3, 16, T[42]);\n b = HH(b, c, d, a, M_offset_6, 23, T[43]);\n a = HH(a, b, c, d, M_offset_9, 4, T[44]);\n d = HH(d, a, b, c, M_offset_12, 11, T[45]);\n c = HH(c, d, a, b, M_offset_15, 16, T[46]);\n b = HH(b, c, d, a, M_offset_2, 23, T[47]);\n\n a = II(a, b, c, d, M_offset_0, 6, T[48]);\n d = II(d, a, b, c, M_offset_7, 10, T[49]);\n c = II(c, d, a, b, M_offset_14, 15, T[50]);\n b = II(b, c, d, a, M_offset_5, 21, T[51]);\n a = II(a, b, c, d, M_offset_12, 6, T[52]);\n d = II(d, a, b, c, M_offset_3, 10, T[53]);\n c = II(c, d, a, b, M_offset_10, 15, T[54]);\n b = II(b, c, d, a, M_offset_1, 21, T[55]);\n a = II(a, b, c, d, M_offset_8, 6, T[56]);\n d = II(d, a, b, c, M_offset_15, 10, T[57]);\n c = II(c, d, a, b, M_offset_6, 15, T[58]);\n b = II(b, c, d, a, M_offset_13, 21, T[59]);\n a = II(a, b, c, d, M_offset_4, 6, T[60]);\n d = II(d, a, b, c, M_offset_11, 10, T[61]);\n c = II(c, d, a, b, M_offset_2, 15, T[62]);\n b = II(b, c, d, a, M_offset_9, 21, T[63]);\n\n // Intermediate hash value\n H[0] = (H[0] + a) | 0;\n H[1] = (H[1] + b) | 0;\n H[2] = (H[2] + c) | 0;\n H[3] = (H[3] + d) | 0;\n },\n\n _doFinalize: function () {\n // Shortcuts\n var data = this._data;\n var dataWords = data.words;\n\n var nBitsTotal = this._nDataBytes * 8;\n var nBitsLeft = data.sigBytes * 8;\n\n // Add padding\n dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);\n\n var nBitsTotalH = Math.floor(nBitsTotal / 0x100000000);\n var nBitsTotalL = nBitsTotal;\n dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = (\n (((nBitsTotalH << 8) | (nBitsTotalH >>> 24)) & 0x00ff00ff) |\n (((nBitsTotalH << 24) | (nBitsTotalH >>> 8)) & 0xff00ff00)\n );\n dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = (\n (((nBitsTotalL << 8) | (nBitsTotalL >>> 24)) & 0x00ff00ff) |\n (((nBitsTotalL << 24) | (nBitsTotalL >>> 8)) & 0xff00ff00)\n );\n\n data.sigBytes = (dataWords.length + 1) * 4;\n\n // Hash final blocks\n this._process();\n\n // Shortcuts\n var hash = this._hash;\n var H = hash.words;\n\n // Swap endian\n for (var i = 0; i < 4; i++) {\n // Shortcut\n var H_i = H[i];\n\n H[i] = (((H_i << 8) | (H_i >>> 24)) & 0x00ff00ff) |\n (((H_i << 24) | (H_i >>> 8)) & 0xff00ff00);\n }\n\n // Return final computed hash\n return hash;\n },\n\n clone: function () {\n var clone = Hasher.clone.call(this);\n clone._hash = this._hash.clone();\n\n return clone;\n }\n });\n\n function FF (a, b, c, d, x, s, t) {\n var n = a + ((b & c) | (~b & d)) + x + t;\n return ((n << s) | (n >>> (32 - s))) + b;\n }\n\n function GG (a, b, c, d, x, s, t) {\n var n = a + ((b & d) | (c & ~d)) + x + t;\n return ((n << s) | (n >>> (32 - s))) + b;\n }\n\n function HH (a, b, c, d, x, s, t) {\n var n = a + (b ^ c ^ d) + x + t;\n return ((n << s) | (n >>> (32 - s))) + b;\n }\n\n function II (a, b, c, d, x, s, t) {\n var n = a + (c ^ (b | ~d)) + x + t;\n return ((n << s) | (n >>> (32 - s))) + b;\n }\n\n /**\n * Shortcut function to the hasher's object interface.\n *\n * @param {WordArray|string} message The message to hash.\n *\n * @return {WordArray} The hash.\n *\n * @static\n *\n * @example\n *\n * var hash = CryptoJS.MD5('message');\n * var hash = CryptoJS.MD5(wordArray);\n */\n C.MD5 = Hasher._createHelper(MD5);\n\n /**\n * Shortcut function to the HMAC's object interface.\n *\n * @param {WordArray|string} message The message to hash.\n * @param {WordArray|string} key The secret key.\n *\n * @return {WordArray} The HMAC.\n *\n * @static\n *\n * @example\n *\n * var hmac = CryptoJS.HmacMD5(message, key);\n */\n C.HmacMD5 = Hasher._createHmacHelper(MD5);\n }(Math));\n\n /*\n CryptoJS v3.1.2\n code.google.com/p/crypto-js\n (c) 2009-2013 by Jeff Mott. All rights reserved.\n code.google.com/p/crypto-js/wiki/License\n */\n (function () {\n // Shortcuts\n var C = CryptoJS;\n var C_lib = C.lib;\n var Base = C_lib.Base;\n var WordArray = C_lib.WordArray;\n var C_algo = C.algo;\n var MD5 = C_algo.MD5;\n\n /**\n * This key derivation function is meant to conform with EVP_BytesToKey.\n * www.openssl.org/docs/crypto/EVP_BytesToKey.html\n */\n var EvpKDF = C_algo.EvpKDF = Base.extend({\n /**\n * Configuration options.\n *\n * @property {number} keySize The key size in words to generate. Default: 4 (128 bits)\n * @property {Hasher} hasher The hash algorithm to use. Default: MD5\n * @property {number} iterations The number of iterations to perform. Default: 1\n */\n cfg: Base.extend({\n keySize: 128 / 32,\n hasher: MD5,\n iterations: 1\n }),\n\n /**\n * Initializes a newly created key derivation function.\n *\n * @param {Object} cfg (Optional) The configuration options to use for the derivation.\n *\n * @example\n *\n * var kdf = CryptoJS.algo.EvpKDF.create();\n * var kdf = CryptoJS.algo.EvpKDF.create({ keySize: 8 });\n * var kdf = CryptoJS.algo.EvpKDF.create({ keySize: 8, iterations: 1000 });\n */\n init: function (cfg) {\n this.cfg = this.cfg.extend(cfg);\n },\n\n /**\n * Derives a key from a password.\n *\n * @param {WordArray|string} password The password.\n * @param {WordArray|string} salt A salt.\n *\n * @return {WordArray} The derived key.\n *\n * @example\n *\n * var key = kdf.compute(password, salt);\n */\n compute: function (password, salt) {\n // Shortcut\n var cfg = this.cfg;\n\n // Init hasher\n var hasher = cfg.hasher.create();\n\n // Initial values\n var derivedKey = WordArray.create();\n\n // Shortcuts\n var derivedKeyWords = derivedKey.words;\n var keySize = cfg.keySize;\n var iterations = cfg.iterations;\n\n // Generate key\n while (derivedKeyWords.length < keySize) {\n if (block) {\n hasher.update(block);\n }\n var block = hasher.update(password).finalize(salt);\n hasher.reset();\n\n // Iterations\n for (var i = 1; i < iterations; i++) {\n block = hasher.finalize(block);\n hasher.reset();\n }\n\n derivedKey.concat(block);\n }\n derivedKey.sigBytes = keySize * 4;\n\n return derivedKey;\n }\n });\n\n /**\n * Derives a key from a password.\n *\n * @param {WordArray|string} password The password.\n * @param {WordArray|string} salt A salt.\n * @param {Object} cfg (Optional) The configuration options to use for this computation.\n *\n * @return {WordArray} The derived key.\n *\n * @static\n *\n * @example\n *\n * var key = CryptoJS.EvpKDF(password, salt);\n * var key = CryptoJS.EvpKDF(password, salt, { keySize: 8 });\n * var key = CryptoJS.EvpKDF(password, salt, { keySize: 8, iterations: 1000 });\n */\n C.EvpKDF = function (password, salt, cfg) {\n return EvpKDF.create(cfg).compute(password, salt);\n };\n }());\n\n\n /*\n CryptoJS v3.1.2\n code.google.com/p/crypto-js\n (c) 2009-2013 by Jeff Mott. All rights reserved.\n code.google.com/p/crypto-js/wiki/License\n */\n /**\n * Cipher core components.\n */\n CryptoJS.lib.Cipher || (function (undefined) {\n // Shortcuts\n var C = CryptoJS;\n var C_lib = C.lib;\n var Base = C_lib.Base;\n var WordArray = C_lib.WordArray;\n var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm;\n var C_enc = C.enc;\n var Utf8 = C_enc.Utf8;\n var Base64 = C_enc.Base64;\n var C_algo = C.algo;\n var EvpKDF = C_algo.EvpKDF;\n\n /**\n * Abstract base cipher template.\n *\n * @property {number} keySize This cipher's key size. Default: 4 (128 bits)\n * @property {number} ivSize This cipher's IV size. Default: 4 (128 bits)\n * @property {number} _ENC_XFORM_MODE A constant representing encryption mode.\n * @property {number} _DEC_XFORM_MODE A constant representing decryption mode.\n */\n var Cipher = C_lib.Cipher = BufferedBlockAlgorithm.extend({\n /**\n * Configuration options.\n *\n * @property {WordArray} iv The IV to use for this operation.\n */\n cfg: Base.extend(),\n\n /**\n * Creates this cipher in encryption mode.\n *\n * @param {WordArray} key The key.\n * @param {Object} cfg (Optional) The configuration options to use for this operation.\n *\n * @return {Cipher} A cipher instance.\n *\n * @static\n *\n * @example\n *\n * var cipher = CryptoJS.algo.AES.createEncryptor(keyWordArray, { iv: ivWordArray });\n */\n createEncryptor: function (key, cfg) {\n return this.create(this._ENC_XFORM_MODE, key, cfg);\n },\n\n /**\n * Creates this cipher in decryption mode.\n *\n * @param {WordArray} key The key.\n * @param {Object} cfg (Optional) The configuration options to use for this operation.\n *\n * @return {Cipher} A cipher instance.\n *\n * @static\n *\n * @example\n *\n * var cipher = CryptoJS.algo.AES.createDecryptor(keyWordArray, { iv: ivWordArray });\n */\n createDecryptor: function (key, cfg) {\n return this.create(this._DEC_XFORM_MODE, key, cfg);\n },\n\n /**\n * Initializes a newly created cipher.\n *\n * @param {number} xformMode Either the encryption or decryption transormation mode constant.\n * @param {WordArray} key The key.\n * @param {Object} cfg (Optional) The configuration options to use for this operation.\n *\n * @example\n *\n * var cipher = CryptoJS.algo.AES.create(CryptoJS.algo.AES._ENC_XFORM_MODE, keyWordArray, { iv: ivWordArray });\n */\n init: function (xformMode, key, cfg) {\n // Apply config defaults\n this.cfg = this.cfg.extend(cfg);\n\n // Store transform mode and key\n this._xformMode = xformMode;\n this._key = key;\n\n // Set initial values\n this.reset();\n },\n\n /**\n * Resets this cipher to its initial state.\n *\n * @example\n *\n * cipher.reset();\n */\n reset: function () {\n // Reset data buffer\n BufferedBlockAlgorithm.reset.call(this);\n\n // Perform concrete-cipher logic\n this._doReset();\n },\n\n /**\n * Adds data to be encrypted or decrypted.\n *\n * @param {WordArray|string} dataUpdate The data to encrypt or decrypt.\n *\n * @return {WordArray} The data after processing.\n *\n * @example\n *\n * var encrypted = cipher.process('data');\n * var encrypted = cipher.process(wordArray);\n */\n process: function (dataUpdate) {\n // Append\n this._append(dataUpdate);\n\n // Process available blocks\n return this._process();\n },\n\n /**\n * Finalizes the encryption or decryption process.\n * Note that the finalize operation is effectively a destructive, read-once operation.\n *\n * @param {WordArray|string} dataUpdate The final data to encrypt or decrypt.\n *\n * @return {WordArray} The data after final processing.\n *\n * @example\n *\n * var encrypted = cipher.finalize();\n * var encrypted = cipher.finalize('data');\n * var encrypted = cipher.finalize(wordArray);\n */\n finalize: function (dataUpdate) {\n // Final data update\n if (dataUpdate) {\n this._append(dataUpdate);\n }\n\n // Perform concrete-cipher logic\n var finalProcessedData = this._doFinalize();\n\n return finalProcessedData;\n },\n\n keySize: 128 / 32,\n\n ivSize: 128 / 32,\n\n _ENC_XFORM_MODE: 1,\n\n _DEC_XFORM_MODE: 2,\n\n /**\n * Creates shortcut functions to a cipher's object interface.\n *\n * @param {Cipher} cipher The cipher to create a helper for.\n *\n * @return {Object} An object with encrypt and decrypt shortcut functions.\n *\n * @static\n *\n * @example\n *\n * var AES = CryptoJS.lib.Cipher._createHelper(CryptoJS.algo.AES);\n */\n _createHelper: (function () {\n function selectCipherStrategy (key) {\n if (typeof key == 'string') {\n return PasswordBasedCipher;\n } else {\n return SerializableCipher;\n }\n }\n\n return function (cipher) {\n return {\n encrypt: function (message, key, cfg) {\n return selectCipherStrategy(key).encrypt(cipher, message, key, cfg);\n },\n\n decrypt: function (ciphertext, key, cfg) {\n return selectCipherStrategy(key).decrypt(cipher, ciphertext, key, cfg);\n }\n };\n };\n }())\n });\n\n /**\n * Abstract base stream cipher template.\n *\n * @property {number} blockSize The number of 32-bit words this cipher operates on. Default: 1 (32 bits)\n */\n var StreamCipher = C_lib.StreamCipher = Cipher.extend({\n _doFinalize: function () {\n // Process partial blocks\n var finalProcessedBlocks = this._process(!!'flush');\n\n return finalProcessedBlocks;\n },\n\n blockSize: 1\n });\n\n /**\n * Mode namespace.\n */\n var C_mode = C.mode = {};\n\n /**\n * Abstract base block cipher mode template.\n */\n var BlockCipherMode = C_lib.BlockCipherMode = Base.extend({\n /**\n * Creates this mode for encryption.\n *\n * @param {Cipher} cipher A block cipher instance.\n * @param {Array} iv The IV words.\n *\n * @static\n *\n * @example\n *\n * var mode = CryptoJS.mode.CBC.createEncryptor(cipher, iv.words);\n */\n createEncryptor: function (cipher, iv) {\n return this.Encryptor.create(cipher, iv);\n },\n\n /**\n * Creates this mode for decryption.\n *\n * @param {Cipher} cipher A block cipher instance.\n * @param {Array} iv The IV words.\n *\n * @static\n *\n * @example\n *\n * var mode = CryptoJS.mode.CBC.createDecryptor(cipher, iv.words);\n */\n createDecryptor: function (cipher, iv) {\n return this.Decryptor.create(cipher, iv);\n },\n\n /**\n * Initializes a newly created mode.\n *\n * @param {Cipher} cipher A block cipher instance.\n * @param {Array} iv The IV words.\n *\n * @example\n *\n * var mode = CryptoJS.mode.CBC.Encryptor.create(cipher, iv.words);\n */\n init: function (cipher, iv) {\n this._cipher = cipher;\n this._iv = iv;\n }\n });\n\n /**\n * Cipher Block Chaining mode.\n */\n var CBC = C_mode.CBC = (function () {\n /**\n * Abstract base CBC mode.\n */\n var CBC = BlockCipherMode.extend();\n\n /**\n * CBC encryptor.\n */\n CBC.Encryptor = CBC.extend({\n /**\n * Processes the data block at offset.\n *\n * @param {Array} words The data words to operate on.\n * @param {number} offset The offset where the block starts.\n *\n * @example\n *\n * mode.processBlock(data.words, offset);\n */\n processBlock: function (words, offset) {\n // Shortcuts\n var cipher = this._cipher;\n var blockSize = cipher.blockSize;\n\n // XOR and encrypt\n xorBlock.call(this, words, offset, blockSize);\n cipher.encryptBlock(words, offset);\n\n // Remember this block to use with next block\n this._prevBlock = words.slice(offset, offset + blockSize);\n }\n });\n\n /**\n * CBC decryptor.\n */\n CBC.Decryptor = CBC.extend({\n /**\n * Processes the data block at offset.\n *\n * @param {Array} words The data words to operate on.\n * @param {number} offset The offset where the block starts.\n *\n * @example\n *\n * mode.processBlock(data.words, offset);\n */\n processBlock: function (words, offset) {\n // Shortcuts\n var cipher = this._cipher;\n var blockSize = cipher.blockSize;\n\n // Remember this block to use with next block\n var thisBlock = words.slice(offset, offset + blockSize);\n\n // Decrypt and XOR\n cipher.decryptBlock(words, offset);\n xorBlock.call(this, words, offset, blockSize);\n\n // This block becomes the previous block\n this._prevBlock = thisBlock;\n }\n });\n\n function xorBlock (words, offset, blockSize) {\n // Shortcut\n var iv = this._iv;\n\n // Choose mixing block\n if (iv) {\n var block = iv;\n\n // Remove IV for subsequent blocks\n this._iv = undefined;\n } else {\n var block = this._prevBlock;\n }\n\n // XOR blocks\n for (var i = 0; i < blockSize; i++) {\n words[offset + i] ^= block[i];\n }\n }\n\n return CBC;\n }());\n\n /**\n * Padding namespace.\n */\n var C_pad = C.pad = {};\n\n /**\n * PKCS #5/7 padding strategy.\n */\n var Pkcs7 = C_pad.Pkcs7 = {\n /**\n * Pads data using the algorithm defined in PKCS #5/7.\n *\n * @param {WordArray} data The data to pad.\n * @param {number} blockSize The multiple that the data should be padded to.\n *\n * @static\n *\n * @example\n *\n * CryptoJS.pad.Pkcs7.pad(wordArray, 4);\n */\n pad: function (data, blockSize) {\n // Shortcut\n var blockSizeBytes = blockSize * 4;\n\n // Count padding bytes\n var nPaddingBytes = blockSizeBytes - data.sigBytes % blockSizeBytes;\n\n // Create padding word\n var paddingWord = (nPaddingBytes << 24) | (nPaddingBytes << 16) | (nPaddingBytes << 8) | nPaddingBytes;\n\n // Create padding\n var paddingWords = [];\n for (var i = 0; i < nPaddingBytes; i += 4) {\n paddingWords.push(paddingWord);\n }\n var padding = WordArray.create(paddingWords, nPaddingBytes);\n\n // Add padding\n data.concat(padding);\n },\n\n /**\n * Unpads data that had been padded using the algorithm defined in PKCS #5/7.\n *\n * @param {WordArray} data The data to unpad.\n *\n * @static\n *\n * @example\n *\n * CryptoJS.pad.Pkcs7.unpad(wordArray);\n */\n unpad: function (data) {\n // Get number of padding bytes from last byte\n var nPaddingBytes = data.words[(data.sigBytes - 1) >>> 2] & 0xff;\n\n // Remove padding\n data.sigBytes -= nPaddingBytes;\n }\n };\n\n /**\n * Abstract base block cipher template.\n *\n * @property {number} blockSize The number of 32-bit words this cipher operates on. Default: 4 (128 bits)\n */\n var BlockCipher = C_lib.BlockCipher = Cipher.extend({\n /**\n * Configuration options.\n *\n * @property {Mode} mode The block mode to use. Default: CBC\n * @property {Padding} padding The padding strategy to use. Default: Pkcs7\n */\n cfg: Cipher.cfg.extend({\n mode: CBC,\n padding: Pkcs7\n }),\n\n reset: function () {\n // Reset cipher\n Cipher.reset.call(this);\n\n // Shortcuts\n var cfg = this.cfg;\n var iv = cfg.iv;\n var mode = cfg.mode;\n\n // Reset block mode\n if (this._xformMode == this._ENC_XFORM_MODE) {\n var modeCreator = mode.createEncryptor;\n } else /* if (this._xformMode == this._DEC_XFORM_MODE) */ {\n var modeCreator = mode.createDecryptor;\n\n // Keep at least one block in the buffer for unpadding\n this._minBufferSize = 1;\n }\n this._mode = modeCreator.call(mode, this, iv && iv.words);\n },\n\n _doProcessBlock: function (words, offset) {\n this._mode.processBlock(words, offset);\n },\n\n _doFinalize: function () {\n // Shortcut\n var padding = this.cfg.padding;\n\n // Finalize\n if (this._xformMode == this._ENC_XFORM_MODE) {\n // Pad data\n padding.pad(this._data, this.blockSize);\n\n // Process final blocks\n var finalProcessedBlocks = this._process(!!'flush');\n } else /* if (this._xformMode == this._DEC_XFORM_MODE) */ {\n // Process final blocks\n var finalProcessedBlocks = this._process(!!'flush');\n\n // Unpad data\n padding.unpad(finalProcessedBlocks);\n }\n\n return finalProcessedBlocks;\n },\n\n blockSize: 128 / 32\n });\n\n /**\n * A collection of cipher parameters.\n *\n * @property {WordArray} ciphertext The raw ciphertext.\n * @property {WordArray} key The key to this ciphertext.\n * @property {WordArray} iv The IV used in the ciphering operation.\n * @property {WordArray} salt The salt used with a key derivation function.\n * @property {Cipher} algorithm The cipher algorithm.\n * @property {Mode} mode The block mode used in the ciphering operation.\n * @property {Padding} padding The padding scheme used in the ciphering operation.\n * @property {number} blockSize The block size of the cipher.\n * @property {Format} formatter The default formatting strategy to convert this cipher params object to a string.\n */\n var CipherParams = C_lib.CipherParams = Base.extend({\n /**\n * Initializes a newly created cipher params object.\n *\n * @param {Object} cipherParams An object with any of the possible cipher parameters.\n *\n * @example\n *\n * var cipherParams = CryptoJS.lib.CipherParams.create({\n * ciphertext: ciphertextWordArray,\n * key: keyWordArray,\n * iv: ivWordArray,\n * salt: saltWordArray,\n * algorithm: CryptoJS.algo.AES,\n * mode: CryptoJS.mode.CBC,\n * padding: CryptoJS.pad.PKCS7,\n * blockSize: 4,\n * formatter: CryptoJS.format.OpenSSL\n * });\n */\n init: function (cipherParams) {\n this.mixIn(cipherParams);\n },\n\n /**\n * Converts this cipher params object to a string.\n *\n * @param {Format} formatter (Optional) The formatting strategy to use.\n *\n * @return {string} The stringified cipher params.\n *\n * @throws Error If neither the formatter nor the default formatter is set.\n *\n * @example\n *\n * var string = cipherParams + '';\n * var string = cipherParams.toString();\n * var string = cipherParams.toString(CryptoJS.format.OpenSSL);\n */\n toString: function (formatter) {\n return (formatter || this.formatter).stringify(this);\n }\n });\n\n /**\n * Format namespace.\n */\n var C_format = C.format = {};\n\n /**\n * OpenSSL formatting strategy.\n */\n var OpenSSLFormatter = C_format.OpenSSL = {\n /**\n * Converts a cipher params object to an OpenSSL-compatible string.\n *\n * @param {CipherParams} cipherParams The cipher params object.\n *\n * @return {string} The OpenSSL-compatible string.\n *\n * @static\n *\n * @example\n *\n * var openSSLString = CryptoJS.format.OpenSSL.stringify(cipherParams);\n */\n stringify: function (cipherParams) {\n // Shortcuts\n var ciphertext = cipherParams.ciphertext;\n var salt = cipherParams.salt;\n\n // Format\n if (salt) {\n var wordArray = WordArray.create([0x53616c74, 0x65645f5f]).concat(salt).concat(ciphertext);\n } else {\n var wordArray = ciphertext;\n }\n\n return wordArray.toString(Base64);\n },\n\n /**\n * Converts an OpenSSL-compatible string to a cipher params object.\n *\n * @param {string} openSSLStr The OpenSSL-compatible string.\n *\n * @return {CipherParams} The cipher params object.\n *\n * @static\n *\n * @example\n *\n * var cipherParams = CryptoJS.format.OpenSSL.parse(openSSLString);\n */\n parse: function (openSSLStr) {\n // Parse base64\n var ciphertext = Base64.parse(openSSLStr);\n\n // Shortcut\n var ciphertextWords = ciphertext.words;\n\n // Test for salt\n if (ciphertextWords[0] == 0x53616c74 && ciphertextWords[1] == 0x65645f5f) {\n // Extract salt\n var salt = WordArray.create(ciphertextWords.slice(2, 4));\n\n // Remove salt from ciphertext\n ciphertextWords.splice(0, 4);\n ciphertext.sigBytes -= 16;\n }\n\n return CipherParams.create({ciphertext: ciphertext, salt: salt});\n }\n };\n\n /**\n * A cipher wrapper that returns ciphertext as a serializable cipher params object.\n */\n var SerializableCipher = C_lib.SerializableCipher = Base.extend({\n /**\n * Configuration options.\n *\n * @property {Formatter} format The formatting strategy to convert cipher param objects to and from a string. Default: OpenSSL\n */\n cfg: Base.extend({\n format: OpenSSLFormatter\n }),\n\n /**\n * Encrypts a message.\n *\n * @param {Cipher} cipher The cipher algorithm to use.\n * @param {WordArray|string} message The message to encrypt.\n * @param {WordArray} key The key.\n * @param {Object} cfg (Optional) The configuration options to use for this operation.\n *\n * @return {CipherParams} A cipher params object.\n *\n * @static\n *\n * @example\n *\n * var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key);\n * var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key, { iv: iv });\n * var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key, { iv: iv, format: CryptoJS.format.OpenSSL });\n */\n encrypt: function (cipher, message, key, cfg) {\n // Apply config defaults\n cfg = this.cfg.extend(cfg);\n\n // Encrypt\n var encryptor = cipher.createEncryptor(key, cfg);\n var ciphertext = encryptor.finalize(message);\n\n // Shortcut\n var cipherCfg = encryptor.cfg;\n\n // Create and return serializable cipher params\n return CipherParams.create({\n ciphertext: ciphertext,\n key: key,\n iv: cipherCfg.iv,\n algorithm: cipher,\n mode: cipherCfg.mode,\n padding: cipherCfg.padding,\n blockSize: cipher.blockSize,\n formatter: cfg.format\n });\n },\n\n /**\n * Decrypts serialized ciphertext.\n *\n * @param {Cipher} cipher The cipher algorithm to use.\n * @param {CipherParams|string} ciphertext The ciphertext to decrypt.\n * @param {WordArray} key The key.\n * @param {Object} cfg (Optional) The configuration options to use for this operation.\n *\n * @return {WordArray} The plaintext.\n *\n * @static\n *\n * @example\n *\n * var plaintext = CryptoJS.lib.SerializableCipher.decrypt(CryptoJS.algo.AES, formattedCiphertext, key, { iv: iv, format: CryptoJS.format.OpenSSL });\n * var plaintext = CryptoJS.lib.SerializableCipher.decrypt(CryptoJS.algo.AES, ciphertextParams, key, { iv: iv, format: CryptoJS.format.OpenSSL });\n */\n decrypt: function (cipher, ciphertext, key, cfg) {\n // Apply config defaults\n cfg = this.cfg.extend(cfg);\n\n // Convert string to CipherParams\n ciphertext = this._parse(ciphertext, cfg.format);\n\n // Decrypt\n var plaintext = cipher.createDecryptor(key, cfg).finalize(ciphertext.ciphertext);\n\n return plaintext;\n },\n\n /**\n * Converts serialized ciphertext to CipherParams,\n * else assumed CipherParams already and returns ciphertext unchanged.\n *\n * @param {CipherParams|string} ciphertext The ciphertext.\n * @param {Formatter} format The formatting strategy to use to parse serialized ciphertext.\n *\n * @return {CipherParams} The unserialized ciphertext.\n *\n * @static\n *\n * @example\n *\n * var ciphertextParams = CryptoJS.lib.SerializableCipher._parse(ciphertextStringOrParams, format);\n */\n _parse: function (ciphertext, format) {\n if (typeof ciphertext == 'string') {\n return format.parse(ciphertext, this);\n } else {\n return ciphertext;\n }\n }\n });\n\n /**\n * Key derivation function namespace.\n */\n var C_kdf = C.kdf = {};\n\n /**\n * OpenSSL key derivation function.\n */\n var OpenSSLKdf = C_kdf.OpenSSL = {\n /**\n * Derives a key and IV from a password.\n *\n * @param {string} password The password to derive from.\n * @param {number} keySize The size in words of the key to generate.\n * @param {number} ivSize The size in words of the IV to generate.\n * @param {WordArray|string} salt (Optional) A 64-bit salt to use. If omitted, a salt will be generated randomly.\n *\n * @return {CipherParams} A cipher params object with the key, IV, and salt.\n *\n * @static\n *\n * @example\n *\n * var derivedParams = CryptoJS.kdf.OpenSSL.execute('Password', 256/32, 128/32);\n * var derivedParams = CryptoJS.kdf.OpenSSL.execute('Password', 256/32, 128/32, 'saltsalt');\n */\n execute: function (password, keySize, ivSize, salt) {\n // Generate random salt\n if (!salt) {\n salt = WordArray.random(64 / 8);\n }\n\n // Derive key and IV\n var key = EvpKDF.create({keySize: keySize + ivSize}).compute(password, salt);\n\n // Separate key and IV\n var iv = WordArray.create(key.words.slice(keySize), ivSize * 4);\n key.sigBytes = keySize * 4;\n\n // Return params\n return CipherParams.create({key: key, iv: iv, salt: salt});\n }\n };\n\n /**\n * A serializable cipher wrapper that derives the key from a password,\n * and returns ciphertext as a serializable cipher params object.\n */\n var PasswordBasedCipher = C_lib.PasswordBasedCipher = SerializableCipher.extend({\n /**\n * Configuration options.\n *\n * @property {KDF} kdf The key derivation function to use to generate a key and IV from a password. Default: OpenSSL\n */\n cfg: SerializableCipher.cfg.extend({\n kdf: OpenSSLKdf\n }),\n\n /**\n * Encrypts a message using a password.\n *\n * @param {Cipher} cipher The cipher algorithm to use.\n * @param {WordArray|string} message The message to encrypt.\n * @param {string} password The password.\n * @param {Object} cfg (Optional) The configuration options to use for this operation.\n *\n * @return {CipherParams} A cipher params object.\n *\n * @static\n *\n * @example\n *\n * var ciphertextParams = CryptoJS.lib.PasswordBasedCipher.encrypt(CryptoJS.algo.AES, message, 'password');\n * var ciphertextParams = CryptoJS.lib.PasswordBasedCipher.encrypt(CryptoJS.algo.AES, message, 'password', { format: CryptoJS.format.OpenSSL });\n */\n encrypt: function (cipher, message, password, cfg) {\n // Apply config defaults\n cfg = this.cfg.extend(cfg);\n\n // Derive key and other params\n var derivedParams = cfg.kdf.execute(password, cipher.keySize, cipher.ivSize);\n\n // Add IV to config\n cfg.iv = derivedParams.iv;\n\n // Encrypt\n var ciphertext = SerializableCipher.encrypt.call(this, cipher, message, derivedParams.key, cfg);\n\n // Mix in derived params\n ciphertext.mixIn(derivedParams);\n\n return ciphertext;\n },\n\n /**\n * Decrypts serialized ciphertext using a password.\n *\n * @param {Cipher} cipher The cipher algorithm to use.\n * @param {CipherParams|string} ciphertext The ciphertext to decrypt.\n * @param {string} password The password.\n * @param {Object} cfg (Optional) The configuration options to use for this operation.\n *\n * @return {WordArray} The plaintext.\n *\n * @static\n *\n * @example\n *\n * var plaintext = CryptoJS.lib.PasswordBasedCipher.decrypt(CryptoJS.algo.AES, formattedCiphertext, 'password', { format: CryptoJS.format.OpenSSL });\n * var plaintext = CryptoJS.lib.PasswordBasedCipher.decrypt(CryptoJS.algo.AES, ciphertextParams, 'password', { format: CryptoJS.format.OpenSSL });\n */\n decrypt: function (cipher, ciphertext, password, cfg) {\n // Apply config defaults\n cfg = this.cfg.extend(cfg);\n\n // Convert string to CipherParams\n ciphertext = this._parse(ciphertext, cfg.format);\n\n // Derive key and other params\n var derivedParams = cfg.kdf.execute(password, cipher.keySize, cipher.ivSize, ciphertext.salt);\n\n // Add IV to config\n cfg.iv = derivedParams.iv;\n\n // Decrypt\n var plaintext = SerializableCipher.decrypt.call(this, cipher, ciphertext, derivedParams.key, cfg);\n\n return plaintext;\n }\n });\n }());\n\n /*\n CryptoJS v3.1.2\n code.google.com/p/crypto-js\n (c) 2009-2013 by Jeff Mott. All rights reserved.\n code.google.com/p/crypto-js/wiki/License\n */\n /**\n * Electronic Codebook block mode.\n */\n CryptoJS.mode.ECB = (function () {\n var ECB = CryptoJS.lib.BlockCipherMode.extend();\n\n ECB.Encryptor = ECB.extend({\n processBlock: function (words, offset) {\n this._cipher.encryptBlock(words, offset);\n }\n });\n\n ECB.Decryptor = ECB.extend({\n processBlock: function (words, offset) {\n this._cipher.decryptBlock(words, offset);\n }\n });\n\n return ECB;\n }());\n\n\n /*\n CryptoJS v3.1.2\n code.google.com/p/crypto-js\n (c) 2009-2013 by Jeff Mott. All rights reserved.\n code.google.com/p/crypto-js/wiki/License\n */\n (function () {\n // Shortcuts\n var C = CryptoJS;\n var C_lib = C.lib;\n var BlockCipher = C_lib.BlockCipher;\n var C_algo = C.algo;\n\n // Lookup tables\n var SBOX = [];\n var INV_SBOX = [];\n var SUB_MIX_0 = [];\n var SUB_MIX_1 = [];\n var SUB_MIX_2 = [];\n var SUB_MIX_3 = [];\n var INV_SUB_MIX_0 = [];\n var INV_SUB_MIX_1 = [];\n var INV_SUB_MIX_2 = [];\n var INV_SUB_MIX_3 = [];\n\n // Compute lookup tables\n (function () {\n // Compute double table\n var d = [];\n for (var i = 0; i < 256; i++) {\n if (i < 128) {\n d[i] = i << 1;\n } else {\n d[i] = (i << 1) ^ 0x11b;\n }\n }\n\n // Walk GF(2^8)\n var x = 0;\n var xi = 0;\n for (var i = 0; i < 256; i++) {\n // Compute sbox\n var sx = xi ^ (xi << 1) ^ (xi << 2) ^ (xi << 3) ^ (xi << 4);\n sx = (sx >>> 8) ^ (sx & 0xff) ^ 0x63;\n SBOX[x] = sx;\n INV_SBOX[sx] = x;\n\n // Compute multiplication\n var x2 = d[x];\n var x4 = d[x2];\n var x8 = d[x4];\n\n // Compute sub bytes, mix columns tables\n var t = (d[sx] * 0x101) ^ (sx * 0x1010100);\n SUB_MIX_0[x] = (t << 24) | (t >>> 8);\n SUB_MIX_1[x] = (t << 16) | (t >>> 16);\n SUB_MIX_2[x] = (t << 8) | (t >>> 24);\n SUB_MIX_3[x] = t;\n\n // Compute inv sub bytes, inv mix columns tables\n var t = (x8 * 0x1010101) ^ (x4 * 0x10001) ^ (x2 * 0x101) ^ (x * 0x1010100);\n INV_SUB_MIX_0[sx] = (t << 24) | (t >>> 8);\n INV_SUB_MIX_1[sx] = (t << 16) | (t >>> 16);\n INV_SUB_MIX_2[sx] = (t << 8) | (t >>> 24);\n INV_SUB_MIX_3[sx] = t;\n\n // Compute next counter\n if (!x) {\n x = xi = 1;\n } else {\n x = x2 ^ d[d[d[x8 ^ x2]]];\n xi ^= d[d[xi]];\n }\n }\n }());\n\n // Precomputed Rcon lookup\n var RCON = [0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36];\n\n /**\n * AES block cipher algorithm.\n */\n var AES = C_algo.AES = BlockCipher.extend({\n _doReset: function () {\n // Shortcuts\n var key = this._key;\n var keyWords = key.words;\n var keySize = key.sigBytes / 4;\n\n // Compute number of rounds\n var nRounds = this._nRounds = keySize + 6;\n\n // Compute number of key schedule rows\n var ksRows = (nRounds + 1) * 4;\n\n // Compute key schedule\n var keySchedule = this._keySchedule = [];\n for (var ksRow = 0; ksRow < ksRows; ksRow++) {\n if (ksRow < keySize) {\n keySchedule[ksRow] = keyWords[ksRow];\n } else {\n var t = keySchedule[ksRow - 1];\n\n if (!(ksRow % keySize)) {\n // Rot word\n t = (t << 8) | (t >>> 24);\n\n // Sub word\n t = (SBOX[t >>> 24] << 24) | (SBOX[(t >>> 16) & 0xff] << 16) | (SBOX[(t >>> 8) & 0xff] << 8) | SBOX[t & 0xff];\n\n // Mix Rcon\n t ^= RCON[(ksRow / keySize) | 0] << 24;\n } else if (keySize > 6 && ksRow % keySize == 4) {\n // Sub word\n t = (SBOX[t >>> 24] << 24) | (SBOX[(t >>> 16) & 0xff] << 16) | (SBOX[(t >>> 8) & 0xff] << 8) | SBOX[t & 0xff];\n }\n\n keySchedule[ksRow] = keySchedule[ksRow - keySize] ^ t;\n }\n }\n\n // Compute inv key schedule\n var invKeySchedule = this._invKeySchedule = [];\n for (var invKsRow = 0; invKsRow < ksRows; invKsRow++) {\n var ksRow = ksRows - invKsRow;\n\n if (invKsRow % 4) {\n var t = keySchedule[ksRow];\n } else {\n var t = keySchedule[ksRow - 4];\n }\n\n if (invKsRow < 4 || ksRow <= 4) {\n invKeySchedule[invKsRow] = t;\n } else {\n invKeySchedule[invKsRow] = INV_SUB_MIX_0[SBOX[t >>> 24]] ^ INV_SUB_MIX_1[SBOX[(t >>> 16) & 0xff]] ^\n INV_SUB_MIX_2[SBOX[(t >>> 8) & 0xff]] ^ INV_SUB_MIX_3[SBOX[t & 0xff]];\n }\n }\n },\n\n encryptBlock: function (M, offset) {\n this._doCryptBlock(M, offset, this._keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX);\n },\n\n decryptBlock: function (M, offset) {\n // Swap 2nd and 4th rows\n var t = M[offset + 1];\n M[offset + 1] = M[offset + 3];\n M[offset + 3] = t;\n\n this._doCryptBlock(M, offset, this._invKeySchedule, INV_SUB_MIX_0, INV_SUB_MIX_1, INV_SUB_MIX_2, INV_SUB_MIX_3, INV_SBOX);\n\n // Inv swap 2nd and 4th rows\n var t = M[offset + 1];\n M[offset + 1] = M[offset + 3];\n M[offset + 3] = t;\n },\n\n _doCryptBlock: function (M, offset, keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX) {\n // Shortcut\n var nRounds = this._nRounds;\n\n // Get input, add round key\n var s0 = M[offset] ^ keySchedule[0];\n var s1 = M[offset + 1] ^ keySchedule[1];\n var s2 = M[offset + 2] ^ keySchedule[2];\n var s3 = M[offset + 3] ^ keySchedule[3];\n\n // Key schedule row counter\n var ksRow = 4;\n\n // Rounds\n for (var round = 1; round < nRounds; round++) {\n // Shift rows, sub bytes, mix columns, add round key\n var t0 = SUB_MIX_0[s0 >>> 24] ^ SUB_MIX_1[(s1 >>> 16) & 0xff] ^ SUB_MIX_2[(s2 >>> 8) & 0xff] ^ SUB_MIX_3[s3 & 0xff] ^ keySchedule[ksRow++];\n var t1 = SUB_MIX_0[s1 >>> 24] ^ SUB_MIX_1[(s2 >>> 16) & 0xff] ^ SUB_MIX_2[(s3 >>> 8) & 0xff] ^ SUB_MIX_3[s0 & 0xff] ^ keySchedule[ksRow++];\n var t2 = SUB_MIX_0[s2 >>> 24] ^ SUB_MIX_1[(s3 >>> 16) & 0xff] ^ SUB_MIX_2[(s0 >>> 8) & 0xff] ^ SUB_MIX_3[s1 & 0xff] ^ keySchedule[ksRow++];\n var t3 = SUB_MIX_0[s3 >>> 24] ^ SUB_MIX_1[(s0 >>> 16) & 0xff] ^ SUB_MIX_2[(s1 >>> 8) & 0xff] ^ SUB_MIX_3[s2 & 0xff] ^ keySchedule[ksRow++];\n\n // Update state\n s0 = t0;\n s1 = t1;\n s2 = t2;\n s3 = t3;\n }\n\n // Shift rows, sub bytes, add round key\n var t0 = ((SBOX[s0 >>> 24] << 24) | (SBOX[(s1 >>> 16) & 0xff] << 16) | (SBOX[(s2 >>> 8) & 0xff] << 8) | SBOX[s3 & 0xff]) ^ keySchedule[ksRow++];\n var t1 = ((SBOX[s1 >>> 24] << 24) | (SBOX[(s2 >>> 16) & 0xff] << 16) | (SBOX[(s3 >>> 8) & 0xff] << 8) | SBOX[s0 & 0xff]) ^ keySchedule[ksRow++];\n var t2 = ((SBOX[s2 >>> 24] << 24) | (SBOX[(s3 >>> 16) & 0xff] << 16) | (SBOX[(s0 >>> 8) & 0xff] << 8) | SBOX[s1 & 0xff]) ^ keySchedule[ksRow++];\n var t3 = ((SBOX[s3 >>> 24] << 24) | (SBOX[(s0 >>> 16) & 0xff] << 16) | (SBOX[(s1 >>> 8) & 0xff] << 8) | SBOX[s2 & 0xff]) ^ keySchedule[ksRow++];\n\n // Set output\n M[offset] = t0;\n M[offset + 1] = t1;\n M[offset + 2] = t2;\n M[offset + 3] = t3;\n },\n\n keySize: 256 / 32\n });\n\n /**\n * Shortcut functions to the cipher's object interface.\n *\n * @example\n *\n * var ciphertext = CryptoJS.AES.encrypt(message, key, cfg);\n * var plaintext = CryptoJS.AES.decrypt(ciphertext, key, cfg);\n */\n C.AES = BlockCipher._createHelper(AES);\n }());\n\n\n _.extend(BI, {\n /**\n * aes加密方法\n * aes-128-ecb\n *\n * @example\n *\n * var ciphertext = BI.aesEncrypt(text, key);\n */\n aesEncrypt: function (text, key) {\n key = CryptoJS.enc.Utf8.parse(key);\n var cipher = CryptoJS.AES.encrypt(text, key, {\n mode: CryptoJS.mode.ECB,\n padding: CryptoJS.pad.Pkcs7\n });\n\n var base64Cipher = cipher.ciphertext.toString(CryptoJS.enc.Base64);\n return base64Cipher;\n }\n });\n}());!(function () {\n function aspect (type) {\n return function (target, methodName, advice) {\n var exist = target[methodName],\n dispatcher;\n\n if (!exist || exist.target != target) {\n dispatcher = target[methodName] = function () {\n // before methods\n var beforeArr = dispatcher.before;\n var args = arguments, next;\n for (var l = beforeArr.length; l--;) {\n next = beforeArr[l].advice.apply(this, args);\n if (next === false) {\n return false;\n }\n args = next || args;\n }\n // target method\n var rs = dispatcher.method.apply(this, args);\n // after methods\n var afterArr = dispatcher.after;\n for (var i = 0, ii = afterArr.length; i < ii; i++) {\n next = afterArr[i].advice.call(this, rs, args);\n if (rs === false) {\n return false;\n }\n args = next || args;\n }\n return rs;\n };\n\n dispatcher.before = [];\n dispatcher.after = [];\n\n if (exist) {\n dispatcher.method = exist;\n }\n dispatcher.target = target;\n }\n\n var aspectArr = (dispatcher || exist)[type];\n var obj = {\n advice: advice,\n _index: aspectArr.length,\n remove: function () {\n aspectArr.splice(this._index, 1);\n }\n };\n aspectArr.push(obj);\n\n return obj;\n };\n }\n\n BI.aspect = {\n before: aspect(\"before\"),\n after: aspect(\"after\")\n };\n\n return BI.aspect;\n\n})();\n!(function () {\n\n var _keyStr = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\";\n\n\n // private method for UTF-8 encoding\n var _utf8_encode = function (string) {\n string = string.replace(/\\r\\n/g, \"\\n\");\n var utftext = \"\";\n\n for (var n = 0; n < string.length; n++) {\n\n var c = string.charCodeAt(n);\n\n if (c < 128) {\n utftext += String.fromCharCode(c);\n } else if ((c > 127) && (c < 2048)) {\n utftext += String.fromCharCode((c >> 6) | 192);\n utftext += String.fromCharCode((c & 63) | 128);\n } else {\n utftext += String.fromCharCode((c >> 12) | 224);\n utftext += String.fromCharCode(((c >> 6) & 63) | 128);\n utftext += String.fromCharCode((c & 63) | 128);\n }\n\n }\n\n return utftext;\n };\n\n // private method for UTF-8 decoding\n var _utf8_decode = function (utftext) {\n var string = \"\";\n var i = 0;\n var c = 0, c3 = 0, c2 = 0;\n\n while (i < utftext.length) {\n\n c = utftext.charCodeAt(i);\n\n if (c < 128) {\n string += String.fromCharCode(c);\n i++;\n } else if ((c > 191) && (c < 224)) {\n c2 = utftext.charCodeAt(i + 1);\n string += String.fromCharCode(((c & 31) << 6) | (c2 & 63));\n i += 2;\n } else {\n c2 = utftext.charCodeAt(i + 1);\n c3 = utftext.charCodeAt(i + 2);\n string += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));\n i += 3;\n }\n\n }\n return string;\n };\n\n _.extend(BI, {\n\n encode: function (input) {\n var output = \"\";\n var chr1, chr2, chr3, enc1, enc2, enc3, enc4;\n var i = 0;\n\n input = _utf8_encode(input);\n\n while (i < input.length) {\n\n chr1 = input.charCodeAt(i++);\n chr2 = input.charCodeAt(i++);\n chr3 = input.charCodeAt(i++);\n\n enc1 = chr1 >> 2;\n enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);\n enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);\n enc4 = chr3 & 63;\n\n if (isNaN(chr2)) {\n enc3 = enc4 = 64;\n } else if (isNaN(chr3)) {\n enc4 = 64;\n }\n\n output = output + _keyStr.charAt(enc1) + _keyStr.charAt(enc2) + _keyStr.charAt(enc3) + _keyStr.charAt(enc4);\n\n }\n\n return output;\n },\n\n // public method for decoding\n decode: function (input) {\n var output = \"\";\n var chr1, chr2, chr3;\n var enc1, enc2, enc3, enc4;\n var i = 0;\n\n input = input.replace(/[^A-Za-z0-9\\+\\/\\=]/g, \"\");\n\n while (i < input.length) {\n\n enc1 = _keyStr.indexOf(input.charAt(i++));\n enc2 = _keyStr.indexOf(input.charAt(i++));\n enc3 = _keyStr.indexOf(input.charAt(i++));\n enc4 = _keyStr.indexOf(input.charAt(i++));\n\n chr1 = (enc1 << 2) | (enc2 >> 4);\n chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);\n chr3 = ((enc3 & 3) << 6) | enc4;\n\n output = output + String.fromCharCode(chr1);\n\n if (enc3 != 64) {\n output = output + String.fromCharCode(chr2);\n }\n if (enc4 != 64) {\n output = output + String.fromCharCode(chr3);\n }\n\n }\n\n output = _utf8_decode(output);\n\n return output;\n\n }\n });\n})();\nBI.Cache = {\n _prefix: \"bi\",\n setUsername: function (username) {\n localStorage.setItem(BI.Cache._prefix + \".username\", (username + \"\" || \"\").toUpperCase());\n },\n getUsername: function () {\n return localStorage.getItem(BI.Cache._prefix + \".username\") || \"\";\n },\n _getKeyPrefix: function () {\n return BI.Cache.getUsername() + \".\" + BI.Cache._prefix + \".\";\n },\n _generateKey: function (key) {\n return BI.Cache._getKeyPrefix() + (key || \"\");\n },\n getItem: function (key) {\n return localStorage.getItem(BI.Cache._generateKey(key));\n },\n setItem: function (key, value) {\n localStorage.setItem(BI.Cache._generateKey(key), value);\n },\n removeItem: function (key) {\n localStorage.removeItem(BI.Cache._generateKey(key));\n },\n clear: function () {\n for (var i = localStorage.length; i >= 0; i--) {\n var key = localStorage.key(i);\n if (key) {\n if (key.indexOf(BI.Cache._getKeyPrefix()) === 0) {\n localStorage.removeItem(key);\n }\n }\n }\n },\n keys: function () {\n var result = [];\n for (var i = localStorage.length; i >= 0; i--) {\n var key = localStorage.key(i);\n if (key) {\n var prefix = BI.Cache._getKeyPrefix();\n if (key.indexOf(prefix) === 0) {\n result[result.length] = key.substring(prefix.length);\n }\n }\n }\n return result;\n },\n\n addCookie: function (name, value, path, expiresHours) {\n var cookieString = name + \"=\" + escape(value);\n // 判断是否设置过期时间\n if (expiresHours && expiresHours > 0) {\n var date = new Date();\n date.setTime(BI.getTime() + expiresHours * 3600 * 1000);\n cookieString = cookieString + \"; expires=\" + date.toGMTString();\n }\n if (path) {\n cookieString = cookieString + \"; path=\" + path;\n }\n document.cookie = cookieString;\n },\n getCookie: function (name) {\n var arr, reg = new RegExp(\"(^| )\" + name + \"=([^;]*)(;|$)\");\n if (arr = document.cookie.match(reg)) {return unescape(arr[2]);}\n return null;\n },\n deleteCookie: function (name, path) {\n var date = new Date();\n date.setTime(BI.getTime() - 10000);\n var cookieString = name + \"=v; expires=\" + date.toGMTString();\n if (path) {\n cookieString = cookieString + \"; path=\" + path;\n }\n document.cookie = cookieString;\n }\n};BI.CellSizeAndPositionManager = function (cellCount, cellSizeGetter, estimatedCellSize) {\n this._cellSizeGetter = cellSizeGetter;\n this._cellCount = cellCount;\n this._estimatedCellSize = estimatedCellSize;\n this._cellSizeAndPositionData = {};\n this._lastMeasuredIndex = -1;\n};\n\nBI.CellSizeAndPositionManager.prototype = {\n constructor: BI.CellSizeAndPositionManager,\n configure: function (cellCount, estimatedCellSize) {\n this._cellCount = cellCount;\n this._estimatedCellSize = estimatedCellSize;\n },\n\n getCellCount: function () {\n return this._cellCount;\n },\n\n getEstimatedCellSize: function () {\n return this._estimatedCellSize;\n },\n\n getLastMeasuredIndex: function () {\n return this._lastMeasuredIndex;\n },\n\n getSizeAndPositionOfCell: function (index) {\n if (index < 0 || index >= this._cellCount) {\n return;\n }\n if (index > this._lastMeasuredIndex) {\n var lastMeasuredCellSizeAndPosition = this.getSizeAndPositionOfLastMeasuredCell();\n var offset = lastMeasuredCellSizeAndPosition.offset + lastMeasuredCellSizeAndPosition.size;\n\n for (var i = this._lastMeasuredIndex + 1; i <= index; i++) {\n var size = this._cellSizeGetter(i);\n\n if (size == null || isNaN(size)) {\n continue;\n }\n\n this._cellSizeAndPositionData[i] = {\n offset: offset,\n size: size\n };\n\n offset += size;\n }\n\n this._lastMeasuredIndex = index;\n }\n return this._cellSizeAndPositionData[index];\n },\n\n getSizeAndPositionOfLastMeasuredCell: function () {\n return this._lastMeasuredIndex >= 0\n ? this._cellSizeAndPositionData[this._lastMeasuredIndex]\n : {\n offset: 0,\n size: 0\n };\n },\n\n getTotalSize: function () {\n var lastMeasuredCellSizeAndPosition = this.getSizeAndPositionOfLastMeasuredCell();\n return lastMeasuredCellSizeAndPosition.offset + lastMeasuredCellSizeAndPosition.size + (this._cellCount - this._lastMeasuredIndex - 1) * this._estimatedCellSize;\n },\n\n getUpdatedOffsetForIndex: function (align, containerSize, currentOffset, targetIndex) {\n var datum = this.getSizeAndPositionOfCell(targetIndex);\n var maxOffset = datum.offset;\n var minOffset = maxOffset - containerSize + datum.size;\n\n var idealOffset;\n\n switch (align) {\n case \"start\":\n idealOffset = maxOffset;\n break;\n case \"end\":\n idealOffset = minOffset;\n break;\n case \"center\":\n idealOffset = maxOffset - ((containerSize - datum.size) / 2);\n break;\n default:\n idealOffset = Math.max(minOffset, Math.min(maxOffset, currentOffset));\n break;\n }\n\n var totalSize = this.getTotalSize();\n\n return Math.max(0, Math.min(totalSize - containerSize, idealOffset));\n },\n\n getVisibleCellRange: function (containerSize, offset) {\n var totalSize = this.getTotalSize();\n\n if (totalSize === 0) {\n return {};\n }\n\n var maxOffset = offset + containerSize;\n var start = this._findNearestCell(offset);\n\n var datum = this.getSizeAndPositionOfCell(start);\n offset = datum.offset + datum.size;\n\n var stop = start;\n\n while (offset < maxOffset && stop < this._cellCount - 1) {\n stop++;\n offset += this.getSizeAndPositionOfCell(stop).size;\n }\n\n return {\n start: start,\n stop: stop\n };\n },\n\n resetCell: function (index) {\n this._lastMeasuredIndex = Math.min(this._lastMeasuredIndex, index - 1);\n },\n\n _binarySearch: function (high, low, offset) {\n var middle;\n var currentOffset;\n\n while (low <= high) {\n middle = low + Math.floor((high - low) / 2);\n currentOffset = this.getSizeAndPositionOfCell(middle).offset;\n\n if (currentOffset === offset) {\n return middle;\n } else if (currentOffset < offset) {\n low = middle + 1;\n } else if (currentOffset > offset) {\n high = middle - 1;\n }\n }\n\n if (low > 0) {\n return low - 1;\n }\n },\n\n _exponentialSearch: function (index, offset) {\n var interval = 1;\n\n while (index < this._cellCount && this.getSizeAndPositionOfCell(index).offset < offset) {\n index += interval;\n interval *= 2;\n }\n\n return this._binarySearch(Math.min(index, this._cellCount - 1), Math.floor(index / 2), offset);\n },\n\n _findNearestCell: function (offset) {\n if (isNaN(offset)) {\n return;\n }\n\n offset = Math.max(0, offset);\n\n var lastMeasuredCellSizeAndPosition = this.getSizeAndPositionOfLastMeasuredCell();\n var lastMeasuredIndex = Math.max(0, this._lastMeasuredIndex);\n\n if (lastMeasuredCellSizeAndPosition.offset >= offset) {\n return this._binarySearch(lastMeasuredIndex, 0, offset);\n }\n return this._exponentialSearch(lastMeasuredIndex, offset);\n \n }\n};\n\nBI.ScalingCellSizeAndPositionManager = function (cellCount, cellSizeGetter, estimatedCellSize, maxScrollSize) {\n this._cellSizeAndPositionManager = new BI.CellSizeAndPositionManager(cellCount, cellSizeGetter, estimatedCellSize);\n this._maxScrollSize = maxScrollSize || 10000000;\n};\n\nBI.ScalingCellSizeAndPositionManager.prototype = {\n constructor: BI.ScalingCellSizeAndPositionManager,\n\n configure: function () {\n this._cellSizeAndPositionManager.configure.apply(this._cellSizeAndPositionManager, arguments);\n },\n\n getCellCount: function () {\n return this._cellSizeAndPositionManager.getCellCount();\n },\n\n getEstimatedCellSize: function () {\n return this._cellSizeAndPositionManager.getEstimatedCellSize();\n },\n\n getLastMeasuredIndex: function () {\n return this._cellSizeAndPositionManager.getLastMeasuredIndex();\n },\n\n getOffsetAdjustment: function (containerSize, offset) {\n var totalSize = this._cellSizeAndPositionManager.getTotalSize();\n var safeTotalSize = this.getTotalSize();\n var offsetPercentage = this._getOffsetPercentage(containerSize, offset, safeTotalSize);\n\n return Math.round(offsetPercentage * (safeTotalSize - totalSize));\n },\n\n getSizeAndPositionOfCell: function (index) {\n return this._cellSizeAndPositionManager.getSizeAndPositionOfCell(index);\n },\n\n getSizeAndPositionOfLastMeasuredCell: function () {\n return this._cellSizeAndPositionManager.getSizeAndPositionOfLastMeasuredCell();\n },\n\n getTotalSize: function () {\n return Math.min(this._maxScrollSize, this._cellSizeAndPositionManager.getTotalSize());\n },\n\n getUpdatedOffsetForIndex: function (align, containerSize, currentOffset, targetIndex) {\n currentOffset = this._safeOffsetToOffset(containerSize, currentOffset);\n\n var offset = this._cellSizeAndPositionManager.getUpdatedOffsetForIndex(align, containerSize, currentOffset, targetIndex);\n\n return this._offsetToSafeOffset(containerSize, offset);\n },\n\n getVisibleCellRange: function (containerSize, offset) {\n offset = this._safeOffsetToOffset(containerSize, offset);\n\n return this._cellSizeAndPositionManager.getVisibleCellRange(containerSize, offset);\n },\n\n resetCell: function (index) {\n this._cellSizeAndPositionManager.resetCell(index);\n },\n\n _getOffsetPercentage: function (containerSize, offset, totalSize) {\n return totalSize <= containerSize\n ? 0\n : offset / (totalSize - containerSize);\n },\n\n _offsetToSafeOffset: function (containerSize, offset) {\n var totalSize = this._cellSizeAndPositionManager.getTotalSize();\n var safeTotalSize = this.getTotalSize();\n\n if (totalSize === safeTotalSize) {\n return offset;\n }\n var offsetPercentage = this._getOffsetPercentage(containerSize, offset, totalSize);\n\n return Math.round(offsetPercentage * (safeTotalSize - containerSize));\n \n },\n\n _safeOffsetToOffset: function (containerSize, offset) {\n var totalSize = this._cellSizeAndPositionManager.getTotalSize();\n var safeTotalSize = this.getTotalSize();\n\n if (totalSize === safeTotalSize) {\n return offset;\n }\n var offsetPercentage = this._getOffsetPercentage(containerSize, offset, safeTotalSize);\n\n return Math.round(offsetPercentage * (totalSize - containerSize));\n \n }\n};/**\n * 汉字拼音索引\n */\n\n!(function () {\n var _ChineseFirstPY = \"YDYQSXMWZSSXJBYMGCCZQPSSQBYCDSCDQLDYLYBSSJGYZZJJFKCCLZDHWDWZJLJPFYYNWJJTMYHZWZHFLZPPQHGSCYYYNJQYXXGJHHSDSJNKKTMOMLCRXYPSNQSECCQZGGLLYJLMYZZSECYKYYHQWJSSGGYXYZYJWWKDJHYCHMYXJTLXJYQBYXZLDWRDJRWYSRLDZJPCBZJJBRCFTLECZSTZFXXZHTRQHYBDLYCZSSYMMRFMYQZPWWJJYFCRWFDFZQPYDDWYXKYJAWJFFXYPSFTZYHHYZYSWCJYXSCLCXXWZZXNBGNNXBXLZSZSBSGPYSYZDHMDZBQBZCWDZZYYTZHBTSYYBZGNTNXQYWQSKBPHHLXGYBFMJEBJHHGQTJCYSXSTKZHLYCKGLYSMZXYALMELDCCXGZYRJXSDLTYZCQKCNNJWHJTZZCQLJSTSTBNXBTYXCEQXGKWJYFLZQLYHYXSPSFXLMPBYSXXXYDJCZYLLLSJXFHJXPJBTFFYABYXBHZZBJYZLWLCZGGBTSSMDTJZXPTHYQTGLJSCQFZKJZJQNLZWLSLHDZBWJNCJZYZSQQYCQYRZCJJWYBRTWPYFTWEXCSKDZCTBZHYZZYYJXZCFFZZMJYXXSDZZOTTBZLQWFCKSZSXFYRLNYJMBDTHJXSQQCCSBXYYTSYFBXDZTGBCNSLCYZZPSAZYZZSCJCSHZQYDXLBPJLLMQXTYDZXSQJTZPXLCGLQTZWJBHCTSYJSFXYEJJTLBGXSXJMYJQQPFZASYJNTYDJXKJCDJSZCBARTDCLYJQMWNQNCLLLKBYBZZSYHQQLTWLCCXTXLLZNTYLNEWYZYXCZXXGRKRMTCNDNJTSYYSSDQDGHSDBJGHRWRQLYBGLXHLGTGXBQJDZPYJSJYJCTMRNYMGRZJCZGJMZMGXMPRYXKJNYMSGMZJYMKMFXMLDTGFBHCJHKYLPFMDXLQJJSMTQGZSJLQDLDGJYCALCMZCSDJLLNXDJFFFFJCZFMZFFPFKHKGDPSXKTACJDHHZDDCRRCFQYJKQCCWJDXHWJLYLLZGCFCQDSMLZPBJJPLSBCJGGDCKKDEZSQCCKJGCGKDJTJDLZYCXKLQSCGJCLTFPCQCZGWPJDQYZJJBYJHSJDZWGFSJGZKQCCZLLPSPKJGQJHZZLJPLGJGJJTHJJYJZCZMLZLYQBGJWMLJKXZDZNJQSYZMLJLLJKYWXMKJLHSKJGBMCLYYMKXJQLBMLLKMDXXKWYXYSLMLPSJQQJQXYXFJTJDXMXXLLCXQBSYJBGWYMBGGBCYXPJYGPEPFGDJGBHBNSQJYZJKJKHXQFGQZKFHYGKHDKLLSDJQXPQYKYBNQSXQNSZSWHBSXWHXWBZZXDMNSJBSBKBBZKLYLXGWXDRWYQZMYWSJQLCJXXJXKJEQXSCYETLZHLYYYSDZPAQYZCMTLSHTZCFYZYXYLJSDCJQAGYSLCQLYYYSHMRQQKLDXZSCSSSYDYCJYSFSJBFRSSZQSBXXPXJYSDRCKGJLGDKZJZBDKTCSYQPYHSTCLDJDHMXMCGXYZHJDDTMHLTXZXYLYMOHYJCLTYFBQQXPFBDFHHTKSQHZYYWCNXXCRWHOWGYJLEGWDQCWGFJYCSNTMYTOLBYGWQWESJPWNMLRYDZSZTXYQPZGCWXHNGPYXSHMYQJXZTDPPBFYHZHTJYFDZWKGKZBLDNTSXHQEEGZZYLZMMZYJZGXZXKHKSTXNXXWYLYAPSTHXDWHZYMPXAGKYDXBHNHXKDPJNMYHYLPMGOCSLNZHKXXLPZZLBMLSFBHHGYGYYGGBHSCYAQTYWLXTZQCEZYDQDQMMHTKLLSZHLSJZWFYHQSWSCWLQAZYNYTLSXTHAZNKZZSZZLAXXZWWCTGQQTDDYZTCCHYQZFLXPSLZYGPZSZNGLNDQTBDLXGTCTAJDKYWNSYZLJHHZZCWNYYZYWMHYCHHYXHJKZWSXHZYXLYSKQYSPSLYZWMYPPKBYGLKZHTYXAXQSYSHXASMCHKDSCRSWJPWXSGZJLWWSCHSJHSQNHCSEGNDAQTBAALZZMSSTDQJCJKTSCJAXPLGGXHHGXXZCXPDMMHLDGTYBYSJMXHMRCPXXJZCKZXSHMLQXXTTHXWZFKHCCZDYTCJYXQHLXDHYPJQXYLSYYDZOZJNYXQEZYSQYAYXWYPDGXDDXSPPYZNDLTWRHXYDXZZJHTCXMCZLHPYYYYMHZLLHNXMYLLLMDCPPXHMXDKYCYRDLTXJCHHZZXZLCCLYLNZSHZJZZLNNRLWHYQSNJHXYNTTTKYJPYCHHYEGKCTTWLGQRLGGTGTYGYHPYHYLQYQGCWYQKPYYYTTTTLHYHLLTYTTSPLKYZXGZWGPYDSSZZDQXSKCQNMJJZZBXYQMJRTFFBTKHZKBXLJJKDXJTLBWFZPPTKQTZTGPDGNTPJYFALQMKGXBDCLZFHZCLLLLADPMXDJHLCCLGYHDZFGYDDGCYYFGYDXKSSEBDHYKDKDKHNAXXYBPBYYHXZQGAFFQYJXDMLJCSQZLLPCHBSXGJYNDYBYQSPZWJLZKSDDTACTBXZDYZYPJZQSJNKKTKNJDJGYYPGTLFYQKASDNTCYHBLWDZHBBYDWJRYGKZYHEYYFJMSDTYFZJJHGCXPLXHLDWXXJKYTCYKSSSMTWCTTQZLPBSZDZWZXGZAGYKTYWXLHLSPBCLLOQMMZSSLCMBJCSZZKYDCZJGQQDSMCYTZQQLWZQZXSSFPTTFQMDDZDSHDTDWFHTDYZJYQJQKYPBDJYYXTLJHDRQXXXHAYDHRJLKLYTWHLLRLLRCXYLBWSRSZZSYMKZZHHKYHXKSMDSYDYCJPBZBSQLFCXXXNXKXWYWSDZYQOGGQMMYHCDZTTFJYYBGSTTTYBYKJDHKYXBELHTYPJQNFXFDYKZHQKZBYJTZBXHFDXKDASWTAWAJLDYJSFHBLDNNTNQJTJNCHXFJSRFWHZFMDRYJYJWZPDJKZYJYMPCYZNYNXFBYTFYFWYGDBNZZZDNYTXZEMMQBSQEHXFZMBMFLZZSRXYMJGSXWZJSPRYDJSJGXHJJGLJJYNZZJXHGXKYMLPYYYCXYTWQZSWHWLYRJLPXSLSXMFSWWKLCTNXNYNPSJSZHDZEPTXMYYWXYYSYWLXJQZQXZDCLEEELMCPJPCLWBXSQHFWWTFFJTNQJHJQDXHWLBYZNFJLALKYYJLDXHHYCSTYYWNRJYXYWTRMDRQHWQCMFJDYZMHMYYXJWMYZQZXTLMRSPWWCHAQBXYGZYPXYYRRCLMPYMGKSJSZYSRMYJSNXTPLNBAPPYPYLXYYZKYNLDZYJZCZNNLMZHHARQMPGWQTZMXXMLLHGDZXYHXKYXYCJMFFYYHJFSBSSQLXXNDYCANNMTCJCYPRRNYTYQNYYMBMSXNDLYLYSLJRLXYSXQMLLYZLZJJJKYZZCSFBZXXMSTBJGNXYZHLXNMCWSCYZYFZLXBRNNNYLBNRTGZQYSATSWRYHYJZMZDHZGZDWYBSSCSKXSYHYTXXGCQGXZZSHYXJSCRHMKKBXCZJYJYMKQHZJFNBHMQHYSNJNZYBKNQMCLGQHWLZNZSWXKHLJHYYBQLBFCDSXDLDSPFZPSKJYZWZXZDDXJSMMEGJSCSSMGCLXXKYYYLNYPWWWGYDKZJGGGZGGSYCKNJWNJPCXBJJTQTJWDSSPJXZXNZXUMELPXFSXTLLXCLJXJJLJZXCTPSWXLYDHLYQRWHSYCSQYYBYAYWJJJQFWQCQQCJQGXALDBZZYJGKGXPLTZYFXJLTPADKYQHPMATLCPDCKBMTXYBHKLENXDLEEGQDYMSAWHZMLJTWYGXLYQZLJEEYYBQQFFNLYXRDSCTGJGXYYNKLLYQKCCTLHJLQMKKZGCYYGLLLJDZGYDHZWXPYSJBZKDZGYZZHYWYFQYTYZSZYEZZLYMHJJHTSMQWYZLKYYWZCSRKQYTLTDXWCTYJKLWSQZWBDCQYNCJSRSZJLKCDCDTLZZZACQQZZDDXYPLXZBQJYLZLLLQDDZQJYJYJZYXNYYYNYJXKXDAZWYRDLJYYYRJLXLLDYXJCYWYWNQCCLDDNYYYNYCKCZHXXCCLGZQJGKWPPCQQJYSBZZXYJSQPXJPZBSBDSFNSFPZXHDWZTDWPPTFLZZBZDMYYPQJRSDZSQZSQXBDGCPZSWDWCSQZGMDHZXMWWFYBPDGPHTMJTHZSMMBGZMBZJCFZWFZBBZMQCFMBDMCJXLGPNJBBXGYHYYJGPTZGZMQBQTCGYXJXLWZKYDPDYMGCFTPFXYZTZXDZXTGKMTYBBCLBJASKYTSSQYYMSZXFJEWLXLLSZBQJJJAKLYLXLYCCTSXMCWFKKKBSXLLLLJYXTYLTJYYTDPJHNHNNKBYQNFQYYZBYYESSESSGDYHFHWTCJBSDZZTFDMXHCNJZYMQWSRYJDZJQPDQBBSTJGGFBKJBXTGQHNGWJXJGDLLTHZHHYYYYYYSXWTYYYCCBDBPYPZYCCZYJPZYWCBDLFWZCWJDXXHYHLHWZZXJTCZLCDPXUJCZZZLYXJJTXPHFXWPYWXZPTDZZBDZCYHJHMLXBQXSBYLRDTGJRRCTTTHYTCZWMXFYTWWZCWJWXJYWCSKYBZSCCTZQNHXNWXXKHKFHTSWOCCJYBCMPZZYKBNNZPBZHHZDLSYDDYTYFJPXYNGFXBYQXCBHXCPSXTYZDMKYSNXSXLHKMZXLYHDHKWHXXSSKQYHHCJYXGLHZXCSNHEKDTGZXQYPKDHEXTYKCNYMYYYPKQYYYKXZLTHJQTBYQHXBMYHSQCKWWYLLHCYYLNNEQXQWMCFBDCCMLJGGXDQKTLXKGNQCDGZJWYJJLYHHQTTTNWCHMXCXWHWSZJYDJCCDBQCDGDNYXZTHCQRXCBHZTQCBXWGQWYYBXHMBYMYQTYEXMQKYAQYRGYZSLFYKKQHYSSQYSHJGJCNXKZYCXSBXYXHYYLSTYCXQTHYSMGSCPMMGCCCCCMTZTASMGQZJHKLOSQYLSWTMXSYQKDZLJQQYPLSYCZTCQQPBBQJZCLPKHQZYYXXDTDDTSJCXFFLLCHQXMJLWCJCXTSPYCXNDTJSHJWXDQQJSKXYAMYLSJHMLALYKXCYYDMNMDQMXMCZNNCYBZKKYFLMCHCMLHXRCJJHSYLNMTJZGZGYWJXSRXCWJGJQHQZDQJDCJJZKJKGDZQGJJYJYLXZXXCDQHHHEYTMHLFSBDJSYYSHFYSTCZQLPBDRFRZTZYKYWHSZYQKWDQZRKMSYNBCRXQBJYFAZPZZEDZCJYWBCJWHYJBQSZYWRYSZPTDKZPFPBNZTKLQYHBBZPNPPTYZZYBQNYDCPJMMCYCQMCYFZZDCMNLFPBPLNGQJTBTTNJZPZBBZNJKLJQYLNBZQHKSJZNGGQSZZKYXSHPZSNBCGZKDDZQANZHJKDRTLZLSWJLJZLYWTJNDJZJHXYAYNCBGTZCSSQMNJPJYTYSWXZFKWJQTKHTZPLBHSNJZSYZBWZZZZLSYLSBJHDWWQPSLMMFBJDWAQYZTCJTBNNWZXQXCDSLQGDSDPDZHJTQQPSWLYYJZLGYXYZLCTCBJTKTYCZJTQKBSJLGMGZDMCSGPYNJZYQYYKNXRPWSZXMTNCSZZYXYBYHYZAXYWQCJTLLCKJJTJHGDXDXYQYZZBYWDLWQCGLZGJGQRQZCZSSBCRPCSKYDZNXJSQGXSSJMYDNSTZTPBDLTKZWXQWQTZEXNQCZGWEZKSSBYBRTSSSLCCGBPSZQSZLCCGLLLZXHZQTHCZMQGYZQZNMCOCSZJMMZSQPJYGQLJYJPPLDXRGZYXCCSXHSHGTZNLZWZKJCXTCFCJXLBMQBCZZWPQDNHXLJCTHYZLGYLNLSZZPCXDSCQQHJQKSXZPBAJYEMSMJTZDXLCJYRYYNWJBNGZZTMJXLTBSLYRZPYLSSCNXPHLLHYLLQQZQLXYMRSYCXZLMMCZLTZSDWTJJLLNZGGQXPFSKYGYGHBFZPDKMWGHCXMSGDXJMCJZDYCABXJDLNBCDQYGSKYDQTXDJJYXMSZQAZDZFSLQXYJSJZYLBTXXWXQQZBJZUFBBLYLWDSLJHXJYZJWTDJCZFQZQZZDZSXZZQLZCDZFJHYSPYMPQZMLPPLFFXJJNZZYLSJEYQZFPFZKSYWJJJHRDJZZXTXXGLGHYDXCSKYSWMMZCWYBAZBJKSHFHJCXMHFQHYXXYZFTSJYZFXYXPZLCHMZMBXHZZSXYFYMNCWDABAZLXKTCSHHXKXJJZJSTHYGXSXYYHHHJWXKZXSSBZZWHHHCWTZZZPJXSNXQQJGZYZYWLLCWXZFXXYXYHXMKYYSWSQMNLNAYCYSPMJKHWCQHYLAJJMZXHMMCNZHBHXCLXTJPLTXYJHDYYLTTXFSZHYXXSJBJYAYRSMXYPLCKDUYHLXRLNLLSTYZYYQYGYHHSCCSMZCTZQXKYQFPYYRPFFLKQUNTSZLLZMWWTCQQYZWTLLMLMPWMBZSSTZRBPDDTLQJJBXZCSRZQQYGWCSXFWZLXCCRSZDZMCYGGDZQSGTJSWLJMYMMZYHFBJDGYXCCPSHXNZCSBSJYJGJMPPWAFFYFNXHYZXZYLREMZGZCYZSSZDLLJCSQFNXZKPTXZGXJJGFMYYYSNBTYLBNLHPFZDCYFBMGQRRSSSZXYSGTZRNYDZZCDGPJAFJFZKNZBLCZSZPSGCYCJSZLMLRSZBZZLDLSLLYSXSQZQLYXZLSKKBRXBRBZCYCXZZZEEYFGKLZLYYHGZSGZLFJHGTGWKRAAJYZKZQTSSHJJXDCYZUYJLZYRZDQQHGJZXSSZBYKJPBFRTJXLLFQWJHYLQTYMBLPZDXTZYGBDHZZRBGXHWNJTJXLKSCFSMWLSDQYSJTXKZSCFWJLBXFTZLLJZLLQBLSQMQQCGCZFPBPHZCZJLPYYGGDTGWDCFCZQYYYQYSSCLXZSKLZZZGFFCQNWGLHQYZJJCZLQZZYJPJZZBPDCCMHJGXDQDGDLZQMFGPSYTSDYFWWDJZJYSXYYCZCYHZWPBYKXRYLYBHKJKSFXTZJMMCKHLLTNYYMSYXYZPYJQYCSYCWMTJJKQYRHLLQXPSGTLYYCLJSCPXJYZFNMLRGJJTYZBXYZMSJYJHHFZQMSYXRSZCWTLRTQZSSTKXGQKGSPTGCZNJSJCQCXHMXGGZTQYDJKZDLBZSXJLHYQGGGTHQSZPYHJHHGYYGKGGCWJZZYLCZLXQSFTGZSLLLMLJSKCTBLLZZSZMMNYTPZSXQHJCJYQXYZXZQZCPSHKZZYSXCDFGMWQRLLQXRFZTLYSTCTMJCXJJXHJNXTNRZTZFQYHQGLLGCXSZSJDJLJCYDSJTLNYXHSZXCGJZYQPYLFHDJSBPCCZHJJJQZJQDYBSSLLCMYTTMQTBHJQNNYGKYRQYQMZGCJKPDCGMYZHQLLSLLCLMHOLZGDYYFZSLJCQZLYLZQJESHNYLLJXGJXLYSYYYXNBZLJSSZCQQCJYLLZLTJYLLZLLBNYLGQCHXYYXOXCXQKYJXXXYKLXSXXYQXCYKQXQCSGYXXYQXYGYTQOHXHXPYXXXULCYEYCHZZCBWQBBWJQZSCSZSSLZYLKDESJZWMYMCYTSDSXXSCJPQQSQYLYYZYCMDJDZYWCBTJSYDJKCYDDJLBDJJSODZYSYXQQYXDHHGQQYQHDYXWGMMMAJDYBBBPPBCMUUPLJZSMTXERXJMHQNUTPJDCBSSMSSSTKJTSSMMTRCPLZSZMLQDSDMJMQPNQDXCFYNBFSDQXYXHYAYKQYDDLQYYYSSZBYDSLNTFQTZQPZMCHDHCZCWFDXTMYQSPHQYYXSRGJCWTJTZZQMGWJJTJHTQJBBHWZPXXHYQFXXQYWYYHYSCDYDHHQMNMTMWCPBSZPPZZGLMZFOLLCFWHMMSJZTTDHZZYFFYTZZGZYSKYJXQYJZQBHMBZZLYGHGFMSHPZFZSNCLPBQSNJXZSLXXFPMTYJYGBXLLDLXPZJYZJYHHZCYWHJYLSJEXFSZZYWXKZJLUYDTMLYMQJPWXYHXSKTQJEZRPXXZHHMHWQPWQLYJJQJJZSZCPHJLCHHNXJLQWZJHBMZYXBDHHYPZLHLHLGFWLCHYYTLHJXCJMSCPXSTKPNHQXSRTYXXTESYJCTLSSLSTDLLLWWYHDHRJZSFGXTSYCZYNYHTDHWJSLHTZDQDJZXXQHGYLTZPHCSQFCLNJTCLZPFSTPDYNYLGMJLLYCQHYSSHCHYLHQYQTMZYPBYWRFQYKQSYSLZDQJMPXYYSSRHZJNYWTQDFZBWWTWWRXCWHGYHXMKMYYYQMSMZHNGCEPMLQQMTCWCTMMPXJPJJHFXYYZSXZHTYBMSTSYJTTQQQYYLHYNPYQZLCYZHZWSMYLKFJXLWGXYPJYTYSYXYMZCKTTWLKSMZSYLMPWLZWXWQZSSAQSYXYRHSSNTSRAPXCPWCMGDXHXZDZYFJHGZTTSBJHGYZSZYSMYCLLLXBTYXHBBZJKSSDMALXHYCFYGMQYPJYCQXJLLLJGSLZGQLYCJCCZOTYXMTMTTLLWTGPXYMZMKLPSZZZXHKQYSXCTYJZYHXSHYXZKXLZWPSQPYHJWPJPWXQQYLXSDHMRSLZZYZWTTCYXYSZZSHBSCCSTPLWSSCJCHNLCGCHSSPHYLHFHHXJSXYLLNYLSZDHZXYLSXLWZYKCLDYAXZCMDDYSPJTQJZLNWQPSSSWCTSTSZLBLNXSMNYYMJQBQHRZWTYYDCHQLXKPZWBGQYBKFCMZWPZLLYYLSZYDWHXPSBCMLJBSCGBHXLQHYRLJXYSWXWXZSLDFHLSLYNJLZYFLYJYCDRJLFSYZFSLLCQYQFGJYHYXZLYLMSTDJCYHBZLLNWLXXYGYYHSMGDHXXHHLZZJZXCZZZCYQZFNGWPYLCPKPYYPMCLQKDGXZGGWQBDXZZKZFBXXLZXJTPJPTTBYTSZZDWSLCHZHSLTYXHQLHYXXXYYZYSWTXZKHLXZXZPYHGCHKCFSYHUTJRLXFJXPTZTWHPLYXFCRHXSHXKYXXYHZQDXQWULHYHMJTBFLKHTXCWHJFWJCFPQRYQXCYYYQYGRPYWSGSUNGWCHKZDXYFLXXHJJBYZWTSXXNCYJJYMSWZJQRMHXZWFQSYLZJZGBHYNSLBGTTCSYBYXXWXYHXYYXNSQYXMQYWRGYQLXBBZLJSYLPSYTJZYHYZAWLRORJMKSCZJXXXYXCHDYXRYXXJDTSQFXLYLTSFFYXLMTYJMJUYYYXLTZCSXQZQHZXLYYXZHDNBRXXXJCTYHLBRLMBRLLAXKYLLLJLYXXLYCRYLCJTGJCMTLZLLCYZZPZPCYAWHJJFYBDYYZSMPCKZDQYQPBPCJPDCYZMDPBCYYDYCNNPLMTMLRMFMMGWYZBSJGYGSMZQQQZTXMKQWGXLLPJGZBQCDJJJFPKJKCXBLJMSWMDTQJXLDLPPBXCWRCQFBFQJCZAHZGMYKPHYYHZYKNDKZMBPJYXPXYHLFPNYYGXJDBKXNXHJMZJXSTRSTLDXSKZYSYBZXJLXYSLBZYSLHXJPFXPQNBYLLJQKYGZMCYZZYMCCSLCLHZFWFWYXZMWSXTYNXJHPYYMCYSPMHYSMYDYSHQYZCHMJJMZCAAGCFJBBHPLYZYLXXSDJGXDHKXXTXXNBHRMLYJSLTXMRHNLXQJXYZLLYSWQGDLBJHDCGJYQYCMHWFMJYBMBYJYJWYMDPWHXQLDYGPDFXXBCGJSPCKRSSYZJMSLBZZJFLJJJLGXZGYXYXLSZQYXBEXYXHGCXBPLDYHWETTWWCJMBTXCHXYQXLLXFLYXLLJLSSFWDPZSMYJCLMWYTCZPCHQEKCQBWLCQYDPLQPPQZQFJQDJHYMMCXTXDRMJWRHXCJZYLQXDYYNHYYHRSLSRSYWWZJYMTLTLLGTQCJZYABTCKZCJYCCQLJZQXALMZYHYWLWDXZXQDLLQSHGPJFJLJHJABCQZDJGTKHSSTCYJLPSWZLXZXRWGLDLZRLZXTGSLLLLZLYXXWGDZYGBDPHZPBRLWSXQBPFDWOFMWHLYPCBJCCLDMBZPBZZLCYQXLDOMZBLZWPDWYYGDSTTHCSQSCCRSSSYSLFYBFNTYJSZDFNDPDHDZZMBBLSLCMYFFGTJJQWFTMTPJWFNLBZCMMJTGBDZLQLPYFHYYMJYLSDCHDZJWJCCTLJCLDTLJJCPDDSQDSSZYBNDBJLGGJZXSXNLYCYBJXQYCBYLZCFZPPGKCXZDZFZTJJFJSJXZBNZYJQTTYJYHTYCZHYMDJXTTMPXSPLZCDWSLSHXYPZGTFMLCJTYCBPMGDKWYCYZCDSZZYHFLYCTYGWHKJYYLSJCXGYWJCBLLCSNDDBTZBSCLYZCZZSSQDLLMQYYHFSLQLLXFTYHABXGWNYWYYPLLSDLDLLBJCYXJZMLHLJDXYYQYTDLLLBUGBFDFBBQJZZMDPJHGCLGMJJPGAEHHBWCQXAXHHHZCHXYPHJAXHLPHJPGPZJQCQZGJJZZUZDMQYYBZZPHYHYBWHAZYJHYKFGDPFQSDLZMLJXKXGALXZDAGLMDGXMWZQYXXDXXPFDMMSSYMPFMDMMKXKSYZYSHDZKXSYSMMZZZMSYDNZZCZXFPLSTMZDNMXCKJMZTYYMZMZZMSXHHDCZJEMXXKLJSTLWLSQLYJZLLZJSSDPPMHNLZJCZYHMXXHGZCJMDHXTKGRMXFWMCGMWKDTKSXQMMMFZZYDKMSCLCMPCGMHSPXQPZDSSLCXKYXTWLWJYAHZJGZQMCSNXYYMMPMLKJXMHLMLQMXCTKZMJQYSZJSYSZHSYJZJCDAJZYBSDQJZGWZQQXFKDMSDJLFWEHKZQKJPEYPZYSZCDWYJFFMZZYLTTDZZEFMZLBNPPLPLPEPSZALLTYLKCKQZKGENQLWAGYXYDPXLHSXQQWQCQXQCLHYXXMLYCCWLYMQYSKGCHLCJNSZKPYZKCQZQLJPDMDZHLASXLBYDWQLWDNBQCRYDDZTJYBKBWSZDXDTNPJDTCTQDFXQQMGNXECLTTBKPWSLCTYQLPWYZZKLPYGZCQQPLLKCCYLPQMZCZQCLJSLQZDJXLDDHPZQDLJJXZQDXYZQKZLJCYQDYJPPYPQYKJYRMPCBYMCXKLLZLLFQPYLLLMBSGLCYSSLRSYSQTMXYXZQZFDZUYSYZTFFMZZSMZQHZSSCCMLYXWTPZGXZJGZGSJSGKDDHTQGGZLLBJDZLCBCHYXYZHZFYWXYZYMSDBZZYJGTSMTFXQYXQSTDGSLNXDLRYZZLRYYLXQHTXSRTZNGZXBNQQZFMYKMZJBZYMKBPNLYZPBLMCNQYZZZSJZHJCTZKHYZZJRDYZHNPXGLFZTLKGJTCTSSYLLGZRZBBQZZKLPKLCZYSSUYXBJFPNJZZXCDWXZYJXZZDJJKGGRSRJKMSMZJLSJYWQSKYHQJSXPJZZZLSNSHRNYPZTWCHKLPSRZLZXYJQXQKYSJYCZTLQZYBBYBWZPQDWWYZCYTJCJXCKCWDKKZXSGKDZXWWYYJQYYTCYTDLLXWKCZKKLCCLZCQQDZLQLCSFQCHQHSFSMQZZLNBJJZBSJHTSZDYSJQJPDLZCDCWJKJZZLPYCGMZWDJJBSJQZSYZYHHXJPBJYDSSXDZNCGLQMBTSFSBPDZDLZNFGFJGFSMPXJQLMBLGQCYYXBQKDJJQYRFKZTJDHCZKLBSDZCFJTPLLJGXHYXZCSSZZXSTJYGKGCKGYOQXJPLZPBPGTGYJZGHZQZZLBJLSQFZGKQQJZGYCZBZQTLDXRJXBSXXPZXHYZYCLWDXJJHXMFDZPFZHQHQMQGKSLYHTYCGFRZGNQXCLPDLBZCSCZQLLJBLHBZCYPZZPPDYMZZSGYHCKCPZJGSLJLNSCDSLDLXBMSTLDDFJMKDJDHZLZXLSZQPQPGJLLYBDSZGQLBZLSLKYYHZTTNTJYQTZZPSZQZTLLJTYYLLQLLQYZQLBDZLSLYYZYMDFSZSNHLXZNCZQZPBWSKRFBSYZMTHBLGJPMCZZLSTLXSHTCSYZLZBLFEQHLXFLCJLYLJQCBZLZJHHSSTBRMHXZHJZCLXFNBGXGTQJCZTMSFZKJMSSNXLJKBHSJXNTNLZDNTLMSJXGZJYJCZXYJYJWRWWQNZTNFJSZPZSHZJFYRDJSFSZJZBJFZQZZHZLXFYSBZQLZSGYFTZDCSZXZJBQMSZKJRHYJZCKMJKHCHGTXKXQGLXPXFXTRTYLXJXHDTSJXHJZJXZWZLCQSBTXWXGXTXXHXFTSDKFJHZYJFJXRZSDLLLTQSQQZQWZXSYQTWGWBZCGZLLYZBCLMQQTZHZXZXLJFRMYZFLXYSQXXJKXRMQDZDMMYYBSQBHGZMWFWXGMXLZPYYTGZYCCDXYZXYWGSYJYZNBHPZJSQSYXSXRTFYZGRHZTXSZZTHCBFCLSYXZLZQMZLMPLMXZJXSFLBYZMYQHXJSXRXSQZZZSSLYFRCZJRCRXHHZXQYDYHXSJJHZCXZBTYNSYSXJBQLPXZQPYMLXZKYXLXCJLCYSXXZZLXDLLLJJYHZXGYJWKJRWYHCPSGNRZLFZWFZZNSXGXFLZSXZZZBFCSYJDBRJKRDHHGXJLJJTGXJXXSTJTJXLYXQFCSGSWMSBCTLQZZWLZZKXJMLTMJYHSDDBXGZHDLBMYJFRZFSGCLYJBPMLYSMSXLSZJQQHJZFXGFQFQBPXZGYYQXGZTCQWYLTLGWSGWHRLFSFGZJMGMGBGTJFSYZZGZYZAFLSSPMLPFLCWBJZCLJJMZLPJJLYMQDMYYYFBGYGYZMLYZDXQYXRQQQHSYYYQXYLJTYXFSFSLLGNQCYHYCWFHCCCFXPYLYPLLZYXXXXXKQHHXSHJZCFZSCZJXCPZWHHHHHAPYLQALPQAFYHXDYLUKMZQGGGDDESRNNZLTZGCHYPPYSQJJHCLLJTOLNJPZLJLHYMHEYDYDSQYCDDHGZUNDZCLZYZLLZNTNYZGSLHSLPJJBDGWXPCDUTJCKLKCLWKLLCASSTKZZDNQNTTLYYZSSYSSZZRYLJQKCQDHHCRXRZYDGRGCWCGZQFFFPPJFZYNAKRGYWYQPQXXFKJTSZZXSWZDDFBBXTBGTZKZNPZZPZXZPJSZBMQHKCYXYLDKLJNYPKYGHGDZJXXEAHPNZKZTZCMXCXMMJXNKSZQNMNLWBWWXJKYHCPSTMCSQTZJYXTPCTPDTNNPGLLLZSJLSPBLPLQHDTNJNLYYRSZFFJFQWDPHZDWMRZCCLODAXNSSNYZRESTYJWJYJDBCFXNMWTTBYLWSTSZGYBLJPXGLBOCLHPCBJLTMXZLJYLZXCLTPNCLCKXTPZJSWCYXSFYSZDKNTLBYJCYJLLSTGQCBXRYZXBXKLYLHZLQZLNZCXWJZLJZJNCJHXMNZZGJZZXTZJXYCYYCXXJYYXJJXSSSJSTSSTTPPGQTCSXWZDCSYFPTFBFHFBBLZJCLZZDBXGCXLQPXKFZFLSYLTUWBMQJHSZBMDDBCYSCCLDXYCDDQLYJJWMQLLCSGLJJSYFPYYCCYLTJANTJJPWYCMMGQYYSXDXQMZHSZXPFTWWZQSWQRFKJLZJQQYFBRXJHHFWJJZYQAZMYFRHCYYBYQWLPEXCCZSTYRLTTDMQLYKMBBGMYYJPRKZNPBSXYXBHYZDJDNGHPMFSGMWFZMFQMMBCMZZCJJLCNUXYQLMLRYGQZCYXZLWJGCJCGGMCJNFYZZJHYCPRRCMTZQZXHFQGTJXCCJEAQCRJYHPLQLSZDJRBCQHQDYRHYLYXJSYMHZYDWLDFRYHBPYDTSSCNWBXGLPZMLZZTQSSCPJMXXYCSJYTYCGHYCJWYRXXLFEMWJNMKLLSWTXHYYYNCMMCWJDQDJZGLLJWJRKHPZGGFLCCSCZMCBLTBHBQJXQDSPDJZZGHGLFQYWBZYZJLTSTDHQHCTCBCHFLQMPWDSHYYTQWCNZZJTLBYMBPDYYYXSQKXWYYFLXXNCWCXYPMAELYKKJMZZZBRXYYQJFLJPFHHHYTZZXSGQQMHSPGDZQWBWPJHZJDYSCQWZKTXXSQLZYYMYSDZGRXCKKUJLWPYSYSCSYZLRMLQSYLJXBCXTLWDQZPCYCYKPPPNSXFYZJJRCEMHSZMSXLXGLRWGCSTLRSXBZGBZGZTCPLUJLSLYLYMTXMTZPALZXPXJTJWTCYYZLBLXBZLQMYLXPGHDSLSSDMXMBDZZSXWHAMLCZCPJMCNHJYSNSYGCHSKQMZZQDLLKABLWJXSFMOCDXJRRLYQZKJMYBYQLYHETFJZFRFKSRYXFJTWDSXXSYSQJYSLYXWJHSNLXYYXHBHAWHHJZXWMYLJCSSLKYDZTXBZSYFDXGXZJKHSXXYBSSXDPYNZWRPTQZCZENYGCXQFJYKJBZMLJCMQQXUOXSLYXXLYLLJDZBTYMHPFSTTQQWLHOKYBLZZALZXQLHZWRRQHLSTMYPYXJJXMQSJFNBXYXYJXXYQYLTHYLQYFMLKLJTMLLHSZWKZHLJMLHLJKLJSTLQXYLMBHHLNLZXQJHXCFXXLHYHJJGBYZZKBXSCQDJQDSUJZYYHZHHMGSXCSYMXFEBCQWWRBPYYJQTYZCYQYQQZYHMWFFHGZFRJFCDPXNTQYZPDYKHJLFRZXPPXZDBBGZQSTLGDGYLCQMLCHHMFYWLZYXKJLYPQHSYWMQQGQZMLZJNSQXJQSYJYCBEHSXFSZPXZWFLLBCYYJDYTDTHWZSFJMQQYJLMQXXLLDTTKHHYBFPWTYYSQQWNQWLGWDEBZWCMYGCULKJXTMXMYJSXHYBRWFYMWFRXYQMXYSZTZZTFYKMLDHQDXWYYNLCRYJBLPSXCXYWLSPRRJWXHQYPHTYDNXHHMMYWYTZCSQMTSSCCDALWZTCPQPYJLLQZYJSWXMZZMMYLMXCLMXCZMXMZSQTZPPQQBLPGXQZHFLJJHYTJSRXWZXSCCDLXTYJDCQJXSLQYCLZXLZZXMXQRJMHRHZJBHMFLJLMLCLQNLDXZLLLPYPSYJYSXCQQDCMQJZZXHNPNXZMEKMXHYKYQLXSXTXJYYHWDCWDZHQYYBGYBCYSCFGPSJNZDYZZJZXRZRQJJYMCANYRJTLDPPYZBSTJKXXZYPFDWFGZZRPYMTNGXZQBYXNBUFNQKRJQZMJEGRZGYCLKXZDSKKNSXKCLJSPJYYZLQQJYBZSSQLLLKJXTBKTYLCCDDBLSPPFYLGYDTZJYQGGKQTTFZXBDKTYYHYBBFYTYYBCLPDYTGDHRYRNJSPTCSNYJQHKLLLZSLYDXXWBCJQSPXBPJZJCJDZFFXXBRMLAZHCSNDLBJDSZBLPRZTSWSBXBCLLXXLZDJZSJPYLYXXYFTFFFBHJJXGBYXJPMMMPSSJZJMTLYZJXSWXTYLEDQPJMYGQZJGDJLQJWJQLLSJGJGYGMSCLJJXDTYGJQJQJCJZCJGDZZSXQGSJGGCXHQXSNQLZZBXHSGZXCXYLJXYXYYDFQQJHJFXDHCTXJYRXYSQTJXYEFYYSSYYJXNCYZXFXMSYSZXYYSCHSHXZZZGZZZGFJDLTYLNPZGYJYZYYQZPBXQBDZTZCZYXXYHHSQXSHDHGQHJHGYWSZTMZMLHYXGEBTYLZKQWYTJZRCLEKYSTDBCYKQQSAYXCJXWWGSBHJYZYDHCSJKQCXSWXFLTYNYZPZCCZJQTZWJQDZZZQZLJJXLSBHPYXXPSXSHHEZTXFPTLQYZZXHYTXNCFZYYHXGNXMYWXTZSJPTHHGYMXMXQZXTSBCZYJYXXTYYZYPCQLMMSZMJZZLLZXGXZAAJZYXJMZXWDXZSXZDZXLEYJJZQBHZWZZZQTZPSXZTDSXJJJZNYAZPHXYYSRNQDTHZHYYKYJHDZXZLSWCLYBZYECWCYCRYLCXNHZYDZYDYJDFRJJHTRSQTXYXJRJHOJYNXELXSFSFJZGHPZSXZSZDZCQZBYYKLSGSJHCZSHDGQGXYZGXCHXZJWYQWGYHKSSEQZZNDZFKWYSSTCLZSTSYMCDHJXXYWEYXCZAYDMPXMDSXYBSQMJMZJMTZQLPJYQZCGQHXJHHLXXHLHDLDJQCLDWBSXFZZYYSCHTYTYYBHECXHYKGJPXHHYZJFXHWHBDZFYZBCAPNPGNYDMSXHMMMMAMYNBYJTMPXYYMCTHJBZYFCGTYHWPHFTWZZEZSBZEGPFMTSKFTYCMHFLLHGPZJXZJGZJYXZSBBQSCZZLZCCSTPGXMJSFTCCZJZDJXCYBZLFCJSYZFGSZLYBCWZZBYZDZYPSWYJZXZBDSYUXLZZBZFYGCZXBZHZFTPBGZGEJBSTGKDMFHYZZJHZLLZZGJQZLSFDJSSCBZGPDLFZFZSZYZYZSYGCXSNXXCHCZXTZZLJFZGQSQYXZJQDCCZTQCDXZJYQJQCHXZTDLGSCXZSYQJQTZWLQDQZTQCHQQJZYEZZZPBWKDJFCJPZTYPQYQTTYNLMBDKTJZPQZQZZFPZSBNJLGYJDXJDZZKZGQKXDLPZJTCJDQBXDJQJSTCKNXBXZMSLYJCQMTJQWWCJQNJNLLLHJCWQTBZQYDZCZPZZDZYDDCYZZZCCJTTJFZDPRRTZTJDCQTQZDTJNPLZBCLLCTZSXKJZQZPZLBZRBTJDCXFCZDBCCJJLTQQPLDCGZDBBZJCQDCJWYNLLZYZCCDWLLXWZLXRXNTQQCZXKQLSGDFQTDDGLRLAJJTKUYMKQLLTZYTDYYCZGJWYXDXFRSKSTQTENQMRKQZHHQKDLDAZFKYPBGGPZREBZZYKZZSPEGJXGYKQZZZSLYSYYYZWFQZYLZZLZHWCHKYPQGNPGBLPLRRJYXCCSYYHSFZFYBZYYTGZXYLXCZWXXZJZBLFFLGSKHYJZEYJHLPLLLLCZGXDRZELRHGKLZZYHZLYQSZZJZQLJZFLNBHGWLCZCFJYSPYXZLZLXGCCPZBLLCYBBBBUBBCBPCRNNZCZYRBFSRLDCGQYYQXYGMQZWTZYTYJXYFWTEHZZJYWLCCNTZYJJZDEDPZDZTSYQJHDYMBJNYJZLXTSSTPHNDJXXBYXQTZQDDTJTDYYTGWSCSZQFLSHLGLBCZPHDLYZJYCKWTYTYLBNYTSDSYCCTYSZYYEBHEXHQDTWNYGYCLXTSZYSTQMYGZAZCCSZZDSLZCLZRQXYYELJSBYMXSXZTEMBBLLYYLLYTDQYSHYMRQWKFKBFXNXSBYCHXBWJYHTQBPBSBWDZYLKGZSKYHXQZJXHXJXGNLJKZLYYCDXLFYFGHLJGJYBXQLYBXQPQGZTZPLNCYPXDJYQYDYMRBESJYYHKXXSTMXRCZZYWXYQYBMCLLYZHQYZWQXDBXBZWZMSLPDMYSKFMZKLZCYQYCZLQXFZZYDQZPZYGYJYZMZXDZFYFYTTQTZHGSPCZMLCCYTZXJCYTJMKSLPZHYSNZLLYTPZCTZZCKTXDHXXTQCYFKSMQCCYYAZHTJPCYLZLYJBJXTPNYLJYYNRXSYLMMNXJSMYBCSYSYLZYLXJJQYLDZLPQBFZZBLFNDXQKCZFYWHGQMRDSXYCYTXNQQJZYYPFZXDYZFPRXEJDGYQBXRCNFYYQPGHYJDYZXGRHTKYLNWDZNTSMPKLBTHBPYSZBZTJZSZZJTYYXZPHSSZZBZCZPTQFZMYFLYPYBBJQXZMXXDJMTSYSKKBJZXHJCKLPSMKYJZCXTMLJYXRZZQSLXXQPYZXMKYXXXJCLJPRMYYGADYSKQLSNDHYZKQXZYZTCGHZTLMLWZYBWSYCTBHJHJFCWZTXWYTKZLXQSHLYJZJXTMPLPYCGLTBZZTLZJCYJGDTCLKLPLLQPJMZPAPXYZLKKTKDZCZZBNZDYDYQZJYJGMCTXLTGXSZLMLHBGLKFWNWZHDXUHLFMKYSLGXDTWWFRJEJZTZHYDXYKSHWFZCQSHKTMQQHTZHYMJDJSKHXZJZBZZXYMPAGQMSTPXLSKLZYNWRTSQLSZBPSPSGZWYHTLKSSSWHZZLYYTNXJGMJSZSUFWNLSOZTXGXLSAMMLBWLDSZYLAKQCQCTMYCFJBSLXCLZZCLXXKSBZQCLHJPSQPLSXXCKSLNHPSFQQYTXYJZLQLDXZQJZDYYDJNZPTUZDSKJFSLJHYLZSQZLBTXYDGTQFDBYAZXDZHZJNHHQBYKNXJJQCZMLLJZKSPLDYCLBBLXKLELXJLBQYCXJXGCNLCQPLZLZYJTZLJGYZDZPLTQCSXFDMNYCXGBTJDCZNBGBQYQJWGKFHTNPYQZQGBKPBBYZMTJDYTBLSQMPSXTBNPDXKLEMYYCJYNZCTLDYKZZXDDXHQSHDGMZSJYCCTAYRZLPYLTLKXSLZCGGEXCLFXLKJRTLQJAQZNCMBYDKKCXGLCZJZXJHPTDJJMZQYKQSECQZDSHHADMLZFMMZBGNTJNNLGBYJBRBTMLBYJDZXLCJLPLDLPCQDHLXZLYCBLCXZZJADJLNZMMSSSMYBHBSQKBHRSXXJMXSDZNZPXLGBRHWGGFCXGMSKLLTSJYYCQLTSKYWYYHYWXBXQYWPYWYKQLSQPTNTKHQCWDQKTWPXXHCPTHTWUMSSYHBWCRWXHJMKMZNGWTMLKFGHKJYLSYYCXWHYECLQHKQHTTQKHFZLDXQWYZYYDESBPKYRZPJFYYZJCEQDZZDLATZBBFJLLCXDLMJSSXEGYGSJQXCWBXSSZPDYZCXDNYXPPZYDLYJCZPLTXLSXYZYRXCYYYDYLWWNZSAHJSYQYHGYWWAXTJZDAXYSRLTDPSSYYFNEJDXYZHLXLLLZQZSJNYQYQQXYJGHZGZCYJCHZLYCDSHWSHJZYJXCLLNXZJJYYXNFXMWFPYLCYLLABWDDHWDXJMCXZTZPMLQZHSFHZYNZTLLDYWLSLXHYMMYLMBWWKYXYADTXYLLDJPYBPWUXJMWMLLSAFDLLYFLBHHHBQQLTZJCQJLDJTFFKMMMBYTHYGDCQRDDWRQJXNBYSNWZDBYYTBJHPYBYTTJXAAHGQDQTMYSTQXKBTZPKJLZRBEQQSSMJJBDJOTGTBXPGBKTLHQXJJJCTHXQDWJLWRFWQGWSHCKRYSWGFTGYGBXSDWDWRFHWYTJJXXXJYZYSLPYYYPAYXHYDQKXSHXYXGSKQHYWFDDDPPLCJLQQEEWXKSYYKDYPLTJTHKJLTCYYHHJTTPLTZZCDLTHQKZXQYSTEEYWYYZYXXYYSTTJKLLPZMCYHQGXYHSRMBXPLLNQYDQHXSXXWGDQBSHYLLPJJJTHYJKYPPTHYYKTYEZYENMDSHLCRPQFDGFXZPSFTLJXXJBSWYYSKSFLXLPPLBBBLBSFXFYZBSJSSYLPBBFFFFSSCJDSTZSXZRYYSYFFSYZYZBJTBCTSBSDHRTJJBYTCXYJEYLXCBNEBJDSYXYKGSJZBXBYTFZWGENYHHTHZHHXFWGCSTBGXKLSXYWMTMBYXJSTZSCDYQRCYTWXZFHMYMCXLZNSDJTTTXRYCFYJSBSDYERXJLJXBBDEYNJGHXGCKGSCYMBLXJMSZNSKGXFBNBPTHFJAAFXYXFPXMYPQDTZCXZZPXRSYWZDLYBBKTYQPQJPZYPZJZNJPZJLZZFYSBTTSLMPTZRTDXQSJEHBZYLZDHLJSQMLHTXTJECXSLZZSPKTLZKQQYFSYGYWPCPQFHQHYTQXZKRSGTTSQCZLPTXCDYYZXSQZSLXLZMYCPCQBZYXHBSXLZDLTCDXTYLZJYYZPZYZLTXJSJXHLPMYTXCQRBLZSSFJZZTNJYTXMYJHLHPPLCYXQJQQKZZSCPZKSWALQSBLCCZJSXGWWWYGYKTJBBZTDKHXHKGTGPBKQYSLPXPJCKBMLLXDZSTBKLGGQKQLSBKKTFXRMDKBFTPZFRTBBRFERQGXYJPZSSTLBZTPSZQZSJDHLJQLZBPMSMMSXLQQNHKNBLRDDNXXDHDDJCYYGYLXGZLXSYGMQQGKHBPMXYXLYTQWLWGCPBMQXCYZYDRJBHTDJYHQSHTMJSBYPLWHLZFFNYPMHXXHPLTBQPFBJWQDBYGPNZTPFZJGSDDTQSHZEAWZZYLLTYYBWJKXXGHLFKXDJTMSZSQYNZGGSWQSPHTLSSKMCLZXYSZQZXNCJDQGZDLFNYKLJCJLLZLMZZNHYDSSHTHZZLZZBBHQZWWYCRZHLYQQJBEYFXXXWHSRXWQHWPSLMSSKZTTYGYQQWRSLALHMJTQJSMXQBJJZJXZYZKXBYQXBJXSHZTSFJLXMXZXFGHKZSZGGYLCLSARJYHSLLLMZXELGLXYDJYTLFBHBPNLYZFBBHPTGJKWETZHKJJXZXXGLLJLSTGSHJJYQLQZFKCGNNDJSSZFDBCTWWSEQFHQJBSAQTGYPQLBXBMMYWXGSLZHGLZGQYFLZBYFZJFRYSFMBYZHQGFWZSYFYJJPHZBYYZFFWODGRLMFTWLBZGYCQXCDJYGZYYYYTYTYDWEGAZYHXJLZYYHLRMGRXXZCLHNELJJTJTPWJYBJJBXJJTJTEEKHWSLJPLPSFYZPQQBDLQJJTYYQLYZKDKSQJYYQZLDQTGJQYZJSUCMRYQTHTEJMFCTYHYPKMHYZWJDQFHYYXWSHCTXRLJHQXHCCYYYJLTKTTYTMXGTCJTZAYYOCZLYLBSZYWJYTSJYHBYSHFJLYGJXXTMZYYLTXXYPZLXYJZYZYYPNHMYMDYYLBLHLSYYQQLLNJJYMSOYQBZGDLYXYLCQYXTSZEGXHZGLHWBLJHEYXTWQMAKBPQCGYSHHEGQCMWYYWLJYJHYYZLLJJYLHZYHMGSLJLJXCJJYCLYCJPCPZJZJMMYLCQLNQLJQJSXYJMLSZLJQLYCMMHCFMMFPQQMFYLQMCFFQMMMMHMZNFHHJGTTHHKHSLNCHHYQDXTMMQDCYZYXYQMYQYLTDCYYYZAZZCYMZYDLZFFFMMYCQZWZZMABTBYZTDMNZZGGDFTYPCGQYTTSSFFWFDTZQSSYSTWXJHXYTSXXYLBYQHWWKXHZXWZNNZZJZJJQJCCCHYYXBZXZCYZTLLCQXYNJYCYYCYNZZQYYYEWYCZDCJYCCHYJLBTZYYCQWMPWPYMLGKDLDLGKQQBGYCHJXY\";\n\n // 此处收录了375个多音字,数据来自于http://www.51windows.net/pages/pinyin.asp\n var oMultiDiff = {\n 19969: \"DZ\",\n 19975: \"WM\",\n 19988: \"QJ\",\n 20048: \"YL\",\n 20056: \"SC\",\n 20060: \"NM\",\n 20094: \"QG\",\n 20127: \"QJ\",\n 20167: \"QC\",\n 20193: \"YG\",\n 20250: \"KH\",\n 20256: \"ZC\",\n 20282: \"SC\",\n 20285: \"QJG\",\n 20291: \"TD\",\n 20314: \"YD\",\n 20315: \"BF\",\n 20340: \"NE\",\n 20375: \"TD\",\n 20389: \"YJ\",\n 20391: \"CZ\",\n 20415: \"PB\",\n 20446: \"YS\",\n 20447: \"SQ\",\n 20504: \"TC\",\n 20608: \"KG\",\n 20854: \"QJ\",\n 20857: \"ZC\",\n 20911: \"PF\",\n 20985: \"AW\",\n 21032: \"PB\",\n 21048: \"XQ\",\n 21049: \"SC\",\n 21089: \"YS\",\n 21119: \"JC\",\n 21242: \"SB\",\n 21273: \"SC\",\n 21305: \"YP\",\n 21306: \"QO\",\n 21330: \"ZC\",\n 21333: \"SDC\",\n 21345: \"QK\",\n 21378: \"CA\",\n 21397: \"SC\",\n 21414: \"XS\",\n 21442: \"SC\",\n 21477: \"JG\",\n 21480: \"TD\",\n 21484: \"ZS\",\n 21494: \"YX\",\n 21505: \"YX\",\n 21512: \"HG\",\n 21523: \"XH\",\n 21537: \"PB\",\n 21542: \"PF\",\n 21549: \"KH\",\n 21571: \"E\",\n 21574: \"DA\",\n 21588: \"TD\",\n 21589: \"O\",\n 21618: \"ZC\",\n 21621: \"KHA\",\n 21632: \"ZJ\",\n 21654: \"KG\",\n 21679: \"LKG\",\n 21683: \"KH\",\n 21710: \"A\",\n 21719: \"YH\",\n 21734: \"WOE\",\n 21769: \"A\",\n 21780: \"WN\",\n 21804: \"XH\",\n 21834: \"A\",\n 21899: \"ZD\",\n 21903: \"RN\",\n 21908: \"WO\",\n 21939: \"ZC\",\n 21956: \"SA\",\n 21964: \"YA\",\n 21970: \"TD\",\n 22003: \"A\",\n 22031: \"JG\",\n 22040: \"XS\",\n 22060: \"ZC\",\n 22066: \"ZC\",\n 22079: \"MH\",\n 22129: \"XJ\",\n 22179: \"XA\",\n 22237: \"NJ\",\n 22244: \"TD\",\n 22280: \"JQ\",\n 22300: \"YH\",\n 22313: \"XW\",\n 22331: \"YQ\",\n 22343: \"YJ\",\n 22351: \"PH\",\n 22395: \"DC\",\n 22412: \"TD\",\n 22484: \"PB\",\n 22500: \"PB\",\n 22534: \"ZD\",\n 22549: \"DH\",\n 22561: \"PB\",\n 22612: \"TD\",\n 22771: \"KQ\",\n 22831: \"HB\",\n 22841: \"JG\",\n 22855: \"QJ\",\n 22865: \"XQ\",\n 23013: \"ML\",\n 23081: \"WM\",\n 23487: \"SX\",\n 23558: \"QJ\",\n 23561: \"YW\",\n 23586: \"YW\",\n 23614: \"YW\",\n 23615: \"SN\",\n 23631: \"PB\",\n 23646: \"ZS\",\n 23663: \"ZT\",\n 23673: \"YG\",\n 23762: \"TD\",\n 23769: \"ZS\",\n 23780: \"QJ\",\n 23884: \"QK\",\n 24055: \"XH\",\n 24113: \"DC\",\n 24162: \"ZC\",\n 24191: \"GA\",\n 24273: \"QJ\",\n 24324: \"NL\",\n 24377: \"TD\",\n 24378: \"QJ\",\n 24439: \"PF\",\n 24554: \"ZS\",\n 24683: \"TD\",\n 24694: \"WE\",\n 24733: \"LK\",\n 24925: \"TN\",\n 25094: \"ZG\",\n 25100: \"XQ\",\n 25103: \"XH\",\n 25153: \"PB\",\n 25170: \"PB\",\n 25179: \"KG\",\n 25203: \"PB\",\n 25240: \"ZS\",\n 25282: \"FB\",\n 25303: \"NA\",\n 25324: \"KG\",\n 25341: \"ZY\",\n 25373: \"WZ\",\n 25375: \"XJ\",\n 25384: \"A\",\n 25457: \"A\",\n 25528: \"SD\",\n 25530: \"SC\",\n 25552: \"TD\",\n 25774: \"ZC\",\n 25874: \"ZC\",\n 26044: \"YW\",\n 26080: \"WM\",\n 26292: \"PB\",\n 26333: \"PB\",\n 26355: \"ZY\",\n 26366: \"CZ\",\n 26397: \"ZC\",\n 26399: \"QJ\",\n 26415: \"ZS\",\n 26451: \"SB\",\n 26526: \"ZC\",\n 26552: \"JG\",\n 26561: \"TD\",\n 26588: \"JG\",\n 26597: \"CZ\",\n 26629: \"ZS\",\n 26638: \"YL\",\n 26646: \"XQ\",\n 26653: \"KG\",\n 26657: \"XJ\",\n 26727: \"HG\",\n 26894: \"ZC\",\n 26937: \"ZS\",\n 26946: \"ZC\",\n 26999: \"KJ\",\n 27099: \"KJ\",\n 27449: \"YQ\",\n 27481: \"XS\",\n 27542: \"ZS\",\n 27663: \"ZS\",\n 27748: \"TS\",\n 27784: \"SC\",\n 27788: \"ZD\",\n 27795: \"TD\",\n 27812: \"O\",\n 27850: \"PB\",\n 27852: \"MB\",\n 27895: \"SL\",\n 27898: \"PL\",\n 27973: \"QJ\",\n 27981: \"KH\",\n 27986: \"HX\",\n 27994: \"XJ\",\n 28044: \"YC\",\n 28065: \"WG\",\n 28177: \"SM\",\n 28267: \"QJ\",\n 28291: \"KH\",\n 28337: \"ZQ\",\n 28463: \"TL\",\n 28548: \"DC\",\n 28601: \"TD\",\n 28689: \"PB\",\n 28805: \"JG\",\n 28820: \"QG\",\n 28846: \"PB\",\n 28952: \"TD\",\n 28975: \"ZC\",\n 29100: \"A\",\n 29325: \"QJ\",\n 29575: \"SL\",\n 29602: \"FB\",\n 30010: \"TD\",\n 30044: \"CX\",\n 30058: \"PF\",\n 30091: \"YSP\",\n 30111: \"YN\",\n 30229: \"XJ\",\n 30427: \"SC\",\n 30465: \"SX\",\n 30631: \"YQ\",\n 30655: \"QJ\",\n 30684: \"QJG\",\n 30707: \"SD\",\n 30729: \"XH\",\n 30796: \"LG\",\n 30917: \"PB\",\n 31074: \"NM\",\n 31085: \"JZ\",\n 31109: \"SC\",\n 31181: \"ZC\",\n 31192: \"MLB\",\n 31293: \"JQ\",\n 31400: \"YX\",\n 31584: \"YJ\",\n 31896: \"ZN\",\n 31909: \"ZY\",\n 31995: \"XJ\",\n 32321: \"PF\",\n 32327: \"ZY\",\n 32418: \"HG\",\n 32420: \"XQ\",\n 32421: \"HG\",\n 32438: \"LG\",\n 32473: \"GJ\",\n 32488: \"TD\",\n 32521: \"QJ\",\n 32527: \"PB\",\n 32562: \"ZSQ\",\n 32564: \"JZ\",\n 32735: \"ZD\",\n 32793: \"PB\",\n 33071: \"PF\",\n 33098: \"XL\",\n 33100: \"YA\",\n 33152: \"PB\",\n 33261: \"CX\",\n 33324: \"BP\",\n 33333: \"TD\",\n 33406: \"YA\",\n 33426: \"WM\",\n 33432: \"PB\",\n 33445: \"JG\",\n 33486: \"ZN\",\n 33493: \"TS\",\n 33507: \"QJ\",\n 33540: \"QJ\",\n 33544: \"ZC\",\n 33564: \"XQ\",\n 33617: \"YT\",\n 33632: \"QJ\",\n 33636: \"XH\",\n 33637: \"YX\",\n 33694: \"WG\",\n 33705: \"PF\",\n 33728: \"YW\",\n 33882: \"SR\",\n 34067: \"WM\",\n 34074: \"YW\",\n 34121: \"QJ\",\n 34255: \"ZC\",\n 34259: \"XL\",\n 34425: \"JH\",\n 34430: \"XH\",\n 34485: \"KH\",\n 34503: \"YS\",\n 34532: \"HG\",\n 34552: \"XS\",\n 34558: \"YE\",\n 34593: \"ZL\",\n 34660: \"YQ\",\n 34892: \"XH\",\n 34928: \"SC\",\n 34999: \"QJ\",\n 35048: \"PB\",\n 35059: \"SC\",\n 35098: \"ZC\",\n 35203: \"TQ\",\n 35265: \"JX\",\n 35299: \"JX\",\n 35782: \"SZ\",\n 35828: \"YS\",\n 35830: \"E\",\n 35843: \"TD\",\n 35895: \"YG\",\n 35977: \"MH\",\n 36158: \"JG\",\n 36228: \"QJ\",\n 36426: \"XQ\",\n 36466: \"DC\",\n 36710: \"JC\",\n 36711: \"ZYG\",\n 36767: \"PB\",\n 36866: \"SK\",\n 36951: \"YW\",\n 37034: \"YX\",\n 37063: \"XH\",\n 37218: \"ZC\",\n 37325: \"ZC\",\n 38063: \"PB\",\n 38079: \"TD\",\n 38085: \"QY\",\n 38107: \"DC\",\n 38116: \"TD\",\n 38123: \"YD\",\n 38224: \"HG\",\n 38241: \"XTC\",\n 38271: \"ZC\",\n 38415: \"YE\",\n 38426: \"KH\",\n 38461: \"YD\",\n 38463: \"AE\",\n 38466: \"PB\",\n 38477: \"XJ\",\n 38518: \"YT\",\n 38551: \"WK\",\n 38585: \"ZC\",\n 38704: \"XS\",\n 38739: \"LJ\",\n 38761: \"GJ\",\n 38808: \"SQ\",\n 39048: \"JG\",\n 39049: \"XJ\",\n 39052: \"HG\",\n 39076: \"CZ\",\n 39271: \"XT\",\n 39534: \"TD\",\n 39552: \"TD\",\n 39584: \"PB\",\n 39647: \"SB\",\n 39730: \"LG\",\n 39748: \"TPB\",\n 40109: \"ZQ\",\n 40479: \"ND\",\n 40516: \"HG\",\n 40536: \"HG\",\n 40583: \"QJ\",\n 40765: \"YQ\",\n 40784: \"QJ\",\n 40840: \"YK\",\n 40863: \"QJG\"\n };\n\n var _checkPYCh = function (ch) {\n var uni = ch.charCodeAt(0);\n // 如果不在汉字处理范围之内,返回原字符,也可以调用自己的处理函数\n if (uni > 40869 || uni < 19968) {return ch;} // dealWithOthers(ch);\n return (oMultiDiff[uni] ? oMultiDiff[uni] : (_ChineseFirstPY.charAt(uni - 19968)));\n };\n\n var _mkPYRslt = function (arr, options) {\n var ignoreMulti = options.ignoreMulti;\n var splitChar = options.splitChar;\n var arrRslt = [\"\"], k, multiLen = 0;\n for (var i = 0, len = arr.length; i < len; i++) {\n var str = arr[i];\n var strlen = str.length;\n // 多音字过多的情况下，指数增长会造成浏览器卡死，超过20完全卡死，18勉强能用，考虑到不同性能最好是16或者14\n // 超过14个多音字之后，后面的都用第一个拼音\n if (strlen == 1 || multiLen > 14 || ignoreMulti) {\n var tmpStr = str.substring(0, 1);\n for (k = 0; k < arrRslt.length; k++) {\n arrRslt[k] += tmpStr;\n }\n } else {\n var tmpArr = arrRslt.slice(0);\n arrRslt = [];\n multiLen ++;\n for (k = 0; k < strlen; k++) {\n // 复制一个相同的arrRslt\n var tmp = tmpArr.slice(0);\n // 把当前字符str[k]添加到每个元素末尾\n for (var j = 0; j < tmp.length; j++) {\n tmp[j] += str.charAt(k);\n }\n // 把复制并修改后的数组连接到arrRslt上\n arrRslt = arrRslt.concat(tmp);\n }\n }\n }\n // BI-56386 这边直接将所有多音字组合拼接是有风险的，因为丢失了每一组的起始索引信息, 外部使用indexOf等方法会造成错位\n // 一旦错位就可能认为不符合条件， 但实际上还是有可能符合条件的，故此处以一个无法搜索的不可见字符作为连接\n return arrRslt.join(splitChar || \"\").toLowerCase();\n };\n\n _.extend(BI, {\n makeFirstPY: function (str, options) {\n options = options || {};\n if (typeof (str) !== \"string\") {return \"\" + str;}\n var arrResult = []; // 保存中间结果的数组\n for (var i = 0, len = str.length; i < len; i++) {\n // 获得unicode码\n var ch = str.charAt(i);\n // 检查该unicode码是否在处理范围之内,在则返回该码对映汉字的拼音首字母,不在则调用其它函数处理\n arrResult.push(_checkPYCh(ch));\n }\n // 处理arrResult,返回所有可能的拼音首字母串数组\n return _mkPYRslt(arrResult, options);\n }\n });\n})();\n(function () {\n function defaultComparator (a, b) {\n return a < b;\n }\n\n BI.Heap = function (items, comparator) {\n this._items = items || [];\n this._size = this._items.length;\n this._comparator = comparator || defaultComparator;\n this._heapify();\n };\n\n BI.Heap.prototype = {\n constructor: BI.Heap,\n empty: function () {\n return this._size === 0;\n },\n\n pop: function () {\n if (this._size === 0) {\n return;\n }\n\n var elt = this._items[0];\n\n var lastElt = this._items.pop();\n this._size--;\n\n if (this._size > 0) {\n this._items[0] = lastElt;\n this._sinkDown(0);\n }\n\n return elt;\n },\n\n push: function (item) {\n this._items[this._size++] = item;\n this._bubbleUp(this._size - 1);\n },\n\n size: function () {\n return this._size;\n },\n\n peek: function () {\n if (this._size === 0) {\n return;\n }\n\n return this._items[0];\n },\n\n _heapify: function () {\n for (var index = Math.floor((this._size + 1) / 2); index >= 0; index--) {\n this._sinkDown(index);\n }\n },\n\n _bubbleUp: function (index) {\n var elt = this._items[index];\n while (index > 0) {\n var parentIndex = Math.floor((index + 1) / 2) - 1;\n var parentElt = this._items[parentIndex];\n\n // if parentElt < elt, stop\n if (this._comparator(parentElt, elt)) {\n return;\n }\n\n // swap\n this._items[parentIndex] = elt;\n this._items[index] = parentElt;\n index = parentIndex;\n }\n },\n\n _sinkDown: function (index) {\n var elt = this._items[index];\n\n while (true) {\n var leftChildIndex = 2 * (index + 1) - 1;\n var rightChildIndex = 2 * (index + 1);\n var swapIndex = -1;\n\n if (leftChildIndex < this._size) {\n var leftChild = this._items[leftChildIndex];\n if (this._comparator(leftChild, elt)) {\n swapIndex = leftChildIndex;\n }\n }\n\n if (rightChildIndex < this._size) {\n var rightChild = this._items[rightChildIndex];\n if (this._comparator(rightChild, elt)) {\n if (swapIndex === -1 ||\n this._comparator(rightChild, this._items[swapIndex])) {\n swapIndex = rightChildIndex;\n }\n }\n }\n\n // if we don't have a swap, stop\n if (swapIndex === -1) {\n return;\n }\n\n this._items[index] = this._items[swapIndex];\n this._items[swapIndex] = elt;\n index = swapIndex;\n }\n }\n };\n})();\n\n!(function () {\n BI.LinkHashMap = function () {\n this.array = [];\n this.map = {};\n };\n BI.LinkHashMap.prototype = {\n constructor: BI.LinkHashMap,\n has: function (key) {\n if (key in this.map) {\n return true;\n }\n return false;\n },\n\n add: function (key, value) {\n if (typeof key === \"undefined\") {\n return;\n }\n if (key in this.map) {\n this.map[key] = value;\n } else {\n this.array.push(key);\n this.map[key] = value;\n }\n },\n\n remove: function (key) {\n if (key in this.map) {\n delete this.map[key];\n for (var i = 0; i < this.array.length; i++) {\n if (this.array[i] == key) {\n this.array.splice(i, 1);\n break;\n }\n }\n }\n },\n\n size: function () {\n return this.array.length;\n },\n\n each: function (fn, scope) {\n var scope = scope || window;\n var fn = fn || null;\n if (fn == null || typeof (fn) !== \"function\") {\n return;\n }\n for (var i = 0; i < this.array.length; i++) {\n var key = this.array[i];\n var value = this.map[key];\n var re = fn.call(scope, key, value, i, this.array, this.map);\n if (re == false) {\n break;\n }\n }\n },\n\n get: function (key) {\n return this.map[key];\n },\n\n toArray: function () {\n var array = [];\n this.each(function (key, value) {\n array.push(value);\n });\n return array;\n }\n };\n})();\n!(function () {\n BI.LRU = function (limit) {\n this.size = 0;\n this.limit = limit;\n this.head = this.tail = undefined;\n this._keymap = {};\n };\n\n var p = BI.LRU.prototype;\n\n p.put = function (key, value) {\n var removed;\n if (this.size === this.limit) {\n removed = this.shift();\n }\n\n var entry = this.get(key, true);\n if (!entry) {\n entry = {\n key: key\n };\n this._keymap[key] = entry;\n if (this.tail) {\n this.tail.newer = entry;\n entry.older = this.tail;\n } else {\n this.head = entry;\n }\n this.tail = entry;\n this.size++;\n }\n entry.value = value;\n\n return removed;\n };\n\n p.shift = function () {\n var entry = this.head;\n if (entry) {\n this.head = this.head.newer;\n this.head.older = undefined;\n entry.newer = entry.older = undefined;\n this._keymap[entry.key] = undefined;\n this.size--;\n }\n return entry;\n };\n\n\n p.get = function (key, returnEntry) {\n var entry = this._keymap[key];\n if (entry === undefined) return;\n if (entry === this.tail) {\n return returnEntry\n ? entry\n : entry.value;\n }\n // HEAD--------------TAIL\n // <.older .newer>\n // <--- add direction --\n // A B C <D> E\n if (entry.newer) {\n if (entry === this.head) {\n this.head = entry.newer;\n }\n entry.newer.older = entry.older; // C <-- E.\n }\n if (entry.older) {\n entry.older.newer = entry.newer; // C. --> E\n }\n entry.newer = undefined; // D --x\n entry.older = this.tail; // D. --> E\n if (this.tail) {\n this.tail.newer = entry; // E. <-- D\n }\n this.tail = entry;\n return returnEntry\n ? entry\n : entry.value;\n };\n\n p.has = function (key) {\n return this._keymap[key] != null;\n };\n})();// 线段树\n(function () {\n var parent = function (node) {\n return Math.floor(node / 2);\n };\n\n var Int32Array = _global.Int32Array || function (size) {\n var xs = [];\n for (var i = size - 1; i >= 0; --i) {\n xs[i] = 0;\n }\n return xs;\n };\n\n var ceilLog2 = function (x) {\n var y = 1;\n while (y < x) {\n y *= 2;\n }\n return y;\n };\n\n BI.PrefixIntervalTree = function (xs) {\n this._size = xs.length;\n this._half = ceilLog2(this._size);\n // _heap是一个_size两倍以上的堆\n this._heap = new Int32Array(2 * this._half);\n\n var i;\n // 初始化 >= _size 的堆空间, 即叶子节点\n for (i = 0; i < this._size; ++i) {\n this._heap[this._half + i] = xs[i];\n }\n // 初始化 < _size 的堆空间, 即非叶子节点，根节点包含整个区间\n for (i = this._half - 1; i > 0; --i) {\n this._heap[i] = this._heap[2 * i] + this._heap[2 * i + 1];\n }\n };\n\n BI.PrefixIntervalTree.prototype = {\n constructor: BI.PrefixIntervalTree,\n // 往_half之后的空间set值，需要更新其所有祖先节点的值\n set: function (index, value) {\n var node = this._half + index;\n this._heap[node] = value;\n\n node = parent(node);\n for (; node !== 0; node = parent(node)) {\n this._heap[node] =\n this._heap[2 * node] + this._heap[2 * node + 1];\n }\n },\n\n get: function (index) {\n var node = this._half + index;\n return this._heap[node];\n },\n\n getSize: function () {\n return this._size;\n },\n\n /**\n * get(0) + get(1) + ... + get(end - 1).\n */\n sumUntil: function (end) {\n if (end === 0) {\n return 0;\n }\n\n var node = this._half + end - 1;\n var sum = this._heap[node];\n for (; node !== 1; node = parent(node)) {\n if (node % 2 === 1) {\n sum += this._heap[node - 1];\n }\n }\n\n return sum;\n },\n\n /**\n * get(0) + get(1) + ... + get(inclusiveEnd).\n */\n sumTo: function (inclusiveEnd) {\n return this.sumUntil(inclusiveEnd + 1);\n },\n\n /**\n * sum get(begin) + get(begin + 1) + ... + get(end - 1).\n */\n sum: function (begin, end) {\n return this.sumUntil(end) - this.sumUntil(begin);\n },\n\n /**\n * Returns the smallest i such that 0 <= i <= size and sumUntil(i) <= t, or\n * -1 if no such i exists.\n */\n greatestLowerBound: function (t) {\n if (t < 0) {\n return -1;\n }\n\n var node = 1;\n if (this._heap[node] <= t) {\n return this._size;\n }\n\n while (node < this._half) {\n var leftSum = this._heap[2 * node];\n if (t < leftSum) {\n node = 2 * node;\n } else {\n node = 2 * node + 1;\n t -= leftSum;\n }\n }\n\n return node - this._half;\n },\n\n /**\n * Returns the smallest i such that 0 <= i <= size and sumUntil(i) < t, or\n * -1 if no such i exists.\n */\n greatestStrictLowerBound: function (t) {\n if (t <= 0) {\n return -1;\n }\n\n var node = 1;\n if (this._heap[node] < t) {\n return this._size;\n }\n\n while (node < this._half) {\n var leftSum = this._heap[2 * node];\n if (t <= leftSum) {\n node = 2 * node;\n } else {\n node = 2 * node + 1;\n t -= leftSum;\n }\n }\n\n return node - this._half;\n },\n\n /**\n * Returns the smallest i such that 0 <= i <= size and t <= sumUntil(i), or\n * size + 1 if no such i exists.\n */\n leastUpperBound: function (t) {\n return this.greatestStrictLowerBound(t) + 1;\n },\n\n /**\n * Returns the smallest i such that 0 <= i <= size and t < sumUntil(i), or\n * size + 1 if no such i exists.\n */\n leastStrictUpperBound: function (t) {\n return this.greatestLowerBound(t) + 1;\n }\n };\n\n BI.PrefixIntervalTree.uniform = function (size, initialValue) {\n var xs = [];\n for (var i = size - 1; i >= 0; --i) {\n xs[i] = initialValue;\n }\n\n return new BI.PrefixIntervalTree(xs);\n };\n\n BI.PrefixIntervalTree.empty = function (size) {\n return BI.PrefixIntervalTree.uniform(size, 0);\n };\n\n})();\n\n!(function () {\n BI.Queue = function (capacity) {\n this.capacity = capacity;\n this.array = [];\n };\n BI.Queue.prototype = {\n constructor: BI.Queue,\n\n contains: function (v) {\n return BI.contains(this.array, v);\n },\n\n indexOf: function (v) {\n return BI.contains(this.array, v);\n },\n\n getElementByIndex: function (index) {\n return this.array[index];\n },\n\n push: function (v) {\n this.array.push(v);\n if (this.capacity && this.array.length > this.capacity) {\n this.array.shift();\n }\n },\n\n pop: function () {\n this.array.pop();\n },\n\n shift: function () {\n this.array.shift();\n },\n\n unshift: function (v) {\n this.array.unshift(v);\n if (this.capacity && this.array.length > this.capacity) {\n this.array.pop();\n }\n },\n\n remove: function (v) {\n BI.remove(this.array, v);\n },\n\n splice: function () {\n this.array.splice.apply(this.array, arguments);\n },\n\n slice: function () {\n this.array.slice.apply(this.array, arguments);\n },\n\n size: function () {\n return this.array.length;\n },\n\n each: function (fn, scope) {\n var scope = scope || window;\n var fn = fn || null;\n if (fn == null || typeof (fn) !== \"function\") {\n return;\n }\n for (var i = 0; i < this.array.length; i++) {\n var re = fn.call(scope, i, this.array[i], this.array);\n if (re == false) {\n break;\n }\n }\n },\n\n toArray: function () {\n return this.array;\n },\n\n fromArray: function (array) {\n var self = this;\n BI.each(array, function (i, v) {\n self.push(v);\n });\n },\n\n clear: function () {\n this.array.length = 0;\n }\n };\n})();!(function () {\n var Section = function (height, width, x, y) {\n this.height = height;\n this.width = width;\n this.x = x;\n this.y = y;\n\n this._indexMap = {};\n this._indices = [];\n };\n\n Section.prototype = {\n constructor: Section,\n addCellIndex: function (index) {\n if (!this._indexMap[index]) {\n this._indexMap[index] = true;\n this._indices.push(index);\n }\n },\n\n getCellIndices: function () {\n return this._indices;\n }\n };\n\n var SECTION_SIZE = 100;\n BI.SectionManager = function (sectionSize) {\n this._sectionSize = sectionSize || SECTION_SIZE;\n this._cellMetadata = [];\n this._sections = {};\n };\n\n BI.SectionManager.prototype = {\n constructor: BI.SectionManager,\n getCellIndices: function (height, width, x, y) {\n var indices = {};\n\n BI.each(this.getSections(height, width, x, y), function (i, section) {\n BI.each(section.getCellIndices(), function (j, index) {\n indices[index] = index;\n });\n });\n\n return BI.map(BI.keys(indices), function (i, index) {\n return indices[index];\n });\n },\n\n getCellMetadata: function (index) {\n return this._cellMetadata[index];\n },\n\n getSections: function (height, width, x, y) {\n var sectionXStart = Math.floor(x / this._sectionSize);\n var sectionXStop = Math.floor((x + width - 1) / this._sectionSize);\n var sectionYStart = Math.floor(y / this._sectionSize);\n var sectionYStop = Math.floor((y + height - 1) / this._sectionSize);\n\n var sections = [];\n\n for (var sectionX = sectionXStart; sectionX <= sectionXStop; sectionX++) {\n for (var sectionY = sectionYStart; sectionY <= sectionYStop; sectionY++) {\n var key = sectionX + \".\" + sectionY;\n\n if (!this._sections[key]) {\n this._sections[key] = new Section(this._sectionSize, this._sectionSize, sectionX * this._sectionSize, sectionY * this._sectionSize);\n }\n\n sections.push(this._sections[key]);\n }\n }\n\n return sections;\n },\n\n getTotalSectionCount: function () {\n return BI.size(this._sections);\n },\n\n registerCell: function (cellMetadatum, index) {\n this._cellMetadata[index] = cellMetadatum;\n\n BI.each(this.getSections(cellMetadatum.height, cellMetadatum.width, cellMetadatum.x, cellMetadatum.y), function (i, section) {\n section.addCellIndex(index);\n });\n }\n };\n})();(function () {\n BI.Tree = function () {\n this.root = new BI.Node(BI.UUID());\n };\n\n BI.Tree.prototype = {\n constructor: BI.Tree,\n addNode: function (node, newNode, index) {\n if (BI.isNull(newNode)) {\n this.root.addChild(node, index);\n } else if (BI.isNull(node)) {\n this.root.addChild(newNode, index);\n } else {\n node.addChild(newNode, index);\n }\n },\n\n isRoot: function (node) {\n return node === this.root;\n },\n\n getRoot: function () {\n return this.root;\n },\n\n clear: function () {\n this.root.clear();\n },\n\n initTree: function (nodes) {\n var self = this;\n this.clear();\n var queue = [];\n BI.each(nodes, function (i, node) {\n var n = new BI.Node(node);\n n.set(\"data\", node);\n self.addNode(n);\n queue.push(n);\n });\n while (!BI.isEmpty(queue)) {\n var parent = queue.shift();\n var node = parent.get(\"data\");\n BI.each(node.children, function (i, child) {\n var n = new BI.Node(child);\n n.set(\"data\", child);\n queue.push(n);\n self.addNode(parent, n);\n });\n }\n },\n\n _toJSON: function (node) {\n var self = this;\n var children = [];\n BI.each(node.getChildren(), function (i, child) {\n children.push(self._toJSON(child));\n });\n return BI.extend({\n id: node.id\n }, BI.deepClone(node.get(\"data\")), (children.length > 0 ? {\n children: children\n } : {}));\n },\n\n toJSON: function (node) {\n var self = this, result = [];\n BI.each((node || this.root).getChildren(), function (i, child) {\n result.push(self._toJSON(child));\n });\n return result;\n },\n\n _toJSONWithNode: function (node) {\n var self = this;\n var children = [];\n BI.each(node.getChildren(), function (i, child) {\n children.push(self._toJSONWithNode(child));\n });\n return BI.extend({\n id: node.id\n }, BI.deepClone(node.get(\"data\")), {\n node: node\n }, (children.length > 0 ? {\n children: children\n } : {}));\n },\n\n toJSONWithNode: function (node) {\n var self = this, result = [];\n BI.each((node || this.root).getChildren(), function (i, child) {\n result.push(self._toJSONWithNode(child));\n });\n return result;\n },\n\n search: function (root, target, param) {\n if (!(root instanceof BI.Node)) {\n return arguments.callee.apply(this, [this.root, root, target]);\n }\n var self = this, next = null;\n\n if (BI.isNull(target)) {\n return null;\n }\n if (BI.isEqual(root[param || \"id\"], target)) {\n return root;\n }\n BI.any(root.getChildren(), function (i, child) {\n next = self.search(child, target, param);\n if (null !== next) {\n return true;\n }\n });\n return next;\n },\n\n _traverse: function (node, callback) {\n var queue = [];\n queue.push(node);\n while (!BI.isEmpty(queue)) {\n var temp = queue.shift();\n var b = callback && callback(temp);\n if (b === false) {\n break;\n }\n if (b === true) {\n continue;\n }\n if (temp != null) {\n queue = queue.concat(temp.getChildren());\n }\n }\n },\n\n traverse: function (callback) {\n this._traverse(this.root, callback);\n },\n\n _recursion: function (node, route, callback) {\n var self = this;\n return BI.every(node.getChildren(), function (i, child) {\n var next = BI.clone(route);\n next.push(child.id);\n var b = callback && callback(child, next);\n if (b === false) {\n return false;\n }\n if (b === true) {\n return true;\n }\n return self._recursion(child, next, callback);\n });\n },\n\n recursion: function (callback) {\n this._recursion(this.root, [], callback);\n },\n\n inOrderTraverse: function (callback) {\n this._inOrderTraverse(this.root, callback);\n },\n\n // 中序遍历(递归)\n _inOrderTraverse: function (node, callback) {\n if (node != null) {\n this._inOrderTraverse(node.getLeft());\n callback && callback(node);\n this._inOrderTraverse(node.getRight());\n }\n },\n\n // 中序遍历(非递归)\n nrInOrderTraverse: function (callback) {\n\n var stack = [];\n var node = this.root;\n while (node != null || !BI.isEmpty(stack)) {\n while (node != null) {\n stack.push(node);\n node = node.getLeft();\n }\n node = stack.pop();\n callback && callback(node);\n node = node.getRight();\n }\n },\n\n preOrderTraverse: function (callback) {\n this._preOrderTraverse(this.root, callback);\n },\n\n // 先序遍历(递归)\n _preOrderTraverse: function (node, callback) {\n if (node != null) {\n callback && callback(node);\n this._preOrderTraverse(node.getLeft());\n this._preOrderTraverse(node.getRight());\n }\n },\n\n // 先序遍历（非递归）\n nrPreOrderTraverse: function (callback) {\n\n var stack = [];\n var node = this.root;\n\n while (node != null || !BI.isEmpty(stack)) {\n\n while (node != null) {\n callback && callback(node);\n stack.push(node);\n node = node.getLeft();\n }\n node = stack.pop();\n node = node.getRight();\n }\n },\n\n postOrderTraverse: function (callback) {\n this._postOrderTraverse(this.root, callback);\n },\n\n // 后序遍历(递归)\n _postOrderTraverse: function (node, callback) {\n if (node != null) {\n this._postOrderTraverse(node.getLeft());\n this._postOrderTraverse(node.getRight());\n callback && callback(node);\n }\n },\n\n // 后续遍历(非递归)\n nrPostOrderTraverse: function (callback) {\n\n var stack = [];\n var node = this.root;\n var preNode = null;// 表示最近一次访问的节点\n\n while (node != null || !BI.isEmpty(stack)) {\n\n while (node != null) {\n stack.push(node);\n node = node.getLeft();\n }\n\n node = BI.last(stack);\n\n if (node.getRight() == null || node.getRight() == preNode) {\n callback && callback(node);\n node = stack.pop();\n preNode = node;\n node = null;\n } else {\n node = node.getRight();\n }\n }\n }\n };\n\n BI.Node = function (id) {\n if (BI.isObject(id)) {\n BI.extend(this, id);\n } else {\n this.id = id;\n }\n this.clear.apply(this, arguments);\n };\n\n BI.Node.prototype = {\n constructor: BI.Node,\n\n set: function (key, value) {\n if (BI.isObject(key)) {\n BI.extend(this, key);\n return;\n }\n this[key] = value;\n },\n\n get: function (key) {\n return this[key];\n },\n\n isLeaf: function () {\n return BI.isEmpty(this.children);\n },\n\n getChildren: function () {\n return this.children;\n },\n\n getChildrenLength: function () {\n return this.children.length;\n },\n\n getFirstChild: function () {\n return BI.first(this.children);\n },\n\n getLastChild: function () {\n return BI.last(this.children);\n },\n\n setLeft: function (left) {\n this.left = left;\n },\n\n getLeft: function () {\n return this.left;\n },\n\n setRight: function (right) {\n this.right = right;\n },\n\n getRight: function () {\n return this.right;\n },\n\n setParent: function (parent) {\n this.parent = parent;\n },\n\n getParent: function () {\n return this.parent;\n },\n\n getChild: function (index) {\n return this.children[index];\n },\n\n getChildIndex: function (id) {\n return BI.findIndex(this.children, function (i, ch) {\n return ch.get(\"id\") === id;\n });\n },\n\n removeChild: function (id) {\n this.removeChildByIndex(this.getChildIndex(id));\n },\n\n removeChildByIndex: function (index) {\n var before = this.getChild(index - 1);\n var behind = this.getChild(index + 1);\n if (before != null) {\n before.setRight(behind || null);\n }\n if (behind != null) {\n behind.setLeft(before || null);\n }\n this.children.splice(index, 1);\n },\n\n removeAllChilds: function () {\n this.children = [];\n },\n\n addChild: function (child, index) {\n var cur = null;\n if (BI.isUndefined(index)) {\n cur = this.children.length - 1;\n } else {\n cur = index - 1;\n }\n child.setParent(this);\n if (cur >= 0) {\n this.getChild(cur) && this.getChild(cur).setRight(child);\n child.setLeft(this.getChild(cur));\n }\n if (BI.isUndefined(index)) {\n this.children.push(child);\n } else {\n this.children.splice(index, 0, child);\n }\n },\n\n equals: function (obj) {\n return this === obj || this.id === obj.id;\n },\n\n clear: function () {\n this.parent = null;\n this.left = null;\n this.right = null;\n this.children = [];\n }\n };\n\n BI.extend(BI.Tree, {\n transformToArrayFormat: function (nodes, pId) {\n if (!nodes) return [];\n var r = [];\n if (BI.isArray(nodes)) {\n for (var i = 0, l = nodes.length; i < l; i++) {\n var node = BI.clone(nodes[i]);\n node.pId = node.pId == null ? pId : node.pId;\n delete node.children;\n r.push(node);\n if (nodes[i][\"children\"]) {\n r = r.concat(BI.Tree.transformToArrayFormat(nodes[i][\"children\"], node.id));\n }\n }\n } else {\n var newNodes = BI.clone(nodes);\n newNodes.pId = newNodes.pId == null ? pId : newNodes.pId;\n delete newNodes.children;\n r.push(newNodes);\n if (nodes[\"children\"]) {\n r = r.concat(BI.Tree.transformToArrayFormat(nodes[\"children\"], newNodes.id));\n }\n }\n return r;\n },\n\n arrayFormat: function (nodes, pId) {\n if (!nodes) {\n return [];\n }\n var r = [];\n if (BI.isArray(nodes)) {\n for (var i = 0, l = nodes.length; i < l; i++) {\n var node = nodes[i];\n node.pId = node.pId == null ? pId : node.pId;\n r.push(node);\n if (nodes[i][\"children\"]) {\n r = r.concat(BI.Tree.arrayFormat(nodes[i][\"children\"], node.id));\n }\n }\n } else {\n var newNodes = nodes;\n newNodes.pId = newNodes.pId == null ? pId : newNodes.pId;\n r.push(newNodes);\n if (nodes[\"children\"]) {\n r = r.concat(BI.Tree.arrayFormat(nodes[\"children\"], newNodes.id));\n }\n }\n return r;\n },\n\n transformToTreeFormat: function (sNodes) {\n var i, l;\n if (!sNodes) {\n return [];\n }\n\n if (BI.isArray(sNodes)) {\n var r = [];\n var tmpMap = {};\n for (i = 0, l = sNodes.length; i < l; i++) {\n if (BI.isNull(sNodes[i].id)) {\n return sNodes;\n }\n tmpMap[sNodes[i].id] = BI.clone(sNodes[i]);\n }\n for (i = 0, l = sNodes.length; i < l; i++) {\n if (tmpMap[sNodes[i].pId] && sNodes[i].id !== sNodes[i].pId) {\n if (!tmpMap[sNodes[i].pId].children) {\n tmpMap[sNodes[i].pId].children = [];\n }\n tmpMap[sNodes[i].pId].children.push(tmpMap[sNodes[i].id]);\n } else {\n r.push(tmpMap[sNodes[i].id]);\n }\n delete tmpMap[sNodes[i].id].pId;\n }\n return r;\n }\n return [sNodes];\n \n },\n\n treeFormat: function (sNodes) {\n var i, l;\n if (!sNodes) {\n return [];\n }\n\n if (BI.isArray(sNodes)) {\n var r = [];\n var tmpMap = {};\n for (i = 0, l = sNodes.length; i < l; i++) {\n if (BI.isNull(sNodes[i].id)) {\n return sNodes;\n }\n tmpMap[sNodes[i].id] = sNodes[i];\n }\n for (i = 0, l = sNodes.length; i < l; i++) {\n if (tmpMap[sNodes[i].pId] && sNodes[i].id !== sNodes[i].pId) {\n if (!tmpMap[sNodes[i].pId].children) {\n tmpMap[sNodes[i].pId].children = [];\n }\n tmpMap[sNodes[i].pId].children.push(tmpMap[sNodes[i].id]);\n } else {\n r.push(tmpMap[sNodes[i].id]);\n }\n }\n return r;\n }\n return [sNodes];\n \n },\n\n traversal: function (array, callback) {\n if (BI.isNull(array)) {\n return;\n }\n var self = this;\n BI.some(array, function (i, item) {\n if (callback(i, item) === false) {\n return true;\n }\n self.traversal(item.children, callback);\n });\n }\n });\n})();// 向量操作\nBI.Vector = function (x, y) {\n this.x = x;\n this.y = y;\n};\nBI.Vector.prototype = {\n constructor: BI.Vector,\n cross: function (v) {\n return (this.x * v.y - this.y * v.x);\n },\n length: function (v) {\n return (Math.sqrt(this.x * v.x + this.y * v.y));\n }\n};\nBI.Region = function (x, y, w, h) {\n this.x = x;\n this.y = y;\n this.w = w;\n this.h = h;\n};\nBI.Region.prototype = {\n constructor: BI.Region,\n // 判断两个区域是否相交，若相交，则要么顶点互相包含，要么矩形边界（或对角线）相交\n isIntersects: function (obj) {\n if (this.isPointInside(obj.x, obj.y) ||\n this.isPointInside(obj.x + obj.w, obj.y) ||\n this.isPointInside(obj.x, obj.y + obj.h) ||\n this.isPointInside(obj.x + obj.w, obj.y + obj.h)) {\n return true;\n } else if (obj.isPointInside(this.x, this.y) ||\n obj.isPointInside(this.x + this.w, this.y) ||\n obj.isPointInside(this.x, this.y + this.h) ||\n obj.isPointInside(this.x + this.w, this.y + this.h)) {\n return true;\n } else if (obj.x != null && obj.y != null)// 判断矩形对角线相交 |v1 X v2||v1 X v3| < 0\n {\n var vector1 = new BI.Vector(this.w, this.h);// 矩形对角线向量\n var vector2 = new BI.Vector(obj.x - this.x, obj.y - this.y);\n var vector3 = new BI.Vector(vector2.x + obj.w, vector2.y + obj.h);\n if ((vector1.cross(vector2) * vector1.cross(vector3)) < 0) {\n return true;\n }\n }\n return false;\n },\n // 判断一个点是否在这个区域内部\n isPointInside: function (x, y) {\n if (this.x == null || this.y == null) {\n return false;\n }\n if (x >= this.x && x <= this.x + this.w && y >= this.y && y <= this.y + this.h) {\n return true;\n }\n return false;\n },\n // 返回区域的重心，因为是矩形所以返回中点\n getPosition: function () {\n var pos = [];\n pos.push(this.x + this.w / 2);\n pos.push(this.y + this.h / 2);\n return pos;\n }\n};BI.i18n = {\n \"BI-Multi_Date_Quarter_End\": \"季度末\",\n \"BI-Multi_Date_Month_Begin\": \"月初\",\n \"BI-Multi_Date_YMD\": \"年月日\",\n \"BI-Custom_Color\": \"自定义颜色\",\n \"BI-Numerical_Interval_Input_Data\": \"请输入数值\",\n \"BI-Please_Input_Natural_Number\": \"请输入非负整数\",\n \"BI-No_More_Data\": \"无更多数据\",\n \"BI-Basic_Altogether\": \"共\",\n \"BI-Basic_Sunday\": \"星期日\",\n \"BI-Widget_Background_Colour\": \"组件背景\",\n \"BI-Color_Picker_Error_Text\": \"请输入0~255的正整数\",\n \"BI-Multi_Date_Month\": \"月\",\n \"BI-No_Selected_Item\": \"没有可选项\",\n \"BI-Multi_Date_Year_Begin\": \"年初\",\n \"BI-Quarter_1\": \"第1季度\",\n \"BI-Quarter_2\": \"第2季度\",\n \"BI-Quarter_3\": \"第3季度\",\n \"BI-Quarter_4\": \"第4季度\",\n \"BI-Multi_Date_Year_Next\": \"年后\",\n \"BI-Multi_Date_Month_Prev\": \"个月前\",\n \"BI-Month_Trigger_Error_Text\": \"请输入1~12的正整数\",\n \"BI-Less_And_Equal\": \"小于等于\",\n \"BI-Year_Trigger_Invalid_Text\": \"请输入有效时间\",\n \"BI-Multi_Date_Week_Next\": \"周后\",\n \"BI-Font_Size\": \"字号\",\n \"BI-Basic_Total\": \"共\",\n \"BI-Already_Selected\": \"已选择\",\n \"BI-Formula_Insert\": \"插入\",\n \"BI-Select_All\": \"全选\",\n \"BI-Basic_Tuesday\": \"星期二\",\n \"BI-Multi_Date_Month_End\": \"月末\",\n \"BI-Load_More\": \"点击加载更多数据\",\n \"BI-Basic_September\": \"九月\",\n \"BI-Current_Is_Last_Page\": \"当前已是最后一页\",\n \"BI-Basic_Auto\": \"自动\",\n \"BI-Basic_Count\": \"个\",\n \"BI-Basic_Value\": \"值\",\n \"BI-Basic_Unrestricted\": \"无限制\",\n \"BI-Quarter_Trigger_Error_Text\": \"请输入1~4的正整数\",\n \"BI-Basic_More\": \"更多\",\n \"BI-Basic_Wednesday\": \"星期三\",\n \"BI-Basic_Bold\": \"加粗\",\n \"BI-Basic_Simple_Saturday\": \"六\",\n \"BI-Multi_Date_Month_Next\": \"个月后\",\n \"BI-Basic_March\": \"三月\",\n \"BI-Current_Is_First_Page\": \"当前已是第一页\",\n \"BI-Basic_Thursday\": \"星期四\",\n \"BI-Basic_Prompt\": \"提示\",\n \"BI-Multi_Date_Today\": \"今天\",\n \"BI-Multi_Date_Quarter_Prev\": \"个季度前\",\n \"BI-Row_Header\": \"行表头\",\n \"BI-Date_Trigger_Error_Text\": \"日期格式示例:2015-3-11\",\n \"BI-Basic_Cancel\": \"取消\",\n \"BI-Basic_January\": \"一月\",\n \"BI-Basic_June\": \"六月\",\n \"BI-Basic_July\": \"七月\",\n \"BI-Basic_April\": \"四月\",\n \"BI-Multi_Date_Quarter_Begin\": \"季度初\",\n \"BI-Multi_Date_Week\": \"周\",\n \"BI-Click_Blank_To_Select\": \"点击\\\"空格键\\\"选中完全匹配项\",\n \"BI-Basic_August\": \"八月\",\n \"BI-Word_Align_Left\": \"文字居左\",\n \"BI-Basic_November\": \"十一月\",\n \"BI-Font_Colour\": \"字体颜色\",\n \"BI-Multi_Date_Day_Prev\": \"天前\",\n \"BI-Select_Part\": \"部分选择\",\n \"BI-Multi_Date_Day_Next\": \"天后\",\n \"BI-Less_Than\": \"小于\",\n \"BI-Basic_February\": \"二月\",\n \"BI-Multi_Date_Year\": \"年\",\n \"BI-Number_Index\": \"序号\",\n \"BI-Multi_Date_Week_Prev\": \"周前\",\n \"BI-Next_Page\": \"下一页\",\n \"BI-Right_Page\": \"向右翻页\",\n \"BI-Numerical_Interval_Signal_Value\": \"前后值相等，请将操作符改为“≤”\",\n \"BI-Basic_December\": \"十二月\",\n \"BI-Basic_Saturday\": \"星期六\",\n \"BI-Basic_Simple_Wednesday\": \"三\",\n \"BI-Multi_Date_Quarter_Next\": \"个季度后\",\n \"BI-Basic_October\": \"十月\",\n \"BI-Basic_Simple_Friday\": \"五\",\n \"BI-Basic_Save\": \"保存\",\n \"BI-Numerical_Interval_Number_Value\": \"请保证前面的数值小于/等于后面的数值\",\n \"BI-Previous_Page\": \"上一页\",\n \"BI-No_Select\": \"搜索结果为空\",\n \"BI-Basic_Clears\": \"清空\",\n \"BI-Created_By_Me\": \"我创建的\",\n \"BI-Basic_Simple_Tuesday\": \"二\",\n \"BI-Word_Align_Right\": \"文字居右\",\n \"BI-Summary_Values\": \"汇总\",\n \"BI-Basic_Clear\": \"清除\",\n \"BI-Upload_File_Size_Error\": \"文件大小不支持\",\n \"BI-Up_Page\": \"向上翻页\",\n \"BI-Basic_Simple_Sunday\": \"日\",\n \"BI-Multi_Date_Relative_Current_Time\": \"相对当前时间\",\n \"BI-Selected_Data\": \"已选数据：\",\n \"BI-Multi_Date_Quarter\": \"季度\",\n \"BI-Check_Selected\": \"查看已选\",\n \"BI-Basic_Search\": \"搜索\",\n \"BI-Basic_May\": \"五月\",\n \"BI-Continue_Select\": \"继续选择\",\n \"BI-Please_Input_Positive_Integer\": \"请输入正整数\",\n \"BI-Upload_File_Type_Error\": \"文件类型不支持\",\n \"BI-Upload_File_Error\": \"文件上传失败\",\n \"BI-Basic_Friday\": \"星期五\",\n \"BI-Down_Page\": \"向下翻页\",\n \"BI-Basic_Monday\": \"星期一\",\n \"BI-Left_Page\": \"向左翻页\",\n \"BI-Transparent_Color\": \"透明\",\n \"BI-Basic_Simple_Monday\": \"一\",\n \"BI-Multi_Date_Year_End\": \"年末\",\n \"BI-Time_Interval_Error_Text\": \"请保证开始时间早于/等于结束时间\",\n \"BI-Basic_Time\": \"时间\",\n \"BI-Basic_OK\": \"确定\",\n \"BI-Basic_Sure\": \"确定\",\n \"BI-Basic_Simple_Thursday\": \"四\",\n \"BI-Multi_Date_Year_Prev\": \"年前\",\n \"BI-Tiao_Data\": \"条数据\",\n \"BI-Basic_Italic\": \"斜体\",\n \"BI-Basic_Dynamic_Title\": \"动态时间\",\n \"BI-Basic_Year\": \"年\",\n \"BI-Basic_Single_Quarter\": \"季\",\n \"BI-Basic_Month\": \"月\",\n \"BI-Basic_Week\": \"周\",\n \"BI-Basic_Day\": \"天\",\n \"BI-Basic_Work_Day\": \"工作日\",\n \"BI-Basic_Front\": \"前\",\n \"BI-Basic_Behind\": \"后\",\n \"BI-Basic_Empty\": \"空\",\n \"BI-Basic_Month_End\": \"月末\",\n \"BI-Basic_Month_Begin\": \"月初\",\n \"BI-Basic_Year_End\": \"年末\",\n \"BI-Basic_Year_Begin\": \"年初\",\n \"BI-Basic_Quarter_End\": \"季末\",\n \"BI-Basic_Quarter_Begin\": \"季初\",\n \"BI-Basic_Week_End\": \"周末\",\n \"BI-Basic_Week_Begin\": \"周初\",\n \"BI-Basic_Current_Day\": \"当天\",\n \"BI-Basic_Begin_Start\": \"初\",\n \"BI-Basic_End_Stop\": \"末\",\n \"BI-Basic_Current_Year\": \"今年\",\n \"BI-Basic_Year_Fen\": \"年份\",\n \"BI-Basic_Current_Month\": \"本月\",\n \"BI-Basic_Current_Quarter\": \"本季度\",\n \"BI-Basic_Year_Month\": \"年月\",\n \"BI-Basic_Year_Quarter\": \"年季度\",\n \"BI-Basic_Input_Can_Not_Null\": \"输入框不能为空\",\n \"BI-Basic_Date_Time_Error_Text\": \"日期格式示例:2015-3-11 00:00:00\",\n \"BI-Basic_Input_From_To_Number\": \"请输入{R1}的数值\",\n \"BI-Basic_Or\": \"或\",\n \"BI-Basic_And\": \"且\",\n \"BI-Conf_Add_Formula\": \"添加公式\",\n \"BI-Conf_Add_Condition\": \"添加条件\",\n \"BI-Conf_Formula_And\": \"且公式条件\",\n \"BI-Conf_Formula_Or\": \"或公式条件\",\n \"BI-Conf_Condition_And\": \"且条件\",\n \"BI-Conf_Condition_Or\": \"或条件\",\n \"BI-Microsoft_YaHei\": \"微软雅黑\",\n \"BI-Apple_Light\": \"苹方-light\",\n \"BI-Font_Family\": \"字体\",\n \"BI-Basic_Please_Input_Content\": \"请输入内容\",\n \"BI-Word_Align_Center\": \"文字居中\",\n \"BI-Basic_Please_Enter_Number_Between\": \"请输入{R1}-{R2}的值\",\n \"BI-More_Than\": \"大于\",\n \"BI-More_And_Equal\": \"大于等于\",\n \"BI-Please_Enter_SQL\": \"请输入SQL\",\n \"BI-Basic_Click_To_Add_Text\": \"+点击新增\\\"{R1}\\\"\",\n \"BI-Basic_Please_Select\": \"请选择\",\n \"BI-Basic_Font_Color\": \"文字颜色\",\n \"BI-Basic_Background_Color\": \"背景色\",\n \"BI-Basic_Underline\": \"下划线\",\n \"BI-Basic_Param_Month\": \"{R1}月\",\n \"BI-Basic_Param_Day\": \"{R1}日\",\n \"BI-Basic_Param_Quarter\": \"{R1}季度\",\n \"BI-Basic_Param_Week_Count\": \"第{R1}周\",\n \"BI-Basic_Param_Hour\": \"{R1}时\",\n \"BI-Basic_Param_Minute\": \"{R1}分\",\n \"BI-Basic_Param_Second\": \"{R1}秒\",\n \"BI-Basic_Param_Year\": \"{R1}年\",\n \"BI-Basic_Date_Day\": \"日\",\n \"BI-Basic_Hour_Sin\": \"时\",\n \"BI-Basic_Seconds\": \"秒\",\n \"BI-Basic_Minute\": \"分\",\n \"BI-Basic_Wan\": \"万\",\n \"BI-Basic_Million\": \"百万\",\n \"BI-Basic_Billion\": \"亿\",\n \"BI-Basic_Quarter\": \"季度\",\n \"BI-Basic_No_Select\": \"不选\",\n \"BI-Basic_Now\": \"此刻\"\n};/**\n * Created by astronaut007 on 2018/8/8\n */\n// 牵扯到国际化这些常量在页面加载后再生效\n// full day names\nBI.Date = BI.Date || {};\nBI.Date._DN = [\"星期日\",\n \"星期一\",\n \"星期二\",\n \"星期三\",\n \"星期四\",\n \"星期五\",\n \"星期六\",\n \"星期日\"];\n\n// short day names\nBI.Date._SDN = [\"日\",\n \"一\",\n \"二\",\n \"三\",\n \"四\",\n \"五\",\n \"六\",\n \"日\"];\n\n// Monday first, etc.\nBI.Date._FD = 1;\n\n// full month namesdat\nBI.Date._MN = [\n \"一月\",\n \"二月\",\n \"三月\",\n \"四月\",\n \"五月\",\n \"六月\",\n \"七月\",\n \"八月\",\n \"九月\",\n \"十月\",\n \"十一月\",\n \"十二月\"];\n\n// short month names\nBI.Date._SMN = [0,\n 1,\n 2,\n 3,\n 4,\n 5,\n 6,\n 7,\n 8,\n 9,\n 10,\n 11];\n\nBI.Date._QN = [\"\", \"第1季度\",\n \"第2季度\",\n \"第3季度\",\n \"第4季度\"];\n\n/** Adds the number of days array to the Date object. */\nBI.Date._MD = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];\n\n// 实际上无论周几作为一周的第一天，周初周末都是在-6-0间做偏移，用一个数组就可以\nBI.Date._OFFSET = [0, -1, -2, -3, -4, -5, -6];\n/**\n * 缓冲池\n * @type {{Buffer: {}}}\n */\n\n(function () {\n var Buffer = {};\n var MODE = false;// 设置缓存模式为关闭\n\n BI.BufferPool = {\n put: function (name, cache) {\n if (BI.isNotNull(Buffer[name])) {\n throw new Error(\"Buffer Pool has the key already!\");\n }\n Buffer[name] = cache;\n },\n\n get: function (name) {\n return Buffer[name];\n }\n };\n})();/**\n * 共享池\n * @type {{Shared: {}}}\n */\n\n(function () {\n var _Shared = {};\n BI.SharingPool = {\n _Shared: _Shared,\n put: function (name, shared) {\n _Shared[name] = shared;\n },\n\n cat: function () {\n var args = Array.prototype.slice.call(arguments, 0),\n copy = _Shared;\n for (var i = 0; i < args.length; i++) {\n copy = copy && copy[args[i]];\n }\n return copy;\n },\n\n get: function () {\n return BI.deepClone(this.cat.apply(this, arguments));\n },\n\n remove: function (key) {\n delete _Shared[key];\n }\n };\n})();BI.Req = {\n\n};\n\n//# sourceMappingURL=utils.js.map"]} |