Underscore.js 1.13.8
https://underscorejs.org
(c) 2009-2026 Jeremy Ashkenas, Julian Gonggrijp, and DocumentCloud and Investigative Reporters & Editors
Underscore may be freely distributed under the MIT license.

varVERSION='1.13.8';

varroot = (typeofself =='object'&& self.self=== self && self) ||
          (typeofglobal=='object'&&global.global===global&&global) ||Function('return this')() ||
          {};

varArrayProto=Array.prototype,ObjProto=Object.prototype;varSymbolProto=typeofSymbol!=='undefined'?Symbol.prototype:null;

varpush =ArrayProto.push,
    slice =ArrayProto.slice,
    toString =ObjProto.toString,
    hasOwnProperty =ObjProto.hasOwnProperty;

varsupportsArrayBuffer =typeofArrayBuffer!=='undefined',
    supportsDataView =typeofDataView!=='undefined';

varnativeIsArray =Array.isArray,
    nativeKeys =Object.keys,
    nativeCreate =Object.create,
    nativeIsView = supportsArrayBuffer &&ArrayBuffer.isView;

var_isNaN =isNaN,
    _isFinite =isFinite;

varhasEnumBug = !{toString:null}.propertyIsEnumerable('toString');varnonEnumerableProps = ['valueOf','isPrototypeOf','toString','propertyIsEnumerable','hasOwnProperty','toLocaleString'];

varMAX\_ARRAY\_INDEX=Math.pow(2,53) -1;

functionrestArguments(func, startIndex) {
  startIndex = startIndex ==null? func.length-1: +startIndex;returnfunction() {varlength =Math.max(arguments.length- startIndex,0),
        rest =Array(length),
        index =0;for(; index < length; index++) {
      rest[index] =arguments[index + startIndex];
    }switch(startIndex) {case0:returnfunc.call(this, rest);case1:returnfunc.call(this,arguments[0], rest);case2:returnfunc.call(this,arguments[0],arguments[1], rest);
    }varargs =Array(startIndex +1);for(index =0; index < startIndex; index++) {
      args[index] =arguments[index];
    }
    args[startIndex] = rest;returnfunc.apply(this, args);
  };
}

functionisObject(obj) {vartype =typeofobj;returntype ==='function'|| (type ==='object'&& !!obj);
}

functionisNull(obj) {returnobj ===null;
}

functionisUndefined(obj) {returnobj ===void0;
}

functionisBoolean(obj) {returnobj ===true|| obj ===false|| toString.call(obj) ==='[object Boolean]';
}

functionisElement(obj) {return!!(obj && obj.nodeType===1);
}

functiontagTester(name) {vartag ='[object '+ name +']';returnfunction(obj) {returntoString.call(obj) === tag;
  };
}varisString =tagTester('String');varisNumber =tagTester('Number');varisDate =tagTester('Date');varisRegExp =tagTester('RegExp');varisError =tagTester('Error');varisSymbol =tagTester('Symbol');varisArrayBuffer =tagTester('ArrayBuffer');varisFunction =tagTester('Function');

varnodelist = root.document&& root.document.childNodes;if(typeof/./ !='function'&&typeofInt8Array!='object'&&typeofnodelist !='function') {
  isFunction =function(obj) {returntypeofobj =='function'||false;
  };
}varisFunction$1= isFunction;varhasObjectTag =tagTester('Object');

varhasDataViewBug = (
      supportsDataView && (!/\[native code\]/.test(String(DataView)) ||hasObjectTag(newDataView(newArrayBuffer(8))))
    ),
    isIE11 = (typeofMap!=='undefined'&&hasObjectTag(newMap));varisDataView =tagTester('DataView');

functionalternateIsDataView(obj) {returnobj !=null&&isFunction$1(obj.getInt8) &&isArrayBuffer(obj.buffer);
}varisDataView$1= (hasDataViewBug ? alternateIsDataView : isDataView);

varisArray = nativeIsArray ||tagTester('Array');

functionhas$1(obj, key) {returnobj !=null&& hasOwnProperty.call(obj, key);
}varisArguments =tagTester('Arguments');

(function() {if(!isArguments(arguments)) {
    isArguments =function(obj) {returnhas$1(obj,'callee');
    };
  }
}());varisArguments$1= isArguments;

functionisFinite$1(obj) {return!isSymbol(obj) &&\_isFinite(obj) && !isNaN(parseFloat(obj));
}

functionisNaN$1(obj) {returnisNumber(obj) &&\_isNaN(obj);
}

functionconstant(value) {returnfunction() {returnvalue;
  };
}

functioncreateSizePropertyCheck(getSizeProperty) {returnfunction(collection) {varsizeProperty =getSizeProperty(collection);returntypeofsizeProperty =='number'&& sizeProperty >=0&& sizeProperty <=MAX\_ARRAY\_INDEX;
  }
}

functionshallowProperty(key) {returnfunction(obj) {returnobj ==null?void0: obj[key];
  };
}

vargetByteLength =shallowProperty('byteLength');

varisBufferLike =createSizePropertyCheck(getByteLength);

vartypedArrayPattern =/\[object ((I|Ui)nt(8|16|32)|Float(32|64)|Uint8Clamped|Big(I|Ui)nt64)Array\]/;functionisTypedArray(obj) {

returnnativeIsView ? (nativeIsView(obj) && !isDataView$1(obj)) :isBufferLike(obj) && typedArrayPattern.test(toString.call(obj));
}varisTypedArray$1= supportsArrayBuffer ? isTypedArray :constant(false);

vargetLength =shallowProperty('length');

