1 /**

     2  * @license

     3  * Lodash <https://lodash.com/>

     4  * Copyright JS Foundation and other contributors <https://js.foundation/>

     5  * Released under MIT license <https://lodash.com/license>

     6  * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>

     7  * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors

     8  */

     9 ;(function() {

    10 

    11   /** Used as a safe reference for `undefined` in pre-ES5 environments. */

    12   var undefined;

    13 

    14   /** Used as the semantic version number. */

    15   var VERSION = '4.17.11';

    16 

    17   /** Used as the size to enable large array optimizations. */

    18   var LARGE_ARRAY_SIZE = 200;

    19 

    20   /** Error message constants. */

    21   var CORE_ERROR_TEXT = 'Unsupported core-js use. Try https://npms.io/search?q=ponyfill.',

    22       FUNC_ERROR_TEXT = 'Expected a function';

    23 

    24   /** Used to stand-in for `undefined` hash values. */

    25   var HASH_UNDEFINED = '__lodash_hash_undefined__';

    26 

    27   /** Used as the maximum memoize cache size. */

    28   var MAX_MEMOIZE_SIZE = 500;

    29 

    30   /** Used as the internal argument placeholder. */

    31   var PLACEHOLDER = '__lodash_placeholder__';

    32 

    33   /** Used to compose bitmasks for cloning. */

    34   var CLONE_DEEP_FLAG = 1,

    35       CLONE_FLAT_FLAG = 2,

    36       CLONE_SYMBOLS_FLAG = 4;

    37 

    38   /** Used to compose bitmasks for value comparisons. */

    39   var COMPARE_PARTIAL_FLAG = 1,

    40       COMPARE_UNORDERED_FLAG = 2;

    41 

    42   /** Used to compose bitmasks for function metadata. */

    43   var WRAP_BIND_FLAG = 1,

    44       WRAP_BIND_KEY_FLAG = 2,

    45       WRAP_CURRY_BOUND_FLAG = 4,

    46       WRAP_CURRY_FLAG = 8,

    47       WRAP_CURRY_RIGHT_FLAG = 16,

    48       WRAP_PARTIAL_FLAG = 32,

    49       WRAP_PARTIAL_RIGHT_FLAG = 64,

    50       WRAP_ARY_FLAG = 128,

    51       WRAP_REARG_FLAG = 256,

    52       WRAP_FLIP_FLAG = 512;

    53 

    54   /** Used as default options for `_.truncate`. */

    55   var DEFAULT_TRUNC_LENGTH = 30,

    56       DEFAULT_TRUNC_OMISSION = '...';

    57 

    58   /** Used to detect hot functions by number of calls within a span of milliseconds. */

    59   var HOT_COUNT = 800,

    60       HOT_SPAN = 16;

    61 

    62   /** Used to indicate the type of lazy iteratees. */

    63   var LAZY_FILTER_FLAG = 1,

    64       LAZY_MAP_FLAG = 2,

    65       LAZY_WHILE_FLAG = 3;

    66 

    67   /** Used as references for various `Number` constants. */

    68   var INFINITY = 1 / 0,

    69       MAX_SAFE_INTEGER = 9007199254740991,

    70       MAX_INTEGER = 1.7976931348623157e+308,

    71       NAN = 0 / 0;

    72 

    73   /** Used as references for the maximum length and index of an array. */

    74   var MAX_ARRAY_LENGTH = 4294967295,

    75       MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1,

    76       HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1;

    77 

    78   /** Used to associate wrap methods with their bit flags. */

    79   var wrapFlags = [

    80     ['ary', WRAP_ARY_FLAG],

    81     ['bind', WRAP_BIND_FLAG],

    82     ['bindKey', WRAP_BIND_KEY_FLAG],

    83     ['curry', WRAP_CURRY_FLAG],

    84     ['curryRight', WRAP_CURRY_RIGHT_FLAG],

    85     ['flip', WRAP_FLIP_FLAG],

    86     ['partial', WRAP_PARTIAL_FLAG],

    87     ['partialRight', WRAP_PARTIAL_RIGHT_FLAG],

    88     ['rearg', WRAP_REARG_FLAG]

    89   ];

    90 

    91   /** `Object#toString` result references. */

    92   var argsTag = '[object Arguments]',

    93       arrayTag = '[object Array]',

    94       asyncTag = '[object AsyncFunction]',

    95       boolTag = '[object Boolean]',

    96       dateTag = '[object Date]',

    97       domExcTag = '[object DOMException]',

    98       errorTag = '[object Error]',

    99       funcTag = '[object Function]',

   100       genTag = '[object GeneratorFunction]',

   101       mapTag = '[object Map]',

   102       numberTag = '[object Number]',

   103       nullTag = '[object Null]',

   104       objectTag = '[object Object]',

   105       promiseTag = '[object Promise]',

   106       proxyTag = '[object Proxy]',

   107       regexpTag = '[object RegExp]',

   108       setTag = '[object Set]',

   109       stringTag = '[object String]',

   110       symbolTag = '[object Symbol]',

   111       undefinedTag = '[object Undefined]',

   112       weakMapTag = '[object WeakMap]',

   113       weakSetTag = '[object WeakSet]';

   114 

   115   var arrayBufferTag = '[object ArrayBuffer]',

   116       dataViewTag = '[object DataView]',

   117       float32Tag = '[object Float32Array]',

   118       float64Tag = '[object Float64Array]',

   119       int8Tag = '[object Int8Array]',

   120       int16Tag = '[object Int16Array]',

   121       int32Tag = '[object Int32Array]',

   122       uint8Tag = '[object Uint8Array]',

   123       uint8ClampedTag = '[object Uint8ClampedArray]',

   124       uint16Tag = '[object Uint16Array]',

   125       uint32Tag = '[object Uint32Array]';

   126 

   127   /** Used to match empty string literals in compiled template source. */

   128   var reEmptyStringLeading = /\b__p \+= '';/g,

   129       reEmptyStringMiddle = /\b(__p \+=) '' \+/g,

   130       reEmptyStringTrailing = /(__e\(.*?\)|\b__t\)) \+\n'';/g;

   131 

   132   /** Used to match HTML entities and HTML characters. */

   133   var reEscapedHtml = /&(?:amp|lt|gt|quot|#39);/g,

   134       reUnescapedHtml = /[&<>"']/g,

   135       reHasEscapedHtml = RegExp(reEscapedHtml.source),

   136       reHasUnescapedHtml = RegExp(reUnescapedHtml.source);

   137 

   138   /** Used to match template delimiters. */

   139   var reEscape = /<%-([\s\S]+?)%>/g,

   140       reEvaluate = /<%([\s\S]+?)%>/g,

   141       reInterpolate = /<%=([\s\S]+?)%>/g;

   142 

   143   /** Used to match property names within property paths. */

   144   var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,

   145       reIsPlainProp = /^\w*$/,

   146       rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;

   147 

   148   /**

   149    * Used to match `RegExp`

   150    * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).

   151    */

   152   var reRegExpChar = /[\\^$.*+?()[\]{}|]/g,

   153       reHasRegExpChar = RegExp(reRegExpChar.source);

   154 

   155   /** Used to match leading and trailing whitespace. */

   156   var reTrim = /^\s+|\s+$/g,

   157       reTrimStart = /^\s+/,

   158       reTrimEnd = /\s+$/;

   159 

   160   /** Used to match wrap detail comments. */

   161   var reWrapComment = /\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/,

   162       reWrapDetails = /\{\n\/\* \[wrapped with (.+)\] \*/,

   163       reSplitDetails = /,? & /;

   164 

   165   /** Used to match words composed of alphanumeric characters. */

   166   var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;

   167 

   168   /** Used to match backslashes in property paths. */

   169   var reEscapeChar = /\\(\\)?/g;

   170 

   171   /**

   172    * Used to match

   173    * [ES template delimiters](http://ecma-international.org/ecma-262/7.0/#sec-template-literal-lexical-components).

   174    */

   175   var reEsTemplate = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g;

   176 

   177   /** Used to match `RegExp` flags from their coerced string values. */

   178   var reFlags = /\w*$/;

   179 

   180   /** Used to detect bad signed hexadecimal string values. */

   181   var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;

   182 

   183   /** Used to detect binary string values. */

   184   var reIsBinary = /^0b[01]+$/i;

   185 

   186   /** Used to detect host constructors (Safari). */

   187   var reIsHostCtor = /^\[object .+?Constructor\]$/;

   188 

   189   /** Used to detect octal string values. */

   190   var reIsOctal = /^0o[0-7]+$/i;

   191 

   192   /** Used to detect unsigned integer values. */

   193   var reIsUint = /^(?:0|[1-9]\d*)$/;

   194 

   195   /** Used to match Latin Unicode letters (excluding mathematical operators). */

   196   var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g;

   197 

   198   /** Used to ensure capturing order of template delimiters. */

   199   var reNoMatch = /($^)/;

   200 

   201   /** Used to match unescaped characters in compiled string literals. */

   202   var reUnescapedString = /['\n\r\u2028\u2029\\]/g;

   203 

   204   /** Used to compose unicode character classes. */

   205   var rsAstralRange = '\\ud800-\\udfff',

   206       rsComboMarksRange = '\\u0300-\\u036f',

   207       reComboHalfMarksRange = '\\ufe20-\\ufe2f',

   208       rsComboSymbolsRange = '\\u20d0-\\u20ff',

   209       rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange,

   210       rsDingbatRange = '\\u2700-\\u27bf',

   211       rsLowerRange = 'a-z\\xdf-\\xf6\\xf8-\\xff',

   212       rsMathOpRange = '\\xac\\xb1\\xd7\\xf7',

   213       rsNonCharRange = '\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf',

   214       rsPunctuationRange = '\\u2000-\\u206f',

   215       rsSpaceRange = ' \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000',

   216       rsUpperRange = 'A-Z\\xc0-\\xd6\\xd8-\\xde',

   217       rsVarRange = '\\ufe0e\\ufe0f',

   218       rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;

   219 

   220   /** Used to compose unicode capture groups. */

   221   var rsApos = "['\u2019]",

   222       rsAstral = '[' + rsAstralRange + ']',

   223       rsBreak = '[' + rsBreakRange + ']',

   224       rsCombo = '[' + rsComboRange + ']',

   225       rsDigits = '\\d+',

   226       rsDingbat = '[' + rsDingbatRange + ']',

   227       rsLower = '[' + rsLowerRange + ']',

   228       rsMisc = '[^' + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + ']',

   229       rsFitz = '\\ud83c[\\udffb-\\udfff]',

   230       rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')',

   231       rsNonAstral = '[^' + rsAstralRange + ']',

   232       rsRegional = '(?:\\ud83c[\\udde6-\\uddff]){2}',

   233       rsSurrPair = '[\\ud800-\\udbff][\\udc00-\\udfff]',

   234       rsUpper = '[' + rsUpperRange + ']',

   235       rsZWJ = '\\u200d';

   236 

   237   /** Used to compose unicode regexes. */

   238   var rsMiscLower = '(?:' + rsLower + '|' + rsMisc + ')',

   239       rsMiscUpper = '(?:' + rsUpper + '|' + rsMisc + ')',

   240       rsOptContrLower = '(?:' + rsApos + '(?:d|ll|m|re|s|t|ve))?',

   241       rsOptContrUpper = '(?:' + rsApos + '(?:D|LL|M|RE|S|T|VE))?',

   242       reOptMod = rsModifier + '?',

   243       rsOptVar = '[' + rsVarRange + ']?',

   244       rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*',

   245       rsOrdLower = '\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])',

   246       rsOrdUpper = '\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])',

   247       rsSeq = rsOptVar + reOptMod + rsOptJoin,

   248       rsEmoji = '(?:' + [rsDingbat, rsRegional, rsSurrPair].join('|') + ')' + rsSeq,

   249       rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')';

   250 

   251   /** Used to match apostrophes. */

   252   var reApos = RegExp(rsApos, 'g');

   253 

   254   /**

   255    * Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks) and

   256    * [combining diacritical marks for symbols](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks_for_Symbols).

   257    */

   258   var reComboMark = RegExp(rsCombo, 'g');

   259 

   260   /** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */

   261   var reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g');

   262 

   263   /** Used to match complex or compound words. */

   264   var reUnicodeWord = RegExp([

   265     rsUpper + '?' + rsLower + '+' + rsOptContrLower + '(?=' + [rsBreak, rsUpper, '$'].join('|') + ')',

   266     rsMiscUpper + '+' + rsOptContrUpper + '(?=' + [rsBreak, rsUpper + rsMiscLower, '$'].join('|') + ')',

   267     rsUpper + '?' + rsMiscLower + '+' + rsOptContrLower,

   268     rsUpper + '+' + rsOptContrUpper,

   269     rsOrdUpper,

   270     rsOrdLower,

   271     rsDigits,

   272     rsEmoji

   273   ].join('|'), 'g');

   274 

   275   /** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */

   276   var reHasUnicode = RegExp('[' + rsZWJ + rsAstralRange  + rsComboRange + rsVarRange + ']');

   277 

   278   /** Used to detect strings that need a more robust regexp to match words. */

   279   var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;

   280 

   281   /** Used to assign default `context` object properties. */

   282   var contextProps = [

   283     'Array', 'Buffer', 'DataView', 'Date', 'Error', 'Float32Array', 'Float64Array',

   284     'Function', 'Int8Array', 'Int16Array', 'Int32Array', 'Map', 'Math', 'Object',

   285     'Promise', 'RegExp', 'Set', 'String', 'Symbol', 'TypeError', 'Uint8Array',

   286     'Uint8ClampedArray', 'Uint16Array', 'Uint32Array', 'WeakMap',

   287     '_', 'clearTimeout', 'isFinite', 'parseInt', 'setTimeout'

   288   ];

   289 

   290   /** Used to make template sourceURLs easier to identify. */

   291   var templateCounter = -1;

   292 

   293   /** Used to identify `toStringTag` values of typed arrays. */

   294   var typedArrayTags = {};

   295   typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =

   296   typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =

   297   typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =

   298   typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =

   299   typedArrayTags[uint32Tag] = true;

   300   typedArrayTags[argsTag] = typedArrayTags[arrayTag] =

   301   typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =

   302   typedArrayTags[dataViewTag] = typedArrayTags[dateTag] =

   303   typedArrayTags[errorTag] = typedArrayTags[funcTag] =

   304   typedArrayTags[mapTag] = typedArrayTags[numberTag] =

   305   typedArrayTags[objectTag] = typedArrayTags[regexpTag] =

   306   typedArrayTags[setTag] = typedArrayTags[stringTag] =

   307   typedArrayTags[weakMapTag] = false;

   308 

   309   /** Used to identify `toStringTag` values supported by `_.clone`. */

   310   var cloneableTags = {};

   311   cloneableTags[argsTag] = cloneableTags[arrayTag] =

   312   cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =

   313   cloneableTags[boolTag] = cloneableTags[dateTag] =

   314   cloneableTags[float32Tag] = cloneableTags[float64Tag] =

   315   cloneableTags[int8Tag] = cloneableTags[int16Tag] =

   316   cloneableTags[int32Tag] = cloneableTags[mapTag] =

   317   cloneableTags[numberTag] = cloneableTags[objectTag] =

   318   cloneableTags[regexpTag] = cloneableTags[setTag] =

   319   cloneableTags[stringTag] = cloneableTags[symbolTag] =

   320   cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =

   321   cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;

   322   cloneableTags[errorTag] = cloneableTags[funcTag] =

   323   cloneableTags[weakMapTag] = false;

   324 

   325   /** Used to map Latin Unicode letters to basic Latin letters. */

   326   var deburredLetters = {

   327     // Latin-1 Supplement block.

   328     '\xc0': 'A',  '\xc1': 'A', '\xc2': 'A', '\xc3': 'A', '\xc4': 'A', '\xc5': 'A',

   329     '\xe0': 'a',  '\xe1': 'a', '\xe2': 'a', '\xe3': 'a', '\xe4': 'a', '\xe5': 'a',

   330     '\xc7': 'C',  '\xe7': 'c',

   331     '\xd0': 'D',  '\xf0': 'd',

   332     '\xc8': 'E',  '\xc9': 'E', '\xca': 'E', '\xcb': 'E',

   333     '\xe8': 'e',  '\xe9': 'e', '\xea': 'e', '\xeb': 'e',

   334     '\xcc': 'I',  '\xcd': 'I', '\xce': 'I', '\xcf': 'I',

   335     '\xec': 'i',  '\xed': 'i', '\xee': 'i', '\xef': 'i',

   336     '\xd1': 'N',  '\xf1': 'n',

   337     '\xd2': 'O',  '\xd3': 'O', '\xd4': 'O', '\xd5': 'O', '\xd6': 'O', '\xd8': 'O',

   338     '\xf2': 'o',  '\xf3': 'o', '\xf4': 'o', '\xf5': 'o', '\xf6': 'o', '\xf8': 'o',

   339     '\xd9': 'U',  '\xda': 'U', '\xdb': 'U', '\xdc': 'U',

   340     '\xf9': 'u',  '\xfa': 'u', '\xfb': 'u', '\xfc': 'u',

   341     '\xdd': 'Y',  '\xfd': 'y', '\xff': 'y',

   342     '\xc6': 'Ae', '\xe6': 'ae',

   343     '\xde': 'Th', '\xfe': 'th',

   344     '\xdf': 'ss',

   345     // Latin Extended-A block.

   346     '\u0100': 'A',  '\u0102': 'A', '\u0104': 'A',

   347     '\u0101': 'a',  '\u0103': 'a', '\u0105': 'a',

   348     '\u0106': 'C',  '\u0108': 'C', '\u010a': 'C', '\u010c': 'C',

   349     '\u0107': 'c',  '\u0109': 'c', '\u010b': 'c', '\u010d': 'c',

   350     '\u010e': 'D',  '\u0110': 'D', '\u010f': 'd', '\u0111': 'd',

   351     '\u0112': 'E',  '\u0114': 'E', '\u0116': 'E', '\u0118': 'E', '\u011a': 'E',

   352     '\u0113': 'e',  '\u0115': 'e', '\u0117': 'e', '\u0119': 'e', '\u011b': 'e',

   353     '\u011c': 'G',  '\u011e': 'G', '\u0120': 'G', '\u0122': 'G',

   354     '\u011d': 'g',  '\u011f': 'g', '\u0121': 'g', '\u0123': 'g',

   355     '\u0124': 'H',  '\u0126': 'H', '\u0125': 'h', '\u0127': 'h',

   356     '\u0128': 'I',  '\u012a': 'I', '\u012c': 'I', '\u012e': 'I', '\u0130': 'I',

   357     '\u0129': 'i',  '\u012b': 'i', '\u012d': 'i', '\u012f': 'i', '\u0131': 'i',

   358     '\u0134': 'J',  '\u0135': 'j',

   359     '\u0136': 'K',  '\u0137': 'k', '\u0138': 'k',

   360     '\u0139': 'L',  '\u013b': 'L', '\u013d': 'L', '\u013f': 'L', '\u0141': 'L',

   361     '\u013a': 'l',  '\u013c': 'l', '\u013e': 'l', '\u0140': 'l', '\u0142': 'l',

   362     '\u0143': 'N',  '\u0145': 'N', '\u0147': 'N', '\u014a': 'N',

   363     '\u0144': 'n',  '\u0146': 'n', '\u0148': 'n', '\u014b': 'n',

   364     '\u014c': 'O',  '\u014e': 'O', '\u0150': 'O',

   365     '\u014d': 'o',  '\u014f': 'o', '\u0151': 'o',

   366     '\u0154': 'R',  '\u0156': 'R', '\u0158': 'R',

   367     '\u0155': 'r',  '\u0157': 'r', '\u0159': 'r',

   368     '\u015a': 'S',  '\u015c': 'S', '\u015e': 'S', '\u0160': 'S',

   369     '\u015b': 's',  '\u015d': 's', '\u015f': 's', '\u0161': 's',

   370     '\u0162': 'T',  '\u0164': 'T', '\u0166': 'T',

   371     '\u0163': 't',  '\u0165': 't', '\u0167': 't',

   372     '\u0168': 'U',  '\u016a': 'U', '\u016c': 'U', '\u016e': 'U', '\u0170': 'U', '\u0172': 'U',

   373     '\u0169': 'u',  '\u016b': 'u', '\u016d': 'u', '\u016f': 'u', '\u0171': 'u', '\u0173': 'u',

   374     '\u0174': 'W',  '\u0175': 'w',

   375     '\u0176': 'Y',  '\u0177': 'y', '\u0178': 'Y',

   376     '\u0179': 'Z',  '\u017b': 'Z', '\u017d': 'Z',

   377     '\u017a': 'z',  '\u017c': 'z', '\u017e': 'z',

   378     '\u0132': 'IJ', '\u0133': 'ij',

   379     '\u0152': 'Oe', '\u0153': 'oe',

   380     '\u0149': "'n", '\u017f': 's'

   381   };

   382 

   383   /** Used to map characters to HTML entities. */

   384   var htmlEscapes = {

   385     '&': '&',

   386     '<': '&lt;',

   387     '>': '>',

   388     '"': '"',

   389     "'": '''

   390   };

   391 

   392   /** Used to map HTML entities to characters. */

   393   var htmlUnescapes = {

   394     '&': '&',

   395     '&lt;': '<',

   396     '>': '>',

   397     '"': '"',

   398     ''': "'"

   399   };

   400 

   401   /** Used to escape characters for inclusion in compiled string literals. */

   402   var stringEscapes = {

   403     '\\': '\\',

   404     "'": "'",

   405     '\n': 'n',

   406     '\r': 'r',

   407     '\u2028': 'u2028',

   408     '\u2029': 'u2029'

   409   };

   410 

   411   /** Built-in method references without a dependency on `root`. */

   412   var freeParseFloat = parseFloat,

   413       freeParseInt = parseInt;

   414 

   415   /** Detect free variable `global` from Node.js. */

   416   var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;

   417 

   418   /** Detect free variable `self`. */

   419   var freeSelf = typeof self == 'object' && self && self.Object === Object && self;

   420 

   421   /** Used as a reference to the global object. */

   422   var root = freeGlobal || freeSelf || Function('return this')();

   423 

   424   /** Detect free variable `exports`. */

   425   var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;

   426 

   427   /** Detect free variable `module`. */

   428   var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;

   429 

   430   /** Detect the popular CommonJS extension `module.exports`. */

   431   var moduleExports = freeModule && freeModule.exports === freeExports;

   432 

   433   /** Detect free variable `process` from Node.js. */

   434   var freeProcess = moduleExports && freeGlobal.process;

   435 

   436   /** Used to access faster Node.js helpers. */

   437   var nodeUtil = (function() {

   438     try {

   439       // Use `util.types` for Node.js 10+.

   440       var types = freeModule && freeModule.require && freeModule.require('util').types;

   441 

   442       if (types) {

   443         return types;

   444       }

   445 

   446       // Legacy `process.binding('util')` for Node.js < 10.

   447       return freeProcess && freeProcess.binding && freeProcess.binding('util');

   448     } catch (e) {}

   449   }());

   450 

   451   /* Node.js helper references. */

   452   var nodeIsArrayBuffer = nodeUtil && nodeUtil.isArrayBuffer,

   453       nodeIsDate = nodeUtil && nodeUtil.isDate,

   454       nodeIsMap = nodeUtil && nodeUtil.isMap,

   455       nodeIsRegExp = nodeUtil && nodeUtil.isRegExp,

   456       nodeIsSet = nodeUtil && nodeUtil.isSet,

   457       nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;

   458 

   459   /*--------------------------------------------------------------------------*/

   460 

   461   /**

   462    * A faster alternative to `Function#apply`, this function invokes `func`

   463    * with the `this` binding of `thisArg` and the arguments of `args`.

   464    *

   465    * @private

   466    * @param {Function} func The function to invoke.

   467    * @param {*} thisArg The `this` binding of `func`.

   468    * @param {Array} args The arguments to invoke `func` with.

   469    * @returns {*} Returns the result of `func`.

   470    */

   471   function apply(func, thisArg, args) {

   472     switch (args.length) {

   473       case 0: return func.call(thisArg);

   474       case 1: return func.call(thisArg, args[0]);

   475       case 2: return func.call(thisArg, args[0], args[1]);

   476       case 3: return func.call(thisArg, args[0], args[1], args[2]);

   477     }

   478     return func.apply(thisArg, args);

   479   }

   480 

   481   /**

   482    * A specialized version of `baseAggregator` for arrays.

   483    *

   484    * @private

   485    * @param {Array} [array] The array to iterate over.

   486    * @param {Function} setter The function to set `accumulator` values.

   487    * @param {Function} iteratee The iteratee to transform keys.

   488    * @param {Object} accumulator The initial aggregated object.

   489    * @returns {Function} Returns `accumulator`.

   490    */

   491   function arrayAggregator(array, setter, iteratee, accumulator) {

   492     var index = -1,

   493         length = array == null ? 0 : array.length;

   494 

   495     while (++index < length) {

   496       var value = array[index];

   497       setter(accumulator, value, iteratee(value), array);

   498     }

   499     return accumulator;

   500   }

   501 

   502   /**

   503    * A specialized version of `_.forEach` for arrays without support for

   504    * iteratee shorthands.

   505    *

   506    * @private

   507    * @param {Array} [array] The array to iterate over.

   508    * @param {Function} iteratee The function invoked per iteration.

   509    * @returns {Array} Returns `array`.

   510    */

   511   function arrayEach(array, iteratee) {

   512     var index = -1,

   513         length = array == null ? 0 : array.length;

   514 

   515     while (++index < length) {

   516       if (iteratee(array[index], index, array) === false) {

   517         break;

   518       }

   519     }

   520     return array;

   521   }

   522 

   523   /**

   524    * A specialized version of `_.forEachRight` for arrays without support for

   525    * iteratee shorthands.

   526    *

   527    * @private

   528    * @param {Array} [array] The array to iterate over.

   529    * @param {Function} iteratee The function invoked per iteration.

   530    * @returns {Array} Returns `array`.

   531    */

   532   function arrayEachRight(array, iteratee) {

   533     var length = array == null ? 0 : array.length;

   534 

   535     while (length--) {

   536       if (iteratee(array[length], length, array) === false) {

   537         break;

   538       }

   539     }

   540     return array;

   541   }

   542 

   543   /**

   544    * A specialized version of `_.every` for arrays without support for

   545    * iteratee shorthands.

   546    *

   547    * @private

   548    * @param {Array} [array] The array to iterate over.

   549    * @param {Function} predicate The function invoked per iteration.

   550    * @returns {boolean} Returns `true` if all elements pass the predicate check,

   551    *  else `false`.

   552    */

   553   function arrayEvery(array, predicate) {

   554     var index = -1,

   555         length = array == null ? 0 : array.length;

   556 

   557     while (++index < length) {

   558       if (!predicate(array[index], index, array)) {

   559         return false;

   560       }

   561     }

   562     return true;

   563   }

   564 

   565   /**

   566    * A specialized version of `_.filter` for arrays without support for

   567    * iteratee shorthands.

   568    *

   569    * @private

   570    * @param {Array} [array] The array to iterate over.

   571    * @param {Function} predicate The function invoked per iteration.

   572    * @returns {Array} Returns the new filtered array.

   573    */

   574   function arrayFilter(array, predicate) {

   575     var index = -1,

   576         length = array == null ? 0 : array.length,

   577         resIndex = 0,

   578         result = [];

   579 

   580     while (++index < length) {

   581       var value = array[index];

   582       if (predicate(value, index, array)) {

   583         result[resIndex++] = value;

   584       }

   585     }

   586     return result;

   587   }

   588 

   589   /**

   590    * A specialized version of `_.includes` for arrays without support for

   591    * specifying an index to search from.

   592    *

   593    * @private

   594    * @param {Array} [array] The array to inspect.

   595    * @param {*} target The value to search for.

   596    * @returns {boolean} Returns `true` if `target` is found, else `false`.

   597    */

   598   function arrayIncludes(array, value) {

   599     var length = array == null ? 0 : array.length;

   600     return !!length && baseIndexOf(array, value, 0) > -1;

   601   }

   602 

   603   /**

   604    * This function is like `arrayIncludes` except that it accepts a comparator.

   605    *

   606    * @private

   607    * @param {Array} [array] The array to inspect.

   608    * @param {*} target The value to search for.

   609    * @param {Function} comparator The comparator invoked per element.

   610    * @returns {boolean} Returns `true` if `target` is found, else `false`.

   611    */

   612   function arrayIncludesWith(array, value, comparator) {

   613     var index = -1,

   614         length = array == null ? 0 : array.length;

   615 

   616     while (++index < length) {

   617       if (comparator(value, array[index])) {

   618         return true;

   619       }

   620     }

   621     return false;

   622   }

   623 

   624   /**

   625    * A specialized version of `_.map` for arrays without support for iteratee

   626    * shorthands.

   627    *

   628    * @private

   629    * @param {Array} [array] The array to iterate over.

   630    * @param {Function} iteratee The function invoked per iteration.

   631    * @returns {Array} Returns the new mapped array.

   632    */

   633   function arrayMap(array, iteratee) {

   634     var index = -1,

   635         length = array == null ? 0 : array.length,

   636         result = Array(length);

   637 

   638     while (++index < length) {

   639       result[index] = iteratee(array[index], index, array);

   640     }

   641     return result;

   642   }

   643 

   644   /**

   645    * Appends the elements of `values` to `array`.

   646    *

   647    * @private

   648    * @param {Array} array The array to modify.

   649    * @param {Array} values The values to append.

   650    * @returns {Array} Returns `array`.

   651    */

   652   function arrayPush(array, values) {

   653     var index = -1,

   654         length = values.length,

   655         offset = array.length;

   656 

   657     while (++index < length) {

   658       array[offset + index] = values[index];

   659     }

   660     return array;

   661   }

   662 

   663   /**

   664    * A specialized version of `_.reduce` for arrays without support for

   665    * iteratee shorthands.

   666    *

   667    * @private

   668    * @param {Array} [array] The array to iterate over.

   669    * @param {Function} iteratee The function invoked per iteration.

   670    * @param {*} [accumulator] The initial value.

   671    * @param {boolean} [initAccum] Specify using the first element of `array` as

   672    *  the initial value.

   673    * @returns {*} Returns the accumulated value.

   674    */

   675   function arrayReduce(array, iteratee, accumulator, initAccum) {

   676     var index = -1,

   677         length = array == null ? 0 : array.length;

   678 

   679     if (initAccum && length) {

   680       accumulator = array[++index];

   681     }

   682     while (++index < length) {

   683       accumulator = iteratee(accumulator, array[index], index, array);

   684     }

   685     return accumulator;

   686   }

   687 

   688   /**

   689    * A specialized version of `_.reduceRight` for arrays without support for

   690    * iteratee shorthands.

   691    *

   692    * @private

   693    * @param {Array} [array] The array to iterate over.

   694    * @param {Function} iteratee The function invoked per iteration.

   695    * @param {*} [accumulator] The initial value.

   696    * @param {boolean} [initAccum] Specify using the last element of `array` as

   697    *  the initial value.

   698    * @returns {*} Returns the accumulated value.

   699    */

   700   function arrayReduceRight(array, iteratee, accumulator, initAccum) {

   701     var length = array == null ? 0 : array.length;

   702     if (initAccum && length) {

   703       accumulator = array[--length];

   704     }

   705     while (length--) {

   706       accumulator = iteratee(accumulator, array[length], length, array);

   707     }

   708     return accumulator;

   709   }

   710 

   711   /**

   712    * A specialized version of `_.some` for arrays without support for iteratee

   713    * shorthands.

   714    *

   715    * @private

   716    * @param {Array} [array] The array to iterate over.

   717    * @param {Function} predicate The function invoked per iteration.

   718    * @returns {boolean} Returns `true` if any element passes the predicate check,

   719    *  else `false`.

   720    */

   721   function arraySome(array, predicate) {

   722     var index = -1,

   723         length = array == null ? 0 : array.length;

   724 

   725     while (++index < length) {

   726       if (predicate(array[index], index, array)) {

   727         return true;

   728       }

   729     }

   730     return false;

   731   }

   732 

   733   /**

   734    * Gets the size of an ASCII `string`.

   735    *

   736    * @private

   737    * @param {string} string The string inspect.

   738    * @returns {number} Returns the string size.

   739    */

   740   var asciiSize = baseProperty('length');

   741 

   742   /**

   743    * Converts an ASCII `string` to an array.

   744    *

   745    * @private

   746    * @param {string} string The string to convert.

   747    * @returns {Array} Returns the converted array.

   748    */

   749   function asciiToArray(string) {

   750     return string.split('');

   751   }

   752 

   753   /**

   754    * Splits an ASCII `string` into an array of its words.

   755    *

   756    * @private

   757    * @param {string} The string to inspect.

   758    * @returns {Array} Returns the words of `string`.

   759    */

   760   function asciiWords(string) {

   761     return string.match(reAsciiWord) || [];

   762   }

   763 

   764   /**

   765    * The base implementation of methods like `_.findKey` and `_.findLastKey`,

   766    * without support for iteratee shorthands, which iterates over `collection`

   767    * using `eachFunc`.

   768    *

   769    * @private

   770    * @param {Array|Object} collection The collection to inspect.

   771    * @param {Function} predicate The function invoked per iteration.

   772    * @param {Function} eachFunc The function to iterate over `collection`.

   773    * @returns {*} Returns the found element or its key, else `undefined`.

   774    */

   775   function baseFindKey(collection, predicate, eachFunc) {

   776     var result;

   777     eachFunc(collection, function(value, key, collection) {

   778       if (predicate(value, key, collection)) {

   779         result = key;

   780         return false;

   781       }

   782     });

   783     return result;

   784   }

   785 

   786   /**

   787    * The base implementation of `_.findIndex` and `_.findLastIndex` without

   788    * support for iteratee shorthands.

   789    *

   790    * @private

   791    * @param {Array} array The array to inspect.

   792    * @param {Function} predicate The function invoked per iteration.

   793    * @param {number} fromIndex The index to search from.

   794    * @param {boolean} [fromRight] Specify iterating from right to left.

   795    * @returns {number} Returns the index of the matched value, else `-1`.

   796    */

   797   function baseFindIndex(array, predicate, fromIndex, fromRight) {

   798     var length = array.length,

   799         index = fromIndex + (fromRight ? 1 : -1);

   800 

   801     while ((fromRight ? index-- : ++index < length)) {

   802       if (predicate(array[index], index, array)) {

   803         return index;

   804       }

   805     }

   806     return -1;

   807   }

   808 

   809   /**

   810    * The base implementation of `_.indexOf` without `fromIndex` bounds checks.

   811    *

   812    * @private

   813    * @param {Array} array The array to inspect.

   814    * @param {*} value The value to search for.

   815    * @param {number} fromIndex The index to search from.

   816    * @returns {number} Returns the index of the matched value, else `-1`.

   817    */

   818   function baseIndexOf(array, value, fromIndex) {

   819     return value === value

   820       ? strictIndexOf(array, value, fromIndex)

   821       : baseFindIndex(array, baseIsNaN, fromIndex);

   822   }

   823 

   824   /**

   825    * This function is like `baseIndexOf` except that it accepts a comparator.

   826    *

   827    * @private

   828    * @param {Array} array The array to inspect.

   829    * @param {*} value The value to search for.

   830    * @param {number} fromIndex The index to search from.

   831    * @param {Function} comparator The comparator invoked per element.

   832    * @returns {number} Returns the index of the matched value, else `-1`.

   833    */

   834   function baseIndexOfWith(array, value, fromIndex, comparator) {

   835     var index = fromIndex - 1,

   836         length = array.length;

   837 

   838     while (++index < length) {

   839       if (comparator(array[index], value)) {

   840         return index;

   841       }

   842     }

   843     return -1;

   844   }

   845 

   846   /**

   847    * The base implementation of `_.isNaN` without support for number objects.

   848    *

   849    * @private

   850    * @param {*} value The value to check.

   851    * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.

   852    */

   853   function baseIsNaN(value) {

   854     return value !== value;

   855   }

   856 

   857   /**

   858    * The base implementation of `_.mean` and `_.meanBy` without support for

   859    * iteratee shorthands.

   860    *

   861    * @private

   862    * @param {Array} array The array to iterate over.

   863    * @param {Function} iteratee The function invoked per iteration.

   864    * @returns {number} Returns the mean.

   865    */

   866   function baseMean(array, iteratee) {

   867     var length = array == null ? 0 : array.length;

   868     return length ? (baseSum(array, iteratee) / length) : NAN;

   869   }

   870 

   871   /**

   872    * The base implementation of `_.property` without support for deep paths.

   873    *

   874    * @private

   875    * @param {string} key The key of the property to get.

   876    * @returns {Function} Returns the new accessor function.

   877    */

   878   function baseProperty(key) {

   879     return function(object) {

   880       return object == null ? undefined : object[key];

   881     };

   882   }

   883 

   884   /**

   885    * The base implementation of `_.propertyOf` without support for deep paths.

   886    *

   887    * @private

   888    * @param {Object} object The object to query.

   889    * @returns {Function} Returns the new accessor function.

   890    */

   891   function basePropertyOf(object) {

   892     return function(key) {

   893       return object == null ? undefined : object[key];

   894     };

   895   }

   896 

   897   /**

   898    * The base implementation of `_.reduce` and `_.reduceRight`, without support

   899    * for iteratee shorthands, which iterates over `collection` using `eachFunc`.

   900    *

   901    * @private

   902    * @param {Array|Object} collection The collection to iterate over.

   903    * @param {Function} iteratee The function invoked per iteration.

   904    * @param {*} accumulator The initial value.

   905    * @param {boolean} initAccum Specify using the first or last element of

   906    *  `collection` as the initial value.

   907    * @param {Function} eachFunc The function to iterate over `collection`.

   908    * @returns {*} Returns the accumulated value.

   909    */

   910   function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) {

   911     eachFunc(collection, function(value, index, collection) {

   912       accumulator = initAccum

   913         ? (initAccum = false, value)

   914         : iteratee(accumulator, value, index, collection);

   915     });

   916     return accumulator;

   917   }

   918 

   919   /**

   920    * The base implementation of `_.sortBy` which uses `comparer` to define the

   921    * sort order of `array` and replaces criteria objects with their corresponding

   922    * values.

   923    *

   924    * @private

   925    * @param {Array} array The array to sort.

   926    * @param {Function} comparer The function to define sort order.

   927    * @returns {Array} Returns `array`.

   928    */

   929   function baseSortBy(array, comparer) {

   930     var length = array.length;

   931 

   932     array.sort(comparer);

   933     while (length--) {

   934       array[length] = array[length].value;

   935     }

   936     return array;

   937   }

   938 

   939   /**

   940    * The base implementation of `_.sum` and `_.sumBy` without support for

   941    * iteratee shorthands.

   942    *

   943    * @private

   944    * @param {Array} array The array to iterate over.

   945    * @param {Function} iteratee The function invoked per iteration.

   946    * @returns {number} Returns the sum.

   947    */

   948   function baseSum(array, iteratee) {

   949     var result,

   950         index = -1,

   951         length = array.length;

   952 

   953     while (++index < length) {

   954       var current = iteratee(array[index]);

   955       if (current !== undefined) {

   956         result = result === undefined ? current : (result + current);

   957       }

   958     }

   959     return result;

   960   }

   961 

   962   /**

   963    * The base implementation of `_.times` without support for iteratee shorthands

   964    * or max array length checks.

   965    *

   966    * @private

   967    * @param {number} n The number of times to invoke `iteratee`.

   968    * @param {Function} iteratee The function invoked per iteration.

   969    * @returns {Array} Returns the array of results.

   970    */

   971   function baseTimes(n, iteratee) {

   972     var index = -1,

   973         result = Array(n);

   974 

   975     while (++index < n) {

   976       result[index] = iteratee(index);

   977     }

   978     return result;

   979   }

   980 

   981   /**

   982    * The base implementation of `_.toPairs` and `_.toPairsIn` which creates an array

   983    * of key-value pairs for `object` corresponding to the property names of `props`.

   984    *

   985    * @private

   986    * @param {Object} object The object to query.

   987    * @param {Array} props The property names to get values for.

   988    * @returns {Object} Returns the key-value pairs.

   989    */

   990   function baseToPairs(object, props) {

   991     return arrayMap(props, function(key) {

   992       return [key, object[key]];

   993     });

   994   }

   995 

   996   /**

   997    * The base implementation of `_.unary` without support for storing metadata.

   998    *

   999    * @private

  1000    * @param {Function} func The function to cap arguments for.

  1001    * @returns {Function} Returns the new capped function.

  1002    */

  1003   function baseUnary(func) {

  1004     return function(value) {

  1005       return func(value);

  1006     };

  1007   }

  1008 

  1009   /**

  1010    * The base implementation of `_.values` and `_.valuesIn` which creates an

  1011    * array of `object` property values corresponding to the property names

  1012    * of `props`.

  1013    *

  1014    * @private

  1015    * @param {Object} object The object to query.

  1016    * @param {Array} props The property names to get values for.

  1017    * @returns {Object} Returns the array of property values.

  1018    */

  1019   function baseValues(object, props) {

  1020     return arrayMap(props, function(key) {

  1021       return object[key];

  1022     });

  1023   }

  1024 

  1025   /**

  1026    * Checks if a `cache` value for `key` exists.

  1027    *

  1028    * @private

  1029    * @param {Object} cache The cache to query.

  1030    * @param {string} key The key of the entry to check.

  1031    * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.

  1032    */

  1033   function cacheHas(cache, key) {

  1034     return cache.has(key);

  1035   }

  1036 

  1037   /**

  1038    * Used by `_.trim` and `_.trimStart` to get the index of the first string symbol

  1039    * that is not found in the character symbols.

  1040    *

  1041    * @private

  1042    * @param {Array} strSymbols The string symbols to inspect.

  1043    * @param {Array} chrSymbols The character symbols to find.

  1044    * @returns {number} Returns the index of the first unmatched string symbol.

  1045    */

  1046   function charsStartIndex(strSymbols, chrSymbols) {

  1047     var index = -1,

  1048         length = strSymbols.length;

  1049 

  1050     while (++index < length && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {}

  1051     return index;

  1052   }

  1053 

  1054   /**

  1055    * Used by `_.trim` and `_.trimEnd` to get the index of the last string symbol

  1056    * that is not found in the character symbols.

  1057    *

  1058    * @private

  1059    * @param {Array} strSymbols The string symbols to inspect.

  1060    * @param {Array} chrSymbols The character symbols to find.

  1061    * @returns {number} Returns the index of the last unmatched string symbol.

  1062    */

  1063   function charsEndIndex(strSymbols, chrSymbols) {

  1064     var index = strSymbols.length;

  1065 

  1066     while (index-- && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {}

  1067     return index;

  1068   }

  1069 

  1070   /**

  1071    * Gets the number of `placeholder` occurrences in `array`.

  1072    *

  1073    * @private

  1074    * @param {Array} array The array to inspect.

  1075    * @param {*} placeholder The placeholder to search for.

  1076    * @returns {number} Returns the placeholder count.

  1077    */

  1078   function countHolders(array, placeholder) {

  1079     var length = array.length,

  1080         result = 0;

  1081 

  1082     while (length--) {

  1083       if (array[length] === placeholder) {

  1084         ++result;

  1085       }

  1086     }

  1087     return result;

  1088   }

  1089 

  1090   /**

  1091    * Used by `_.deburr` to convert Latin-1 Supplement and Latin Extended-A

  1092    * letters to basic Latin letters.

  1093    *

  1094    * @private

  1095    * @param {string} letter The matched letter to deburr.

  1096    * @returns {string} Returns the deburred letter.

  1097    */

  1098   var deburrLetter = basePropertyOf(deburredLetters);

  1099 

  1100   /**

  1101    * Used by `_.escape` to convert characters to HTML entities.

  1102    *

  1103    * @private

  1104    * @param {string} chr The matched character to escape.

  1105    * @returns {string} Returns the escaped character.

  1106    */

  1107   var escapeHtmlChar = basePropertyOf(htmlEscapes);

  1108 

  1109   /**

  1110    * Used by `_.template` to escape characters for inclusion in compiled string literals.

  1111    *

  1112    * @private

  1113    * @param {string} chr The matched character to escape.

  1114    * @returns {string} Returns the escaped character.

  1115    */

  1116   function escapeStringChar(chr) {

  1117     return '\\' + stringEscapes[chr];

  1118   }

  1119 

  1120   /**

  1121    * Gets the value at `key` of `object`.

  1122    *

  1123    * @private

  1124    * @param {Object} [object] The object to query.

  1125    * @param {string} key The key of the property to get.

  1126    * @returns {*} Returns the property value.

  1127    */

  1128   function getValue(object, key) {

  1129     return object == null ? undefined : object[key];

  1130   }

  1131 

  1132   /**

  1133    * Checks if `string` contains Unicode symbols.

  1134    *

  1135    * @private