//下划线.js 1.13.7// https://underscorejs.org//（c）2009-2024年Jeremy Ashkenas、Julian Gonggrijp、DocumentCloud和调查记者与编辑//根据麻省理工学院的许可证，底核可以自由分发。//当前版本。var版本=“1.13.7”；//在浏览器中建立根对象`window`（`self`），`global`//在服务器上，或在某些虚拟机中为“this”。我们使用`self`//而不是“window”来支持“WebWorker”。var根=（typeof self==“对象”&&self.self==self&&self）||（全局类型==“对象”&&global.global===global&&全局）||函数（“return this”）（）||{};//在缩小（但不是gzipped）版本中保存字节：var ArrayProto=数组原型，ObjProto=对象原型；var SymbolProto=符号类型！=='未定义'？Symbol.protype：空；//创建快速参考变量，以加快对核心原型的访问。var push=阵列协议push，slice=阵列协议slice，toString=对象协议.toString，hasOwnProperty=ObjProto.hasOwn属性；//现代特征检测。var supportsArrayBuffer=数组缓冲区类型！=='未定义'，supportsDataView=数据视图类型！=='未定义'；//我们希望使用的所有**ECMAScript 5+**本机函数实现//在此声明。var nativeIsArray=数组.isArray，nativeKeys=Object.keys，nativeCreate=Object.create，nativeIsView=支持数组缓冲区&&数组缓冲区.isView；//创建对这些内置函数的引用，因为我们会覆盖它们。isNaN＝isNaN，_isFinite=isFinite；//IE<9中不会被“for key in…”迭代的键因此错过了。var hasEnumBug=！{toString:空}.propertyIsEnumerable（'toString'）；var nonEnumerableProps=['valueOf'，'是原型'，'到字符串'，“propertyIsEnumerable”、“hasOwnProperty”、“toLocaleString”]；//可以精确表示的最大整数。var MAX_ARRAY_INDEX=数学.pow（2,53）-1；//一些函数接受的参数数量可变，或者需要一些//参数，然后是可变数量的要操作的值//启用。此帮助器累计超过函数的所有剩余参数//参数长度（或显式`startIndex`），转换为//最后一个论点。与ES6的“rest参数”类似。函数restArguments（func，startIndex）{startIndex=startIndex==null？函数长度-1:+startIndex；返回函数（）{var length=数学最大值（arguments.length-startIndex，0），rest=数组（长度），指数=0；for（；索引<长度；索引++）{rest[index]=参数[index+startIndex]；}开关（startIndex）{case 0：返回函数调用（this，rest）；案例1：返回函数调用（this，arguments[0]，rest）；案例2：返回函数调用（this，参数[0]，参数[1]，rest）；}var args=数组（startIndex+1）；for（index=0；index<startIndex；index++）{args[索引]=参数[索引]；}args[startIndex]=rest；返回函数apply（this，args）；};}//给定的变量是对象吗？函数isObject（obj）{var类型=对象类型；return type===“函数”||（type==“对象”&&！！obj）；}//给定的值等于null吗？函数为Null（obj）{return obj===空；}//给定变量是否未定义？函数未定义（obj）{返回obj===无效0；}//给定值是布尔值吗？函数isBoolean（obj）{return obj===true||obj==false||toString.call（obj）===“[对象布尔值]”；}//给定值是DOM元素吗？函数isElement（obj）{返回！！（obj&&obj.nodeType===1）；}//用于创建基于“toString”的类型测试仪的内部函数。功能标签测试仪（名称）{var标记='[object'+name+']'；返回函数（obj）{return toString.call（obj）===标记；};}var isString=标记测试仪（'String'）；var isNumber=标记测试仪（“编号”）；var isDate=tagTester（“日期”）；var isRegExp=标记测试仪（“RegExp”）；var isError=tagTester（“错误”）；var isSymbol=标记测试仪（“符号”）；var isArrayBuffer=tagTester（“数组缓冲区”）；var isFunction=tagTester（“函数”）；//如果合适，优化“isFunction”。解决旧版本中的一些“类型”错误//v8、IE 11（#1621）、Safari 8（#1929）和PhantomJS（#2236）。var nodelist=根文档&&root.document.childNodes；if（typeof/./！='function'&&typeof Int8Array！='object'&&typeof nodelist！='function'）{isFunction=函数（obj）{返回obj类型==“函数”||false；};}var isFunction$1=isFunctional；var hasObjectTag=tagTester（“对象”）；//在IE 10-Edge 13中，“DataView”具有字符串标记“[object object]'”。//在IE 11中，最常见的问题也适用于//`Map`、`WeakMap`和`Set`。//此外，在某些情况下，应用程序可以覆盖本机//`DataView`对象，在这种情况下，我们不能使用构造函数//安全且只应依赖替代的“DataView”检查var hasDataViewBug=(supportsDataView&&（！/\[本机代码\]/.test（String（DataView））||hasObjectTag（new DataView（new ArrayBuffer（8）））),isIE11=（映射类型！==“未定义”&&hasObjectTag（新映射））；var isDataView=标记测试仪（“数据视图”）；//在IE 10-Edge 13中，我们需要一个不同的启发式//以确定对象是否为“DataView”。//此外，在本机“DataView”为//我们不能依赖标签本身。函数alternateIsDataView（obj）{返回对象！=null&&isFunction$1（obj.getInt8）&&isArrayBuffer（obj.buffer）；}var isDataView$1=（hasDataViewBug？alternateIsDataView:isDataView）；//给定值是数组吗？//委托ECMA5的本机`Array.isArray`。var isArray=nativeIsArray ||tagTester（“阵列”）；//检查“key”是否是“obj”自己的属性名的内部函数。函数有$1（obj，key）{返回对象！=null&&hasOwnProperty.call（obj，key）；}var isArguments=tagTester（“参数”）；//在浏览器中定义方法的后备版本（ahem，IE<9），其中//没有任何可检查的“Arguments”类型。（函数（）{if（！isArguments（arguments））{isArguments=函数（obj）{return有$1（obj，'callee'）；};}}());var isArguments$1=isArgument；//给定的对象是有限数吗？函数是有限的$1（obj）{返回！isSymbol（obj）&&_isFinite（obj）&&！isNaN（parseFloat（obj））；}//给定值是`NaN`吗？函数是NaN$1（obj）{return isNumber（obj）&&_isNaN（obj）；}//谓词生成函数。通常在Undercore之外有用。函数常数（值）{返回函数（）{返回值；};}//“isArrayLike”和“isBufferLike”的通用内部逻辑。函数createSizePropertyCheck（getSizePropert）{返回函数（集合）{var sizeProperty=getSizeProperty（集合）；返回sizeProperty类型=='number'&&sizeProporty>=0&&size Property<=MAX_ARRAY_INDEX；}}//内部帮助程序，用于生成从“obj”获取属性“key”的函数。函数shallowProperty（key）{返回函数（obj）{返回obj==空？void 0:obj[key]；};}//内部帮助器，用于获取对象的“byteLength”属性。var getByteLength=浅属性（'byteLength'）；//内部助手确定我们是否应该对//`ArrayBuffer`等人。var isBufferLike=创建SizePropertyCheck（getByteLength）；//给定值是类型化数组吗？var typedArrayPattern=/\[对象（（I|Ui）nt（8|16|32）|Float（32|64）|Uint8Clamped|Big（I|Ui）nt64）数组\]/；函数isTypedArray（obj）{//`ArrayBuffer.isView`是最经得起未来考验的，所以请在可用时使用它。//否则，回到上面的正则表达式。返回nativeIsView？（本机IsView（obj）&&！isDataView$1（对象））：isBufferLike（obj）&&typedArrayPattern.test（toString.call（obj））；}var isTypedArray$1=supportsArrayBuffer？isTypedArray：常量（false）；//内部帮助器，用于获取对象的“长度”属性。var getLength=浅属性（'length'）；//创建简单查找结构的内部帮助器。//`collectNonEnumProps`过去依赖于`_.contains`，但这导致了//循环导入`emulatedSet是一种一次性解决方案，仅适用于//字符串数组。函数模拟集（键）{var散列={}；对于（var l=键长度，i=0；i<l；++i）散列[键[i]]=true；返回{包含：函数（键）{return hash[key]===true；}，按键：功能（按键）{hash[key]=true；返回键。按下（键）；}};}//内部助手。检查“keys”在IE<9中是否存在不会//由“for key in…”迭代因此错过了。如果//需要。函数collectNonEnumProps（obj，keys）{keys=模拟集（keys）；var nonEnumIdx=nonEnumerableProps.length；var构造函数=obj.constructor；var proto=（isFunction$1（constructor）&&constructor.prototype）||ObjProto；//构造函数是一个特例。var prop=“构造函数”；如果（有$1（obj，prop）&&！keys.contains（prop））keys.push（pop）；while（非EnumIdx-）{prop=nonEnumerableProps[nonEnumIdx]；if（obj中的prop&&obj[prop]！==proto[prop]&&！keys.contains（prop））{按键。推动（道具）；}}}//检索对象自身属性的名称。//委托给**ECMAScript 5**的本机`Object.keys`。功能键（obj）{if（！isObject（obj））return[]；if（nativeKeys）返回nativeKey（obj）；var键=[]；for（obj中的var键）if（有$1（obj，key））keys.push（key）；//啊哼，IE<9。if（hasEnumBug）collectNonEnumProps（obj，keys）；返回键；}//给定的数组、字符串或对象是否为空？//“空”对象没有可枚举的自身属性。函数isEmpty（obj）{if（obj==null）返回true；//如果`obj`没有，则跳过更昂贵的基于`toString`的类型检查//`.length`。var长度=getLength（obj）；if（typeof length==“数字”&&(isArray（obj）|| isString（obj）|| isArguments$1（obj）))返回长度===0；return getLength（keys（obj））===0；}//返回对象是否具有给定的一组“key:value”对。函数isMatch（对象，属性）{var_keys=密钥（属性），长度=密钥长度；if（object==null）返回！长度；var obj=对象（Object）；for（var i=0；i<长度；i++）{var键=键[i]；if（attrs[key]！==obj[key]|！（obj中的key））返回false；}返回true；}//如果Undercore作为函数调用，它将返回一个可以//使用OO样式。此包装器保存添加的所有函数的更改版本//通过`_.mixin`。包裹的对象可以链接。函数_$1（obj）{if（obj实例_$1）返回obj；if（！（此实例为$1））返回new$1（obj）；这个_包裹=对象；}_$1.VERSION=版本；//从包装和链接的对象中提取结果。_$1.prototype.value=函数（）{返回这个_包裹；};//为引擎操作中使用的某些方法提供展开代理//例如算术和JSON字符串化。_$1.prototype.valueOf=_$1.proto类型.toJSON=_$1.原型.value；_$1.prototype.toString=函数（）{return String（this._wrapped）；};//包装或浅拷贝ArrayBuffer的内部函数，//类型化数组或DataView转换为新视图，重用缓冲区。函数到BufferView（bufferSource）{返回新的Uint8Array(bufferSource.buffer||bufferSource，bufferSource.byteOffset ||0，getByteLength（bufferSource）);}//我们使用这个字符串两次，因此为其命名以进行缩小。var tagDataView=“[对象数据视图]”；//`_.isEqual`的内部递归比较函数。函数eq（a、b、a堆栈、b堆栈）{//相同的对象是相等的`0====-0`，但它们并不完全相同。//参见[Harmony `egal`提案](https://wiki.ecmascript.org/doku.php？id=harmony:egal).如果（a===b）返回a！==0||1/a===1/b；//`null`或`undefined`仅等于自身（严格比较）。如果（a==null|b==null）返回false；//`NaN`是等价的，但不是自反的。如果（a！==a）返回b！==b；//排气基本检查var类型=a的类型；if（type！==“function”&&type！=“object”&&typeof b！=“object”）返回false；return deepEq（a，b，aStack，bStack）；}//`_.isEqual`的内部递归比较函数。函数deepEq（a，b，aStack，bStack）{//展开所有包裹的对象。if（_$1的实例）a=a.wrapped；如果（b实例_$1）b=b_wrapped；//比较`[[Class]]`名称。var className=toString.call（a）；如果（className！==toString.call（b））返回false；//解决IE 10-Edge 13中的错误。if（hasDataViewBug&&className=='[object object]'&&isDataView$1（a））{如果（！isDataView$1（b））返回false；className=标记数据视图；}开关（className）{//这些类型按值进行比较。案例“[object RegExp]”：//RegExp被强制为字符串进行比较（注意：“”+/a/i===“/a/i”）案例“[object String]”：//基本体及其对应的对象包装器是等效的；因此，“5”是//相当于`new String（“5”）`。返回“”+a===“”+b；案例“[对象编号]”：//`NaN`是等价的，但不是自反的。//对象（NaN）等效于NaN。如果（+a！==+a）返回+b！==+b；//对其他数值执行“合法”比较。return+a===0？1/+a===1/b:+a===+b；案例“[对象日期]”：案例“[object Boolean]”：//将日期和布尔值强制为数字基元值。日期按其//毫秒表示。请注意，具有毫秒表示的无效日期//“NaN”的不等价。返回+a===+b；案例“[object Symbol]”：return SymbolProto.valueOf.call（a）===SymbolProto.valueOf.call（b）；案例“[object ArrayBuffer]”：案例标记数据视图：//强制类型化数组，这样我们就可以通过了。return deepEq（到BufferView（a），到Buffer View（b），aStack，bStack）；}var areArrays=className===“[object Array]”；if（！areArrays&&isTypedArray$1（a））{var byteLength=获取字节长度（a）；if（byteLength！==getByteLengment（b））返回false；如果（a.buffer===b.buffer&&a.byteOffset===b字节偏移）返回true；areArrays=true；}if（！areArrays）{if（typeof a！=“object”| | typeof b！=“object”）返回false；//具有不同构造函数的对象不是等价的，而是“Object”或“Array”//来自不同帧的。var aCtor=a.constructor，bCtor=b.constructor；if（aCtor！==bC或&&！（isFunction$1（aC或）&&aC或aC的实例&&isFunction$1（bC或）&&bC或bC的实例&&（a中的“施工方”和b中的“承包商”）{返回false；}}//假设循环结构相等。循环检测算法//结构改编自ES 5.1第15.12.3节，抽象操作“JO”。//正在初始化已遍历对象的堆栈。//之所以在这里这样做，是因为我们只需要它们来比较对象和数组。a堆栈=a堆栈||[]；bStack=bStack | |[]；var长度=堆叠长度；while（长度--）{//线性搜索。性能与//独特的嵌套结构。如果（aStack[length]===a）返回bStack[longth]===b；}//将第一个对象添加到遍历对象的堆栈中。a堆栈推送（a）；b堆叠推动（b）；//递归比较对象和数组。if（areArrays）（如果（areArrays））{//比较数组长度以确定是否需要进行深入比较。长度=a.length；如果（length！==b.length）返回false；//深入比较内容，忽略非数字属性。while（长度--）{如果（！eq（a[length]，b[length]，aStack，bStack））返回false；}}其他{//深入比较对象。var_keys=键（a），键；长度=键长度；//在比较深度相等之前，请确保两个对象包含相同数量的属性。if（键（b）.length！==长度）返回false；while（长度--）{//深入比较每个成员键=键[长度]；if（！（有$1（b，key）&&eq（a[key]，b[key]、aStack、bStack）））返回false；}}//从遍历对象堆栈中移除第一个对象。aStack.pop（）；bStack.pop（）；返回true；}//进行深入比较以检查两个对象是否相等。函数等于（a，b）{返回eq（a，b）；}//检索对象的所有可枚举属性名称。函数allKeys（obj）{if（！isObject（obj））return[]；var键=[]；for（obj中的var键）键。push（键）；//啊哼，IE<9。if（hasEnumBug）collectNonEnumProps（obj，keys）；返回键；}//由于常规的“Object.prototype.toString”类型测试不适用于//在IE 11中的某些类型中，我们使用基于指纹的启发式//关于方法。这不太好，但这是我们最好的。//指纹方法列表定义如下。函数ie11指纹（方法）{var length=getLength（方法）；返回函数（obj）{如果（obj==null）返回false；//“Map”、“WeakMap”和“Set”没有可枚举键。var键=所有键（obj）；if（getLength（keys））返回false；for（var i=0；i<长度；i++）{如果（！isFunction$1（obj[methods[i]]））返回false；}//如果我们正在对“WeakMap”进行测试，我们需要确保//`obj`没有`forEach`方法来区分//它来自常规的“地图”。返回方法！==weakMapMethods||！isFunction$1（对象[forEachName]）；};}//为了紧凑小型化，我们写道//指纹中的每一根弦只有一次。var forEachName='forEach'，hasName=“has”，commonInit=['clear'，'delete']，mapTail=['get'，hasName，'set']；//`Map`、`WeakMap`和`Set`各自略有不同//上述子列表的组合。var mapMethods=commonInit.concat（用于EachName，mapTail），weakMapMethods=commonInit.concat（mapTail），setMethods=['add'].concat（commonInit，用于EachName，hasName）；var isMap=isIE11？ie11指纹（mapMethods）：tagTester（'Map'）；var isWeakMap=isIE11？ie11指纹（weakMapMethods）：tagTester（“WeakMap”）；var isSet=isIE11？ie11指纹（setMethods）：tagTester（“设置”）；var isWeakSet=标记测试仪（“WeakSet”）；//检索对象属性的值。函数值（obj）{var键=键（obj）；var长度=键长度；var值=数组（长度）；for（var i=0；i<长度；i++）{值[i]=对象[_keys[i]]；}返回值；}//将对象转换为`[key，value]`对的列表。//与“_.object”相对的是一个参数。函数对（obj）{var键=键（obj）；var长度=键长度；var pairs=数组（长度）；for（var i=0；i<长度；i++）{pairs[i]=[_keys[i]，obj[_keys[i]]]；}返回对；}//反转对象的关键帧和值。这些值必须是可序列化的。函数反转（obj）{var结果={}；var键=键（obj）；for（var i=0，length=_keys.length；i<长度；i++）{结果[obj[_keys[i]]]=键[i]；}返回结果；}//返回对象上可用函数名的排序列表。功能函数（obj）{var名称=[]；for（obj中的var键）{if（isFunction$1（obj[key]））名称.push（key）；}return names.sort（）；}//用于创建赋值函数的内部函数。函数createAssigner（keysFunc，默认值）{返回函数（obj）{var length=arguments.length；如果（默认）obj=对象（obj）；if（length<2|obj==null）返回obj；for（var索引=1；索引<长度；索引++）{var源=参数[索引]，keys=keysFunc（源），l=键长度；对于（var i=0；i<l；i++）{var键=键[i]；如果（！defaults||obj[key]===void 0）obj[key]=source[key]；}}返回对象；};}//使用传入对象中的所有属性扩展给定对象。var extend=createAssigner（所有键）；//为给定对象分配传入中所有自己的属性//个对象。// (https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/assign)var extendOwn=createAssigner（密钥）；//使用默认属性填充给定对象。var defaults=createAssigner（allKeys，true）；//为代理prototype-swapping创建裸函数引用。函数ctor（）{返回函数（）{}；}//用于创建从另一个对象继承的新对象的内部函数。函数baseCreate（原型）{if（！isObject（prototype））返回{}；if（nativeCreate）return nationalCreate（prototype）；var Ctor=系数（）；Ctor.prototype=原型；var结果=新Ctor；Ctor.protype=空；返回结果；}//创建从给定原型对象继承的对象。//如果提供了其他属性，则它们将添加到//已创建对象。功能创建（原型、道具）{var result=baseCreate（原型）；if（props）extendOwn（result，props）；返回结果；}//创建对象的（浅克隆）副本。功能克隆（obj）{if（！isObject（obj））返回obj；返回isArray（obj）？obj.slice（）：扩展（{}，obj）；}//用`obj`调用`interceptor`，然后返回`obj'。//此方法的主要目的是在//以便对链中的中间结果执行操作。功能抽头（obj、拦截器）{拦截器（obj）；返回对象；}//将（深层）属性“path”规范化为数组。//与`_.interate`类似，此函数也可以自定义。函数到路径$1（路径）{返回isArray（路径）？路径：[路径]；}_$1.toPath=路径$1；//“_.toPath”的内部包装以启用缩小。//类似于`_.interate`的`cb`。函数到路径（path）{return _$1.toPath（路径）；}//内部函数，用于沿“path”获取“obj”中的嵌套属性。函数deepGet（obj，path）{var长度=路径长度；for（var i=0；i<长度；i++）{如果（obj==null）返回void 0；obj=obj[路径[i]]；}返回长度？obj:无效0；}//从“object”中获取“path”上（深层）属性的值。//如果“path”中的任何属性不存在或值为//`undefined`，返回`defaultValue`。//`path`通过`_.toPath`规范化。函数get（对象、路径、默认值）{var值=deepGet（对象，toPath（路径））；返回未定义（值）？defaultValue：值；}//用于检查对象是否直接具有给定属性的快捷函数//本身（换句话说，不是在原型上）。与内部`has不同`//函数，此公共版本还可以遍历嵌套属性。函数具有（obj，path）{path=路径（path）；var长度=路径长度；for（var i=0；i<长度；i++）{var键=路径[i]；如果（！有$1（obj，key））返回false；obj=对象[键]；}返回！！长度；}//保留identity函数用于默认迭代。函数标识（值）{返回值；}//返回一个谓词，用于检查对象是否具有给定的//`key:value`对。函数匹配器（属性）{attrs=extendOwn（{}，attrs）；返回函数（obj）{return isMatch（obj，attrs）；};}//创建一个函数，当传递对象时，该函数将遍历该对象的//指定为键或索引数组的给定路径下的属性。函数属性（路径）{path=路径（path）；返回函数（obj）{return deepGet（obj，path）；};}//返回有效（对于当前发动机）版本的内部函数//传入回调，在其他Undercore中重复应用//功能。函数optimizeCb（func、context、argCount）{if（context==void 0）返回func；开关（argCount==null？3:argCount）{情况1：返回函数（值）{返回函数调用（上下文，值）；};//由于我们没有使用双参数情况，因此省略了双参数情况。案例3：返回函数（值、索引、集合）{返回函数调用（上下文、值、索引、集合）；};案例4：返回函数（累加器、值、索引、集合）{返回函数调用（上下文、累加器、值、索引、集合）；};}返回函数（）{return func.apply（上下文、参数）；};}//一个内部函数，用于生成可应用于每个//元素，返回所需的结果-`_.identity`，//任意回调、属性匹配器或属性访问器。函数baseIterate（值、上下文、argCount）{if（value==null）返回标识；if（isFunction$1（value））返回optimizeCb（value、context、argCount）；if（isObject（value）&&！isArray（值））返回匹配器（值）；返回属性（值）；}//回调生成器的外部包装。用户可以自定义//`_.interate`如果他们想要额外的谓词/迭代速记样式。//此抽象隐藏了内部唯一的“argCount”参数。函数iterate（value，context）{return baseIterate（value，context，Infinity）；}_$1.interate=迭代；//我们在内部调用以生成回调的函数。它调用//`_.iterate`如果被重写，则为`baseIterate`。函数cb（值、上下文、argCount）{如果（_$1.iterate！==iterate）返回_$1.interate（value，context）；return baseIterate（value，context，argCount）；}//返回将“iterate”应用于“obj”的每个元素的结果。//与`_.map`相反，它返回一个对象。函数映射对象（obj，iteratee，context）{iterate=cb（iterate，context）；var_keys=键（obj），长度=键长度，结果=｛｝；for（var索引=0；索引<长度；索引++）{var currentKey=_keys[索引]；results[currentKey]=迭代（obj[current Key]，currentKey，obj）；}回报结果；}//谓词生成函数。通常在Undercore之外有用。函数noop（）{}//为返回给定属性的给定对象生成函数。函数属性Of（obj）{如果（obj==null）返回noop；返回函数（路径）{返回get（obj，路径）；};}//运行函数**n**次。函数时间（n，iterate，context）{var accum=数组（数学最大值（0，n））；iterate=优化Cb（iterate，context，1）；对于（var i=0；i<n；i++）accum[i]=迭代（i）；回归累积；}//返回一个介于“min”和“max”（含）之间的随机整数。函数随机（最小、最大）{if（最大值==空）{最大值=最小值；最小值=0；}return min+Math.floor（Math.random（）*（max-min+1））；}//一种（可能更快）获取当前时间戳作为整数的方法。var now=日期now | |函数（）{return new Date（）.getTime（）；};//生成用于转义和取消转义字符串的函数的内部帮助器//到/从HTML插值。函数createEscaper（映射）{var转义符=函数（匹配）{返回映射[匹配]；};//用于标识需要转义的密钥的正则表达式。var源='（？：'+键（映射）.join（'|'）+'）'；var testRegexp=RegExp（源）；var replaceRegexp=RegExp（源，'g'）；返回函数（字符串）{string=string==null？“”：“”+字符串；是否返回testRegexp.test（字符串）？replace（replaceRegexp，转义符）：string；};}//用于转义的HTML实体的内部列表。变量escapeMap={'&': '&','<': '<','>': '>','"': '"',"'": ''','`': '`'};//将字符串转义为HTML插值的函数。var_escape=创建Escaper（escapeMap）；//用于取消转义的HTML实体的内部列表。var unescapeMap=反转（转义Map）；//用于从HTML插值中取消转义字符串的函数。var_unescape=创建Escaper（unescapeMap）；//默认情况下，Undercore使用ERB样式的模板分隔符。更改//按照模板设置使用替代分隔符。var templateSettings=_$1.templateSettings={评估：/<%（[\s\s]+？）%>/g，插值：/<%=（[\s\s]+？）%>/g，转义：/<%-（[\s\s]+？）%>/g};//自定义“_.templateSettings”时，如果不想定义//插值、求值或转义正则表达式，我们需要一个//保证不匹配。var noMatch=/（.）^/；//某些字符需要转义，以便将其放入//字符串文字。var转义={"'": "'",'\\': '\\',“\r”：“r”，“\n”：“n”，'\u2028'：'u2028''，'\u2029'：'u2029]};var escapeRegExp=/\\|'|\r|\n|\u2028|\u029/g；函数escapeChar（匹配）{return'\\'+转义[match]；}//为了防止第三方代码通过//`_.templateSettings.variable`，我们根据以下规则对其进行测试//表达。它有意比只匹配有效值更自由一些//标识符，但仍然可以通过默认值或//正在破坏赋值。var bareIdentifier=/^\s*（\w|\$）+\s*$/；//JavaScript微模板，类似于John Resig的实现。//底层模板处理任意分隔符，保留空白，//并在插值代码中正确转义引号。//注意：“oldSettings”仅用于向后兼容。功能模板（文本、设置、旧设置）{if（！settings&&oldSettings）settings=oldSettings；settings=默认值（{}，settings，_$1.templateSettings）；//通过交替将分隔符组合成一个正则表达式。var matcher=注册费用([（settings.escape||noMatch）.source，（settings.interpolate||noMatch）.source，（settings.evaluate ||noMatch）.source].join（“|”）+“|$”，“g”）；//编译模板源，适当转义字符串文本。var指数=0；var源=“__p+='”；text.replace（匹配器、函数（匹配、转义、插值、求值、偏移）{source+=text.slice（index，offset）.replace（escapeRegExp，escapeChar）；索引=偏移量+匹配长度；if（转义）{source+=“'+\n（（__t=（“+escape+”））==空？'：_.escape（__t））+\n'”；}else if（插值）{source+=“'+\n（（__t=（“+interpolate+”））==空？''：__t）+\n'”；}else if（评估）{source+=“'；\n”+evaluate+“\n_p+='”；}//Adobe VM需要返回匹配以生成正确的偏移量。返回匹配；});source+=“'；\n”；var参数=settings.variable；if（参数）{//确保不受第三方代码注入的影响。（CVE-2021-23358）if（！bareIdentifier.test（argument））引发新错误(“变量不是空标识符：”+参数);}其他{//如果未指定变量，请将数据值放置在本地范围内。source=“with（obj||{}）｛\n'+source+”｝\n'；参数=“obj”；}source=“var__t，__p=''，__j=数组.protype.join，”+“print=函数（）{__p+=__j.call（参数，''）；}；\n”+source+'返回__p；\n’；var渲染；尝试{render=新函数（参数，“_”，源）；}捕捉（e）{e.source=源；抛出e；}var模板=函数（数据）{返回render.call（this，data，_$1）；};//提供编译后的源代码以便于预编译。template.source='函数（'+argument+'）{\n'+source+'}'；返回模板；}//沿“path”遍历“obj”的子级。如果子级是函数，则它//以其父级作为上下文调用。返回最终值//child，如果任何子级未定义，则为“fallback”。功能结果（obj、路径、回退）{path=路径（path）；var长度=路径长度；if（！长度）{返回是函数$1（回退）吗？fallback.call（obj）：回退；}for（var i=0；i<长度；i++）{var-prop=obj==null？void 0:obj[路径[i]]；if（prop===void 0）{prop=后备；i=长度；//确保我们不会继续迭代。}obj=isFunction$1（道具）？属性调用（obj）：属性；}返回对象；}//生成唯一的整数id（在整个客户端会话中唯一）。//用于临时DOM ID。var idCounter=0；函数uniqueId（前缀）{var id=++idCounter+''；返回前缀？前缀+id:id；}//开始链接包裹的Undercore对象。函数链（obj）{var实例=_$1（obj）；实例_链=真；返回实例；}//用于执行绑定到“context”（可选）的“sourceFunc”的内部函数//“参数”。确定是作为构造函数还是作为//功能正常。函数executeBound（sourceFunc，boundFunc，context，callingContext，args）{if（！（callingContext instanceof boundFunc））返回sourceFunc.apply（context，args）；var self=baseCreate（sourceFunc.prototype）；var result=sourceFunc.apply（self，args）；if（isObject（result））返回结果；回归自我；}//通过创建具有部分//参数已预先填充，但未更改其动态“this`上下文。`_`行为//默认情况下作为占位符，允许任何参数组合//预先填充。为自定义占位符参数设置`_.partial.placeholder`。var partial=restArguments（函数（func，boundArgs）{var占位符=partial.placeholder；var绑定=函数（）{var位置=0，长度=boundArgs.length；var args=数组（长度）；for（var i=0；i<长度；i++）{args[i]=boundArgs[i]===占位符？参数[位置++]：boundArgs[i]；}while（position<arguments.length）args.push（arguments[position++]）；return executeBound（函数，绑定，此，此，参数）；};回归界；});partial.placeholder=_$1；//创建绑定到给定对象的函数（赋值`this`和参数，//（可选）。var bind=restArguments（函数（func，context，args）{if（！isFunction$1（func））引发新的TypeError（“必须对函数调用绑定”）；var bound=restArguments（函数（callArgs）{return executeBound（func，bound，context，this，args.concat（callArgs））；});回归界；});//集合方法的内部助手，用于确定集合是否//应该作为数组或对象进行迭代。//相关：网址：https://people.mozilla.org/~jorendorff/es6-draft.html#秒长度//避免ARM-64上出现非常严重的iOS 8 JIT错误#2094var isArrayLike=创建SizePropertyCheck（getLength）；//递归“flatten”函数的内部实现。函数展平$1（输入、深度、严格、输出）{output=输出| |[]；如果（！depth&&depth！==0）{深度=无限；}else if（深度<=0）{返回output.concat（输入）；}var idx=输出长度；for（var i=0，length=getLength（输入）；i<长度；i++）{var值=输入[i]；if（isArrayLike（值）&&（isArray（值）||isArguments$1（值））{//展平数组或参数对象的当前级别。if（深度>1）{展平$1（值，深度-1，严格，输出）；idx=输出长度；}其他{var j=0，len=值。长度；而（j<len）输出[idx++]=值[j++]；}}else if（！strict）{输出[idx++]=值；}}返回输出；}//将多个对象的方法绑定到该对象。剩余参数//是要绑定的方法名称。用于确保所有回调//在属于它的对象上定义。var bindAll=restArguments（函数（obj，键）{keys=平坦$1（keys，false，false）；var索引=键长度；if（index<1）throw new Error（'bindAll必须传递函数名'）；while（索引--）{var键=键[索引]；obj[key]=绑定（obj[key]，obj）；}返回对象；});//通过存储一个昂贵的函数的结果来记忆它。函数memoize（func，hasher）{var memory=函数（键）{var缓存=memoize.cache；var address=''+（hasher？hasher.apply（this，arguments）：key）；如果（！有$1（cache，address））cache[address]=func.apply（this，arguments）；返回缓存[地址]；};memoize.cache={}；回执；}//将函数延迟给定的毫秒数，然后调用//它带有提供的参数。var delay=restArguments（函数（func，wait，args）{return setTimeout（function（））{返回函数apply（null，args）；}，等待）；});//延迟函数，将其调度为在当前调用堆栈具有//已清除。var defer=部分（延迟，_$1,1）；//返回一个函数，该函数在调用时最多只能触发一次//在给定的时间窗口内。正常情况下，节流功能将运行//尽可能多地等待，每次等待都不会超过一次；//但如果要禁用前缘的执行，请传递//`{leading:false}`。要禁用后缘执行，同上。功能调节（func、wait、options）{var超时，上下文，参数，结果；之前的var=0；if（！options）options={}；var later=函数（）{previous=options.leading===false？0:now（）；超时=空；结果=func.apply（上下文，参数）；如果（！timeout）context=args=null；};var throttled=函数（）{var _now=现在（）；if（！previous&&options.leading===false）previous=_now；var剩余=等待-（_now-之前）；上下文=此；args=参数；if（剩余<=0||剩余>等待）{if（超时）{clearTimeout（超时）；超时=空；}上一个=_now；结果=func.apply（上下文，参数）；如果（！timeout）context=args=null；}else if（！timeout&&options.trail！==false）{timeout=setTimeout（稍后，剩余）；}返回结果；};throttled.cancel=函数（）{clearTimeout（超时）；上一个=0；超时=上下文=参数=空；};回程节流；}//当返回函数的调用序列结束时，参数//函数被触发。序列的结束由“wait”定义`//参数。如果传递了“immediate”，则参数函数将为//在序列的开头而不是结尾触发。函数去抖动（func，wait，immediate）{var timeout，previous，args，result，context；var later=函数（）{var passed=now（）-前一个；if（等待>通过）{timeout=setTimeout（稍后，等待-通过）；}其他{超时=空；if（！immediate）result=func.apply（context，args）；//需要进行此检查，因为“func”可以递归调用“debounded”。如果（！timeout）args=context=null；}};var debounded=restArguments（函数（_args）{上下文=此；args=args；上一个=现在（）；if（！超时）{timeout=setTimeout（稍后，等待）；if（立即）结果=func.apply（上下文，参数）；}返回结果；});debounzed.cancel=函数（）{clearTimeout（超时）；超时=参数=上下文=空；};退弹；}//返回第一个函数作为参数传递给第二个函数，//允许您调整参数、在之前和之后运行代码，以及//有条件地执行原始函数。函数包装（func，wrapper）{return partial（wrapper，func）；}//返回传入谓词的否定版本。函数求反（谓词）{返回函数（）{返回！谓词.apply（this，参数）；};}//返回由函数列表组成的函数，每个函数//使用后面函数的返回值。函数compose（）{var args=参数；var开始=args.length-1；返回函数（）{var i=开始；var结果=args[start].apply（this，arguments）；while（i--）result=args[i].call（this，result）；返回结果；};}//返回一个仅在第N次调用时或之后执行的函数。函数after（times，func）{返回函数（）{if（--倍<1）{返回函数apply（this，参数）；}};}//返回一个只在//第N次呼叫。函数before（times，func）{var备忘录；返回函数（）{if（--次数>0）{memo=函数应用（this，参数）；}如果（次数<=1）func=null；回执；};}//返回最多一次执行的函数，无论如何执行//经常调用它。对于延迟初始化很有用。var一次=部分（之前，2）；//返回通过真值测试的对象的第一个键。函数findKey（obj，谓词，上下文）{谓词=cb（谓词，上下文）；var_keys=键（obj），键；for（var i=0，length=_keys.length；i<长度；i++）{键=键[i]；if（谓词（obj[key]，key，obj））返回键；}}//生成`_.findIndex`和`_.findLastIndex`的内部函数。函数createPredicateIndexFinder（目录）{返回函数（数组、谓词、上下文）{谓词=cb（谓词，上下文）；var length=getLength（数组）；var指数=dir>0？0：长度-1；for（；index>=0&&index<length；index+=dir）{if（谓词（array[index]，index，array））返回索引；}返回-1；};}//返回通过真值测试的类数组上的第一个索引。var findIndex=创建预测索引查找器（1）；//返回通过真值测试的类数组上的最后一个索引。var findLastIndex=创建预测索引查找器（-1）；//使用比较器函数计算出最小指数//应该插入一个对象以保持顺序。使用二进制搜索。函数sortedIndex（数组、obj、iterate、context）{iterate=cb（iterate，context，1）；var值=迭代（obj）；var low=0，high=getLength（数组）；while（低<高）{var mid=数学地板（（低+高）/2）；if（iterate（array[mid]）<value）low=mid+1；其他高=中等；}回报低；}//生成`_.indexOf`和`_.lastIndexOf'函数的内部函数。函数createIndexFinder（dir，谓词Find，sortedIndex）{返回函数（数组、项、idx）{var i=0，length=getLength（数组）；if（idx类型==“数字”）{如果（dir>0）{i=idx>=0？idx：数学最大值（idx+长度，i）；}其他{长度=idx>=0？数学最小值（idx+1，长度）：idx+length+1；}}否则如果（sortedIndex&&idx&&length）{idx=sortedIndex（数组，项）；返回数组[idx]===项？idx:-1；}if（item！==item）{idx=谓词查找（slice.call（array，i，length），isNaN$1）；返回idx>=0？idx+i:-1；}for（idx=dir>0？i:length-1；idx>=0&&idx<length；idx+=dir）{if（array[idx]===项）返回idx；}返回-1；};}//返回数组中第一次出现项的位置，//如果数组中不包含该项，则返回-1。//如果数组较大且已按排序顺序排列，则传递`true`//用于**isSorted**以使用二进制搜索。var indexOf=创建索引查找器（1，findIndex，sortedIndex）；//返回数组中某项最后一次出现的位置，//如果数组中不包含该项，则返回-1。var lastIndexOf=createIndexFinder（-1，findLastIndex）；//返回通过真值测试的第一个值。函数find（obj，谓词，上下文）{var keyFinder=isArrayLike（obj）？findIndex:findKey；var key=keyFinder（obj，谓词，上下文）；如果（key！==void 0&&key！==-1）返回obj[key]；}//常见用例`_.find`的便捷版本：获取第一个//包含特定“key:value”对的对象。函数findWhere（obj，attrs）{返回查找（obj，matcher（attrs））；}//收集功能的基石`//实现，也称为“forEach”。//除处理类似阵列的对象外，还处理原始对象。治疗所有人//稀疏的排列像是密集的。函数each（obj、iterate、context）{iterate=optimizeCb（iterate，context）；变量i，长度；if（isArrayLike（obj））{对于（i=0，长度=obj.length；i<长度；i++）{迭代（obj[i]，i，obj）；}}其他{var键=键（obj）；对于（i=0，长度=_keys.length；i<长度；i++）{迭代（obj[_keys[i]]，_keys[i]，obj）；}}返回对象；}//返回对每个元素应用迭代的结果。函数映射（obj、iterate、context）{iterate=cb（iterate，context）；var_keys=！类似数组（对象）和键（对象），长度=（_keys||obj）.length，results=数组（长度）；for（var索引=0；索引<长度；索引++）{var currentKey=_keys_keys[index]：索引；结果[索引]=迭代（obj[当前键]，当前键，obj）；}回报结果；}//内部助手，用于创建减少函数，向左或向右迭代。函数createReduce（dir）{//在单独的函数中重新分配参数变量的包装代码//访问“arguments.length”以避免性能命中的函数。(#1991)var reducer=函数（obj，iterate，memo，initial）{var_keys=！类似数组（对象）和键（对象），长度=（_keys||obj）.length，索引=dir>0？0：长度-1；if（！initial）{memo=对象[_keys？_keys[index]：索引]；指数+=dir；}for（；index>=0&&index<length；index+=dir）{var currentKey=_keys_keys[index]：索引；memo=迭代（memo，obj[当前键]，currentKey，obj）；}回执；};返回函数（obj、iterate、memo、context）{var initial=arguments.length>=3；return reducer（obj，optimizeCb（iterate，context，4），memo，initial）；};}//**Reduce**从值列表中构建单个结果，也称为“注入”，//或“foldl”。var reduce=创建reduce（1）；//reduce的右关联版本，也称为“foldr”。var reduceRight=创建减少（-1）；//返回通过真相测试的所有元素。函数过滤器（obj、谓词、上下文）{var结果=[]；谓词=cb（谓词，上下文）；每个（对象、函数（值、索引、列表）{if（谓词（value，index，list））results.push（value）；});回报结果；}//返回真理测试失败的所有元素。函数拒绝（obj、谓词、上下文）{返回过滤器（obj，否定（cb（谓词）），上下文）；}//确定是否所有元素都通过了真实性测试。函数every（obj，谓词，上下文）{谓词=cb（谓词，上下文）；var_keys=！类似数组（对象）和键（对象），长度=（_keys||obj）.length；for（var索引=0；索引<长度；索引++）{var currentKey=_keys_keys[index]：索引；if（！谓词（obj[currentKey]，currentKey，obj））返回false；}返回true；}//确定对象中是否至少有一个元素通过了真值测试。函数some（obj，谓词，上下文）{谓词=cb（谓词，上下文）；var_keys=！类似数组（对象）和键（对象），长度=（_keys||obj）.length；for（var索引=0；索引<长度；索引++）{var currentKey=_keys_keys[index]：索引；if（谓词（obj[currentKey]，currentKey，obj））返回true；}返回false；}//确定数组或对象是否包含给定项（使用`===`）。函数包含（obj，item，fromIndex，guard）{if（！isArrayLike（obj））obj=值（obj；if（typeof fromIndex！='number'||guard）fromIndex=0；return indexOf（obj，item，fromIndex）>=0；}//对集合中的每个项调用方法（带参数）。var invoke=restArguments（函数（obj、路径、args）{var contextPath，函数；if（isFunction$1（路径））{func=路径；}其他{path=路径（path）；contextPath=路径切片（0，-1）；path=路径[path.length-1]；}返回映射（obj，函数（上下文）{var方法=func；if（！方法）{if（contextPath和contextPath.length）{context=deepGet（context，contextPath）；}if（context==null）返回void 0；方法=上下文[路径]；}return方法==null？方法：method.apply（context，args）；});});//“_.map`常见用例的便利版本：获取属性。功能提取（对象，键）{返回映射（obj，属性（键））；}//“_.filter”常见用例的方便版本：仅选择//包含特定“key:value”对的对象。函数，其中（obj，attrs）{返回过滤器（obj，matcher（attrs））；}//返回最大元素（或基于元素的计算）。函数max（obj，iterate，context）{var result=无限，lastComputed=无限，计算值；if（iteratee==null ||（iteratee的类型==“number”&&类型的obj[0]！=“object”&&obj！=null））{obj=类似数组（obj）？obj：值（obj）；for（var i=0，length=obj.length；i<length；i++）{值=对象[i]；if（value！=null&&value>result）{结果=值；}}}其他{iterate=cb（iterate，context）；每个（obj，函数（v，索引，列表）{计算=迭代（v，索引，列表）；if（computed>lastComputed||（computed===-无限&&result===-无限））{结果=v；lastComputed=已计算；}});}返回结果；}//返回最小元素（或基于元素的计算）。函数min（obj，iterate，context）{var result=无穷大，lastComputed=无穷大，计算值；if（iteratee==null ||（iteratee的类型==“number”&&类型的obj[0]！=“object”&&obj！=null））{obj=类似数组（obj）？obj：值（obj）；for（var i=0，length=obj.length；i<length；i++）{值=对象[i]；if（value！=空&&value<结果）{结果=值；}}}其他{iterate=cb（iterate，context）；每个（obj，函数（v，索引，列表）{计算=迭代（v，索引，列表）；if（computed<lastComputed | |（computed===无限&&result===无穷））{结果=v；lastComputed=已计算；}});}返回结果；}//从任何可迭代的内容安全地创建一个真实的活动数组。var reStrSymbol=/[^\ud800-\udfff]|[\ud800-\udbff][\udc00-\udfff]|[\ ud800-\ udfff]/g；函数toArray（obj）{如果（！obj）返回[]；if（isArray（obj））返回slice.call（obj）；if（isString（obj））{//将代理项对字符放在一起。返回对象匹配（reStrSymbol）；}if（isArrayLike（obj））返回映射（obj，identity）；返回值（obj）；}//使用现代版本的//[渔夫-耶茨洗牌](https://en.wikipedia.org/wiki/Fisher网站–Yates_shuffle）。//如果未指定**n**，则返回单个随机元素。//内部的“guard”参数允许它与“_.map”一起使用。函数示例（obj，n，guard）{if（n==null||guard）{if（！isArrayLike（obj））obj=值（obj；return obj[随机（obj.length-1）]；}var样本=toArray（obj）；var length=getLength（示例）；n=数学最大值（数学最小值（n，长度），0）；var last=长度-1；for（var index=0；index<n；index++）{var rand=随机（索引，最后一个）；var temp=样本[指数]；sample[index]=样本[rand]；样本[rand]=温度；}返回sample.slice（0，n）；}//洗牌系列。函数洗牌（obj）{返回样本（obj，Infinity）；}//根据iterate生成的条件对对象的值进行排序。函数sortBy（obj，iterate，context）{var指数=0；iterate=cb（iterate，context）；返回pull（map（obj，函数（value，key，list））{返回{value：值，索引：索引++，条件：迭代（值、键、列表）};}).sort（函数（左、右）{var a=左侧标准；var b=权利标准；如果（a！==b）{如果（a>b|a===void 0）返回1；如果（a<b|b===void 0）返回-1；}return left.index—right.index；})，“值”）；}//用于聚合“分组依据”操作的内部函数。功能组（行为、分区）{返回函数（obj、iterate、context）{var结果=分区？[[], []] : {};iterate=cb（iterate，context）；每个（对象、函数（值、索引）{var键=迭代（值、索引、对象）；行为（结果、值、键）；});返回结果；};}//按条件对对象的值进行分组。传递字符串属性//分组依据或返回条件的函数。var groupBy=组（函数（结果、值、键）{if（有$1（result，key））result[key].push（value）；否则结果[key]=[value]；});//按类似于`_.groupBy`的条件为对象的值编制索引，但对于//当您知道您的索引值将是唯一的。var indexBy=组（函数（结果、值、键）{结果[key]=值；});//统计按特定条件分组的对象实例。通过//计数依据的字符串属性，或返回//标准。var countBy=组（函数（结果、值、键）{if（有$1（result，key））result[key]++；else结果[key]=1；});//将集合拆分为两个数组：一个数组的元素全部传递给定的//真理测试，一个所有要素都没有通过真理测试的人。var分区=组（函数（结果、值、通过）{结果[pass？0:1].push（value）；}，true）；//返回集合中的元素数。函数大小（obj）{如果（obj==null）返回0；return是ArrayLike（obj）吗？obj.length：键（obj）.length；}//内部`_.pick`帮助函数，用于确定`key`是否是可枚举的//“obj”的属性名。函数keyInObj（值、键、对象）{obj中的return键；}//返回仅包含允许属性的对象的副本。var pick=restArguments（函数（obj，键）{var结果={}，iterate=键[0]；如果（obj==null）返回结果；if（isFunction$1（iterate））{if（keys.length>1）iterate=optimizeCb（iterate，keys[1]）；keys=所有键（obj）；}其他{iterate=keyInObj；keys=平坦$1（keys，false，false）；obj=对象（obj）；}for（var i=0，length=keys.length；i<长度；i++）{var键=键[i]；var值=对象[键]；if（iterate（value，key，obj））result[key]=值；}返回结果；});//返回不包含不允许的属性的对象的副本。var omit=restArguments（函数（obj，键）{var iteratee=keys[0]，上下文；if（isFunction$1（iterate））{iterate=否定（iterate）；if（keys.length>1）上下文=键[1]；}其他{keys=映射（展平$1（keys，false，false），String）；iterate=函数（值，键）{返回！包含（键，键）；};}返回pick（obj，iterate，context）；});//返回除数组最后一个项之外的所有项。特别适用于//arguments对象。传递**n**将返回中的所有值//数组，不包括最后一个N。函数初始值（数组、n、保护）{return slice.call（数组，0，Math.max（0，array.length-（n==null||guard？1:n））；}//获取数组的第一个元素。通过**n**将返回第一个n//数组中的值。**guard**检查允许它使用`_.map`。函数优先（数组、n、保护）{如果（array==null|array.length<1）返回n==null | | guard？无效0:[]；if（n==null||guard）返回数组[0]；返回初始值（数组，array.length-n）；}//返回除“数组”的第一项之外的所有内容。特别适用于//“arguments”对象。传递**n**将返回//“数组”。函数rest（数组、n、保护）{return slice.call（数组，n==null||guard？1:n）；}//获取数组的最后一个元素。通过**n**将返回最后一个n//数组中的值。函数last（数组，n，保护）{如果（array==null|array.length<1）返回n==null | | guard？无效0:[]；如果（n==null | | guard）返回数组[array.length-1]；return rest（数组，Math.max（0，array.length-n））；}//从数组中删除所有错误的值。函数压缩（数组）{返回过滤器（数组，布尔）；}//以递归方式（默认情况下）或达到“深度”展平数组。//将“true”或“false”传递为“depth”分别表示“1”或“Infinity”。函数展平（数组、深度）{返回平坦$1（数组，深度，false）；}//取一个数组和许多其他数组之间的差异。//只有第一个数组中的元素才会保留。var difference=restArguments（函数（数组，rest）{rest=压平$1（rest，true，true）；返回过滤器（数组、函数（值））{返回！包含（rest，value）；});});//返回不包含指定值的数组版本。var without=restArguments（函数（数组，otherArrays）{返回差异（数组，otherArrays）；});//生成阵列的无重复版本。如果阵列已经//排序后，您可以选择使用更快的算法。//如果迭代，更快的算法将无法与迭代一起使用//不是一对一函数，因此提供迭代将禁用//更快的算法。函数uniq（数组、isSorted、iterate、context）{if（！isBoolean（isSorted））{context=迭代；iterate=isSorted；isSorted=false；}if（iterate！=null）iterate=cb（itemate，context）；var结果=[]；var seen=[]；for（var i=0，length=getLength（数组）；i<长度；i++）{var值=数组[i]，计算=迭代？iterate（value，i，array）：值；if（isSorted&&！iterate）{if（！i|seen！==计算的）结果push（value）；可见=计算；}else if（迭代）{if（！包含（可见，计算））{see.push（计算）；结果推送（值）；}}else if（！包含（result，value））{结果推送（值）；}}返回结果；}//生成一个包含联合的数组：//传入阵列。var union=restArguments（函数（数组）{return uniq（压扁$1（数组，true，true））；});//生成一个数组，其中包含所有//传入阵列。函数交集（数组）{var结果=[]；var argsLength=arguments.length；for（var i=0，length=getLength（数组）；i<长度；i++）{var项=数组[i]；如果（包含（结果，项））继续；变量j；对于（j=1；j<argsLength；j++）{if（！contains（arguments[j]，item））break；}如果（j===argsLength）result.push（item）；}返回结果；}//拉链的补充。Unzip接受数组和组的数组//共享索引上每个数组的元素。函数unzip（数组）{var length=（array&&max（array，getLength）.length）||0；var result=数组（长度）；for（var索引=0；索引<长度；索引++）{结果[指数]=pull（数组，指数）；}返回结果；}//将多个列表压缩到一个数组中--共享的元素//一个索引放在一起。var zip=restArguments（解压缩）；//将列表转换为对象。传递`[key，value]的单个数组`//对，或两个长度相同的并行数组--其中一个键，另一个键//相应的值。成对经过与`_.pairs`相反。函数对象（列表，值）{var结果={}；for（var i=0，length=getLength（列表）；i<长度；i++）{if（值）{结果[list[i]]=值[i]；}其他{结果[list[i][0]]=列表[i][1]；}}返回结果；}//生成包含算术级数的整数数组。一个港口//本机Python`range（）`函数。请参见//[Python文档](https://docs.python.org/library/functions.html#range).功能范围（启动、停止、步进）{if（停止==空）{停止=开始|0；开始=0；}if（！步骤）{步骤=停止<开始-1 : 1;}var length=Math.max（Math.ceil（（stop-start）/step），0）；var范围=数组（长度）；for（var idx=0；idx<length；idx++，start+=step）{范围[idx]=开始；}返回范围；}//将单个数组分块为多个数组，每个数组包含“count”或更少//项目。函数块（数组，计数）{如果（count==null|count<1）返回[]；var结果=[]；var i=0，长度=array.length；while（i<长度）{result.push（slice.call（数组，i，i+=计数））；}返回结果；}//Helper函数继续链接中间结果。函数chainResult（instance，obj）{返回实例_链条_$1（obj）.chain（）：obj；}//将您自己的自定义函数添加到Undercore对象。函数混合（obj）{each（函数（对象），函数（名称）{var函数=_$1[名称]=对象[名称]；_$1.原型[name]=函数（）{var args=[this._wrapped]；push.apply（参数，自变量）；return chainResult（this，func.apply（_$1，args））；};});退货_$1；}//将所有mutator `Array`函数添加到包装器中。每个（['pop'，'push'，'reverse'，'shift'，'sort'，'splice'，'unshift']，函数（名称）{var方法=ArrayProto[名称]；_$1.原型[name]=函数（）{var obj=这个_包裹；if（obj！=空）{apply方法（obj，参数）；if（（name===‘shift’|| name====’splice’）&&obj.length===0）{删除对象[0]；}}return chainResult（this，obj）；};});//将所有访问器“数组”函数添加到包装。每个（['concat'，'join'，'slice']，函数（名称）{var方法=ArrayProto[名称]；_$1.原型[name]=函数（）{var obj=这个_包裹；if（obj！=null）obj=method.apply（obj，arguments）；return chainResult（this，obj）；};});//命名导出var all导出={__proto__：空，版本：版本，restArguments:restArugments，isObject:isObject，isNull：为Null，未定义：未定义，isBoolean：是Boolean，isElement：isElement，isString：isString，isNumber：是数字，isDate:isDate，isRegExp：是RegExp，isError:isError，isSymbol:isSymbol，isArrayBuffer：isArrayBuffer，isDataView:isDataView$1，isArray：isArray，isFunction:isFunction$1，isArguments:isArgument$1，isFinite:isFinite$1，isNaN:isNaN$1，isTypedArray:isTypedArray$1，是空的：是空的，isMatch：isMatch，等于：等于，isMap:isMap，isWeakMap：isWeak地图，isSet：isSet，isWeakSet：是WeakSet，键：键，所有键：所有键，值：值，对：对，反转：反转，函数：函数，方法：函数，延伸：延伸，extendOwn:extendOwn，分配：extendOwn，默认值：默认值，创建：创建，克隆：克隆，点击：点击，获取：获取，有：有，mapObject:mapObject，标识：标识，常量：常量，noop：noop，到路径：到路径$1，属性：属性，属性属于：属性属于，匹配器：匹配器，匹配：匹配器，次数：次，随机：随机，现在：现在，转义：_escape，环境景观：环境景观，（_U），模板设置：模板设置，模板：模板，结果：result，uniqueId:uniqueId，链：链，iterate：迭代，部分：部分，绑定：绑定，bindAll:bindAll，memoize:备忘录，延迟：延迟，defer：延迟，油门：油门，去抖动：去抖动，包裹：包裹，否定：否定，合成：合成，之后：之后，之前：之前，一次：一次，findKey:findKey，查找索引：查找索引，查找最后索引：查找最后索引，sortedIndex：排序索引，indexOf：索引Of，最后索引：最后索引，查找：查找，检测：查找，查找位置：查找位置，每个：每个，对于每个：每个，地图：地图，收集：地图，reduce:减少，foldl：减少，注射：减少，reduceRight：reduceRight，foldr:reduce右侧，过滤器：过滤器，选择：过滤器，拒绝：拒绝，每：每，所有：每，一些：一些，任何：一些，包含：包含，包括：包含，包括：包含，调用：调用，拔：拔，其中：其中，max：最大值，分钟：分钟，洗牌：洗牌，sample：样本，排序依据：排序依据，分组依据：分组依据，indexBy:索引依据，countBy:countBy，分区：分区，toArray：toArray，大小：大小，拾取：拾取，省略：省略，第一：第一，头部：首先，采取：首先，initial：初始，last:最后，休息：休息，尾部：休息，下落：静止，紧凑：紧凑，展平：展平，无：无，uniq:uniq，唯一：uniq，联合：联合，交点：交点，差异：差异，解压缩：解压缩，转置：解压缩，zip:zip，对象：对象，范围：范围，chunk：块，mixin：mixin，“默认”：_$1};//默认导出//将所有Underscore函数添加到包装器对象。var _=混合（所有出口）；//旧Node.js API。_._ = _;//ESM导出导出默认值_；出口{VERSION，after，every as all，allKeys，some as any，extendOwn as assign，before，bind，bindAll，chain，chunk，clone，map as collect，compact，compose，constant，contains，countBy，create，deboush，defaults，defer，delay，find as detect，difference，rest as drop，each，_escape as escape，every，isDataView$1作为isDataView，isDate，isElement，isEmpty，isEqual，isError，isFinite$1作为isFinite，isFunction$1作为isFunction，isMap，isMatch，isNaN$1作为isNaN，isNull，isNumber，isObject，isRegExp，isSet，isString，isSymbol，isTypedArray$1作为isTypedArray，isUndefined，isWeakMap，isWeakSet，iteratee，keys，last，lastIndexOf，map，mapObject，matcher，matcher as matches，max，memoize，functions as methods，min，mixin，negate，noop，now，object，omit，once，pairs，partial，partition，pick，pully，property，propertyOf，random，range，reduce，reduceRight，reject，rest，restArguments，restParameters，result，sample，tap，template，templateSettings，throttle，times，toArray，toPath$1 as toPath，unzip as transfate，_unescape as unescape，union，uniq，uniq as unique，uniqueId，unzip，values，where，without，wrap，zip}；//#sourceMappingURL=underscore-esm.js.map