functionemulatedSet(keys) {varhash = {};for(varl = keys.length, i =0; i < l; ++i) hash[keys[i]] =true;return{contains:function(key) {returnhash[key] ===true; },push:function(key) {
      hash[key] =true;returnkeys.push(key);
    }
  };
}

functioncollectNonEnumProps(obj, keys) {
  keys =emulatedSet(keys);varnonEnumIdx = nonEnumerableProps.length;varconstructor = obj.constructor;varproto = (isFunction$1(constructor) && constructor.prototype) ||ObjProto;

varprop ='constructor';if(has$1(obj, prop) && !keys.contains(prop)) keys.push(prop);while(nonEnumIdx--) {
    prop = nonEnumerableProps[nonEnumIdx];if(propinobj && obj[prop] !== proto[prop] && !keys.contains(prop)) {
      keys.push(prop);
    }
  }
}

functionkeys(obj) {if(!isObject(obj))return[];if(nativeKeys)returnnativeKeys(obj);varkeys = [];for(varkeyinobj)if(has$1(obj, key)) keys.push(key);

if(hasEnumBug)collectNonEnumProps(obj, keys);returnkeys;
}

functionisEmpty(obj) {if(obj ==null)returntrue;

varlength =getLength(obj);if(typeoflength =='number'&& (isArray(obj) ||isString(obj) ||isArguments$1(obj)
  ))returnlength ===0;returngetLength(keys(obj)) ===0;
}

functionisMatch(object, attrs) {var_keys =keys(attrs), length = _keys.length;if(object ==null)return!length;varobj =Object(object);for(vari =0; i < length; i++) {varkey = _keys[i];if(attrs[key] !== obj[key] || !(keyinobj))returnfalse;
  }returntrue;
}

function\_$1(obj) {if(objinstanceof_$1)returnobj;if(!(thisinstanceof_$1))returnnew\_$1(obj);this.\_wrapped= obj;
}

_$1.VERSION=VERSION;

_$1.prototype.value=function() {returnthis.\_wrapped;
};

_$1.prototype.valueOf= _$1.prototype.toJSON= _$1.prototype.value;

_$1.prototype.toString=function() {returnString(this.\_wrapped);
};

functiontoBufferView(bufferSource) {returnnewUint8Array(
    bufferSource.buffer|| bufferSource,
    bufferSource.byteOffset||0,getByteLength(bufferSource)
  );
}

vartagDataView ='[object DataView]';

functionisEqual(a, b) {

vartodo = [{a: a,b: b}];

varaStack = [], bStack = [];

while(todo.length) {varframe = todo.pop();

if(frame ===true) {

aStack.pop();
      bStack.pop();continue;
    }
    a = frame.a;
    b = frame.b;

if(a === b) {if(a !==0||1/ a ===1/ b)continue;returnfalse;
    }

if(a ==null|| b ==null)returnfalse;

if(a !== a) {if(b !== b)continue;returnfalse;
    }

vartype =typeofa;if(type !=='function'&& type !=='object'&&typeofb !='object')returnfalse;

if(ainstanceof_$1) a = a.\_wrapped;if(binstanceof_$1) b = b.\_wrapped;

varclassName = toString.call(a);if(className !== toString.call(b))returnfalse;

if(hasDataViewBug && className =='[object Object]'&&isDataView$1(a)) {if(!isDataView$1(b))returnfalse;
      className = tagDataView;
    }switch(className) {

case'[object RegExp]':

case'[object String]':

if(''+ a ===''+ b)continue;returnfalse;case'[object Number]':
      todo.push({a: +a,b: +b});continue;case'[object Date]':case'[object Boolean]':

if(+a === +b)continue;returnfalse;case'[object Symbol]':if(SymbolProto.valueOf.call(a) ===SymbolProto.valueOf.call(b))continue;returnfalse;case'[object ArrayBuffer]':casetagDataView:

todo.push({a:toBufferView(a),b:toBufferView(b)});continue;
    }varareArrays = className ==='[object Array]';if(!areArrays &&isTypedArray$1(a)) {varbyteLength =getByteLength(a);if(byteLength !==getByteLength(b))returnfalse;if(a.buffer=== b.buffer&& a.byteOffset=== b.byteOffset)continue;
      areArrays =true;
    }if(!areArrays) {if(typeofa !='object'||typeofb !='object')returnfalse;

varaCtor = a.constructor, bCtor = b.constructor;if(aCtor !== bCtor && !(isFunction$1(aCtor) && aCtorinstanceofaCtor &&isFunction$1(bCtor) && bCtorinstanceofbCtor)
          && ('constructor'ina &&'constructor'inb)) {returnfalse;
      }
    }

varlength = aStack.length;while(length--) {

if(aStack[length] === a) {

if(bStack[length] === b)break;returnfalse;
      }
    }

if(length >=0)continue;

aStack.push(a);
    bStack.push(b);

todo.push(true);

if(areArrays) {

length = a.length;if(length !== b.length)returnfalse;

while(length--) {
        todo.push({a: a[length],b: b[length]});
      }
    }else{

var_keys =keys(a), key;
      length = _keys.length;

if(keys(b).length!== length)returnfalse;while(length--) {

key = _keys[length];if(!has$1(b, key))returnfalse;
        todo.push({a: a[key],b: b[key]});
      }
    }
  }

returntrue;
}

functionallKeys(obj) {if(!isObject(obj))return[];varkeys = [];for(varkeyinobj) keys.push(key);

if(hasEnumBug)collectNonEnumProps(obj, keys);returnkeys;
}

functionie11fingerprint(methods) {varlength =getLength(methods);returnfunction(obj) {if(obj ==null)returnfalse;

varkeys =allKeys(obj);if(getLength(keys))returnfalse;for(vari =0; i < length; i++) {if(!isFunction$1(obj[methods[i]]))returnfalse;
    }

returnmethods !== weakMapMethods || !isFunction$1(obj[forEachName]);
  };
}

