{"version":3,"sources":["webpack://jrs-ui/./runtime_dependencies/underscore/underscore-umd.js"],"names":["factory","VERSION","root","self","global","Function","ArrayProto","Array","prototype","ObjProto","Object","SymbolProto","Symbol","push","slice","toString","hasOwnProperty","supportsArrayBuffer","ArrayBuffer","supportsDataView","DataView","nativeIsArray","isArray","nativeKeys","keys","nativeCreate","create","nativeIsView","isView","_isNaN","isNaN","_isFinite","isFinite","hasEnumBug","propertyIsEnumerable","nonEnumerableProps","MAX_ARRAY_INDEX","Math","pow","restArguments","func","startIndex","length","max","arguments","rest","index","call","this","args","apply","isObject","obj","type","isUndefined","isBoolean","tagTester","name","tag","isString","isNumber","isDate","isRegExp","isError","isSymbol","isArrayBuffer","isFunction","nodelist","document","childNodes","Int8Array","isFunction$1","hasObjectTag","hasStringTagBug","isIE11","Map","isDataView","isDataView$1","getInt8","buffer","has$1","key","isArguments","isArguments$1","isNaN$1","constant","value","createSizePropertyCheck","getSizeProperty","collection","sizeProperty","shallowProperty","getByteLength","isBufferLike","typedArrayPattern","isTypedArray$1","test","getLength","collectNonEnumProps","hash","l","i","contains","emulatedSet","nonEnumIdx","constructor","proto","prop","isMatch","object","attrs","_keys","_$1","_wrapped","toBufferView","bufferSource","Uint8Array","byteOffset","valueOf","toJSON","String","tagDataView","eq","a","b","aStack","bStack","deepEq","className","areArrays","aCtor","bCtor","pop","allKeys","ie11fingerprint","methods","weakMapMethods","forEachName","commonInit","mapTail","mapMethods","concat","setMethods","isMap","isWeakMap","isSet","isWeakSet","values","invert","result","functions","names","sort","createAssigner","keysFunc","defaults","source","extend","extendOwn","baseCreate","Ctor","clone","toPath$1","path","toPath","deepGet","get","defaultValue","identity","matcher","property","optimizeCb","context","argCount","accumulator","baseIteratee","iteratee","Infinity","cb","noop","random","min","floor","now","Date","getTime","createEscaper","map","escaper","match","join","testRegexp","RegExp","replaceRegexp","string","replace","escapeMap","_escape","_unescape","templateSettings","evaluate","interpolate","escape","noMatch","escapes","escapeRegExp","escapeChar","bareIdentifier","idCounter","executeBound","sourceFunc","boundFunc","callingContext","partial","boundArgs","placeholder","bound","position","bind","TypeError","callArgs","isArrayLike","flatten$1","input","depth","strict","output","idx","j","len","bindAll","Error","delay","wait","setTimeout","defer","negate","predicate","before","times","memo","once","findKey","createPredicateIndexFinder","dir","array","findIndex","findLastIndex","sortedIndex","low","high","mid","createIndexFinder","predicateFind","item","indexOf","lastIndexOf","find","each","results","currentKey","createReduce","reducer","initial","reduce","reduceRight","filter","list","every","some","fromIndex","guard","invoke","contextPath","method","pluck","computed","lastComputed","v","sample","n","last","rand","temp","group","behavior","partition","groupBy","indexBy","countBy","pass","reStrSymbol","keyInObj","pick","omit","first","difference","without","otherArrays","uniq","isSorted","seen","union","arrays","unzip","zip","chainResult","instance","_chain","chain","mixin","_","__proto__","isNull","isElement","nodeType","parseFloat","isTypedArray","isEmpty","isEqual","pairs","assign","props","tap","interceptor","has","mapObject","propertyOf","matches","accum","unescape","template","text","settings","oldSettings","offset","render","argument","variable","e","data","fallback","uniqueId","prefix","id","memoize","hasher","cache","address","throttle","options","timeout","previous","later","leading","throttled","_now","remaining","clearTimeout","trailing","cancel","debounce","immediate","passed","debounced","_args","wrap","wrapper","compose","start","after","detect","findWhere","forEach","collect","foldl","inject","foldr","select","reject","all","any","includes","include","where","shuffle","sortBy","criteria","left","right","toArray","size","head","take","tail","drop","compact","Boolean","flatten","unique","intersection","argsLength","transpose","range","stop","step","ceil","chunk","count","exports","module","define"],"mappings":"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","file":"_chunks/chunk.7836.js","sourcesContent":["(function (global, factory) {\n  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :\n  typeof define === 'function' && define.amd ? define('underscore', factory) :\n  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, (function () {\n    var current = global._;\n    var exports = global._ = factory();\n    exports.noConflict = function () { global._ = current; return exports; };\n  }()));\n}(this, (function () {\n  //     Underscore.js 1.13.1\n  //     https://underscorejs.org\n  //     (c) 2009-2021 Jeremy Ashkenas, Julian Gonggrijp, and DocumentCloud and Investigative Reporters & Editors\n  //     Underscore may be freely distributed under the MIT license.\n\n  // Current version.\n  var VERSION = '1.13.1';\n\n  // Establish the root object, `window` (`self`) in the browser, `global`\n  // on the server, or `this` in some virtual machines. We use `self`\n  // instead of `window` for `WebWorker` support.\n  var root = typeof self == 'object' && self.self === self && self ||\n            typeof global == 'object' && global.global === global && global ||\n            Function('return this')() ||\n            {};\n\n  // Save bytes in the minified (but not gzipped) version:\n  var ArrayProto = Array.prototype, ObjProto = Object.prototype;\n  var SymbolProto = typeof Symbol !== 'undefined' ? Symbol.prototype : null;\n\n  // Create quick reference variables for speed access to core prototypes.\n  var push = ArrayProto.push,\n      slice = ArrayProto.slice,\n      toString = ObjProto.toString,\n      hasOwnProperty = ObjProto.hasOwnProperty;\n\n  // Modern feature detection.\n  var supportsArrayBuffer = typeof ArrayBuffer !== 'undefined',\n      supportsDataView = typeof DataView !== 'undefined';\n\n  // All **ECMAScript 5+** native function implementations that we hope to use\n  // are declared here.\n  var nativeIsArray = Array.isArray,\n      nativeKeys = Object.keys,\n      nativeCreate = Object.create,\n      nativeIsView = supportsArrayBuffer && ArrayBuffer.isView;\n\n  // Create references to these builtin functions because we override them.\n  var _isNaN = isNaN,\n      _isFinite = isFinite;\n\n  // Keys in IE < 9 that won't be iterated by `for key in ...` and thus missed.\n  var hasEnumBug = !{toString: null}.propertyIsEnumerable('toString');\n  var nonEnumerableProps = ['valueOf', 'isPrototypeOf', 'toString',\n    'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];\n\n  // The largest integer that can be represented exactly.\n  var MAX_ARRAY_INDEX = Math.pow(2, 53) - 1;\n\n  // Some functions take a variable number of arguments, or a few expected\n  // arguments at the beginning and then a variable number of values to operate\n  // on. This helper accumulates all remaining arguments past the function’s\n  // argument length (or an explicit `startIndex`), into an array that becomes\n  // the last argument. Similar to ES6’s \"rest parameter\".\n  function restArguments(func, startIndex) {\n    startIndex = startIndex == null ? func.length - 1 : +startIndex;\n    return function() {\n      var length = Math.max(arguments.length - startIndex, 0),\n          rest = Array(length),\n          index = 0;\n      for (; index < length; index++) {\n        rest[index] = arguments[index + startIndex];\n      }\n      switch (startIndex) {\n        case 0: return func.call(this, rest);\n        case 1: return func.call(this, arguments[0], rest);\n        case 2: return func.call(this, arguments[0], arguments[1], rest);\n      }\n      var args = Array(startIndex + 1);\n      for (index = 0; index < startIndex; index++) {\n        args[index] = arguments[index];\n      }\n      args[startIndex] = rest;\n      return func.apply(this, args);\n    };\n  }\n\n  // Is a given variable an object?\n  function isObject(obj) {\n    var type = typeof obj;\n    return type === 'function' || type === 'object' && !!obj;\n  }\n\n  // Is a given value equal to null?\n  function isNull(obj) {\n    return obj === null;\n  }\n\n  // Is a given variable undefined?\n  function isUndefined(obj) {\n    return obj === void 0;\n  }\n\n  // Is a given value a boolean?\n  function isBoolean(obj) {\n    return obj === true || obj === false || toString.call(obj) === '[object Boolean]';\n  }\n\n  // Is a given value a DOM element?\n  function isElement(obj) {\n    return !!(obj && obj.nodeType === 1);\n  }\n\n  // Internal function for creating a `toString`-based type tester.\n  function tagTester(name) {\n    var tag = '[object ' + name + ']';\n    return function(obj) {\n      return toString.call(obj) === tag;\n    };\n  }\n\n  var isString = tagTester('String');\n\n  var isNumber = tagTester('Number');\n\n  var isDate = tagTester('Date');\n\n  var isRegExp = tagTester('RegExp');\n\n  var isError = tagTester('Error');\n\n  var isSymbol = tagTester('Symbol');\n\n  var isArrayBuffer = tagTester('ArrayBuffer');\n\n  var isFunction = tagTester('Function');\n\n  // Optimize `isFunction` if appropriate. Work around some `typeof` bugs in old\n  // v8, IE 11 (#1621), Safari 8 (#1929), and PhantomJS (#2236).\n  var nodelist = root.document && root.document.childNodes;\n  if (typeof /./ != 'function' && typeof Int8Array != 'object' && typeof nodelist != 'function') {\n    isFunction = function(obj) {\n      return typeof obj == 'function' || false;\n    };\n  }\n\n  var isFunction$1 = isFunction;\n\n  var hasObjectTag = tagTester('Object');\n\n  // In IE 10 - Edge 13, `DataView` has string tag `'[object Object]'`.\n  // In IE 11, the most common among them, this problem also applies to\n  // `Map`, `WeakMap` and `Set`.\n  var hasStringTagBug = (\n        supportsDataView && hasObjectTag(new DataView(new ArrayBuffer(8)))\n      ),\n      isIE11 = (typeof Map !== 'undefined' && hasObjectTag(new Map));\n\n  var isDataView = tagTester('DataView');\n\n  // In IE 10 - Edge 13, we need a different heuristic\n  // to determine whether an object is a `DataView`.\n  function ie10IsDataView(obj) {\n    return obj != null && isFunction$1(obj.getInt8) && isArrayBuffer(obj.buffer);\n  }\n\n  var isDataView$1 = (hasStringTagBug ? ie10IsDataView : isDataView);\n\n  // Is a given value an array?\n  // Delegates to ECMA5's native `Array.isArray`.\n  var isArray = nativeIsArray || tagTester('Array');\n\n  // Internal function to check whether `key` is an own property name of `obj`.\n  function has$1(obj, key) {\n    return obj != null && hasOwnProperty.call(obj, key);\n  }\n\n  var isArguments = tagTester('Arguments');\n\n  // Define a fallback version of the method in browsers (ahem, IE < 9), where\n  // there isn't any inspectable \"Arguments\" type.\n  (function() {\n    if (!isArguments(arguments)) {\n      isArguments = function(obj) {\n        return has$1(obj, 'callee');\n      };\n    }\n  }());\n\n  var isArguments$1 = isArguments;\n\n  // Is a given object a finite number?\n  function isFinite$1(obj) {\n    return !isSymbol(obj) && _isFinite(obj) && !isNaN(parseFloat(obj));\n  }\n\n  // Is the given value `NaN`?\n  function isNaN$1(obj) {\n    return isNumber(obj) && _isNaN(obj);\n  }\n\n  // Predicate-generating function. Often useful outside of Underscore.\n  function constant(value) {\n    return function() {\n      return value;\n    };\n  }\n\n  // Common internal logic for `isArrayLike` and `isBufferLike`.\n  function createSizePropertyCheck(getSizeProperty) {\n    return function(collection) {\n      var sizeProperty = getSizeProperty(collection);\n      return typeof sizeProperty == 'number' && sizeProperty >= 0 && sizeProperty <= MAX_ARRAY_INDEX;\n    }\n  }\n\n  // Internal helper to generate a function to obtain property `key` from `obj`.\n  function shallowProperty(key) {\n    return function(obj) {\n      return obj == null ? void 0 : obj[key];\n    };\n  }\n\n  // Internal helper to obtain the `byteLength` property of an object.\n  var getByteLength = shallowProperty('byteLength');\n\n  // Internal helper to determine whether we should spend extensive checks against\n  // `ArrayBuffer` et al.\n  var isBufferLike = createSizePropertyCheck(getByteLength);\n\n  // Is a given value a typed array?\n  var typedArrayPattern = /\\[object ((I|Ui)nt(8|16|32)|Float(32|64)|Uint8Clamped|Big(I|Ui)nt64)Array\\]/;\n  function isTypedArray(obj) {\n    // `ArrayBuffer.isView` is the most future-proof, so use it when available.\n    // Otherwise, fall back on the above regular expression.\n    return nativeIsView ? (nativeIsView(obj) && !isDataView$1(obj)) :\n                  isBufferLike(obj) && typedArrayPattern.test(toString.call(obj));\n  }\n\n  var isTypedArray$1 = supportsArrayBuffer ? isTypedArray : constant(false);\n\n  // Internal helper to obtain the `length` property of an object.\n  var getLength = shallowProperty('length');\n\n  // Internal helper to create a simple lookup structure.\n  // `collectNonEnumProps` used to depend on `_.contains`, but this led to\n  // circular imports. `emulatedSet` is a one-off solution that only works for\n  // arrays of strings.\n  function emulatedSet(keys) {\n    var hash = {};\n    for (var l = keys.length, i = 0; i < l; ++i) hash[keys[i]] = true;\n    return {\n      contains: function(key) { return hash[key]; },\n      push: function(key) {\n        hash[key] = true;\n        return keys.push(key);\n      }\n    };\n  }\n\n  // Internal helper. Checks `keys` for the presence of keys in IE < 9 that won't\n  // be iterated by `for key in ...` and thus missed. Extends `keys` in place if\n  // needed.\n  function collectNonEnumProps(obj, keys) {\n    keys = emulatedSet(keys);\n    var nonEnumIdx = nonEnumerableProps.length;\n    var constructor = obj.constructor;\n    var proto = isFunction$1(constructor) && constructor.prototype || ObjProto;\n\n    // Constructor is a special case.\n    var prop = 'constructor';\n    if (has$1(obj, prop) && !keys.contains(prop)) keys.push(prop);\n\n    while (nonEnumIdx--) {\n      prop = nonEnumerableProps[nonEnumIdx];\n      if (prop in obj && obj[prop] !== proto[prop] && !keys.contains(prop)) {\n        keys.push(prop);\n      }\n    }\n  }\n\n  // Retrieve the names of an object's own properties.\n  // Delegates to **ECMAScript 5**'s native `Object.keys`.\n  function keys(obj) {\n    if (!isObject(obj)) return [];\n    if (nativeKeys) return nativeKeys(obj);\n    var keys = [];\n    for (var key in obj) if (has$1(obj, key)) keys.push(key);\n    // Ahem, IE < 9.\n    if (hasEnumBug) collectNonEnumProps(obj, keys);\n    return keys;\n  }\n\n  // Is a given array, string, or object empty?\n  // An \"empty\" object has no enumerable own-properties.\n  function isEmpty(obj) {\n    if (obj == null) return true;\n    // Skip the more expensive `toString`-based type checks if `obj` has no\n    // `.length`.\n    var length = getLength(obj);\n    if (typeof length == 'number' && (\n      isArray(obj) || isString(obj) || isArguments$1(obj)\n    )) return length === 0;\n    return getLength(keys(obj)) === 0;\n  }\n\n  // Returns whether an object has a given set of `key:value` pairs.\n  function isMatch(object, attrs) {\n    var _keys = keys(attrs), length = _keys.length;\n    if (object == null) return !length;\n    var obj = Object(object);\n    for (var i = 0; i < length; i++) {\n      var key = _keys[i];\n      if (attrs[key] !== obj[key] || !(key in obj)) return false;\n    }\n    return true;\n  }\n\n  // If Underscore is called as a function, it returns a wrapped object that can\n  // be used OO-style. This wrapper holds altered versions of all functions added\n  // through `_.mixin`. Wrapped objects may be chained.\n  function _$1(obj) {\n    if (obj instanceof _$1) return obj;\n    if (!(this instanceof _$1)) return new _$1(obj);\n    this._wrapped = obj;\n  }\n\n  _$1.VERSION = VERSION;\n\n  // Extracts the result from a wrapped and chained object.\n  _$1.prototype.value = function() {\n    return this._wrapped;\n  };\n\n  // Provide unwrapping proxies for some methods used in engine operations\n  // such as arithmetic and JSON stringification.\n  _$1.prototype.valueOf = _$1.prototype.toJSON = _$1.prototype.value;\n\n  _$1.prototype.toString = function() {\n    return String(this._wrapped);\n  };\n\n  // Internal function to wrap or shallow-copy an ArrayBuffer,\n  // typed array or DataView to a new view, reusing the buffer.\n  function toBufferView(bufferSource) {\n    return new Uint8Array(\n      bufferSource.buffer || bufferSource,\n      bufferSource.byteOffset || 0,\n      getByteLength(bufferSource)\n    );\n  }\n\n  // We use this string twice, so give it a name for minification.\n  var tagDataView = '[object DataView]';\n\n  // Internal recursive comparison function for `_.isEqual`.\n  function eq(a, b, aStack, bStack) {\n    // Identical objects are equal. `0 === -0`, but they aren't identical.\n    // See the [Harmony `egal` proposal](https://wiki.ecmascript.org/doku.php?id=harmony:egal).\n    if (a === b) return a !== 0 || 1 / a === 1 / b;\n    // `null` or `undefined` only equal to itself (strict comparison).\n    if (a == null || b == null) return false;\n    // `NaN`s are equivalent, but non-reflexive.\n    if (a !== a) return b !== b;\n    // Exhaust primitive checks\n    var type = typeof a;\n    if (type !== 'function' && type !== 'object' && typeof b != 'object') return false;\n    return deepEq(a, b, aStack, bStack);\n  }\n\n  // Internal recursive comparison function for `_.isEqual`.\n  function deepEq(a, b, aStack, bStack) {\n    // Unwrap any wrapped objects.\n    if (a instanceof _$1) a = a._wrapped;\n    if (b instanceof _$1) b = b._wrapped;\n    // Compare `[[Class]]` names.\n    var className = toString.call(a);\n    if (className !== toString.call(b)) return false;\n    // Work around a bug in IE 10 - Edge 13.\n    if (hasStringTagBug && className == '[object Object]' && isDataView$1(a)) {\n      if (!isDataView$1(b)) return false;\n      className = tagDataView;\n    }\n    switch (className) {\n      // These types are compared by value.\n      case '[object RegExp]':\n        // RegExps are coerced to strings for comparison (Note: '' + /a/i === '/a/i')\n      case '[object String]':\n        // Primitives and their corresponding object wrappers are equivalent; thus, `\"5\"` is\n        // equivalent to `new String(\"5\")`.\n        return '' + a === '' + b;\n      case '[object Number]':\n        // `NaN`s are equivalent, but non-reflexive.\n        // Object(NaN) is equivalent to NaN.\n        if (+a !== +a) return +b !== +b;\n        // An `egal` comparison is performed for other numeric values.\n        return +a === 0 ? 1 / +a === 1 / b : +a === +b;\n      case '[object Date]':\n      case '[object Boolean]':\n        // Coerce dates and booleans to numeric primitive values. Dates are compared by their\n        // millisecond representations. Note that invalid dates with millisecond representations\n        // of `NaN` are not equivalent.\n        return +a === +b;\n      case '[object Symbol]':\n        return SymbolProto.valueOf.call(a) === SymbolProto.valueOf.call(b);\n      case '[object ArrayBuffer]':\n      case tagDataView:\n        // Coerce to typed array so we can fall through.\n        return deepEq(toBufferView(a), toBufferView(b), aStack, bStack);\n    }\n\n    var areArrays = className === '[object Array]';\n    if (!areArrays && isTypedArray$1(a)) {\n        var byteLength = getByteLength(a);\n        if (byteLength !== getByteLength(b)) return false;\n        if (a.buffer === b.buffer && a.byteOffset === b.byteOffset) return true;\n        areArrays = true;\n    }\n    if (!areArrays) {\n      if (typeof a != 'object' || typeof b != 'object') return false;\n\n      // Objects with different constructors are not equivalent, but `Object`s or `Array`s\n      // from different frames are.\n      var aCtor = a.constructor, bCtor = b.constructor;\n      if (aCtor !== bCtor && !(isFunction$1(aCtor) && aCtor instanceof aCtor &&\n                               isFunction$1(bCtor) && bCtor instanceof bCtor)\n                          && ('constructor' in a && 'constructor' in b)) {\n        return false;\n      }\n    }\n    // Assume equality for cyclic structures. The algorithm for detecting cyclic\n    // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.\n\n    // Initializing stack of traversed objects.\n    // It's done here since we only need them for objects and arrays comparison.\n    aStack = aStack || [];\n    bStack = bStack || [];\n    var length = aStack.length;\n    while (length--) {\n      // Linear search. Performance is inversely proportional to the number of\n      // unique nested structures.\n      if (aStack[length] === a) return bStack[length] === b;\n    }\n\n    // Add the first object to the stack of traversed objects.\n    aStack.push(a);\n    bStack.push(b);\n\n    // Recursively compare objects and arrays.\n    if (areArrays) {\n      // Compare array lengths to determine if a deep comparison is necessary.\n      length = a.length;\n      if (length !== b.length) return false;\n      // Deep compare the contents, ignoring non-numeric properties.\n      while (length--) {\n        if (!eq(a[length], b[length], aStack, bStack)) return false;\n      }\n    } else {\n      // Deep compare objects.\n      var _keys = keys(a), key;\n      length = _keys.length;\n      // Ensure that both objects contain the same number of properties before comparing deep equality.\n      if (keys(b).length !== length) return false;\n      while (length--) {\n        // Deep compare each member\n        key = _keys[length];\n        if (!(has$1(b, key) && eq(a[key], b[key], aStack, bStack))) return false;\n      }\n    }\n    // Remove the first object from the stack of traversed objects.\n    aStack.pop();\n    bStack.pop();\n    return true;\n  }\n\n  // Perform a deep comparison to check if two objects are equal.\n  function isEqual(a, b) {\n    return eq(a, b);\n  }\n\n  // Retrieve all the enumerable property names of an object.\n  function allKeys(obj) {\n    if (!isObject(obj)) return [];\n    var keys = [];\n    for (var key in obj) keys.push(key);\n    // Ahem, IE < 9.\n    if (hasEnumBug) collectNonEnumProps(obj, keys);\n    return keys;\n  }\n\n  // Since the regular `Object.prototype.toString` type tests don't work for\n  // some types in IE 11, we use a fingerprinting heuristic instead, based\n  // on the methods. It's not great, but it's the best we got.\n  // The fingerprint method lists are defined below.\n  function ie11fingerprint(methods) {\n    var length = getLength(methods);\n    return function(obj) {\n      if (obj == null) return false;\n      // `Map`, `WeakMap` and `Set` have no enumerable keys.\n      var keys = allKeys(obj);\n      if (getLength(keys)) return false;\n      for (var i = 0; i < length; i++) {\n        if (!isFunction$1(obj[methods[i]])) return false;\n      }\n      // If we are testing against `WeakMap`, we need to ensure that\n      // `obj` doesn't have a `forEach` method in order to distinguish\n      // it from a regular `Map`.\n      return methods !== weakMapMethods || !isFunction$1(obj[forEachName]);\n    };\n  }\n\n  // In the interest of compact minification, we write\n  // each string in the fingerprints only once.\n  var forEachName = 'forEach',\n      hasName = 'has',\n      commonInit = ['clear', 'delete'],\n      mapTail = ['get', hasName, 'set'];\n\n  // `Map`, `WeakMap` and `Set` each have slightly different\n  // combinations of the above sublists.\n  var mapMethods = commonInit.concat(forEachName, mapTail),\n      weakMapMethods = commonInit.concat(mapTail),\n      setMethods = ['add'].concat(commonInit, forEachName, hasName);\n\n  var isMap = isIE11 ? ie11fingerprint(mapMethods) : tagTester('Map');\n\n  var isWeakMap = isIE11 ? ie11fingerprint(weakMapMethods) : tagTester('WeakMap');\n\n  var isSet = isIE11 ? ie11fingerprint(setMethods) : tagTester('Set');\n\n  var isWeakSet = tagTester('WeakSet');\n\n  // Retrieve the values of an object's properties.\n  function values(obj) {\n    var _keys = keys(obj);\n    var length = _keys.length;\n    var values = Array(length);\n    for (var i = 0; i < length; i++) {\n      values[i] = obj[_keys[i]];\n    }\n    return values;\n  }\n\n  // Convert an object into a list of `[key, value]` pairs.\n  // The opposite of `_.object` with one argument.\n  function pairs(obj) {\n    var _keys = keys(obj);\n    var length = _keys.length;\n    var pairs = Array(length);\n    for (var i = 0; i < length; i++) {\n      pairs[i] = [_keys[i], obj[_keys[i]]];\n    }\n    return pairs;\n  }\n\n  // Invert the keys and values of an object. The values must be serializable.\n  function invert(obj) {\n    var result = {};\n    var _keys = keys(obj);\n    for (var i = 0, length = _keys.length; i < length; i++) {\n      result[obj[_keys[i]]] = _keys[i];\n    }\n    return result;\n  }\n\n  // Return a sorted list of the function names available on the object.\n  function functions(obj) {\n    var names = [];\n    for (var key in obj) {\n      if (isFunction$1(obj[key])) names.push(key);\n    }\n    return names.sort();\n  }\n\n  // An internal function for creating assigner functions.\n  function createAssigner(keysFunc, defaults) {\n    return function(obj) {\n      var length = arguments.length;\n      if (defaults) obj = Object(obj);\n      if (length < 2 || obj == null) return obj;\n      for (var index = 1; index < length; index++) {\n        var source = arguments[index],\n            keys = keysFunc(source),\n            l = keys.length;\n        for (var i = 0; i < l; i++) {\n          var key = keys[i];\n          if (!defaults || obj[key] === void 0) obj[key] = source[key];\n        }\n      }\n      return obj;\n    };\n  }\n\n  // Extend a given object with all the properties in passed-in object(s).\n  var extend = createAssigner(allKeys);\n\n  // Assigns a given object with all the own properties in the passed-in\n  // object(s).\n  // (https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/assign)\n  var extendOwn = createAssigner(keys);\n\n  // Fill in a given object with default properties.\n  var defaults = createAssigner(allKeys, true);\n\n  // Create a naked function reference for surrogate-prototype-swapping.\n  function ctor() {\n    return function(){};\n  }\n\n  // An internal function for creating a new object that inherits from another.\n  function baseCreate(prototype) {\n    if (!isObject(prototype)) return {};\n    if (nativeCreate) return nativeCreate(prototype);\n    var Ctor = ctor();\n    Ctor.prototype = prototype;\n    var result = new Ctor;\n    Ctor.prototype = null;\n    return result;\n  }\n\n  // Creates an object that inherits from the given prototype object.\n  // If additional properties are provided then they will be added to the\n  // created object.\n  function create(prototype, props) {\n    var result = baseCreate(prototype);\n    if (props) extendOwn(result, props);\n    return result;\n  }\n\n  // Create a (shallow-cloned) duplicate of an object.\n  function clone(obj) {\n    if (!isObject(obj)) return obj;\n    return isArray(obj) ? obj.slice() : extend({}, obj);\n  }\n\n  // Invokes `interceptor` with the `obj` and then returns `obj`.\n  // The primary purpose of this method is to \"tap into\" a method chain, in\n  // order to perform operations on intermediate results within the chain.\n  function tap(obj, interceptor) {\n    interceptor(obj);\n    return obj;\n  }\n\n  // Normalize a (deep) property `path` to array.\n  // Like `_.iteratee`, this function can be customized.\n  function toPath$1(path) {\n    return isArray(path) ? path : [path];\n  }\n  _$1.toPath = toPath$1;\n\n  // Internal wrapper for `_.toPath` to enable minification.\n  // Similar to `cb` for `_.iteratee`.\n  function toPath(path) {\n    return _$1.toPath(path);\n  }\n\n  // Internal function to obtain a nested property in `obj` along `path`.\n  function deepGet(obj, path) {\n    var length = path.length;\n    for (var i = 0; i < length; i++) {\n      if (obj == null) return void 0;\n      obj = obj[path[i]];\n    }\n    return length ? obj : void 0;\n  }\n\n  // Get the value of the (deep) property on `path` from `object`.\n  // If any property in `path` does not exist or if the value is\n  // `undefined`, return `defaultValue` instead.\n  // The `path` is normalized through `_.toPath`.\n  function get(object, path, defaultValue) {\n    var value = deepGet(object, toPath(path));\n    return isUndefined(value) ? defaultValue : value;\n  }\n\n  // Shortcut function for checking if an object has a given property directly on\n  // itself (in other words, not on a prototype). Unlike the internal `has`\n  // function, this public version can also traverse nested properties.\n  function has(obj, path) {\n    path = toPath(path);\n    var length = path.length;\n    for (var i = 0; i < length; i++) {\n      var key = path[i];\n      if (!has$1(obj, key)) return false;\n      obj = obj[key];\n    }\n    return !!length;\n  }\n\n  // Keep the identity function around for default iteratees.\n  function identity(value) {\n    return value;\n  }\n\n  // Returns a predicate for checking whether an object has a given set of\n  // `key:value` pairs.\n  function matcher(attrs) {\n    attrs = extendOwn({}, attrs);\n    return function(obj) {\n      return isMatch(obj, attrs);\n    };\n  }\n\n  // Creates a function that, when passed an object, will traverse that object’s\n  // properties down the given `path`, specified as an array of keys or indices.\n  function property(path) {\n    path = toPath(path);\n    return function(obj) {\n      return deepGet(obj, path);\n    };\n  }\n\n  // Internal function that returns an efficient (for current engines) version\n  // of the passed-in callback, to be repeatedly applied in other Underscore\n  // functions.\n  function optimizeCb(func, context, argCount) {\n    if (context === void 0) return func;\n    switch (argCount == null ? 3 : argCount) {\n      case 1: return function(value) {\n        return func.call(context, value);\n      };\n      // The 2-argument case is omitted because we’re not using it.\n      case 3: return function(value, index, collection) {\n        return func.call(context, value, index, collection);\n      };\n      case 4: return function(accumulator, value, index, collection) {\n        return func.call(context, accumulator, value, index, collection);\n      };\n    }\n    return function() {\n      return func.apply(context, arguments);\n    };\n  }\n\n  // An internal function to generate callbacks that can be applied to each\n  // element in a collection, returning the desired result — either `_.identity`,\n  // an arbitrary callback, a property matcher, or a property accessor.\n  function baseIteratee(value, context, argCount) {\n    if (value == null) return identity;\n    if (isFunction$1(value)) return optimizeCb(value, context, argCount);\n    if (isObject(value) && !isArray(value)) return matcher(value);\n    return property(value);\n  }\n\n  // External wrapper for our callback generator. Users may customize\n  // `_.iteratee` if they want additional predicate/iteratee shorthand styles.\n  // This abstraction hides the internal-only `argCount` argument.\n  function iteratee(value, context) {\n    return baseIteratee(value, context, Infinity);\n  }\n  _$1.iteratee = iteratee;\n\n  // The function we call internally to generate a callback. It invokes\n  // `_.iteratee` if overridden, otherwise `baseIteratee`.\n  function cb(value, context, argCount) {\n    if (_$1.iteratee !== iteratee) return _$1.iteratee(value, context);\n    return baseIteratee(value, context, argCount);\n  }\n\n  // Returns the results of applying the `iteratee` to each element of `obj`.\n  // In contrast to `_.map` it returns an object.\n  function mapObject(obj, iteratee, context) {\n    iteratee = cb(iteratee, context);\n    var _keys = keys(obj),\n        length = _keys.length,\n        results = {};\n    for (var index = 0; index < length; index++) {\n      var currentKey = _keys[index];\n      results[currentKey] = iteratee(obj[currentKey], currentKey, obj);\n    }\n    return results;\n  }\n\n  // Predicate-generating function. Often useful outside of Underscore.\n  function noop(){}\n\n  // Generates a function for a given object that returns a given property.\n  function propertyOf(obj) {\n    if (obj == null) return noop;\n    return function(path) {\n      return get(obj, path);\n    };\n  }\n\n  // Run a function **n** times.\n  function times(n, iteratee, context) {\n    var accum = Array(Math.max(0, n));\n    iteratee = optimizeCb(iteratee, context, 1);\n    for (var i = 0; i < n; i++) accum[i] = iteratee(i);\n    return accum;\n  }\n\n  // Return a random integer between `min` and `max` (inclusive).\n  function random(min, max) {\n    if (max == null) {\n      max = min;\n      min = 0;\n    }\n    return min + Math.floor(Math.random() * (max - min + 1));\n  }\n\n  // A (possibly faster) way to get the current timestamp as an integer.\n  var now = Date.now || function() {\n    return new Date().getTime();\n  };\n\n  // Internal helper to generate functions for escaping and unescaping strings\n  // to/from HTML interpolation.\n  function createEscaper(map) {\n    var escaper = function(match) {\n      return map[match];\n    };\n    // Regexes for identifying a key that needs to be escaped.\n    var source = '(?:' + keys(map).join('|') + ')';\n    var testRegexp = RegExp(source);\n    var replaceRegexp = RegExp(source, 'g');\n    return function(string) {\n      string = string == null ? '' : '' + string;\n      return testRegexp.test(string) ? string.replace(replaceRegexp, escaper) : string;\n    };\n  }\n\n  // Internal list of HTML entities for escaping.\n  var escapeMap = {\n    '&': '&amp;',\n    '<': '&lt;',\n    '>': '&gt;',\n    '\"': '&quot;',\n    \"'\": '&#x27;',\n    '`': '&#x60;'\n  };\n\n  // Function for escaping strings to HTML interpolation.\n  var _escape = createEscaper(escapeMap);\n\n  // Internal list of HTML entities for unescaping.\n  var unescapeMap = invert(escapeMap);\n\n  // Function for unescaping strings from HTML interpolation.\n  var _unescape = createEscaper(unescapeMap);\n\n  // By default, Underscore uses ERB-style template delimiters. Change the\n  // following template settings to use alternative delimiters.\n  var templateSettings = _$1.templateSettings = {\n    evaluate: /<%([\\s\\S]+?)%>/g,\n    interpolate: /<%=([\\s\\S]+?)%>/g,\n    escape: /<%-([\\s\\S]+?)%>/g\n  };\n\n  // When customizing `_.templateSettings`, if you don't want to define an\n  // interpolation, evaluation or escaping regex, we need one that is\n  // guaranteed not to match.\n  var noMatch = /(.)^/;\n\n  // Certain characters need to be escaped so that they can be put into a\n  // string literal.\n  var escapes = {\n    \"'\": \"'\",\n    '\\\\': '\\\\',\n    '\\r': 'r',\n    '\\n': 'n',\n    '\\u2028': 'u2028',\n    '\\u2029': 'u2029'\n  };\n\n  var escapeRegExp = /\\\\|'|\\r|\\n|\\u2028|\\u2029/g;\n\n  function escapeChar(match) {\n    return '\\\\' + escapes[match];\n  }\n\n  // In order to prevent third-party code injection through\n  // `_.templateSettings.variable`, we test it against the following regular\n  // expression. It is intentionally a bit more liberal than just matching valid\n  // identifiers, but still prevents possible loopholes through defaults or\n  // destructuring assignment.\n  var bareIdentifier = /^\\s*(\\w|\\$)+\\s*$/;\n\n  // JavaScript micro-templating, similar to John Resig's implementation.\n  // Underscore templating handles arbitrary delimiters, preserves whitespace,\n  // and correctly escapes quotes within interpolated code.\n  // NB: `oldSettings` only exists for backwards compatibility.\n  function template(text, settings, oldSettings) {\n    if (!settings && oldSettings) settings = oldSettings;\n    settings = defaults({}, settings, _$1.templateSettings);\n\n    // Combine delimiters into one regular expression via alternation.\n    var matcher = RegExp([\n      (settings.escape || noMatch).source,\n      (settings.interpolate || noMatch).source,\n      (settings.evaluate || noMatch).source\n    ].join('|') + '|$', 'g');\n\n    // Compile the template source, escaping string literals appropriately.\n    var index = 0;\n    var source = \"__p+='\";\n    text.replace(matcher, function(match, escape, interpolate, evaluate, offset) {\n      source += text.slice(index, offset).replace(escapeRegExp, escapeChar);\n      index = offset + match.length;\n\n      if (escape) {\n        source += \"'+\\n((__t=(\" + escape + \"))==null?'':_.escape(__t))+\\n'\";\n      } else if (interpolate) {\n        source += \"'+\\n((__t=(\" + interpolate + \"))==null?'':__t)+\\n'\";\n      } else if (evaluate) {\n        source += \"';\\n\" + evaluate + \"\\n__p+='\";\n      }\n\n      // Adobe VMs need the match returned to produce the correct offset.\n      return match;\n    });\n    source += \"';\\n\";\n\n    var argument = settings.variable;\n    if (argument) {\n      // Insure against third-party code injection. (CVE-2021-23358)\n      if (!bareIdentifier.test(argument)) throw new Error(\n        'variable is not a bare identifier: ' + argument\n      );\n    } else {\n      // If a variable is not specified, place data values in local scope.\n      source = 'with(obj||{}){\\n' + source + '}\\n';\n      argument = 'obj';\n    }\n\n    source = \"var __t,__p='',__j=Array.prototype.join,\" +\n      \"print=function(){__p+=__j.call(arguments,'');};\\n\" +\n      source + 'return __p;\\n';\n\n    var render;\n    try {\n      render = new Function(argument, '_', source);\n    } catch (e) {\n      e.source = source;\n      throw e;\n    }\n\n    var template = function(data) {\n      return render.call(this, data, _$1);\n    };\n\n    // Provide the compiled source as a convenience for precompilation.\n    template.source = 'function(' + argument + '){\\n' + source + '}';\n\n    return template;\n  }\n\n  // Traverses the children of `obj` along `path`. If a child is a function, it\n  // is invoked with its parent as context. Returns the value of the final\n  // child, or `fallback` if any child is undefined.\n  function result(obj, path, fallback) {\n    path = toPath(path);\n    var length = path.length;\n    if (!length) {\n      return isFunction$1(fallback) ? fallback.call(obj) : fallback;\n    }\n    for (var i = 0; i < length; i++) {\n      var prop = obj == null ? void 0 : obj[path[i]];\n      if (prop === void 0) {\n        prop = fallback;\n        i = length; // Ensure we don't continue iterating.\n      }\n      obj = isFunction$1(prop) ? prop.call(obj) : prop;\n    }\n    return obj;\n  }\n\n  // Generate a unique integer id (unique within the entire client session).\n  // Useful for temporary DOM ids.\n  var idCounter = 0;\n  function uniqueId(prefix) {\n    var id = ++idCounter + '';\n    return prefix ? prefix + id : id;\n  }\n\n  // Start chaining a wrapped Underscore object.\n  function chain(obj) {\n    var instance = _$1(obj);\n    instance._chain = true;\n    return instance;\n  }\n\n  // Internal function to execute `sourceFunc` bound to `context` with optional\n  // `args`. Determines whether to execute a function as a constructor or as a\n  // normal function.\n  function executeBound(sourceFunc, boundFunc, context, callingContext, args) {\n    if (!(callingContext instanceof boundFunc)) return sourceFunc.apply(context, args);\n    var self = baseCreate(sourceFunc.prototype);\n    var result = sourceFunc.apply(self, args);\n    if (isObject(result)) return result;\n    return self;\n  }\n\n  // Partially apply a function by creating a version that has had some of its\n  // arguments pre-filled, without changing its dynamic `this` context. `_` acts\n  // as a placeholder by default, allowing any combination of arguments to be\n  // pre-filled. Set `_.partial.placeholder` for a custom placeholder argument.\n  var partial = restArguments(function(func, boundArgs) {\n    var placeholder = partial.placeholder;\n    var bound = function() {\n      var position = 0, length = boundArgs.length;\n      var args = Array(length);\n      for (var i = 0; i < length; i++) {\n        args[i] = boundArgs[i] === placeholder ? arguments[position++] : boundArgs[i];\n      }\n      while (position < arguments.length) args.push(arguments[position++]);\n      return executeBound(func, bound, this, this, args);\n    };\n    return bound;\n  });\n\n  partial.placeholder = _$1;\n\n  // Create a function bound to a given object (assigning `this`, and arguments,\n  // optionally).\n  var bind = restArguments(function(func, context, args) {\n    if (!isFunction$1(func)) throw new TypeError('Bind must be called on a function');\n    var bound = restArguments(function(callArgs) {\n      return executeBound(func, bound, context, this, args.concat(callArgs));\n    });\n    return bound;\n  });\n\n  // Internal helper for collection methods to determine whether a collection\n  // should be iterated as an array or as an object.\n  // Related: https://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength\n  // Avoids a very nasty iOS 8 JIT bug on ARM-64. #2094\n  var isArrayLike = createSizePropertyCheck(getLength);\n\n  // Internal implementation of a recursive `flatten` function.\n  function flatten$1(input, depth, strict, output) {\n    output = output || [];\n    if (!depth && depth !== 0) {\n      depth = Infinity;\n    } else if (depth <= 0) {\n      return output.concat(input);\n    }\n    var idx = output.length;\n    for (var i = 0, length = getLength(input); i < length; i++) {\n      var value = input[i];\n      if (isArrayLike(value) && (isArray(value) || isArguments$1(value))) {\n        // Flatten current level of array or arguments object.\n        if (depth > 1) {\n          flatten$1(value, depth - 1, strict, output);\n          idx = output.length;\n        } else {\n          var j = 0, len = value.length;\n          while (j < len) output[idx++] = value[j++];\n        }\n      } else if (!strict) {\n        output[idx++] = value;\n      }\n    }\n    return output;\n  }\n\n  // Bind a number of an object's methods to that object. Remaining arguments\n  // are the method names to be bound. Useful for ensuring that all callbacks\n  // defined on an object belong to it.\n  var bindAll = restArguments(function(obj, keys) {\n    keys = flatten$1(keys, false, false);\n    var index = keys.length;\n    if (index < 1) throw new Error('bindAll must be passed function names');\n    while (index--) {\n      var key = keys[index];\n      obj[key] = bind(obj[key], obj);\n    }\n    return obj;\n  });\n\n  // Memoize an expensive function by storing its results.\n  function memoize(func, hasher) {\n    var memoize = function(key) {\n      var cache = memoize.cache;\n      var address = '' + (hasher ? hasher.apply(this, arguments) : key);\n      if (!has$1(cache, address)) cache[address] = func.apply(this, arguments);\n      return cache[address];\n    };\n    memoize.cache = {};\n    return memoize;\n  }\n\n  // Delays a function for the given number of milliseconds, and then calls\n  // it with the arguments supplied.\n  var delay = restArguments(function(func, wait, args) {\n    return setTimeout(function() {\n      return func.apply(null, args);\n    }, wait);\n  });\n\n  // Defers a function, scheduling it to run after the current call stack has\n  // cleared.\n  var defer = partial(delay, _$1, 1);\n\n  // Returns a function, that, when invoked, will only be triggered at most once\n  // during a given window of time. Normally, the throttled function will run\n  // as much as it can, without ever going more than once per `wait` duration;\n  // but if you'd like to disable the execution on the leading edge, pass\n  // `{leading: false}`. To disable execution on the trailing edge, ditto.\n  function throttle(func, wait, options) {\n    var timeout, context, args, result;\n    var previous = 0;\n    if (!options) options = {};\n\n    var later = function() {\n      previous = options.leading === false ? 0 : now();\n      timeout = null;\n      result = func.apply(context, args);\n      if (!timeout) context = args = null;\n    };\n\n    var throttled = function() {\n      var _now = now();\n      if (!previous && options.leading === false) previous = _now;\n      var remaining = wait - (_now - previous);\n      context = this;\n      args = arguments;\n      if (remaining <= 0 || remaining > wait) {\n        if (timeout) {\n          clearTimeout(timeout);\n          timeout = null;\n        }\n        previous = _now;\n        result = func.apply(context, args);\n        if (!timeout) context = args = null;\n      } else if (!timeout && options.trailing !== false) {\n        timeout = setTimeout(later, remaining);\n      }\n      return result;\n    };\n\n    throttled.cancel = function() {\n      clearTimeout(timeout);\n      previous = 0;\n      timeout = context = args = null;\n    };\n\n    return throttled;\n  }\n\n  // When a sequence of calls of the returned function ends, the argument\n  // function is triggered. The end of a sequence is defined by the `wait`\n  // parameter. If `immediate` is passed, the argument function will be\n  // triggered at the beginning of the sequence instead of at the end.\n  function debounce(func, wait, immediate) {\n    var timeout, previous, args, result, context;\n\n    var later = function() {\n      var passed = now() - previous;\n      if (wait > passed) {\n        timeout = setTimeout(later, wait - passed);\n      } else {\n        timeout = null;\n        if (!immediate) result = func.apply(context, args);\n        // This check is needed because `func` can recursively invoke `debounced`.\n        if (!timeout) args = context = null;\n      }\n    };\n\n    var debounced = restArguments(function(_args) {\n      context = this;\n      args = _args;\n      previous = now();\n      if (!timeout) {\n        timeout = setTimeout(later, wait);\n        if (immediate) result = func.apply(context, args);\n      }\n      return result;\n    });\n\n    debounced.cancel = function() {\n      clearTimeout(timeout);\n      timeout = args = context = null;\n    };\n\n    return debounced;\n  }\n\n  // Returns the first function passed as an argument to the second,\n  // allowing you to adjust arguments, run code before and after, and\n  // conditionally execute the original function.\n  function wrap(func, wrapper) {\n    return partial(wrapper, func);\n  }\n\n  // Returns a negated version of the passed-in predicate.\n  function negate(predicate) {\n    return function() {\n      return !predicate.apply(this, arguments);\n    };\n  }\n\n  // Returns a function that is the composition of a list of functions, each\n  // consuming the return value of the function that follows.\n  function compose() {\n    var args = arguments;\n    var start = args.length - 1;\n    return function() {\n      var i = start;\n      var result = args[start].apply(this, arguments);\n      while (i--) result = args[i].call(this, result);\n      return result;\n    };\n  }\n\n  // Returns a function that will only be executed on and after the Nth call.\n  function after(times, func) {\n    return function() {\n      if (--times < 1) {\n        return func.apply(this, arguments);\n      }\n    };\n  }\n\n  // Returns a function that will only be executed up to (but not including) the\n  // Nth call.\n  function before(times, func) {\n    var memo;\n    return function() {\n      if (--times > 0) {\n        memo = func.apply(this, arguments);\n      }\n      if (times <= 1) func = null;\n      return memo;\n    };\n  }\n\n  // Returns a function that will be executed at most one time, no matter how\n  // often you call it. Useful for lazy initialization.\n  var once = partial(before, 2);\n\n  // Returns the first key on an object that passes a truth test.\n  function findKey(obj, predicate, context) {\n    predicate = cb(predicate, context);\n    var _keys = keys(obj), key;\n    for (var i = 0, length = _keys.length; i < length; i++) {\n      key = _keys[i];\n      if (predicate(obj[key], key, obj)) return key;\n    }\n  }\n\n  // Internal function to generate `_.findIndex` and `_.findLastIndex`.\n  function createPredicateIndexFinder(dir) {\n    return function(array, predicate, context) {\n      predicate = cb(predicate, context);\n      var length = getLength(array);\n      var index = dir > 0 ? 0 : length - 1;\n      for (; index >= 0 && index < length; index += dir) {\n        if (predicate(array[index], index, array)) return index;\n      }\n      return -1;\n    };\n  }\n\n  // Returns the first index on an array-like that passes a truth test.\n  var findIndex = createPredicateIndexFinder(1);\n\n  // Returns the last index on an array-like that passes a truth test.\n  var findLastIndex = createPredicateIndexFinder(-1);\n\n  // Use a comparator function to figure out the smallest index at which\n  // an object should be inserted so as to maintain order. Uses binary search.\n  function sortedIndex(array, obj, iteratee, context) {\n    iteratee = cb(iteratee, context, 1);\n    var value = iteratee(obj);\n    var low = 0, high = getLength(array);\n    while (low < high) {\n      var mid = Math.floor((low + high) / 2);\n      if (iteratee(array[mid]) < value) low = mid + 1; else high = mid;\n    }\n    return low;\n  }\n\n  // Internal function to generate the `_.indexOf` and `_.lastIndexOf` functions.\n  function createIndexFinder(dir, predicateFind, sortedIndex) {\n    return function(array, item, idx) {\n      var i = 0, length = getLength(array);\n      if (typeof idx == 'number') {\n        if (dir > 0) {\n          i = idx >= 0 ? idx : Math.max(idx + length, i);\n        } else {\n          length = idx >= 0 ? Math.min(idx + 1, length) : idx + length + 1;\n        }\n      } else if (sortedIndex && idx && length) {\n        idx = sortedIndex(array, item);\n        return array[idx] === item ? idx : -1;\n      }\n      if (item !== item) {\n        idx = predicateFind(slice.call(array, i, length), isNaN$1);\n        return idx >= 0 ? idx + i : -1;\n      }\n      for (idx = dir > 0 ? i : length - 1; idx >= 0 && idx < length; idx += dir) {\n        if (array[idx] === item) return idx;\n      }\n      return -1;\n    };\n  }\n\n  // Return the position of the first occurrence of an item in an array,\n  // or -1 if the item is not included in the array.\n  // If the array is large and already in sort order, pass `true`\n  // for **isSorted** to use binary search.\n  var indexOf = createIndexFinder(1, findIndex, sortedIndex);\n\n  // Return the position of the last occurrence of an item in an array,\n  // or -1 if the item is not included in the array.\n  var lastIndexOf = createIndexFinder(-1, findLastIndex);\n\n  // Return the first value which passes a truth test.\n  function find(obj, predicate, context) {\n    var keyFinder = isArrayLike(obj) ? findIndex : findKey;\n    var key = keyFinder(obj, predicate, context);\n    if (key !== void 0 && key !== -1) return obj[key];\n  }\n\n  // Convenience version of a common use case of `_.find`: getting the first\n  // object containing specific `key:value` pairs.\n  function findWhere(obj, attrs) {\n    return find(obj, matcher(attrs));\n  }\n\n  // The cornerstone for collection functions, an `each`\n  // implementation, aka `forEach`.\n  // Handles raw objects in addition to array-likes. Treats all\n  // sparse array-likes as if they were dense.\n  function each(obj, iteratee, context) {\n    iteratee = optimizeCb(iteratee, context);\n    var i, length;\n    if (isArrayLike(obj)) {\n      for (i = 0, length = obj.length; i < length; i++) {\n        iteratee(obj[i], i, obj);\n      }\n    } else {\n      var _keys = keys(obj);\n      for (i = 0, length = _keys.length; i < length; i++) {\n        iteratee(obj[_keys[i]], _keys[i], obj);\n      }\n    }\n    return obj;\n  }\n\n  // Return the results of applying the iteratee to each element.\n  function map(obj, iteratee, context) {\n    iteratee = cb(iteratee, context);\n    var _keys = !isArrayLike(obj) && keys(obj),\n        length = (_keys || obj).length,\n        results = Array(length);\n    for (var index = 0; index < length; index++) {\n      var currentKey = _keys ? _keys[index] : index;\n      results[index] = iteratee(obj[currentKey], currentKey, obj);\n    }\n    return results;\n  }\n\n  // Internal helper to create a reducing function, iterating left or right.\n  function createReduce(dir) {\n    // Wrap code that reassigns argument variables in a separate function than\n    // the one that accesses `arguments.length` to avoid a perf hit. (#1991)\n    var reducer = function(obj, iteratee, memo, initial) {\n      var _keys = !isArrayLike(obj) && keys(obj),\n          length = (_keys || obj).length,\n          index = dir > 0 ? 0 : length - 1;\n      if (!initial) {\n        memo = obj[_keys ? _keys[index] : index];\n        index += dir;\n      }\n      for (; index >= 0 && index < length; index += dir) {\n        var currentKey = _keys ? _keys[index] : index;\n        memo = iteratee(memo, obj[currentKey], currentKey, obj);\n      }\n      return memo;\n    };\n\n    return function(obj, iteratee, memo, context) {\n      var initial = arguments.length >= 3;\n      return reducer(obj, optimizeCb(iteratee, context, 4), memo, initial);\n    };\n  }\n\n  // **Reduce** builds up a single result from a list of values, aka `inject`,\n  // or `foldl`.\n  var reduce = createReduce(1);\n\n  // The right-associative version of reduce, also known as `foldr`.\n  var reduceRight = createReduce(-1);\n\n  // Return all the elements that pass a truth test.\n  function filter(obj, predicate, context) {\n    var results = [];\n    predicate = cb(predicate, context);\n    each(obj, function(value, index, list) {\n      if (predicate(value, index, list)) results.push(value);\n    });\n    return results;\n  }\n\n  // Return all the elements for which a truth test fails.\n  function reject(obj, predicate, context) {\n    return filter(obj, negate(cb(predicate)), context);\n  }\n\n  // Determine whether all of the elements pass a truth test.\n  function every(obj, predicate, context) {\n    predicate = cb(predicate, context);\n    var _keys = !isArrayLike(obj) && keys(obj),\n        length = (_keys || obj).length;\n    for (var index = 0; index < length; index++) {\n      var currentKey = _keys ? _keys[index] : index;\n      if (!predicate(obj[currentKey], currentKey, obj)) return false;\n    }\n    return true;\n  }\n\n  // Determine if at least one element in the object passes a truth test.\n  function some(obj, predicate, context) {\n    predicate = cb(predicate, context);\n    var _keys = !isArrayLike(obj) && keys(obj),\n        length = (_keys || obj).length;\n    for (var index = 0; index < length; index++) {\n      var currentKey = _keys ? _keys[index] : index;\n      if (predicate(obj[currentKey], currentKey, obj)) return true;\n    }\n    return false;\n  }\n\n  // Determine if the array or object contains a given item (using `===`).\n  function contains(obj, item, fromIndex, guard) {\n    if (!isArrayLike(obj)) obj = values(obj);\n    if (typeof fromIndex != 'number' || guard) fromIndex = 0;\n    return indexOf(obj, item, fromIndex) >= 0;\n  }\n\n  // Invoke a method (with arguments) on every item in a collection.\n  var invoke = restArguments(function(obj, path, args) {\n    var contextPath, func;\n    if (isFunction$1(path)) {\n      func = path;\n    } else {\n      path = toPath(path);\n      contextPath = path.slice(0, -1);\n      path = path[path.length - 1];\n    }\n    return map(obj, function(context) {\n      var method = func;\n      if (!method) {\n        if (contextPath && contextPath.length) {\n          context = deepGet(context, contextPath);\n        }\n        if (context == null) return void 0;\n        method = context[path];\n      }\n      return method == null ? method : method.apply(context, args);\n    });\n  });\n\n  // Convenience version of a common use case of `_.map`: fetching a property.\n  function pluck(obj, key) {\n    return map(obj, property(key));\n  }\n\n  // Convenience version of a common use case of `_.filter`: selecting only\n  // objects containing specific `key:value` pairs.\n  function where(obj, attrs) {\n    return filter(obj, matcher(attrs));\n  }\n\n  // Return the maximum element (or element-based computation).\n  function max(obj, iteratee, context) {\n    var result = -Infinity, lastComputed = -Infinity,\n        value, computed;\n    if (iteratee == null || typeof iteratee == 'number' && typeof obj[0] != 'object' && obj != null) {\n      obj = isArrayLike(obj) ? obj : values(obj);\n      for (var i = 0, length = obj.length; i < length; i++) {\n        value = obj[i];\n        if (value != null && value > result) {\n          result = value;\n        }\n      }\n    } else {\n      iteratee = cb(iteratee, context);\n      each(obj, function(v, index, list) {\n        computed = iteratee(v, index, list);\n        if (computed > lastComputed || computed === -Infinity && result === -Infinity) {\n          result = v;\n          lastComputed = computed;\n        }\n      });\n    }\n    return result;\n  }\n\n  // Return the minimum element (or element-based computation).\n  function min(obj, iteratee, context) {\n    var result = Infinity, lastComputed = Infinity,\n        value, computed;\n    if (iteratee == null || typeof iteratee == 'number' && typeof obj[0] != 'object' && obj != null) {\n      obj = isArrayLike(obj) ? obj : values(obj);\n      for (var i = 0, length = obj.length; i < length; i++) {\n        value = obj[i];\n        if (value != null && value < result) {\n          result = value;\n        }\n      }\n    } else {\n      iteratee = cb(iteratee, context);\n      each(obj, function(v, index, list) {\n        computed = iteratee(v, index, list);\n        if (computed < lastComputed || computed === Infinity && result === Infinity) {\n          result = v;\n          lastComputed = computed;\n        }\n      });\n    }\n    return result;\n  }\n\n  // Sample **n** random values from a collection using the modern version of the\n  // [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher–Yates_shuffle).\n  // If **n** is not specified, returns a single random element.\n  // The internal `guard` argument allows it to work with `_.map`.\n  function sample(obj, n, guard) {\n    if (n == null || guard) {\n      if (!isArrayLike(obj)) obj = values(obj);\n      return obj[random(obj.length - 1)];\n    }\n    var sample = isArrayLike(obj) ? clone(obj) : values(obj);\n    var length = getLength(sample);\n    n = Math.max(Math.min(n, length), 0);\n    var last = length - 1;\n    for (var index = 0; index < n; index++) {\n      var rand = random(index, last);\n      var temp = sample[index];\n      sample[index] = sample[rand];\n      sample[rand] = temp;\n    }\n    return sample.slice(0, n);\n  }\n\n  // Shuffle a collection.\n  function shuffle(obj) {\n    return sample(obj, Infinity);\n  }\n\n  // Sort the object's values by a criterion produced by an iteratee.\n  function sortBy(obj, iteratee, context) {\n    var index = 0;\n    iteratee = cb(iteratee, context);\n    return pluck(map(obj, function(value, key, list) {\n      return {\n        value: value,\n        index: index++,\n        criteria: iteratee(value, key, list)\n      };\n    }).sort(function(left, right) {\n      var a = left.criteria;\n      var b = right.criteria;\n      if (a !== b) {\n        if (a > b || a === void 0) return 1;\n        if (a < b || b === void 0) return -1;\n      }\n      return left.index - right.index;\n    }), 'value');\n  }\n\n  // An internal function used for aggregate \"group by\" operations.\n  function group(behavior, partition) {\n    return function(obj, iteratee, context) {\n      var result = partition ? [[], []] : {};\n      iteratee = cb(iteratee, context);\n      each(obj, function(value, index) {\n        var key = iteratee(value, index, obj);\n        behavior(result, value, key);\n      });\n      return result;\n    };\n  }\n\n  // Groups the object's values by a criterion. Pass either a string attribute\n  // to group by, or a function that returns the criterion.\n  var groupBy = group(function(result, value, key) {\n    if (has$1(result, key)) result[key].push(value); else result[key] = [value];\n  });\n\n  // Indexes the object's values by a criterion, similar to `_.groupBy`, but for\n  // when you know that your index values will be unique.\n  var indexBy = group(function(result, value, key) {\n    result[key] = value;\n  });\n\n  // Counts instances of an object that group by a certain criterion. Pass\n  // either a string attribute to count by, or a function that returns the\n  // criterion.\n  var countBy = group(function(result, value, key) {\n    if (has$1(result, key)) result[key]++; else result[key] = 1;\n  });\n\n  // Split a collection into two arrays: one whose elements all pass the given\n  // truth test, and one whose elements all do not pass the truth test.\n  var partition = group(function(result, value, pass) {\n    result[pass ? 0 : 1].push(value);\n  }, true);\n\n  // Safely create a real, live array from anything iterable.\n  var reStrSymbol = /[^\\ud800-\\udfff]|[\\ud800-\\udbff][\\udc00-\\udfff]|[\\ud800-\\udfff]/g;\n  function toArray(obj) {\n    if (!obj) return [];\n    if (isArray(obj)) return slice.call(obj);\n    if (isString(obj)) {\n      // Keep surrogate pair characters together.\n      return obj.match(reStrSymbol);\n    }\n    if (isArrayLike(obj)) return map(obj, identity);\n    return values(obj);\n  }\n\n  // Return the number of elements in a collection.\n  function size(obj) {\n    if (obj == null) return 0;\n    return isArrayLike(obj) ? obj.length : keys(obj).length;\n  }\n\n  // Internal `_.pick` helper function to determine whether `key` is an enumerable\n  // property name of `obj`.\n  function keyInObj(value, key, obj) {\n    return key in obj;\n  }\n\n  // Return a copy of the object only containing the allowed properties.\n  var pick = restArguments(function(obj, keys) {\n    var result = {}, iteratee = keys[0];\n    if (obj == null) return result;\n    if (isFunction$1(iteratee)) {\n      if (keys.length > 1) iteratee = optimizeCb(iteratee, keys[1]);\n      keys = allKeys(obj);\n    } else {\n      iteratee = keyInObj;\n      keys = flatten$1(keys, false, false);\n      obj = Object(obj);\n    }\n    for (var i = 0, length = keys.length; i < length; i++) {\n      var key = keys[i];\n      var value = obj[key];\n      if (iteratee(value, key, obj)) result[key] = value;\n    }\n    return result;\n  });\n\n  // Return a copy of the object without the disallowed properties.\n  var omit = restArguments(function(obj, keys) {\n    var iteratee = keys[0], context;\n    if (isFunction$1(iteratee)) {\n      iteratee = negate(iteratee);\n      if (keys.length > 1) context = keys[1];\n    } else {\n      keys = map(flatten$1(keys, false, false), String);\n      iteratee = function(value, key) {\n        return !contains(keys, key);\n      };\n    }\n    return pick(obj, iteratee, context);\n  });\n\n  // Returns everything but the last entry of the array. Especially useful on\n  // the arguments object. Passing **n** will return all the values in\n  // the array, excluding the last N.\n  function initial(array, n, guard) {\n    return slice.call(array, 0, Math.max(0, array.length - (n == null || guard ? 1 : n)));\n  }\n\n  // Get the first element of an array. Passing **n** will return the first N\n  // values in the array. The **guard** check allows it to work with `_.map`.\n  function first(array, n, guard) {\n    if (array == null || array.length < 1) return n == null || guard ? void 0 : [];\n    if (n == null || guard) return array[0];\n    return initial(array, array.length - n);\n  }\n\n  // Returns everything but the first entry of the `array`. Especially useful on\n  // the `arguments` object. Passing an **n** will return the rest N values in the\n  // `array`.\n  function rest(array, n, guard) {\n    return slice.call(array, n == null || guard ? 1 : n);\n  }\n\n  // Get the last element of an array. Passing **n** will return the last N\n  // values in the array.\n  function last(array, n, guard) {\n    if (array == null || array.length < 1) return n == null || guard ? void 0 : [];\n    if (n == null || guard) return array[array.length - 1];\n    return rest(array, Math.max(0, array.length - n));\n  }\n\n  // Trim out all falsy values from an array.\n  function compact(array) {\n    return filter(array, Boolean);\n  }\n\n  // Flatten out an array, either recursively (by default), or up to `depth`.\n  // Passing `true` or `false` as `depth` means `1` or `Infinity`, respectively.\n  function flatten(array, depth) {\n    return flatten$1(array, depth, false);\n  }\n\n  // Take the difference between one array and a number of other arrays.\n  // Only the elements present in just the first array will remain.\n  var difference = restArguments(function(array, rest) {\n    rest = flatten$1(rest, true, true);\n    return filter(array, function(value){\n      return !contains(rest, value);\n    });\n  });\n\n  // Return a version of the array that does not contain the specified value(s).\n  var without = restArguments(function(array, otherArrays) {\n    return difference(array, otherArrays);\n  });\n\n  // Produce a duplicate-free version of the array. If the array has already\n  // been sorted, you have the option of using a faster algorithm.\n  // The faster algorithm will not work with an iteratee if the iteratee\n  // is not a one-to-one function, so providing an iteratee will disable\n  // the faster algorithm.\n  function uniq(array, isSorted, iteratee, context) {\n    if (!isBoolean(isSorted)) {\n      context = iteratee;\n      iteratee = isSorted;\n      isSorted = false;\n    }\n    if (iteratee != null) iteratee = cb(iteratee, context);\n    var result = [];\n    var seen = [];\n    for (var i = 0, length = getLength(array); i < length; i++) {\n      var value = array[i],\n          computed = iteratee ? iteratee(value, i, array) : value;\n      if (isSorted && !iteratee) {\n        if (!i || seen !== computed) result.push(value);\n        seen = computed;\n      } else if (iteratee) {\n        if (!contains(seen, computed)) {\n          seen.push(computed);\n          result.push(value);\n        }\n      } else if (!contains(result, value)) {\n        result.push(value);\n      }\n    }\n    return result;\n  }\n\n  // Produce an array that contains the union: each distinct element from all of\n  // the passed-in arrays.\n  var union = restArguments(function(arrays) {\n    return uniq(flatten$1(arrays, true, true));\n  });\n\n  // Produce an array that contains every item shared between all the\n  // passed-in arrays.\n  function intersection(array) {\n    var result = [];\n    var argsLength = arguments.length;\n    for (var i = 0, length = getLength(array); i < length; i++) {\n      var item = array[i];\n      if (contains(result, item)) continue;\n      var j;\n      for (j = 1; j < argsLength; j++) {\n        if (!contains(arguments[j], item)) break;\n      }\n      if (j === argsLength) result.push(item);\n    }\n    return result;\n  }\n\n  // Complement of zip. Unzip accepts an array of arrays and groups\n  // each array's elements on shared indices.\n  function unzip(array) {\n    var length = array && max(array, getLength).length || 0;\n    var result = Array(length);\n\n    for (var index = 0; index < length; index++) {\n      result[index] = pluck(array, index);\n    }\n    return result;\n  }\n\n  // Zip together multiple lists into a single array -- elements that share\n  // an index go together.\n  var zip = restArguments(unzip);\n\n  // Converts lists into objects. Pass either a single array of `[key, value]`\n  // pairs, or two parallel arrays of the same length -- one of keys, and one of\n  // the corresponding values. Passing by pairs is the reverse of `_.pairs`.\n  function object(list, values) {\n    var result = {};\n    for (var i = 0, length = getLength(list); i < length; i++) {\n      if (values) {\n        result[list[i]] = values[i];\n      } else {\n        result[list[i][0]] = list[i][1];\n      }\n    }\n    return result;\n  }\n\n  // Generate an integer Array containing an arithmetic progression. A port of\n  // the native Python `range()` function. See\n  // [the Python documentation](https://docs.python.org/library/functions.html#range).\n  function range(start, stop, step) {\n    if (stop == null) {\n      stop = start || 0;\n      start = 0;\n    }\n    if (!step) {\n      step = stop < start ? -1 : 1;\n    }\n\n    var length = Math.max(Math.ceil((stop - start) / step), 0);\n    var range = Array(length);\n\n    for (var idx = 0; idx < length; idx++, start += step) {\n      range[idx] = start;\n    }\n\n    return range;\n  }\n\n  // Chunk a single array into multiple arrays, each containing `count` or fewer\n  // items.\n  function chunk(array, count) {\n    if (count == null || count < 1) return [];\n    var result = [];\n    var i = 0, length = array.length;\n    while (i < length) {\n      result.push(slice.call(array, i, i += count));\n    }\n    return result;\n  }\n\n  // Helper function to continue chaining intermediate results.\n  function chainResult(instance, obj) {\n    return instance._chain ? _$1(obj).chain() : obj;\n  }\n\n  // Add your own custom functions to the Underscore object.\n  function mixin(obj) {\n    each(functions(obj), function(name) {\n      var func = _$1[name] = obj[name];\n      _$1.prototype[name] = function() {\n        var args = [this._wrapped];\n        push.apply(args, arguments);\n        return chainResult(this, func.apply(_$1, args));\n      };\n    });\n    return _$1;\n  }\n\n  // Add all mutator `Array` functions to the wrapper.\n  each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {\n    var method = ArrayProto[name];\n    _$1.prototype[name] = function() {\n      var obj = this._wrapped;\n      if (obj != null) {\n        method.apply(obj, arguments);\n        if ((name === 'shift' || name === 'splice') && obj.length === 0) {\n          delete obj[0];\n        }\n      }\n      return chainResult(this, obj);\n    };\n  });\n\n  // Add all accessor `Array` functions to the wrapper.\n  each(['concat', 'join', 'slice'], function(name) {\n    var method = ArrayProto[name];\n    _$1.prototype[name] = function() {\n      var obj = this._wrapped;\n      if (obj != null) obj = method.apply(obj, arguments);\n      return chainResult(this, obj);\n    };\n  });\n\n  // Named Exports\n\n  var allExports = {\n    __proto__: null,\n    VERSION: VERSION,\n    restArguments: restArguments,\n    isObject: isObject,\n    isNull: isNull,\n    isUndefined: isUndefined,\n    isBoolean: isBoolean,\n    isElement: isElement,\n    isString: isString,\n    isNumber: isNumber,\n    isDate: isDate,\n    isRegExp: isRegExp,\n    isError: isError,\n    isSymbol: isSymbol,\n    isArrayBuffer: isArrayBuffer,\n    isDataView: isDataView$1,\n    isArray: isArray,\n    isFunction: isFunction$1,\n    isArguments: isArguments$1,\n    isFinite: isFinite$1,\n    isNaN: isNaN$1,\n    isTypedArray: isTypedArray$1,\n    isEmpty: isEmpty,\n    isMatch: isMatch,\n    isEqual: isEqual,\n    isMap: isMap,\n    isWeakMap: isWeakMap,\n    isSet: isSet,\n    isWeakSet: isWeakSet,\n    keys: keys,\n    allKeys: allKeys,\n    values: values,\n    pairs: pairs,\n    invert: invert,\n    functions: functions,\n    methods: functions,\n    extend: extend,\n    extendOwn: extendOwn,\n    assign: extendOwn,\n    defaults: defaults,\n    create: create,\n    clone: clone,\n    tap: tap,\n    get: get,\n    has: has,\n    mapObject: mapObject,\n    identity: identity,\n    constant: constant,\n    noop: noop,\n    toPath: toPath$1,\n    property: property,\n    propertyOf: propertyOf,\n    matcher: matcher,\n    matches: matcher,\n    times: times,\n    random: random,\n    now: now,\n    escape: _escape,\n    unescape: _unescape,\n    templateSettings: templateSettings,\n    template: template,\n    result: result,\n    uniqueId: uniqueId,\n    chain: chain,\n    iteratee: iteratee,\n    partial: partial,\n    bind: bind,\n    bindAll: bindAll,\n    memoize: memoize,\n    delay: delay,\n    defer: defer,\n    throttle: throttle,\n    debounce: debounce,\n    wrap: wrap,\n    negate: negate,\n    compose: compose,\n    after: after,\n    before: before,\n    once: once,\n    findKey: findKey,\n    findIndex: findIndex,\n    findLastIndex: findLastIndex,\n    sortedIndex: sortedIndex,\n    indexOf: indexOf,\n    lastIndexOf: lastIndexOf,\n    find: find,\n    detect: find,\n    findWhere: findWhere,\n    each: each,\n    forEach: each,\n    map: map,\n    collect: map,\n    reduce: reduce,\n    foldl: reduce,\n    inject: reduce,\n    reduceRight: reduceRight,\n    foldr: reduceRight,\n    filter: filter,\n    select: filter,\n    reject: reject,\n    every: every,\n    all: every,\n    some: some,\n    any: some,\n    contains: contains,\n    includes: contains,\n    include: contains,\n    invoke: invoke,\n    pluck: pluck,\n    where: where,\n    max: max,\n    min: min,\n    shuffle: shuffle,\n    sample: sample,\n    sortBy: sortBy,\n    groupBy: groupBy,\n    indexBy: indexBy,\n    countBy: countBy,\n    partition: partition,\n    toArray: toArray,\n    size: size,\n    pick: pick,\n    omit: omit,\n    first: first,\n    head: first,\n    take: first,\n    initial: initial,\n    last: last,\n    rest: rest,\n    tail: rest,\n    drop: rest,\n    compact: compact,\n    flatten: flatten,\n    without: without,\n    uniq: uniq,\n    unique: uniq,\n    union: union,\n    intersection: intersection,\n    difference: difference,\n    unzip: unzip,\n    transpose: unzip,\n    zip: zip,\n    object: object,\n    range: range,\n    chunk: chunk,\n    mixin: mixin,\n    'default': _$1\n  };\n\n  // Default Export\n\n  // Add all of the Underscore functions to the wrapper object.\n  var _ = mixin(allExports);\n  // Legacy Node.js API.\n  _._ = _;\n\n  return _;\n\n})));\n//# sourceMappingURL=underscore-umd.js.map\n"],"sourceRoot":""}