(function (global, factory) {

  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :

  typeof define === 'function' && define.amd ? define('underscore', factory) :

  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, (function () {

    var current = global._;

    var exports = global._ = factory();

    exports.noConflict = function () { global._ = current; return exports; };

  }()));

}(this, (function () {

  //     Underscore.js 1.13.1

  //     https://underscorejs.org

  //     (c) 2009-2021 Jeremy Ashkenas, Julian Gonggrijp, and DocumentCloud and Investigative Reporters & Editors

  //     Underscore may be freely distributed under the MIT license.

  var VERSION = '1.13.1';

  // Establish the root object, `window` (`self`) in the browser, `global`

  // on the server, or `this` in some virtual machines. We use `self`

  // instead of `window` for `WebWorker` support.

  var root = typeof self == 'object' && self.self === self && self ||

            typeof global == 'object' && global.global === global && global ||

            Function('return this')() ||

            {};

  // Save bytes in the minified (but not gzipped) version:

  var ArrayProto = Array.prototype, ObjProto = Object.prototype;

  var SymbolProto = typeof Symbol !== 'undefined' ? Symbol.prototype : null;

  // Create quick reference variables for speed access to core prototypes.

  var push = ArrayProto.push,

      slice = ArrayProto.slice,

      toString = ObjProto.toString,

      hasOwnProperty = ObjProto.hasOwnProperty;

  // Modern feature detection.

  var supportsArrayBuffer = typeof ArrayBuffer !== 'undefined',

      supportsDataView = typeof DataView !== 'undefined';

  // All **ECMAScript 5+** native function implementations that we hope to use

  // are declared here.

  var nativeIsArray = Array.isArray,

      nativeKeys = Object.keys,

      nativeCreate = Object.create,

      nativeIsView = supportsArrayBuffer && ArrayBuffer.isView;

  // Create references to these builtin functions because we override them.

  var _isNaN = isNaN,

      _isFinite = isFinite;

    'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];

  // The largest integer that can be represented exactly.

  var MAX_ARRAY_INDEX = Math.pow(2, 53) - 1;

  // Some functions take a variable number of arguments, or a few expected

  // arguments at the beginning and then a variable number of values to operate

  // on. This helper accumulates all remaining arguments past the function’s

  // argument length (or an explicit `startIndex`), into an array that becomes

  // the last argument. Similar to ES6’s "rest parameter".

  function restArguments(func, startIndex) {

    startIndex = startIndex == null ? func.length - 1 : +startIndex;

    return function() {

      var length = Math.max(arguments.length - startIndex, 0),

          rest = Array(length),

          index = 0;

      for (; index < length; index++) {

        rest[index] = arguments[index + startIndex];

      }

      switch (startIndex) {

        case 0: return func.call(this, rest);

        case 1: return func.call(this, arguments[0], rest);

        case 2: return func.call(this, arguments[0], arguments[1], rest);

      }

      var args = Array(startIndex + 1);

      for (index = 0; index < startIndex; index++) {

        args[index] = arguments[index];

      }

      args[startIndex] = rest;

      return func.apply(this, args);

    };

  }

  // Is a given variable an object?

  function isObject(obj) {

    var type = typeof obj;

    return type === 'function' || type === 'object' && !!obj;

  }

  // Is a given value equal to null?

  function isNull(obj) {

    return obj === null;

  }

  // Is a given variable undefined?

  function isUndefined(obj) {

    return obj === void 0;

  }

  // Is a given value a boolean?

  function isBoolean(obj) {

    return obj === true || obj === false || toString.call(obj) === '[object Boolean]';

  }

  // Is a given value a DOM element?

  function isElement(obj) {

    return !!(obj && obj.nodeType === 1);

  }

  // Internal function for creating a `toString`-based type tester.

  function tagTester(name) {

    var tag = '[object ' + name + ']';

    return function(obj) {

      return toString.call(obj) === tag;

    };

  }

  var isString = tagTester('String');

  var isNumber = tagTester('Number');

  var isDate = tagTester('Date');

  var isRegExp = tagTester('RegExp');

  var isError = tagTester('Error');

  var isSymbol = tagTester('Symbol');

  var isArrayBuffer = tagTester('ArrayBuffer');

  var isFunction = tagTester('Function');

  // Optimize `isFunction` if appropriate. Work around some `typeof` bugs in old

  // v8, IE 11 (#1621), Safari 8 (#1929), and PhantomJS (#2236).

  var nodelist = root.document && root.document.childNodes;

  if (typeof /./ != 'function' && typeof Int8Array != 'object' && typeof nodelist != 'function') {

    isFunction = function(obj) {

      return typeof obj == 'function' || false;

    };

  }

  var isFunction$1 = isFunction;

  var hasObjectTag = tagTester('Object');

  // In IE 10 - Edge 13, `DataView` has string tag `'[object Object]'`.

  // In IE 11, the most common among them, this problem also applies to

  // `Map`, `WeakMap` and `Set`.

  var hasStringTagBug = (

        supportsDataView && hasObjectTag(new DataView(new ArrayBuffer(8)))

      ),

      isIE11 = (typeof Map !== 'undefined' && hasObjectTag(new Map));

  var isDataView = tagTester('DataView');

  // In IE 10 - Edge 13, we need a different heuristic

  // to determine whether an object is a `DataView`.

  function ie10IsDataView(obj) {

    return obj != null && isFunction$1(obj.getInt8) && isArrayBuffer(obj.buffer);

  }

  var isDataView$1 = (hasStringTagBug ? ie10IsDataView : isDataView);

  // Is a given value an array?

  // Delegates to ECMA5's native `Array.isArray`.

  var isArray = nativeIsArray || tagTester('Array');

  // Internal function to check whether `key` is an own property name of `obj`.

  function has$1(obj, key) {

    return obj != null && hasOwnProperty.call(obj, key);

  }

  var isArguments = tagTester('Arguments');

  // Define a fallback version of the method in browsers (ahem, IE < 9), where

  // there isn't any inspectable "Arguments" type.

  (function() {

    if (!isArguments(arguments)) {

      isArguments = function(obj) {

        return has$1(obj, 'callee');

      };

    }

  }());

  var isArguments$1 = isArguments;

  // Is a given object a finite number?

  function isFinite$1(obj) {

    return !isSymbol(obj) && _isFinite(obj) && !isNaN(parseFloat(obj));

  }

  // Is the given value `NaN`?

  function isNaN$1(obj) {

    return isNumber(obj) && _isNaN(obj);

  }

  // Predicate-generating function. Often useful outside of Underscore.

  function constant(value) {

    return function() {

      return value;

    };

  }

  // Common internal logic for `isArrayLike` and `isBufferLike`.

  function createSizePropertyCheck(getSizeProperty) {

    return function(collection) {

      var sizeProperty = getSizeProperty(collection);

      return typeof sizeProperty == 'number' && sizeProperty >= 0 && sizeProperty <= MAX_ARRAY_INDEX;

    }

  }

  // Internal helper to generate a function to obtain property `key` from `obj`.

  function shallowProperty(key) {

    return function(obj) {

      return obj == null ? void 0 : obj[key];

    };

  }

  // Internal helper to obtain the `byteLength` property of an object.

  var getByteLength = shallowProperty('byteLength');

  // Internal helper to determine whether we should spend extensive checks against

  // `ArrayBuffer` et al.

  var isBufferLike = createSizePropertyCheck(getByteLength);

  // Is a given value a typed array?

  var typedArrayPattern = /\[object ((I|Ui)nt(8|16|32)|Float(32|64)|Uint8Clamped|Big(I|Ui)nt64)Array\]/;

  function isTypedArray(obj) {

    // `ArrayBuffer.isView` is the most future-proof, so use it when available.

    // Otherwise, fall back on the above regular expression.

    return nativeIsView ? (nativeIsView(obj) && !isDataView$1(obj)) :

                  isBufferLike(obj) && typedArrayPattern.test(toString.call(obj));

  }

  var isTypedArray$1 = supportsArrayBuffer ? isTypedArray : constant(false);

  // Internal helper to obtain the `length` property of an object.

  var getLength = shallowProperty('length');

  // Internal helper to create a simple lookup structure.

  // `collectNonEnumProps` used to depend on `_.contains`, but this led to

  // circular imports. `emulatedSet` is a one-off solution that only works for

  // arrays of strings.

  function emulatedSet(keys) {

    var hash = {};

    for (var l = keys.length, i = 0; i < l; ++i) hash[keys[i]] = true;

    return {

      contains: function(key) { return hash[key]; },

      push: function(key) {

        hash[key] = true;

        return keys.push(key);

      }

    };

  }

  // Internal helper. Checks `keys` for the presence of keys in IE < 9 that won't

  // be iterated by `for key in ...` and thus missed. Extends `keys` in place if

  // needed.

    keys = emulatedSet(keys);

    var proto = isFunction$1(constructor) && constructor.prototype || ObjProto;

    if (has$1(obj, prop) && !keys.contains(prop)) keys.push(prop);

      if (prop in obj && obj[prop] !== proto[prop] && !keys.contains(prop)) {

  // Delegates to **ECMAScript 5**'s native `Object.keys`.

  function keys(obj) {

    if (!isObject(obj)) return [];

    for (var key in obj) if (has$1(obj, key)) keys.push(key);

  }

  // Is a given array, string, or object empty?

  // An "empty" object has no enumerable own-properties.

  function isEmpty(obj) {

    if (obj == null) return true;

    // Skip the more expensive `toString`-based type checks if `obj` has no

    // `.length`.

    var length = getLength(obj);

    if (typeof length == 'number' && (

      isArray(obj) || isString(obj) || isArguments$1(obj)

    )) return length === 0;

    return getLength(keys(obj)) === 0;

  }

  function isMatch(object, attrs) {

    var _keys = keys(attrs), length = _keys.length;

      var key = _keys[i];

  }

  // If Underscore is called as a function, it returns a wrapped object that can

  // be used OO-style. This wrapper holds altered versions of all functions added

  // through `_.mixin`. Wrapped objects may be chained.

  function _$1(obj) {

    if (obj instanceof _$1) return obj;

    if (!(this instanceof _$1)) return new _$1(obj);

    this._wrapped = obj;

  }

  _$1.VERSION = VERSION;

  // Extracts the result from a wrapped and chained object.

  _$1.prototype.value = function() {

    return this._wrapped;

  };

  // Provide unwrapping proxies for some methods used in engine operations

  // such as arithmetic and JSON stringification.

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