varforEachName ='forEach',
    hasName ='has',
    commonInit = ['clear','delete'],
    mapTail = ['get', hasName,'set'];

varmapMethods = commonInit.concat(forEachName, mapTail),
    weakMapMethods = commonInit.concat(mapTail),
    setMethods = ['add'].concat(commonInit, forEachName, hasName);varisMap = isIE11 ?ie11fingerprint(mapMethods) :tagTester('Map');varisWeakMap = isIE11 ?ie11fingerprint(weakMapMethods) :tagTester('WeakMap');varisSet = isIE11 ?ie11fingerprint(setMethods) :tagTester('Set');varisWeakSet =tagTester('WeakSet');

functionvalues(obj) {var_keys =keys(obj);varlength = _keys.length;varvalues =Array(length);for(vari =0; i < length; i++) {
    values[i] = obj[_keys[i]];
  }returnvalues;
}

functionpairs(obj) {var_keys =keys(obj);varlength = _keys.length;varpairs =Array(length);for(vari =0; i < length; i++) {
    pairs[i] = [_keys[i], obj[_keys[i]]];
  }returnpairs;
}

functioninvert(obj) {varresult = {};var_keys =keys(obj);for(vari =0, length = _keys.length; i < length; i++) {
    result[obj[_keys[i]]] = _keys[i];
  }returnresult;
}

functionfunctions(obj) {varnames = [];for(varkeyinobj) {if(isFunction$1(obj[key])) names.push(key);
  }returnnames.sort();
}

functioncreateAssigner(keysFunc, defaults) {returnfunction(obj) {varlength =arguments.length;if(defaults) obj =Object(obj);if(length <2|| obj ==null)returnobj;for(varindex =1; index < length; index++) {varsource =arguments[index],
          keys =keysFunc(source),
          l = keys.length;for(vari =0; i < l; i++) {varkey = keys[i];if(!defaults || obj[key] ===void0) obj[key] = source[key];
      }
    }returnobj;
  };
}

varextend =createAssigner(allKeys);

varextendOwn =createAssigner(keys);

vardefaults =createAssigner(allKeys,true);

functionctor() {returnfunction(){};
}

functionbaseCreate(prototype) {if(!isObject(prototype))return{};if(nativeCreate)returnnativeCreate(prototype);varCtor=ctor();Ctor.prototype= prototype;varresult =newCtor;Ctor.prototype=null;returnresult;
}

functioncreate(prototype, props) {varresult =baseCreate(prototype);if(props)extendOwn(result, props);returnresult;
}

functionclone(obj) {if(!isObject(obj))returnobj;returnisArray(obj) ? obj.slice() :extend({}, obj);
}

functiontap(obj, interceptor) {interceptor(obj);returnobj;
}

functiontoPath$1(path) {returnisArray(path) ? path : [path];
}
_$1.toPath = toPath$1;

functiontoPath(path) {return_$1.toPath(path);
}

functiondeepGet(obj, path) {varlength = path.length;for(vari =0; i < length; i++) {if(obj ==null)returnvoid0;
    obj = obj[path[i]];
  }returnlength ? obj :void0;
}

functionget(object, path, defaultValue) {varvalue =deepGet(object,toPath(path));returnisUndefined(value) ? defaultValue : value;
}

functionhas(obj, path) {
  path =toPath(path);varlength = path.length;for(vari =0; i < length; i++) {varkey = path[i];if(!has$1(obj, key))returnfalse;
    obj = obj[key];
  }return!!length;
}

functionidentity(value) {returnvalue;
}

functionmatcher(attrs) {
  attrs =extendOwn({}, attrs);returnfunction(obj) {returnisMatch(obj, attrs);
  };
}

functionproperty(path) {
  path =toPath(path);returnfunction(obj) {returndeepGet(obj, path);
  };
}

functionoptimizeCb(func, context, argCount) {if(context ===void0)returnfunc;switch(argCount ==null?3: argCount) {case1:returnfunction(value) {returnfunc.call(context, value);
    };

case3:returnfunction(value, index, collection) {returnfunc.call(context, value, index, collection);
    };case4:returnfunction(accumulator, value, index, collection) {returnfunc.call(context, accumulator, value, index, collection);
    };
  }returnfunction() {returnfunc.apply(context,arguments);
  };
}

functionbaseIteratee(value, context, argCount) {if(value ==null)returnidentity;if(isFunction$1(value))returnoptimizeCb(value, context, argCount);if(isObject(value) && !isArray(value))returnmatcher(value);returnproperty(value);
}

functioniteratee(value, context) {returnbaseIteratee(value, context,Infinity);
}
_$1.iteratee = iteratee;

functioncb(value, context, argCount) {if(_$1.iteratee !== iteratee)return_$1.iteratee(value, context);returnbaseIteratee(value, context, argCount);
}

functionmapObject(obj, iteratee, context) {
  iteratee =cb(iteratee, context);var_keys =keys(obj),
      length = _keys.length,
      results = {};for(varindex =0; index < length; index++) {varcurrentKey = _keys[index];
    results[currentKey] =iteratee(obj[currentKey], currentKey, obj);
  }returnresults;
}

functionnoop(){}

functionpropertyOf(obj) {if(obj ==null)returnnoop;returnfunction(path) {returnget(obj, path);
  };
}

functiontimes(n, iteratee, context) {varaccum =Array(Math.max(0, n));
  iteratee =optimizeCb(iteratee, context,1);for(vari =0; i < n; i++) accum[i] =iteratee(i);returnaccum;
}

functionrandom(min, max) {if(max ==null) {
    max = min;
    min =0;
  }returnmin +Math.floor(Math.random() * (max - min +1));
}

varnow =Date.now||function() {returnnewDate().getTime();
};

functioncreateEscaper(map) {varescaper =function(match) {returnmap[match];
  };

varsource ='(?:'+keys(map).join('|') +')';vartestRegexp =RegExp(source);varreplaceRegexp =RegExp(source,'g');returnfunction(string) {
    string = string ==null?'':''+ string;returntestRegexp.test(string) ? string.replace(replaceRegexp, escaper) : string;
  };
}

varescapeMap = {'&':'&amp;','\<':'&lt;','\>':'&gt;','"':'&quot;',"'":'&#x27;','`':'&#x60;'};

var_escape =createEscaper(escapeMap);

varunescapeMap =invert(escapeMap);

var_unescape =createEscaper(unescapeMap);

vartemplateSettings = _$1.templateSettings = {evaluate:/\<%([\s\S]+?)%\>/g,interpolate:/\<%=([\s\S]+?)%\>/g,escape:/\<%-([\s\S]+?)%\>/g};

varnoMatch =/(.)^/;

varescapes = {"'":"'",'\\':'\\','\r':'r','\n':'n','\u2028':'u2028','\u2029':'u2029'};varescapeRegExp =/\\|'|\r|\n|\u2028|\u2029/g;functionescapeChar(match) {return'\\'+ escapes[match];
}

varbareIdentifier =/^\s\*(\w|\$)+\s\*$/;

functiontemplate(text, settings, oldSettings) {if(!settings && oldSettings) settings = oldSettings;
  settings =defaults({}, settings, _$1.templateSettings);

varmatcher =RegExp([
    (settings.escape|| noMatch).source,
    (settings.interpolate|| noMatch).source,
    (settings.evaluate|| noMatch).source].join('|') +'|$','g');

varindex =0;varsource ="\_\_p+='";
  text.replace(matcher,function(match, escape, interpolate, evaluate, offset) {
    source += text.slice(index, offset).replace(escapeRegExp, escapeChar);
    index = offset + match.length;if(escape) {
      source +="'+\n((\_\_t=("+escape+"))==null?'':\_.escape(\_\_t))+\n'";
    }elseif(interpolate) {
      source +="'+\n((\_\_t=("+ interpolate +"))==null?'':\_\_t)+\n'";
    }elseif(evaluate) {
      source +="';\n"+ evaluate +"\n\_\_p+='";
    }

returnmatch;
  });
  source +="';\n";varargument = settings.variable;if(argument) {

if(!bareIdentifier.test(argument))thrownewError('variable is not a bare identifier: '+ argument
    );
  }else{

source ='with(obj||{}){\n'+ source +'}\n';
    argument ='obj';
  }

  source ="var \_\_t,\_\_p='',\_\_j=Array.prototype.join,"+"print=function(){\_\_p+=\_\_j.call(arguments,'');};\n"+
    source +'return \_\_p;\n';varrender;try{
    render =newFunction(argument,'\_', source);
  }catch(e) {
    e.source= source;throwe;
  }vartemplate =function(data) {returnrender.call(this, data, _$1);
  };

template.source='function('+ argument +'){\n'+ source +'}';returntemplate;
}

functionresult(obj, path, fallback) {
  path =toPath(path);varlength = path.length;if(!length) {returnisFunction$1(fallback) ? fallback.call(obj) : fallback;
  }for(vari =0; i < length; i++) {varprop = obj ==null?void0: obj[path[i]];if(prop ===void0) {
      prop = fallback;
      i = length;// Ensure we don't continue iterating.}
    obj =isFunction$1(prop) ? prop.call(obj) : prop;
  }returnobj;
}

varidCounter =0;functionuniqueId(prefix) {varid = ++idCounter +'';returnprefix ? prefix + id : id;
}

functionchain(obj) {varinstance =\_$1(obj);
  instance.\_chain=true;returninstance;
}

functionexecuteBound(sourceFunc, boundFunc, context, callingContext, args) {if(!(callingContextinstanceofboundFunc))returnsourceFunc.apply(context, args);varself =baseCreate(sourceFunc.prototype);varresult = sourceFunc.apply(self, args);if(isObject(result))returnresult;returnself;
}

varpartial =restArguments(function(func, boundArgs) {varplaceholder = partial.placeholder;varbound =function() {varposition =0, length = boundArgs.length;varargs =Array(length);for(vari =0; i < length; i++) {
      args[i] = boundArgs[i] === placeholder ?arguments[position++] : boundArgs[i];
    }while(position <arguments.length) args.push(arguments[position++]);returnexecuteBound(func, bound,this,this, args);
  };returnbound;
});

partial.placeholder= _$1;

varbind =restArguments(function(func, context, args) {if(!isFunction$1(func))thrownewTypeError('Bind must be called on a function');varbound =restArguments(function(callArgs) {returnexecuteBound(func, bound, context,this, args.concat(callArgs));
  });returnbound;
});

varisArrayLike =createSizePropertyCheck(getLength);

functionflatten$1(input, depth, strict) {if(!depth && depth !==0) depth =Infinity;

varoutput = [], idx =0, i =0, length =getLength(input) ||0, stack = [];while(true) {if(i >= length) {if(!stack.length)break;varframe = stack.pop();
      i = frame.i;
      input = frame.v;
      length =getLength(input);continue;
    }varvalue = input[i++];if(stack.length>= depth) {
      output[idx++] = value;
    }elseif(isArrayLike(value) && (isArray(value) ||isArguments$1(value))) {

stack.push({i: i,v: input});
      i =0;
      input = value;
      length =getLength(input);
    }elseif(!strict) {
      output[idx++] = value;
    }
  }returnoutput;
}

varbindAll =restArguments(function(obj, keys) {
  keys =flatten$1(keys,false,false);varindex = keys.length;if(index <1)thrownewError('bindAll must be passed function names');while(index--) {varkey = keys[index];
    obj[key] =bind(obj[key], obj);
  }returnobj;
});

functionmemoize(func, hasher) {varmemoize =function(key) {varcache = memoize.cache;varaddress =''+ (hasher ? hasher.apply(this,arguments) : key);if(!has$1(cache, address)) cache[address] = func.apply(this,arguments);returncache[address];
  };
  memoize.cache= {};returnmemoize;
}

vardelay =restArguments(function(func, wait, args) {returnsetTimeout(function() {returnfunc.apply(null, args);
  }, wait);
});

vardefer =partial(delay, _$1,1);

functionthrottle(func, wait, options) {vartimeout, context, args, result;varprevious =0;if(!options) options = {};varlater =function() {
    previous = options.leading===false?0:now();
    timeout =null;
    result = func.apply(context, args);if(!timeout) context = args =null;
  };varthrottled =function() {var_now =now();if(!previous && options.leading===false) previous = _now;varremaining = wait - (_now - previous);
    context =this;
    args =arguments;if(remaining <=0|| remaining > wait) {if(timeout) {clearTimeout(timeout);
        timeout =null;
      }
      previous = _now;
      result = func.apply(context, args);if(!timeout) context = args =null;
    }elseif(!timeout && options.trailing!==false) {
      timeout =setTimeout(later, remaining);
    }returnresult;
  };

  throttled.cancel=function() {clearTimeout(timeout);
    previous =0;
    timeout = context = args =null;
  };returnthrottled;
}

functiondebounce(func, wait, immediate) {vartimeout, previous, args, result, context;varlater =function() {varpassed =now() - previous;if(wait > passed) {
      timeout =setTimeout(later, wait - passed);
    }else{
      timeout =null;if(!immediate) result = func.apply(context, args);

if(!timeout) args = context =null;
    }
  };vardebounced =restArguments(function(\_args) {
    context =this;
    args = _args;
    previous =now();if(!timeout) {
      timeout =setTimeout(later, wait);if(immediate) result = func.apply(context, args);
    }returnresult;
  });

  debounced.cancel=function() {clearTimeout(timeout);
    timeout = args = context =null;
  };returndebounced;
}

functionwrap(func, wrapper) {returnpartial(wrapper, func);
}

functionnegate(predicate) {returnfunction() {return!predicate.apply(this,arguments);
  };
}

functioncompose() {varargs =arguments;varstart = args.length-1;returnfunction() {vari = start;varresult = args[start].apply(this,arguments);while(i--) result = args[i].call(this, result);returnresult;
  };
}

functionafter(times, func) {returnfunction() {if(--times <1) {returnfunc.apply(this,arguments);
    }
  };
}

functionbefore(times, func) {varmemo;returnfunction() {if(--times >0) {
      memo = func.apply(this,arguments);
    }if(times <=1) func =null;returnmemo;
  };
}

varonce =partial(before,2);

functionfindKey(obj, predicate, context) {
  predicate =cb(predicate, context);var_keys =keys(obj), key;for(vari =0, length = _keys.length; i < length; i++) {
    key = _keys[i];if(predicate(obj[key], key, obj))returnkey;
  }
}

functioncreatePredicateIndexFinder(dir) {returnfunction(array, predicate, context) {
    predicate =cb(predicate, context);varlength =getLength(array);varindex = dir >0?0: length -1;for(; index >=0&& index < length; index += dir) {if(predicate(array[index], index, array))returnindex;
    }return-1;
  };
}

varfindIndex =createPredicateIndexFinder(1);

varfindLastIndex =createPredicateIndexFinder(-1);

functionsortedIndex(array, obj, iteratee, context) {
  iteratee =cb(iteratee, context,1);varvalue =iteratee(obj);varlow =0, high =getLength(array);while(low < high) {varmid =Math.floor((low + high) /2);if(iteratee(array[mid]) < value) low = mid +1;elsehigh = mid;
  }returnlow;
}

functioncreateIndexFinder(dir, predicateFind, sortedIndex) {returnfunction(array, item, idx) {vari =0, length =getLength(array);if(typeofidx =='number') {if(dir >0) {
        i = idx >=0? idx :Math.max(idx + length, i);
      }else{
        length = idx >=0?Math.min(idx +1, length) : idx + length +1;
      }
    }elseif(sortedIndex && idx && length) {
      idx =sortedIndex(array, item);returnarray[idx] === item ? idx : -1;
    }if(item !== item) {
      idx =predicateFind(slice.call(array, i, length), isNaN$1);returnidx >=0? idx + i : -1;
    }for(idx = dir >0? i : length -1; idx >=0&& idx < length; idx += dir) {if(array[idx] === item)returnidx;
    }return-1;
  };
}

varindexOf =createIndexFinder(1, findIndex, sortedIndex);

varlastIndexOf =createIndexFinder(-1, findLastIndex);

functionfind(obj, predicate, context) {varkeyFinder =isArrayLike(obj) ? findIndex : findKey;varkey =keyFinder(obj, predicate, context);if(key !==void0&& key !== -1)returnobj[key];
}

functionfindWhere(obj, attrs) {returnfind(obj,matcher(attrs));
}

functioneach(obj, iteratee, context) {
  iteratee =optimizeCb(iteratee, context);vari, length;if(isArrayLike(obj)) {for(i =0, length = obj.length; i < length; i++) {iteratee(obj[i], i, obj);
    }
  }else{var_keys =keys(obj);for(i =0, length = _keys.length; i < length; i++) {iteratee(obj[_keys[i]], _keys[i], obj);
    }
  }returnobj;
}

functionmap(obj, iteratee, context) {
  iteratee =cb(iteratee, context);var_keys = !isArrayLike(obj) &&keys(obj),
      length = (_keys || obj).length,
      results =Array(length);for(varindex =0; index < length; index++) {varcurrentKey = _keys ? _keys[index] : index;
    results[index] =iteratee(obj[currentKey], currentKey, obj);
  }returnresults;
}

functioncreateReduce(dir) {

varreducer =function(obj, iteratee, memo, initial) {var_keys = !isArrayLike(obj) &&keys(obj),
        length = (_keys || obj).length,
        index = dir >0?0: length -1;if(!initial) {
      memo = obj[_keys ? _keys[index] : index];
      index += dir;
    }for(; index >=0&& index < length; index += dir) {varcurrentKey = _keys ? _keys[index] : index;
      memo =iteratee(memo, obj[currentKey], currentKey, obj);
    }returnmemo;
  };returnfunction(obj, iteratee, memo, context) {varinitial =arguments.length>=3;returnreducer(obj,optimizeCb(iteratee, context,4), memo, initial);
  };
}

varreduce =createReduce(1);

varreduceRight =createReduce(-1);

functionfilter(obj, predicate, context) {varresults = [];
  predicate =cb(predicate, context);each(obj,function(value, index, list) {if(predicate(value, index, list)) results.push(value);
  });returnresults;
}

functionreject(obj, predicate, context) {returnfilter(obj,negate(cb(predicate)), context);
}

functionevery(obj, predicate, context) {
  predicate =cb(predicate, context);var_keys = !isArrayLike(obj) &&keys(obj),
      length = (_keys || obj).length;for(varindex =0; index < length; index++) {varcurrentKey = _keys ? _keys[index] : index;if(!predicate(obj[currentKey], currentKey, obj))returnfalse;
  }returntrue;
}

functionsome(obj, predicate, context) {
  predicate =cb(predicate, context);var_keys = !isArrayLike(obj) &&keys(obj),
      length = (_keys || obj).length;for(varindex =0; index < length; index++) {varcurrentKey = _keys ? _keys[index] : index;if(predicate(obj[currentKey], currentKey, obj))returntrue;
  }returnfalse;
}

functioncontains(obj, item, fromIndex, guard) {if(!isArrayLike(obj)) obj =values(obj);if(typeoffromIndex !='number'|| guard) fromIndex =0;returnindexOf(obj, item, fromIndex) >=0;
}

varinvoke =restArguments(function(obj, path, args) {varcontextPath, func;if(isFunction$1(path)) {
    func = path;
  }else{
    path =toPath(path);
    contextPath = path.slice(0, -1);
    path = path[path.length-1];
  }returnmap(obj,function(context) {varmethod = func;if(!method) {if(contextPath && contextPath.length) {
        context =deepGet(context, contextPath);
      }if(context ==null)returnvoid0;
      method = context[path];
    }returnmethod ==null? method : method.apply(context, args);
  });
});

functionpluck(obj, key) {returnmap(obj,property(key));
}

functionwhere(obj, attrs) {returnfilter(obj,matcher(attrs));
}

functionmax(obj, iteratee, context) {varresult = -Infinity, lastComputed = -Infinity,
      value, computed;if(iteratee ==null|| (typeofiteratee =='number'&&typeofobj[0] !='object'&& obj !=null)) {
    obj =isArrayLike(obj) ? obj :values(obj);for(vari =0, length = obj.length; i < length; i++) {
      value = obj[i];if(value !=null&& value > result) {
        result = value;
      }
    }
  }else{
    iteratee =cb(iteratee, context);each(obj,function(v, index, list) {
      computed =iteratee(v, index, list);if(computed > lastComputed || (computed === -Infinity&& result === -Infinity)) {
        result = v;
        lastComputed = computed;
      }
    });
  }returnresult;
}

functionmin(obj, iteratee, context) {varresult =Infinity, lastComputed =Infinity,
      value, computed;if(iteratee ==null|| (typeofiteratee =='number'&&typeofobj[0] !='object'&& obj !=null)) {
    obj =isArrayLike(obj) ? obj :values(obj);for(vari =0, length = obj.length; i < length; i++) {
      value = obj[i];if(value !=null&& value < result) {
        result = value;
      }
    }
  }else{
    iteratee =cb(iteratee, context);each(obj,function(v, index, list) {
      computed =iteratee(v, index, list);if(computed < lastComputed || (computed ===Infinity&& result ===Infinity)) {
        result = v;
        lastComputed = computed;
      }
    });
  }returnresult;
}

varreStrSymbol =/[^\ud800-\udfff]|[\ud800-\udbff][\udc00-\udfff]|[\ud800-\udfff]/g;functiontoArray(obj) {if(!obj)return[];if(isArray(obj))returnslice.call(obj);if(isString(obj)) {

returnobj.match(reStrSymbol);
  }if(isArrayLike(obj))returnmap(obj, identity);returnvalues(obj);
}

functionsample(obj, n, guard) {if(n ==null|| guard) {if(!isArrayLike(obj)) obj =values(obj);returnobj[random(obj.length-1)];
  }varsample =toArray(obj);varlength =getLength(sample);
  n =Math.max(Math.min(n, length),0);varlast = length -1;for(varindex =0; index < n; index++) {varrand =random(index, last);vartemp = sample[index];
    sample[index] = sample[rand];
    sample[rand] = temp;
  }returnsample.slice(0, n);
}

functionshuffle(obj) {returnsample(obj,Infinity);
}

functionsortBy(obj, iteratee, context) {varindex =0;
  iteratee =cb(iteratee, context);returnpluck(map(obj,function(value, key, list) {return{value: value,index: index++,criteria:iteratee(value, key, list)
    };
  }).sort(function(left, right) {vara = left.criteria;varb = right.criteria;if(a !== b) {if(a > b || a ===void0)return1;if(a < b || b ===void0)return-1;
    }returnleft.index- right.index;
  }),'value');
}

functiongroup(behavior, partition) {returnfunction(obj, iteratee, context) {varresult = partition ? [[], []] : {};
    iteratee =cb(iteratee, context);each(obj,function(value, index) {varkey =iteratee(value, index, obj);behavior(result, value, key);
    });returnresult;
  };
}

vargroupBy =group(function(result, value, key) {if(has$1(result, key)) result[key].push(value);elseresult[key] = [value];
});

varindexBy =group(function(result, value, key) {
  result[key] = value;
});

varcountBy =group(function(result, value, key) {if(has$1(result, key)) result[key]++;elseresult[key] =1;
});

varpartition =group(function(result, value, pass) {
  result[pass ?0:1].push(value);
},true);

functionsize(obj) {if(obj ==null)return0;returnisArrayLike(obj) ? obj.length:keys(obj).length;
}

functionkeyInObj(value, key, obj) {returnkeyinobj;
}

varpick =restArguments(function(obj, keys) {varresult = {}, iteratee = keys[0];if(obj ==null)returnresult;if(isFunction$1(iteratee)) {if(keys.length>1) iteratee =optimizeCb(iteratee, keys[1]);
    keys =allKeys(obj);
  }else{
    iteratee = keyInObj;
    keys =flatten$1(keys,false,false);
    obj =Object(obj);
  }for(vari =0, length = keys.length; i < length; i++) {varkey = keys[i];varvalue = obj[key];if(iteratee(value, key, obj)) result[key] = value;
  }returnresult;
});

varomit =restArguments(function(obj, keys) {variteratee = keys[0], context;if(isFunction$1(iteratee)) {
    iteratee =negate(iteratee);if(keys.length>1) context = keys[1];
  }else{
    keys =map(flatten$1(keys,false,false),String);
    iteratee =function(value, key) {return!contains(keys, key);
    };
  }returnpick(obj, iteratee, context);
});

functioninitial(array, n, guard) {returnslice.call(array,0,Math.max(0, array.length- (n ==null|| guard ?1: n)));
}

functionfirst(array, n, guard) {if(array ==null|| array.length<1)returnn ==null|| guard ?void0: [];if(n ==null|| guard)returnarray[0];returninitial(array, array.length- n);
}

functionrest(array, n, guard) {returnslice.call(array, n ==null|| guard ?1: n);
}

functionlast(array, n, guard) {if(array ==null|| array.length<1)returnn ==null|| guard ?void0: [];if(n ==null|| guard)returnarray[array.length-1];returnrest(array,Math.max(0, array.length- n));
}

functioncompact(array) {returnfilter(array,Boolean);
}

functionflatten(array, depth) {returnflatten$1(array, depth,false);
}

vardifference =restArguments(function(array, rest) {
  rest =flatten$1(rest,true,true);returnfilter(array,function(value){return!contains(rest, value);
  });
});

varwithout =restArguments(function(array, otherArrays) {returndifference(array, otherArrays);
});

functionuniq(array, isSorted, iteratee, context) {if(!isBoolean(isSorted)) {
    context = iteratee;
    iteratee = isSorted;
    isSorted =false;
  }if(iteratee !=null) iteratee =cb(iteratee, context);varresult = [];varseen = [];for(vari =0, length =getLength(array); i < length; i++) {varvalue = array[i],
        computed = iteratee ?iteratee(value, i, array) : value;if(isSorted && !iteratee) {if(!i || seen !== computed) result.push(value);
      seen = computed;
    }elseif(iteratee) {if(!contains(seen, computed)) {
        seen.push(computed);
        result.push(value);
      }
    }elseif(!contains(result, value)) {
      result.push(value);
    }
  }returnresult;
}

varunion =restArguments(function(arrays) {returnuniq(flatten$1(arrays,true,true));
});

functionintersection(array) {varresult = [];varargsLength =arguments.length;for(vari =0, length =getLength(array); i < length; i++) {varitem = array[i];if(contains(result, item))continue;varj;for(j =1; j < argsLength; j++) {if(!contains(arguments[j], item))break;
    }if(j === argsLength) result.push(item);
  }returnresult;
}

functionunzip(array) {varlength = (array &&max(array, getLength).length) ||0;varresult =Array(length);for(varindex =0; index < length; index++) {
    result[index] =pluck(array, index);
  }returnresult;
}

varzip =restArguments(unzip);

functionobject(list, values) {varresult = {};for(vari =0, length =getLength(list); i < length; i++) {if(values) {
      result[list[i]] = values[i];
    }else{
      result[list[i][0]] = list[i][1];
    }
  }returnresult;
}

functionrange(start, stop, step) {if(stop ==null) {
    stop = start ||0;
    start =0;
  }if(!step) {
    step = stop < start ? -1:1;
  }varlength =Math.max(Math.ceil((stop - start) / step),0);varrange =Array(length);for(varidx =0; idx < length; idx++, start += step) {
    range[idx] = start;
  }returnrange;
}

functionchunk(array, count) {if(count ==null|| count <1)return[];varresult = [];vari =0, length = array.length;while(i < length) {
    result.push(slice.call(array, i, i += count));
  }returnresult;
}

functionchainResult(instance, obj) {returninstance.\_chain?\_$1(obj).chain() : obj;
}

functionmixin(obj) {each(functions(obj),function(name) {varfunc = _$1[name] = obj[name];
    _$1.prototype[name] =function() {varargs = [this.\_wrapped];
      push.apply(args,arguments);returnchainResult(this, func.apply(_$1, args));
    };
  });return_$1;
}

each(['pop','push','reverse','shift','sort','splice','unshift'],function(name) {varmethod =ArrayProto[name];
  _$1.prototype[name] =function() {varobj =this.\_wrapped;if(obj !=null) {
      method.apply(obj,arguments);if((name ==='shift'|| name ==='splice') && obj.length===0) {deleteobj[0];
      }
    }returnchainResult(this, obj);
  };
});

each(['concat','join','slice'],function(name) {varmethod =ArrayProto[name];
  _$1.prototype[name] =function() {varobj =this.\_wrapped;if(obj !=null) obj = method.apply(obj,arguments);returnchainResult(this, obj);
  };
});

varallExports = {\_\_proto\_\_:null,VERSION:VERSION,restArguments: restArguments,isObject: isObject,isNull: isNull,isUndefined: isUndefined,isBoolean: isBoolean,isElement: isElement,isString: isString,isNumber: isNumber,isDate: isDate,isRegExp: isRegExp,isError: isError,isSymbol: isSymbol,isArrayBuffer: isArrayBuffer,isDataView: isDataView$1,isArray: isArray,isFunction: isFunction$1,isArguments: isArguments$1,isFinite: isFinite$1,isNaN: isNaN$1,isTypedArray: isTypedArray$1,isEmpty: isEmpty,isMatch: isMatch,isEqual: isEqual,isMap: isMap,isWeakMap: isWeakMap,isSet: isSet,isWeakSet: isWeakSet,keys: keys,allKeys: allKeys,values: values,pairs: pairs,invert: invert,functions: functions,methods: functions,extend: extend,extendOwn: extendOwn,assign: extendOwn,defaults: defaults,create: create,clone: clone,tap: tap,get: get,has: has,mapObject: mapObject,identity: identity,constant: constant,noop: noop,toPath: toPath$1,property: property,propertyOf: propertyOf,matcher: matcher,matches: matcher,times: times,random: random,now: now,escape: _escape,unescape: _unescape,templateSettings: templateSettings,template: template,result: result,uniqueId: uniqueId,chain: chain,iteratee: iteratee,partial: partial,bind: bind,bindAll: bindAll,memoize: memoize,delay: delay,defer: defer,throttle: throttle,debounce: debounce,wrap: wrap,negate: negate,compose: compose,after: after,before: before,once: once,findKey: findKey,findIndex: findIndex,findLastIndex: findLastIndex,sortedIndex: sortedIndex,indexOf: indexOf,lastIndexOf: lastIndexOf,find: find,detect: find,findWhere: findWhere,each: each,forEach: each,map: map,collect: map,reduce: reduce,foldl: reduce,inject: reduce,reduceRight: reduceRight,foldr: reduceRight,filter: filter,select: filter,reject: reject,every: every,all: every,some: some,any: some,contains: contains,includes: contains,include: contains,invoke: invoke,pluck: pluck,where: where,max: max,min: min,shuffle: shuffle,sample: sample,sortBy: sortBy,groupBy: groupBy,indexBy: indexBy,countBy: countBy,partition: partition,toArray: toArray,size: size,pick: pick,omit: omit,first: first,head: first,take: first,initial: initial,last: last,rest: rest,tail: rest,drop: rest,compact: compact,flatten: flatten,without: without,uniq: uniq,unique: uniq,union: union,intersection: intersection,difference: difference,unzip: unzip,transpose: unzip,zip: zip,object: object,range: range,chunk: chunk,mixin: mixin,'default': _$1};

var_ =mixin(allExports);

_.\_= _;

exportdefault_;export{VERSION, after, everyasall, allKeys, someasany, extendOwnasassign, before, bind, bindAll, chain, chunk, clone, mapascollect, compact, compose, constant, contains, countBy, create, debounce, defaults, defer, delay, findasdetect, difference, restasdrop, each, _escapeasescape, every, extend, extendOwn, filter, find, findIndex, findKey, findLastIndex, findWhere, first, flatten, reduceasfoldl, reduceRightasfoldr, eachasforEach, functions, get, groupBy, has, firstashead, identity, containsasinclude, containsasincludes, indexBy, indexOf, initial, reduceasinject, intersection, invert, invoke, isArguments$1asisArguments, isArray, isArrayBuffer, isBoolean, isDataView$1asisDataView, isDate, isElement, isEmpty, isEqual, isError, isFinite$1asisFinite, isFunction$1asisFunction, isMap, isMatch, isNaN$1asisNaN, isNull, isNumber, isObject, isRegExp, isSet, isString, isSymbol, isTypedArray$1asisTypedArray, isUndefined, isWeakMap, isWeakSet, iteratee, keys, last, lastIndexOf, map, mapObject, matcher, matcherasmatches, max, memoize, functionsasmethods, min, mixin, negate, noop, now, object, omit, once, pairs, partial, partition, pick, pluck, property, propertyOf, random, range, reduce, reduceRight, reject, rest, restArguments, result, sample, filterasselect, shuffle, size, some, sortBy, sortedIndex, restastail, firstastake, tap, template, templateSettings, throttle, times, toArray, toPath$1astoPath, unzipastranspose, _unescapeasunescape, union, uniq, uniqasunique, uniqueId, unzip, values, where, without, wrap, zip };