Fix: Corrige mensagem de erro de IP bloqueado no VideoMind quando o vídeo simplesmente não possui legendas

2026-06-05 20:56:39 +00:00
parent 7a2ba56699
commit 281005a8bc
1086 changed files with 46356 additions and 7 deletions
@@ -0,0 +1 @@
 ../he/bin/he
@@ -634,6 +634,15 @@
        "node": ">= 0.4"
      }
    },
    "node_modules/he": {
      "version": "1.2.0",
      "resolved": "https://registry.npmjs.org/he/-/he-1.2.0.tgz",
      "integrity": "sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==",
      "license": "MIT",
      "bin": {
        "he": "bin/he"
      }
    },
    "node_modules/http-errors": {
      "version": "2.0.1",
      "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.1.tgz",
@@ -746,6 +755,12 @@
        "ws": "*"
      }
    },
    "node_modules/lodash": {
      "version": "4.18.1",
      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.18.1.tgz",
      "integrity": "sha512-dMInicTPVE8d1e5otfwmmjlxkZoUpiVLwyeTdUsi/Caj/gfzzblBcCE5sRHV/AsjuCmxWrte2TNGSYuCeCq+0Q==",
      "license": "MIT"
    },
    "node_modules/math-intrinsics": {
      "version": "1.1.0",
      "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
@@ -1302,6 +1317,12 @@
        "safe-buffer": "~5.2.0"
      }
    },
    "node_modules/striptags": {
      "version": "3.2.0",
      "resolved": "https://registry.npmjs.org/striptags/-/striptags-3.2.0.tgz",
      "integrity": "sha512-g45ZOGzHDMe2bdYMdIvdAfCQkCTDMGBazSw1ypMowwGIee7ZQ5dU0rBJ8Jqgl+jAKIv4dbeE1jscZq9wid1Tkw==",
      "license": "MIT"
    },
    "node_modules/toidentifier": {
      "version": "1.0.1",
      "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz",
@@ -1393,6 +1414,18 @@
        "node": ">=0.4"
      }
    },
    "node_modules/youtube-captions-scraper": {
      "version": "2.0.3",
      "resolved": "https://registry.npmjs.org/youtube-captions-scraper/-/youtube-captions-scraper-2.0.3.tgz",
      "integrity": "sha512-XT6U5wFq35P5G99M+2uwNzJFkmGUrb38u8lMMQkv9PpfTOtG8Lpotka7jEqbDnQBshDw6/hgLQV597/tldiyUg==",
      "license": "MIT",
      "dependencies": {
        "axios": "^1.6.7",
        "he": "^1.1.1",
        "lodash": "^4.17.4",
        "striptags": "^3.1.0"
      }
    },
    "node_modules/youtube-transcript": {
      "version": "1.3.1",
      "resolved": "https://registry.npmjs.org/youtube-transcript/-/youtube-transcript-1.3.1.tgz",
@@ -0,0 +1,20 @@
 Copyright Mathias Bynens <https://mathiasbynens.be/>
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
 "Software"), to deal in the Software without restriction, including
 without limitation the rights to use, copy, modify, merge, publish,
 distribute, sublicense, and/or sell copies of the Software, and to
 permit persons to whom the Software is furnished to do so, subject to
 the following conditions:
 The above copyright notice and this permission notice shall be
 included in all copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
@@ -0,0 +1,379 @@
 # he [![Build status](https://travis-ci.org/mathiasbynens/he.svg?branch=master)](https://travis-ci.org/mathiasbynens/he) [![Code coverage status](https://codecov.io/github/mathiasbynens/he/coverage.svg?branch=master)](https://codecov.io/github/mathiasbynens/he?branch=master) [![Dependency status](https://gemnasium.com/mathiasbynens/he.svg)](https://gemnasium.com/mathiasbynens/he)
 _he_ (for “HTML entities”) is a robust HTML entity encoder/decoder written in JavaScript. It supports [all standardized named character references as per HTML](https://html.spec.whatwg.org/multipage/syntax.html#named-character-references), handles [ambiguous ampersands](https://mathiasbynens.be/notes/ambiguous-ampersands) and other edge cases [just like a browser would](https://html.spec.whatwg.org/multipage/syntax.html#tokenizing-character-references), has an extensive test suite, and — contrary to many other JavaScript solutions — _he_ handles astral Unicode symbols just fine. [An online demo is available.](https://mothereff.in/html-entities)
 ## Installation
 Via [npm](https://www.npmjs.com/):
 ```bash
 npm install he
 ```
 Via [Bower](http://bower.io/):
 ```bash
 bower install he
 ```
 Via [Component](https://github.com/component/component):
 ```bash
 component install mathiasbynens/he
 ```
 In a browser:
 ```html
 <script src="he.js"></script>
 ```
 In [Node.js](https://nodejs.org/), [io.js](https://iojs.org/), [Narwhal](http://narwhaljs.org/), and [RingoJS](http://ringojs.org/):
 ```js
 var he = require('he');
 ```
 In [Rhino](http://www.mozilla.org/rhino/):
 ```js
 load('he.js');
 ```
 Using an AMD loader like [RequireJS](http://requirejs.org/):
 ```js
 require(
  {
    'paths': {
      'he': 'path/to/he'
    }
  },
  ['he'],
  function(he) {
    console.log(he);
  }
 );
 ```
 ## API
 ### `he.version`
 A string representing the semantic version number.
 ### `he.encode(text, options)`
 This function takes a string of text and encodes (by default) any symbols that aren’t printable ASCII symbols and `&`, `<`, `>`, `"`, `'`, and `` ` ``, replacing them with character references.
 ```js
 he.encode('foo © bar ≠ baz 𝌆 qux');
 // → 'foo &#xA9; bar &#x2260; baz &#x1D306; qux'
 ```
 As long as the input string contains [allowed code points](https://html.spec.whatwg.org/multipage/parsing.html#preprocessing-the-input-stream) only, the return value of this function is always valid HTML. Any [(invalid) code points that cannot be represented using a character reference](https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides) in the input are not encoded:
 ```js
 he.encode('foo \0 bar');
 // → 'foo \0 bar'
 ```
 However, enabling [the `strict` option](https://github.com/mathiasbynens/he#strict) causes invalid code points to throw an exception. With `strict` enabled, `he.encode` either throws (if the input contains invalid code points) or returns a string of valid HTML.
 The `options` object is optional. It recognizes the following properties:
 #### `useNamedReferences`
 The default value for the `useNamedReferences` option is `false`. This means that `encode()` will not use any named character references (e.g. `&copy;`) in the output — hexadecimal escapes (e.g. `&#xA9;`) will be used instead. Set it to `true` to enable the use of named references.
 **Note that if compatibility with older browsers is a concern, this option should remain disabled.**
 ```js
 // Using the global default setting (defaults to `false`):
 he.encode('foo © bar ≠ baz 𝌆 qux');
 // → 'foo &#xA9; bar &#x2260; baz &#x1D306; qux'
 // Passing an `options` object to `encode`, to explicitly disallow named references:
 he.encode('foo © bar ≠ baz 𝌆 qux', {
  'useNamedReferences': false
 });
 // → 'foo &#xA9; bar &#x2260; baz &#x1D306; qux'
 // Passing an `options` object to `encode`, to explicitly allow named references:
 he.encode('foo © bar ≠ baz 𝌆 qux', {
  'useNamedReferences': true
 });
 // → 'foo &copy; bar &ne; baz &#x1D306; qux'
 ```
 #### `decimal`
 The default value for the `decimal` option is `false`. If the option is enabled, `encode` will generally use decimal escapes (e.g. `&#169;`) rather than hexadecimal escapes (e.g. `&#xA9;`). Beside of this replacement, the basic behavior remains the same when combined with other options. For example: if both options `useNamedReferences` and `decimal` are enabled, named references (e.g. `&copy;`) are used over decimal escapes. HTML entities without a named reference are encoded using decimal escapes.
 ```js
 // Using the global default setting (defaults to `false`):
 he.encode('foo © bar ≠ baz 𝌆 qux');
 // → 'foo &#xA9; bar &#x2260; baz &#x1D306; qux'
 // Passing an `options` object to `encode`, to explicitly disable decimal escapes:
 he.encode('foo © bar ≠ baz 𝌆 qux', {
  'decimal': false
 });
 // → 'foo &#xA9; bar &#x2260; baz &#x1D306; qux'
 // Passing an `options` object to `encode`, to explicitly enable decimal escapes:
 he.encode('foo © bar ≠ baz 𝌆 qux', {
  'decimal': true
 });
 // → 'foo &#169; bar &#8800; baz &#119558; qux'
 // Passing an `options` object to `encode`, to explicitly allow named references and decimal escapes:
 he.encode('foo © bar ≠ baz 𝌆 qux', {
  'useNamedReferences': true,
  'decimal': true
 });
 // → 'foo &copy; bar &ne; baz &#119558; qux'
 ```
 #### `encodeEverything`
 The default value for the `encodeEverything` option is `false`. This means that `encode()` will not use any character references for printable ASCII symbols that don’t need escaping. Set it to `true` to encode every symbol in the input string. When set to `true`, this option takes precedence over `allowUnsafeSymbols` (i.e. setting the latter to `true` in such a case has no effect).
 ```js
 // Using the global default setting (defaults to `false`):
 he.encode('foo © bar ≠ baz 𝌆 qux');
 // → 'foo &#xA9; bar &#x2260; baz &#x1D306; qux'
 // Passing an `options` object to `encode`, to explicitly encode all symbols:
 he.encode('foo © bar ≠ baz 𝌆 qux', {
  'encodeEverything': true
 });
 // → '&#x66;&#x6F;&#x6F;&#x20;&#xA9;&#x20;&#x62;&#x61;&#x72;&#x20;&#x2260;&#x20;&#x62;&#x61;&#x7A;&#x20;&#x1D306;&#x20;&#x71;&#x75;&#x78;'
 // This setting can be combined with the `useNamedReferences` option:
 he.encode('foo © bar ≠ baz 𝌆 qux', {
  'encodeEverything': true,
  'useNamedReferences': true
 });
 // → '&#x66;&#x6F;&#x6F;&#x20;&copy;&#x20;&#x62;&#x61;&#x72;&#x20;&ne;&#x20;&#x62;&#x61;&#x7A;&#x20;&#x1D306;&#x20;&#x71;&#x75;&#x78;'
 ```
 #### `strict`
 The default value for the `strict` option is `false`. This means that `encode()` will encode any HTML text content you feed it, even if it contains any symbols that cause [parse errors](https://html.spec.whatwg.org/multipage/parsing.html#preprocessing-the-input-stream). To throw an error when such invalid HTML is encountered, set the `strict` option to `true`. This option makes it possible to use _he_ as part of HTML parsers and HTML validators.
 ```js
 // Using the global default setting (defaults to `false`, i.e. error-tolerant mode):
 he.encode('\x01');
 // → '&#x1;'
 // Passing an `options` object to `encode`, to explicitly enable error-tolerant mode:
 he.encode('\x01', {
  'strict': false
 });
 // → '&#x1;'
 // Passing an `options` object to `encode`, to explicitly enable strict mode:
 he.encode('\x01', {
  'strict': true
 });
 // → Parse error
 ```
 #### `allowUnsafeSymbols`
 The default value for the `allowUnsafeSymbols` option is `false`. This means that characters that are unsafe for use in HTML content (`&`, `<`, `>`, `"`, `'`, and `` ` ``) will be encoded. When set to `true`, only non-ASCII characters will be encoded. If the `encodeEverything` option is set to `true`, this option will be ignored.
 ```js
 he.encode('foo © and & ampersand', {
  'allowUnsafeSymbols': true
 });
 // → 'foo &#xA9; and & ampersand'
 ```
 #### Overriding default `encode` options globally
 The global default setting can be overridden by modifying the `he.encode.options` object. This saves you from passing in an `options` object for every call to `encode` if you want to use the non-default setting.
 ```js
 // Read the global default setting:
 he.encode.options.useNamedReferences;
 // → `false` by default
 // Override the global default setting:
 he.encode.options.useNamedReferences = true;
 // Using the global default setting, which is now `true`:
 he.encode('foo © bar ≠ baz 𝌆 qux');
 // → 'foo &copy; bar &ne; baz &#x1D306; qux'
 ```
 ### `he.decode(html, options)`
 This function takes a string of HTML and decodes any named and numerical character references in it using [the algorithm described in section 12.2.4.69 of the HTML spec](https://html.spec.whatwg.org/multipage/syntax.html#tokenizing-character-references).
 ```js
 he.decode('foo &copy; bar &ne; baz &#x1D306; qux');
 // → 'foo © bar ≠ baz 𝌆 qux'
 ```
 The `options` object is optional. It recognizes the following properties:
 #### `isAttributeValue`
 The default value for the `isAttributeValue` option is `false`. This means that `decode()` will decode the string as if it were used in [a text context in an HTML document](https://html.spec.whatwg.org/multipage/syntax.html#data-state). HTML has different rules for [parsing character references in attribute values](https://html.spec.whatwg.org/multipage/syntax.html#character-reference-in-attribute-value-state) — set this option to `true` to treat the input string as if it were used as an attribute value.
 ```js
 // Using the global default setting (defaults to `false`, i.e. HTML text context):
 he.decode('foo&ampbar');
 // → 'foo&bar'
 // Passing an `options` object to `decode`, to explicitly assume an HTML text context:
 he.decode('foo&ampbar', {
  'isAttributeValue': false
 });
 // → 'foo&bar'
 // Passing an `options` object to `decode`, to explicitly assume an HTML attribute value context:
 he.decode('foo&ampbar', {
  'isAttributeValue': true
 });
 // → 'foo&ampbar'
 ```
 #### `strict`
 The default value for the `strict` option is `false`. This means that `decode()` will decode any HTML text content you feed it, even if it contains any entities that cause [parse errors](https://html.spec.whatwg.org/multipage/syntax.html#tokenizing-character-references). To throw an error when such invalid HTML is encountered, set the `strict` option to `true`. This option makes it possible to use _he_ as part of HTML parsers and HTML validators.
 ```js
 // Using the global default setting (defaults to `false`, i.e. error-tolerant mode):
 he.decode('foo&ampbar');
 // → 'foo&bar'
 // Passing an `options` object to `decode`, to explicitly enable error-tolerant mode:
 he.decode('foo&ampbar', {
  'strict': false
 });
 // → 'foo&bar'
 // Passing an `options` object to `decode`, to explicitly enable strict mode:
 he.decode('foo&ampbar', {
  'strict': true
 });
 // → Parse error
 ```
 #### Overriding default `decode` options globally
 The global default settings for the `decode` function can be overridden by modifying the `he.decode.options` object. This saves you from passing in an `options` object for every call to `decode` if you want to use a non-default setting.
 ```js
 // Read the global default setting:
 he.decode.options.isAttributeValue;
 // → `false` by default
 // Override the global default setting:
 he.decode.options.isAttributeValue = true;
 // Using the global default setting, which is now `true`:
 he.decode('foo&ampbar');
 // → 'foo&ampbar'
 ```
 ### `he.escape(text)`
 This function takes a string of text and escapes it for use in text contexts in XML or HTML documents. Only the following characters are escaped: `&`, `<`, `>`, `"`, `'`, and `` ` ``.
 ```js
 he.escape('<img src=\'x\' onerror="prompt(1)">');
 // → '&lt;img src=&#x27;x&#x27; onerror=&quot;prompt(1)&quot;&gt;'
 ```
 ### `he.unescape(html, options)`
 `he.unescape` is an alias for `he.decode`. It takes a string of HTML and decodes any named and numerical character references in it.
 ### Using the `he` binary
 To use the `he` binary in your shell, simply install _he_ globally using npm:
 ```bash
 npm install -g he
 ```
 After that you will be able to encode/decode HTML entities from the command line:
 ```bash
 $ he --encode 'föo ♥ bår 𝌆 baz'
 f&#xF6;o &#x2665; b&#xE5;r &#x1D306; baz
 $ he --encode --use-named-refs 'föo ♥ bår 𝌆 baz'
 f&ouml;o &hearts; b&aring;r &#x1D306; baz
 $ he --decode 'f&ouml;o &hearts; b&aring;r &#x1D306; baz'
 föo ♥ bår 𝌆 baz
 ```
 Read a local text file, encode it for use in an HTML text context, and save the result to a new file:
 ```bash
 $ he --encode < foo.txt > foo-escaped.html
 ```
 Or do the same with an online text file:
 ```bash
 $ curl -sL "http://git.io/HnfEaw" | he --encode > escaped.html
 ```
 Or, the opposite — read a local file containing a snippet of HTML in a text context, decode it back to plain text, and save the result to a new file:
 ```bash
 $ he --decode < foo-escaped.html > foo.txt
 ```
 Or do the same with an online HTML snippet:
 ```bash
 $ curl -sL "http://git.io/HnfEaw" | he --decode > decoded.txt
 ```
 See `he --help` for the full list of options.
 ## Support
 _he_ has been tested in at least:
 * Chrome 27-50
 * Firefox 3-45
 * Safari 4-9
 * Opera 10-12, 15–37
 * IE 6–11
 * Edge
 * Narwhal 0.3.2
 * Node.js v0.10, v0.12, v4, v5
 * PhantomJS 1.9.0
 * Rhino 1.7RC4
 * RingoJS 0.8-0.11
 ## Unit tests & code coverage
 After cloning this repository, run `npm install` to install the dependencies needed for he development and testing. You may want to install Istanbul _globally_ using `npm install istanbul -g`.
 Once that’s done, you can run the unit tests in Node using `npm test` or `node tests/tests.js`. To run the tests in Rhino, Ringo, Narwhal, and web browsers as well, use `grunt test`.
 To generate the code coverage report, use `grunt cover`.
 ## Acknowledgements
 Thanks to [Simon Pieters](https://simon.html5.org/) ([@zcorpan](https://twitter.com/zcorpan)) for the many suggestions.
 ## Author
 | [![twitter/mathias](https://gravatar.com/avatar/24e08a9ea84deb17ae121074d0f17125?s=70)](https://twitter.com/mathias "Follow @mathias on Twitter") |
 |---|
 | [Mathias Bynens](https://mathiasbynens.be/) |
 ## License
 _he_ is available under the [MIT](https://mths.be/mit) license.
@@ -0,0 +1,148 @@
 #!/usr/bin/env node
 (function() {
 	var fs = require('fs');
 	var he = require('../he.js');
 	var strings = process.argv.splice(2);
 	var stdin = process.stdin;
 	var data;
 	var timeout;
 	var action;
 	var options = {};
 	var log = console.log;
 	var main = function() {
 		var option = strings[0];
 		var count = 0;
 		if (/^(?:-h|--help|undefined)$/.test(option)) {
 			log(
 				'he v%s - https://mths.be/he',
 				he.version
 			);
 			log([
 				'\nUsage:\n',
 				'\the [--escape] string',
 				'\the [--encode] [--use-named-refs] [--everything] [--allow-unsafe] [--decimal] string',
 				'\the [--decode] [--attribute] [--strict] string',
 				'\the [-v | --version]',
 				'\the [-h | --help]',
 				'\nExamples:\n',
 				'\the --escape \\<img\\ src\\=\\\'x\\\'\\ onerror\\=\\"prompt\\(1\\)\\"\\>',
 				'\techo \'&copy; &#x1D306;\' | he --decode'
 			].join('\n'));
 			return process.exit(option ? 0 : 1);
 		}
 		if (/^(?:-v|--version)$/.test(option)) {
 			log('v%s', he.version);
 			return process.exit(0);
 		}
 		strings.forEach(function(string) {
 			// Process options
 			if (string == '--escape') {
 				action = 'escape';
 				return;
 			}
 			if (string == '--encode') {
 				action = 'encode';
 				return;
 			}
 			if (string == '--use-named-refs') {
 				action = 'encode';
 				options.useNamedReferences = true;
 				return;
 			}
 			if (string == '--everything') {
 				action = 'encode';
 				options.encodeEverything = true;
 				return;
 			}
 			if (string == '--allow-unsafe') {
 				action = 'encode';
 				options.allowUnsafeSymbols = true;
 				return;
 			}
 			if (string == '--decimal') {
 				action = 'encode';
 				options.decimal = true;
 				return;
 			}
 			if (string == '--decode') {
 				action = 'decode';
 				return;
 			}
 			if (string == '--attribute') {
 				action = 'decode';
 				options.isAttributeValue = true;
 				return;
 			}
 			if (string == '--strict') {
 				action = 'decode';
 				options.strict = true;
 				return;
 			}
 			// Process string(s)
 			var result;
 			if (!action) {
 				log('Error: he requires at least one option and a string argument.');
 				log('Try `he --help` for more information.');
 				return process.exit(1);
 			}
 			try {
 				result = he[action](string, options);
 				log(result);
 				count++;
 			} catch(error) {
 				log(error.message + '\n');
 				log('Error: failed to %s.', action);
 				log('If you think this is a bug in he, please report it:');
 				log('https://github.com/mathiasbynens/he/issues/new');
 				log(
 					'\nStack trace using he@%s:\n',
 					he.version
 				);
 				log(error.stack);
 				return process.exit(1);
 			}
 		});
 		if (!count) {
 			log('Error: he requires a string argument.');
 			log('Try `he --help` for more information.');
 			return process.exit(1);
 		}
 		// Return with exit status 0 outside of the `forEach` loop, in case
 		// multiple strings were passed in.
 		return process.exit(0);
 	};
 	if (stdin.isTTY) {
 		// handle shell arguments
 		main();
 	} else {
 		// Either the script is called from within a non-TTY context, or `stdin`
 		// content is being piped in.
 		if (!process.stdout.isTTY) {
 			// The script was called from a non-TTY context. This is a rather uncommon
 			// use case we don’t actively support. However, we don’t want the script
 			// to wait forever in such cases, so…
 			timeout = setTimeout(function() {
 				// …if no piped data arrived after a whole minute, handle shell
 				// arguments instead.
 				main();
 			}, 60000);
 		}
 		data = '';
 		stdin.on('data', function(chunk) {
 			clearTimeout(timeout);
 			data += chunk;
 		});
 		stdin.on('end', function() {
 			strings.push(data.trim());
 			main();
 		});
 		stdin.resume();
 	}
 }());
@@ -0,0 +1,78 @@
 .Dd April 5, 2016
 .Dt he 1
 .Sh NAME
 .Nm he
 .Nd encode/decode HTML entities just like a browser would
 .Sh SYNOPSIS
 .Nm
 .Op Fl -escape Ar string
 .br
 .Op Fl -encode Ar string
 .br
 .Op Fl -encode Fl -use-named-refs Fl -everything Fl -allow-unsafe Ar string
 .br
 .Op Fl -decode Ar string
 .br
 .Op Fl -decode Fl -attribute Ar string
 .br
 .Op Fl -decode Fl -strict Ar string
 .br
 .Op Fl v | -version
 .br
 .Op Fl h | -help
 .Sh DESCRIPTION
 .Nm
 encodes/decodes HTML entities in strings just like a browser would.
 .Sh OPTIONS
 .Bl -ohang -offset
 .It Sy "--escape"
 Take a string of text and escape it for use in text contexts in XML or HTML documents. Only the following characters are escaped: `&`, `<`, `>`, `"`, and `'`.
 .It Sy "--encode"
 Take a string of text and encode any symbols that aren't printable ASCII symbols and that can be replaced with character references. For example, it would turn `©` into `&#xA9;`, but it wouldn't turn `+` into `&#x2B;` since there is no point in doing so. Additionally, it replaces any remaining non-ASCII symbols with a hexadecimal escape sequence (e.g. `&#x1D306;`). The return value of this function is always valid HTML.
 .It Sy "--encode --use-named-refs"
 Enable the use of named character references (like `&copy;`) in the output. If compatibility with older browsers is a concern, don't use this option.
 .It Sy "--encode --everything"
 Encode every symbol in the input string, even safe printable ASCII symbols.
 .It Sy "--encode --allow-unsafe"
 Encode non-ASCII characters only. This leaves unsafe HTML/XML symbols like `&`, `<`, `>`, `"`, and `'` intact.
 .It Sy "--encode --decimal"
 Use decimal digits rather than hexadecimal digits for encoded character references, e.g. output `&#169;` instead of `&#xA9;`.
 .It Sy "--decode"
 Takes a string of HTML and decode any named and numerical character references in it using the algorithm described in the HTML spec.
 .It Sy "--decode --attribute"
 Parse the input as if it was an HTML attribute value rather than a string in an HTML text content.
 .It Sy "--decode --strict"
 Throw an error if an invalid character reference is encountered.
 .It Sy "-v, --version"
 Print he's version.
 .It Sy "-h, --help"
 Show the help screen.
 .El
 .Sh EXIT STATUS
 The
 .Nm he
 utility exits with one of the following values:
 .Pp
 .Bl -tag -width flag -compact
 .It Li 0
 .Nm
 did what it was instructed to do successfully; either it encoded/decoded the input and printed the result, or it printed the version or usage message.
 .It Li 1
 .Nm
 encountered an error.
 .El
 .Sh EXAMPLES
 .Bl -ohang -offset
 .It Sy "he --escape '<script>alert(1)</script>'"
 Print an escaped version of the given string that is safe for use in HTML text contexts, escaping only `&`, `<`, `>`, `"`, and `'`.
 .It Sy "he --decode '&copy;&#x1D306;'"
 Print the decoded version of the given HTML string.
 .It Sy "echo\ '&copy;&#x1D306;'\ |\ he --decode"
 Print the decoded version of the HTML string that gets piped in.
 .El
 .Sh BUGS
 he's bug tracker is located at <https://github.com/mathiasbynens/he/issues>.
 .Sh AUTHOR
 Mathias Bynens <https://mathiasbynens.be/>
 .Sh WWW
 <https://mths.be/he>
@@ -0,0 +1,58 @@
 {
  "name": "he",
  "version": "1.2.0",
  "description": "A robust HTML entities encoder/decoder with full Unicode support.",
  "homepage": "https://mths.be/he",
  "main": "he.js",
  "bin": "bin/he",
  "keywords": [
    "string",
    "entities",
    "entity",
    "html",
    "encode",
    "decode",
    "unicode"
  ],
  "license": "MIT",
  "author": {
    "name": "Mathias Bynens",
    "url": "https://mathiasbynens.be/"
  },
  "repository": {
    "type": "git",
    "url": "https://github.com/mathiasbynens/he.git"
  },
  "bugs": "https://github.com/mathiasbynens/he/issues",
  "files": [
    "LICENSE-MIT.txt",
    "he.js",
    "bin/",
    "man/"
  ],
  "directories": {
    "bin": "bin",
    "man": "man",
    "test": "tests"
  },
  "scripts": {
    "test": "node tests/tests.js",
    "build": "grunt build"
  },
  "devDependencies": {
    "codecov.io": "^0.1.6",
    "grunt": "^0.4.5",
    "grunt-cli": "^1.3.1",
    "grunt-shell": "^1.1.1",
    "grunt-template": "^0.2.3",
    "istanbul": "^0.4.2",
    "jsesc": "^1.0.0",
    "lodash": "^4.8.2",
    "qunit-extras": "^1.4.5",
    "qunitjs": "~1.11.0",
    "regenerate": "^1.2.1",
    "regexgen": "^1.3.0",
    "requirejs": "^2.1.22",
    "sort-object": "^3.0.2"
  }
 }
@@ -0,0 +1,47 @@
 Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
 Based on Underscore.js, copyright Jeremy Ashkenas,
 DocumentCloud and Investigative Reporters & Editors <http://underscorejs.org/>
 This software consists of voluntary contributions made by many
 individuals. For exact contribution history, see the revision history
 available at https://github.com/lodash/lodash
 The following license applies to all parts of this software except as
 documented below:
 ====
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
 "Software"), to deal in the Software without restriction, including
 without limitation the rights to use, copy, modify, merge, publish,
 distribute, sublicense, and/or sell copies of the Software, and to
 permit persons to whom the Software is furnished to do so, subject to
 the following conditions:
 The above copyright notice and this permission notice shall be
 included in all copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 ====
 Copyright and related rights for sample code are waived via CC0. Sample
 code is defined as all source code displayed within the prose of the
 documentation.
 CC0: http://creativecommons.org/publicdomain/zero/1.0/
 ====
 Files located in the node_modules and vendor directories are externally
 maintained libraries used by this software which have their own
 licenses; we recommend you read them, as their terms may differ from the
 terms above.
@@ -0,0 +1,39 @@
 # lodash v4.18.1
 The [Lodash](https://lodash.com/) library exported as [Node.js](https://nodejs.org/) modules.
 ## Installation
 Using npm:
 ```shell
 $ npm i -g npm
 $ npm i --save lodash
 ```
 In Node.js:
 ```js
 // Load the full build.
 var _ = require('lodash');
 // Load the core build.
 var _ = require('lodash/core');
 // Load the FP build for immutable auto-curried iteratee-first data-last methods.
 var fp = require('lodash/fp');
 // Load method categories.
 var array = require('lodash/array');
 var object = require('lodash/fp/object');
 // Cherry-pick methods for smaller browserify/rollup/webpack bundles.
 var at = require('lodash/at');
 var curryN = require('lodash/fp/curryN');
 ```
 See the [package source](https://github.com/lodash/lodash/tree/4.18.1-npm) for more details.
 **Note:**<br>
 Install [n_](https://www.npmjs.com/package/n_) for Lodash use in the Node.js < 6 REPL.
 ## Support
 Tested in Chrome 74-75, Firefox 66-67, IE 11, Edge 18, Safari 11-12, & Node.js 8-12.<br>
 Automated [browser](https://saucelabs.com/u/lodash) & [CI](https://travis-ci.org/lodash/lodash/) test runs are available.
@@ -0,0 +1,7 @@
 var getNative = require('./_getNative'),
    root = require('./_root');
 /* Built-in method references that are verified to be native. */
 var DataView = getNative(root, 'DataView');
 module.exports = DataView;
@@ -0,0 +1,32 @@
 var hashClear = require('./_hashClear'),
    hashDelete = require('./_hashDelete'),
    hashGet = require('./_hashGet'),
    hashHas = require('./_hashHas'),
    hashSet = require('./_hashSet');
 /**
 * Creates a hash object.
 *
 * @private
 * @constructor
 * @param {Array} [entries] The key-value pairs to cache.
 */
 function Hash(entries) {
  var index = -1,
      length = entries == null ? 0 : entries.length;
  this.clear();
  while (++index < length) {
    var entry = entries[index];
    this.set(entry[0], entry[1]);
  }
 }
 // Add methods to `Hash`.
 Hash.prototype.clear = hashClear;
 Hash.prototype['delete'] = hashDelete;
 Hash.prototype.get = hashGet;
 Hash.prototype.has = hashHas;
 Hash.prototype.set = hashSet;
 module.exports = Hash;
@@ -0,0 +1,28 @@
 var baseCreate = require('./_baseCreate'),
    baseLodash = require('./_baseLodash');
 /** Used as references for the maximum length and index of an array. */
 var MAX_ARRAY_LENGTH = 4294967295;
 /**
 * Creates a lazy wrapper object which wraps `value` to enable lazy evaluation.
 *
 * @private
 * @constructor
 * @param {*} value The value to wrap.
 */
 function LazyWrapper(value) {
  this.__wrapped__ = value;
  this.__actions__ = [];
  this.__dir__ = 1;
  this.__filtered__ = false;
  this.__iteratees__ = [];
  this.__takeCount__ = MAX_ARRAY_LENGTH;
  this.__views__ = [];
 }
 // Ensure `LazyWrapper` is an instance of `baseLodash`.
 LazyWrapper.prototype = baseCreate(baseLodash.prototype);
 LazyWrapper.prototype.constructor = LazyWrapper;
 module.exports = LazyWrapper;
@@ -0,0 +1,32 @@
 var listCacheClear = require('./_listCacheClear'),
    listCacheDelete = require('./_listCacheDelete'),
    listCacheGet = require('./_listCacheGet'),
    listCacheHas = require('./_listCacheHas'),
    listCacheSet = require('./_listCacheSet');
 /**
 * Creates an list cache object.
 *
 * @private
 * @constructor
 * @param {Array} [entries] The key-value pairs to cache.
 */
 function ListCache(entries) {
  var index = -1,
      length = entries == null ? 0 : entries.length;
  this.clear();
  while (++index < length) {
    var entry = entries[index];
    this.set(entry[0], entry[1]);
  }
 }
 // Add methods to `ListCache`.
 ListCache.prototype.clear = listCacheClear;
 ListCache.prototype['delete'] = listCacheDelete;
 ListCache.prototype.get = listCacheGet;
 ListCache.prototype.has = listCacheHas;
 ListCache.prototype.set = listCacheSet;
 module.exports = ListCache;
@@ -0,0 +1,22 @@
 var baseCreate = require('./_baseCreate'),
    baseLodash = require('./_baseLodash');
 /**
 * The base constructor for creating `lodash` wrapper objects.
 *
 * @private
 * @param {*} value The value to wrap.
 * @param {boolean} [chainAll] Enable explicit method chain sequences.
 */
 function LodashWrapper(value, chainAll) {
  this.__wrapped__ = value;
  this.__actions__ = [];
  this.__chain__ = !!chainAll;
  this.__index__ = 0;
  this.__values__ = undefined;
 }
 LodashWrapper.prototype = baseCreate(baseLodash.prototype);
 LodashWrapper.prototype.constructor = LodashWrapper;
 module.exports = LodashWrapper;
@@ -0,0 +1,7 @@
 var getNative = require('./_getNative'),
    root = require('./_root');
 /* Built-in method references that are verified to be native. */
 var Map = getNative(root, 'Map');
 module.exports = Map;
@@ -0,0 +1,32 @@
 var mapCacheClear = require('./_mapCacheClear'),
    mapCacheDelete = require('./_mapCacheDelete'),
    mapCacheGet = require('./_mapCacheGet'),
    mapCacheHas = require('./_mapCacheHas'),
    mapCacheSet = require('./_mapCacheSet');
 /**
 * Creates a map cache object to store key-value pairs.
 *
 * @private
 * @constructor
 * @param {Array} [entries] The key-value pairs to cache.
 */
 function MapCache(entries) {
  var index = -1,
      length = entries == null ? 0 : entries.length;
  this.clear();
  while (++index < length) {
    var entry = entries[index];
    this.set(entry[0], entry[1]);
  }
 }
 // Add methods to `MapCache`.
 MapCache.prototype.clear = mapCacheClear;
 MapCache.prototype['delete'] = mapCacheDelete;
 MapCache.prototype.get = mapCacheGet;
 MapCache.prototype.has = mapCacheHas;
 MapCache.prototype.set = mapCacheSet;
 module.exports = MapCache;
@@ -0,0 +1,7 @@
 var getNative = require('./_getNative'),
    root = require('./_root');
 /* Built-in method references that are verified to be native. */
 var Promise = getNative(root, 'Promise');
 module.exports = Promise;
@@ -0,0 +1,7 @@
 var getNative = require('./_getNative'),
    root = require('./_root');
 /* Built-in method references that are verified to be native. */
 var Set = getNative(root, 'Set');
 module.exports = Set;
@@ -0,0 +1,27 @@
 var MapCache = require('./_MapCache'),
    setCacheAdd = require('./_setCacheAdd'),
    setCacheHas = require('./_setCacheHas');
 /**
 *
 * Creates an array cache object to store unique values.
 *
 * @private
 * @constructor
 * @param {Array} [values] The values to cache.
 */
 function SetCache(values) {
  var index = -1,
      length = values == null ? 0 : values.length;
  this.__data__ = new MapCache;
  while (++index < length) {
    this.add(values[index]);
  }
 }
 // Add methods to `SetCache`.
 SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
 SetCache.prototype.has = setCacheHas;
 module.exports = SetCache;
@@ -0,0 +1,27 @@
 var ListCache = require('./_ListCache'),
    stackClear = require('./_stackClear'),
    stackDelete = require('./_stackDelete'),
    stackGet = require('./_stackGet'),
    stackHas = require('./_stackHas'),
    stackSet = require('./_stackSet');
 /**
 * Creates a stack cache object to store key-value pairs.
 *
 * @private
 * @constructor
 * @param {Array} [entries] The key-value pairs to cache.
 */
 function Stack(entries) {
  var data = this.__data__ = new ListCache(entries);
  this.size = data.size;
 }
 // Add methods to `Stack`.
 Stack.prototype.clear = stackClear;
 Stack.prototype['delete'] = stackDelete;
 Stack.prototype.get = stackGet;
 Stack.prototype.has = stackHas;
 Stack.prototype.set = stackSet;
 module.exports = Stack;
@@ -0,0 +1,6 @@
 var root = require('./_root');
 /** Built-in value references. */
 var Symbol = root.Symbol;
 module.exports = Symbol;
@@ -0,0 +1,6 @@
 var root = require('./_root');
 /** Built-in value references. */
 var Uint8Array = root.Uint8Array;
 module.exports = Uint8Array;
@@ -0,0 +1,7 @@
 var getNative = require('./_getNative'),
    root = require('./_root');
 /* Built-in method references that are verified to be native. */
 var WeakMap = getNative(root, 'WeakMap');
 module.exports = WeakMap;
@@ -0,0 +1,21 @@
 /**
 * A faster alternative to `Function#apply`, this function invokes `func`
 * with the `this` binding of `thisArg` and the arguments of `args`.
 *
 * @private
 * @param {Function} func The function to invoke.
 * @param {*} thisArg The `this` binding of `func`.
 * @param {Array} args The arguments to invoke `func` with.
 * @returns {*} Returns the result of `func`.
 */
 function apply(func, thisArg, args) {
  switch (args.length) {
    case 0: return func.call(thisArg);
    case 1: return func.call(thisArg, args[0]);
    case 2: return func.call(thisArg, args[0], args[1]);
    case 3: return func.call(thisArg, args[0], args[1], args[2]);
  }
  return func.apply(thisArg, args);
 }
 module.exports = apply;
@@ -0,0 +1,22 @@
 /**
 * A specialized version of `baseAggregator` for arrays.
 *
 * @private
 * @param {Array} [array] The array to iterate over.
 * @param {Function} setter The function to set `accumulator` values.
 * @param {Function} iteratee The iteratee to transform keys.
 * @param {Object} accumulator The initial aggregated object.
 * @returns {Function} Returns `accumulator`.
 */
 function arrayAggregator(array, setter, iteratee, accumulator) {
  var index = -1,
      length = array == null ? 0 : array.length;
  while (++index < length) {
    var value = array[index];
    setter(accumulator, value, iteratee(value), array);
  }
  return accumulator;
 }
 module.exports = arrayAggregator;
@@ -0,0 +1,22 @@
 /**
 * A specialized version of `_.forEach` for arrays without support for
 * iteratee shorthands.
 *
 * @private
 * @param {Array} [array] The array to iterate over.
 * @param {Function} iteratee The function invoked per iteration.
 * @returns {Array} Returns `array`.
 */
 function arrayEach(array, iteratee) {
  var index = -1,
      length = array == null ? 0 : array.length;
  while (++index < length) {
    if (iteratee(array[index], index, array) === false) {
      break;
    }
  }
  return array;
 }
 module.exports = arrayEach;
@@ -0,0 +1,21 @@
 /**
 * A specialized version of `_.forEachRight` for arrays without support for
 * iteratee shorthands.
 *
 * @private
 * @param {Array} [array] The array to iterate over.
 * @param {Function} iteratee The function invoked per iteration.
 * @returns {Array} Returns `array`.
 */
 function arrayEachRight(array, iteratee) {
  var length = array == null ? 0 : array.length;
  while (length--) {
    if (iteratee(array[length], length, array) === false) {
      break;
    }
  }
  return array;
 }
 module.exports = arrayEachRight;
@@ -0,0 +1,23 @@
 /**
 * A specialized version of `_.every` for arrays without support for
 * iteratee shorthands.
 *
 * @private
 * @param {Array} [array] The array to iterate over.
 * @param {Function} predicate The function invoked per iteration.
 * @returns {boolean} Returns `true` if all elements pass the predicate check,
 *  else `false`.
 */
 function arrayEvery(array, predicate) {
  var index = -1,
      length = array == null ? 0 : array.length;
  while (++index < length) {
    if (!predicate(array[index], index, array)) {
      return false;
    }
  }
  return true;
 }
 module.exports = arrayEvery;
@@ -0,0 +1,25 @@
 /**
 * A specialized version of `_.filter` for arrays without support for
 * iteratee shorthands.
 *
 * @private
 * @param {Array} [array] The array to iterate over.
 * @param {Function} predicate The function invoked per iteration.
 * @returns {Array} Returns the new filtered array.
 */
 function arrayFilter(array, predicate) {
  var index = -1,
      length = array == null ? 0 : array.length,
      resIndex = 0,
      result = [];
  while (++index < length) {
    var value = array[index];
    if (predicate(value, index, array)) {
      result[resIndex++] = value;
    }
  }
  return result;
 }
 module.exports = arrayFilter;
@@ -0,0 +1,17 @@
 var baseIndexOf = require('./_baseIndexOf');
 /**
 * A specialized version of `_.includes` for arrays without support for
 * specifying an index to search from.
 *
 * @private
 * @param {Array} [array] The array to inspect.
 * @param {*} target The value to search for.
 * @returns {boolean} Returns `true` if `target` is found, else `false`.
 */
 function arrayIncludes(array, value) {
  var length = array == null ? 0 : array.length;
  return !!length && baseIndexOf(array, value, 0) > -1;
 }
 module.exports = arrayIncludes;
@@ -0,0 +1,22 @@
 /**
 * This function is like `arrayIncludes` except that it accepts a comparator.
 *
 * @private
 * @param {Array} [array] The array to inspect.
 * @param {*} target The value to search for.
 * @param {Function} comparator The comparator invoked per element.
 * @returns {boolean} Returns `true` if `target` is found, else `false`.
 */
 function arrayIncludesWith(array, value, comparator) {
  var index = -1,
      length = array == null ? 0 : array.length;
  while (++index < length) {
    if (comparator(value, array[index])) {
      return true;
    }
  }
  return false;
 }
 module.exports = arrayIncludesWith;
@@ -0,0 +1,49 @@
 var baseTimes = require('./_baseTimes'),
    isArguments = require('./isArguments'),
    isArray = require('./isArray'),
    isBuffer = require('./isBuffer'),
    isIndex = require('./_isIndex'),
    isTypedArray = require('./isTypedArray');
 /** Used for built-in method references. */
 var objectProto = Object.prototype;
 /** Used to check objects for own properties. */
 var hasOwnProperty = objectProto.hasOwnProperty;
 /**
 * Creates an array of the enumerable property names of the array-like `value`.
 *
 * @private
 * @param {*} value The value to query.
 * @param {boolean} inherited Specify returning inherited property names.
 * @returns {Array} Returns the array of property names.
 */
 function arrayLikeKeys(value, inherited) {
  var isArr = isArray(value),
      isArg = !isArr && isArguments(value),
      isBuff = !isArr && !isArg && isBuffer(value),
      isType = !isArr && !isArg && !isBuff && isTypedArray(value),
      skipIndexes = isArr || isArg || isBuff || isType,
      result = skipIndexes ? baseTimes(value.length, String) : [],
      length = result.length;
  for (var key in value) {
    if ((inherited || hasOwnProperty.call(value, key)) &&
        !(skipIndexes && (
           // Safari 9 has enumerable `arguments.length` in strict mode.
           key == 'length' ||
           // Node.js 0.10 has enumerable non-index properties on buffers.
           (isBuff && (key == 'offset' || key == 'parent')) ||
           // PhantomJS 2 has enumerable non-index properties on typed arrays.
           (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||
           // Skip index properties.
           isIndex(key, length)
        ))) {
      result.push(key);
    }
  }
  return result;
 }
 module.exports = arrayLikeKeys;
@@ -0,0 +1,21 @@
 /**
 * A specialized version of `_.map` for arrays without support for iteratee
 * shorthands.
 *
 * @private
 * @param {Array} [array] The array to iterate over.
 * @param {Function} iteratee The function invoked per iteration.
 * @returns {Array} Returns the new mapped array.
 */
 function arrayMap(array, iteratee) {
  var index = -1,
      length = array == null ? 0 : array.length,
      result = Array(length);
  while (++index < length) {
    result[index] = iteratee(array[index], index, array);
  }
  return result;
 }
 module.exports = arrayMap;
@@ -0,0 +1,20 @@
 /**
 * Appends the elements of `values` to `array`.
 *
 * @private
 * @param {Array} array The array to modify.
 * @param {Array} values The values to append.
 * @returns {Array} Returns `array`.
 */
 function arrayPush(array, values) {
  var index = -1,
      length = values.length,
      offset = array.length;
  while (++index < length) {
    array[offset + index] = values[index];
  }
  return array;
 }
 module.exports = arrayPush;
@@ -0,0 +1,26 @@
 /**
 * A specialized version of `_.reduce` for arrays without support for
 * iteratee shorthands.
 *
 * @private
 * @param {Array} [array] The array to iterate over.
 * @param {Function} iteratee The function invoked per iteration.
 * @param {*} [accumulator] The initial value.
 * @param {boolean} [initAccum] Specify using the first element of `array` as
 *  the initial value.
 * @returns {*} Returns the accumulated value.
 */
 function arrayReduce(array, iteratee, accumulator, initAccum) {
  var index = -1,
      length = array == null ? 0 : array.length;
  if (initAccum && length) {
    accumulator = array[++index];
  }
  while (++index < length) {
    accumulator = iteratee(accumulator, array[index], index, array);
  }
  return accumulator;
 }
 module.exports = arrayReduce;
@@ -0,0 +1,24 @@
 /**
 * A specialized version of `_.reduceRight` for arrays without support for
 * iteratee shorthands.
 *
 * @private
 * @param {Array} [array] The array to iterate over.
 * @param {Function} iteratee The function invoked per iteration.
 * @param {*} [accumulator] The initial value.
 * @param {boolean} [initAccum] Specify using the last element of `array` as
 *  the initial value.
 * @returns {*} Returns the accumulated value.
 */
 function arrayReduceRight(array, iteratee, accumulator, initAccum) {
  var length = array == null ? 0 : array.length;
  if (initAccum && length) {
    accumulator = array[--length];
  }
  while (length--) {
    accumulator = iteratee(accumulator, array[length], length, array);
  }
  return accumulator;
 }
 module.exports = arrayReduceRight;
@@ -0,0 +1,15 @@
 var baseRandom = require('./_baseRandom');
 /**
 * A specialized version of `_.sample` for arrays.
 *
 * @private
 * @param {Array} array The array to sample.
 * @returns {*} Returns the random element.
 */
 function arraySample(array) {
  var length = array.length;
  return length ? array[baseRandom(0, length - 1)] : undefined;
 }
 module.exports = arraySample;
@@ -0,0 +1,17 @@
 var baseClamp = require('./_baseClamp'),
    copyArray = require('./_copyArray'),
    shuffleSelf = require('./_shuffleSelf');
 /**
 * A specialized version of `_.sampleSize` for arrays.
 *
 * @private
 * @param {Array} array The array to sample.
 * @param {number} n The number of elements to sample.
 * @returns {Array} Returns the random elements.
 */
 function arraySampleSize(array, n) {
  return shuffleSelf(copyArray(array), baseClamp(n, 0, array.length));
 }
 module.exports = arraySampleSize;
@@ -0,0 +1,15 @@
 var copyArray = require('./_copyArray'),
    shuffleSelf = require('./_shuffleSelf');
 /**
 * A specialized version of `_.shuffle` for arrays.
 *
 * @private
 * @param {Array} array The array to shuffle.
 * @returns {Array} Returns the new shuffled array.
 */
 function arrayShuffle(array) {
  return shuffleSelf(copyArray(array));
 }
 module.exports = arrayShuffle;
@@ -0,0 +1,23 @@
 /**
 * A specialized version of `_.some` for arrays without support for iteratee
 * shorthands.
 *
 * @private
 * @param {Array} [array] The array to iterate over.
 * @param {Function} predicate The function invoked per iteration.
 * @returns {boolean} Returns `true` if any element passes the predicate check,
 *  else `false`.
 */
 function arraySome(array, predicate) {
  var index = -1,
      length = array == null ? 0 : array.length;
  while (++index < length) {
    if (predicate(array[index], index, array)) {
      return true;
    }
  }
  return false;
 }
 module.exports = arraySome;
@@ -0,0 +1,12 @@
 var baseProperty = require('./_baseProperty');
 /**
 * Gets the size of an ASCII `string`.
 *
 * @private
 * @param {string} string The string inspect.
 * @returns {number} Returns the string size.
 */
 var asciiSize = baseProperty('length');
 module.exports = asciiSize;
@@ -0,0 +1,12 @@
 /**
 * Converts an ASCII `string` to an array.
 *
 * @private
 * @param {string} string The string to convert.
 * @returns {Array} Returns the converted array.
 */
 function asciiToArray(string) {
  return string.split('');
 }
 module.exports = asciiToArray;
@@ -0,0 +1,15 @@
 /** Used to match words composed of alphanumeric characters. */
 var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
 /**
 * Splits an ASCII `string` into an array of its words.
 *
 * @private
 * @param {string} The string to inspect.
 * @returns {Array} Returns the words of `string`.
 */
 function asciiWords(string) {
  return string.match(reAsciiWord) || [];
 }
 module.exports = asciiWords;
@@ -0,0 +1,20 @@
 var baseAssignValue = require('./_baseAssignValue'),
    eq = require('./eq');
 /**
 * This function is like `assignValue` except that it doesn't assign
 * `undefined` values.
 *
 * @private
 * @param {Object} object The object to modify.
 * @param {string} key The key of the property to assign.
 * @param {*} value The value to assign.
 */
 function assignMergeValue(object, key, value) {
  if ((value !== undefined && !eq(object[key], value)) ||
      (value === undefined && !(key in object))) {
    baseAssignValue(object, key, value);
  }
 }
 module.exports = assignMergeValue;
@@ -0,0 +1,28 @@
 var baseAssignValue = require('./_baseAssignValue'),
    eq = require('./eq');
 /** Used for built-in method references. */
 var objectProto = Object.prototype;
 /** Used to check objects for own properties. */
 var hasOwnProperty = objectProto.hasOwnProperty;
 /**
 * Assigns `value` to `key` of `object` if the existing value is not equivalent
 * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
 * for equality comparisons.
 *
 * @private
 * @param {Object} object The object to modify.
 * @param {string} key The key of the property to assign.
 * @param {*} value The value to assign.
 */
 function assignValue(object, key, value) {
  var objValue = object[key];
  if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||
      (value === undefined && !(key in object))) {
    baseAssignValue(object, key, value);
  }
 }
 module.exports = assignValue;
@@ -0,0 +1,21 @@
 var eq = require('./eq');
 /**
 * Gets the index at which the `key` is found in `array` of key-value pairs.
 *
 * @private
 * @param {Array} array The array to inspect.
 * @param {*} key The key to search for.
 * @returns {number} Returns the index of the matched value, else `-1`.
 */
 function assocIndexOf(array, key) {
  var length = array.length;
  while (length--) {
    if (eq(array[length][0], key)) {
      return length;
    }
  }
  return -1;
 }
 module.exports = assocIndexOf;
@@ -0,0 +1,21 @@
 var baseEach = require('./_baseEach');
 /**
 * Aggregates elements of `collection` on `accumulator` with keys transformed
 * by `iteratee` and values set by `setter`.
 *
 * @private
 * @param {Array|Object} collection The collection to iterate over.
 * @param {Function} setter The function to set `accumulator` values.
 * @param {Function} iteratee The iteratee to transform keys.
 * @param {Object} accumulator The initial aggregated object.
 * @returns {Function} Returns `accumulator`.
 */
 function baseAggregator(collection, setter, iteratee, accumulator) {
  baseEach(collection, function(value, key, collection) {
    setter(accumulator, value, iteratee(value), collection);
  });
  return accumulator;
 }
 module.exports = baseAggregator;
@@ -0,0 +1,17 @@
 var copyObject = require('./_copyObject'),
    keys = require('./keys');
 /**
 * The base implementation of `_.assign` without support for multiple sources
 * or `customizer` functions.
 *
 * @private
 * @param {Object} object The destination object.
 * @param {Object} source The source object.
 * @returns {Object} Returns `object`.
 */
 function baseAssign(object, source) {
  return object && copyObject(source, keys(source), object);
 }
 module.exports = baseAssign;
@@ -0,0 +1,17 @@
 var copyObject = require('./_copyObject'),
    keysIn = require('./keysIn');
 /**
 * The base implementation of `_.assignIn` without support for multiple sources
 * or `customizer` functions.
 *
 * @private
 * @param {Object} object The destination object.
 * @param {Object} source The source object.
 * @returns {Object} Returns `object`.
 */
 function baseAssignIn(object, source) {
  return object && copyObject(source, keysIn(source), object);
 }
 module.exports = baseAssignIn;
@@ -0,0 +1,25 @@
 var defineProperty = require('./_defineProperty');
 /**
 * The base implementation of `assignValue` and `assignMergeValue` without
 * value checks.
 *
 * @private
 * @param {Object} object The object to modify.
 * @param {string} key The key of the property to assign.
 * @param {*} value The value to assign.
 */
 function baseAssignValue(object, key, value) {
  if (key == '__proto__' && defineProperty) {
    defineProperty(object, key, {
      'configurable': true,
      'enumerable': true,
      'value': value,
      'writable': true
    });
  } else {
    object[key] = value;
  }
 }
 module.exports = baseAssignValue;
@@ -0,0 +1,23 @@
 var get = require('./get');
 /**
 * The base implementation of `_.at` without support for individual paths.
 *
 * @private
 * @param {Object} object The object to iterate over.
 * @param {string[]} paths The property paths to pick.
 * @returns {Array} Returns the picked elements.
 */
 function baseAt(object, paths) {
  var index = -1,
      length = paths.length,
      result = Array(length),
      skip = object == null;
  while (++index < length) {
    result[index] = skip ? undefined : get(object, paths[index]);
  }
  return result;
 }
 module.exports = baseAt;
@@ -0,0 +1,22 @@
 /**
 * The base implementation of `_.clamp` which doesn't coerce arguments.
 *
 * @private
 * @param {number} number The number to clamp.
 * @param {number} [lower] The lower bound.
 * @param {number} upper The upper bound.
 * @returns {number} Returns the clamped number.
 */
 function baseClamp(number, lower, upper) {
  if (number === number) {
    if (upper !== undefined) {
      number = number <= upper ? number : upper;
    }
    if (lower !== undefined) {
      number = number >= lower ? number : lower;
    }
  }
  return number;
 }
 module.exports = baseClamp;
@@ -0,0 +1,166 @@
 var Stack = require('./_Stack'),
    arrayEach = require('./_arrayEach'),
    assignValue = require('./_assignValue'),
    baseAssign = require('./_baseAssign'),
    baseAssignIn = require('./_baseAssignIn'),
    cloneBuffer = require('./_cloneBuffer'),
    copyArray = require('./_copyArray'),
    copySymbols = require('./_copySymbols'),
    copySymbolsIn = require('./_copySymbolsIn'),
    getAllKeys = require('./_getAllKeys'),
    getAllKeysIn = require('./_getAllKeysIn'),
    getTag = require('./_getTag'),
    initCloneArray = require('./_initCloneArray'),
    initCloneByTag = require('./_initCloneByTag'),
    initCloneObject = require('./_initCloneObject'),
    isArray = require('./isArray'),
    isBuffer = require('./isBuffer'),
    isMap = require('./isMap'),
    isObject = require('./isObject'),
    isSet = require('./isSet'),
    keys = require('./keys'),
    keysIn = require('./keysIn');
 /** Used to compose bitmasks for cloning. */
 var CLONE_DEEP_FLAG = 1,
    CLONE_FLAT_FLAG = 2,
    CLONE_SYMBOLS_FLAG = 4;
 /** `Object#toString` result references. */
 var argsTag = '[object Arguments]',
    arrayTag = '[object Array]',
    boolTag = '[object Boolean]',
    dateTag = '[object Date]',
    errorTag = '[object Error]',
    funcTag = '[object Function]',
    genTag = '[object GeneratorFunction]',
    mapTag = '[object Map]',
    numberTag = '[object Number]',
    objectTag = '[object Object]',
    regexpTag = '[object RegExp]',
    setTag = '[object Set]',
    stringTag = '[object String]',
    symbolTag = '[object Symbol]',
    weakMapTag = '[object WeakMap]';
 var arrayBufferTag = '[object ArrayBuffer]',
    dataViewTag = '[object DataView]',
    float32Tag = '[object Float32Array]',
    float64Tag = '[object Float64Array]',
    int8Tag = '[object Int8Array]',
    int16Tag = '[object Int16Array]',
    int32Tag = '[object Int32Array]',
    uint8Tag = '[object Uint8Array]',
    uint8ClampedTag = '[object Uint8ClampedArray]',
    uint16Tag = '[object Uint16Array]',
    uint32Tag = '[object Uint32Array]';
 /** Used to identify `toStringTag` values supported by `_.clone`. */
 var cloneableTags = {};
 cloneableTags[argsTag] = cloneableTags[arrayTag] =
 cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =
 cloneableTags[boolTag] = cloneableTags[dateTag] =
 cloneableTags[float32Tag] = cloneableTags[float64Tag] =
 cloneableTags[int8Tag] = cloneableTags[int16Tag] =
 cloneableTags[int32Tag] = cloneableTags[mapTag] =
 cloneableTags[numberTag] = cloneableTags[objectTag] =
 cloneableTags[regexpTag] = cloneableTags[setTag] =
 cloneableTags[stringTag] = cloneableTags[symbolTag] =
 cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =
 cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
 cloneableTags[errorTag] = cloneableTags[funcTag] =
 cloneableTags[weakMapTag] = false;
 /**
 * The base implementation of `_.clone` and `_.cloneDeep` which tracks
 * traversed objects.
 *
 * @private
 * @param {*} value The value to clone.
 * @param {boolean} bitmask The bitmask flags.
 *  1 - Deep clone
 *  2 - Flatten inherited properties
 *  4 - Clone symbols
 * @param {Function} [customizer] The function to customize cloning.
 * @param {string} [key] The key of `value`.
 * @param {Object} [object] The parent object of `value`.
 * @param {Object} [stack] Tracks traversed objects and their clone counterparts.
 * @returns {*} Returns the cloned value.
 */
 function baseClone(value, bitmask, customizer, key, object, stack) {
  var result,
      isDeep = bitmask & CLONE_DEEP_FLAG,
      isFlat = bitmask & CLONE_FLAT_FLAG,
      isFull = bitmask & CLONE_SYMBOLS_FLAG;
  if (customizer) {
    result = object ? customizer(value, key, object, stack) : customizer(value);
  }
  if (result !== undefined) {
    return result;
  }
  if (!isObject(value)) {
    return value;
  }
  var isArr = isArray(value);
  if (isArr) {
    result = initCloneArray(value);
    if (!isDeep) {
      return copyArray(value, result);
    }
  } else {
    var tag = getTag(value),
        isFunc = tag == funcTag || tag == genTag;
    if (isBuffer(value)) {
      return cloneBuffer(value, isDeep);
    }
    if (tag == objectTag || tag == argsTag || (isFunc && !object)) {
      result = (isFlat || isFunc) ? {} : initCloneObject(value);
      if (!isDeep) {
        return isFlat
          ? copySymbolsIn(value, baseAssignIn(result, value))
          : copySymbols(value, baseAssign(result, value));
      }
    } else {
      if (!cloneableTags[tag]) {
        return object ? value : {};
      }
      result = initCloneByTag(value, tag, isDeep);
    }
  }
  // Check for circular references and return its corresponding clone.
  stack || (stack = new Stack);
  var stacked = stack.get(value);
  if (stacked) {
    return stacked;
  }
  stack.set(value, result);
  if (isSet(value)) {
    value.forEach(function(subValue) {
      result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));
    });
  } else if (isMap(value)) {
    value.forEach(function(subValue, key) {
      result.set(key, baseClone(subValue, bitmask, customizer, key, value, stack));
    });
  }
  var keysFunc = isFull
    ? (isFlat ? getAllKeysIn : getAllKeys)
    : (isFlat ? keysIn : keys);
  var props = isArr ? undefined : keysFunc(value);
  arrayEach(props || value, function(subValue, key) {
    if (props) {
      key = subValue;
      subValue = value[key];
    }
    // Recursively populate clone (susceptible to call stack limits).
    assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack));
  });
  return result;
 }
 module.exports = baseClone;
@@ -0,0 +1,18 @@
 var baseConformsTo = require('./_baseConformsTo'),
    keys = require('./keys');
 /**
 * The base implementation of `_.conforms` which doesn't clone `source`.
 *
 * @private
 * @param {Object} source The object of property predicates to conform to.
 * @returns {Function} Returns the new spec function.
 */
 function baseConforms(source) {
  var props = keys(source);
  return function(object) {
    return baseConformsTo(object, source, props);
  };
 }
 module.exports = baseConforms;
@@ -0,0 +1,27 @@
 /**
 * The base implementation of `_.conformsTo` which accepts `props` to check.
 *
 * @private
 * @param {Object} object The object to inspect.
 * @param {Object} source The object of property predicates to conform to.
 * @returns {boolean} Returns `true` if `object` conforms, else `false`.
 */
 function baseConformsTo(object, source, props) {
  var length = props.length;
  if (object == null) {
    return !length;
  }
  object = Object(object);
  while (length--) {
    var key = props[length],
        predicate = source[key],
        value = object[key];
    if ((value === undefined && !(key in object)) || !predicate(value)) {
      return false;
    }
  }
  return true;
 }
 module.exports = baseConformsTo;
@@ -0,0 +1,30 @@
 var isObject = require('./isObject');
 /** Built-in value references. */
 var objectCreate = Object.create;
 /**
 * The base implementation of `_.create` without support for assigning
 * properties to the created object.
 *
 * @private
 * @param {Object} proto The object to inherit from.
 * @returns {Object} Returns the new object.
 */
 var baseCreate = (function() {
  function object() {}
  return function(proto) {
    if (!isObject(proto)) {
      return {};
    }
    if (objectCreate) {
      return objectCreate(proto);
    }
    object.prototype = proto;
    var result = new object;
    object.prototype = undefined;
    return result;
  };
 }());
 module.exports = baseCreate;
@@ -0,0 +1,21 @@
 /** Error message constants. */
 var FUNC_ERROR_TEXT = 'Expected a function';
 /**
 * The base implementation of `_.delay` and `_.defer` which accepts `args`
 * to provide to `func`.
 *
 * @private
 * @param {Function} func The function to delay.
 * @param {number} wait The number of milliseconds to delay invocation.
 * @param {Array} args The arguments to provide to `func`.
 * @returns {number|Object} Returns the timer id or timeout object.
 */
 function baseDelay(func, wait, args) {
  if (typeof func != 'function') {
    throw new TypeError(FUNC_ERROR_TEXT);
  }
  return setTimeout(function() { func.apply(undefined, args); }, wait);
 }
 module.exports = baseDelay;
@@ -0,0 +1,67 @@
 var SetCache = require('./_SetCache'),
    arrayIncludes = require('./_arrayIncludes'),
    arrayIncludesWith = require('./_arrayIncludesWith'),
    arrayMap = require('./_arrayMap'),
    baseUnary = require('./_baseUnary'),
    cacheHas = require('./_cacheHas');
 /** Used as the size to enable large array optimizations. */
 var LARGE_ARRAY_SIZE = 200;
 /**
 * The base implementation of methods like `_.difference` without support
 * for excluding multiple arrays or iteratee shorthands.
 *
 * @private
 * @param {Array} array The array to inspect.
 * @param {Array} values The values to exclude.
 * @param {Function} [iteratee] The iteratee invoked per element.
 * @param {Function} [comparator] The comparator invoked per element.
 * @returns {Array} Returns the new array of filtered values.
 */
 function baseDifference(array, values, iteratee, comparator) {
  var index = -1,
      includes = arrayIncludes,
      isCommon = true,
      length = array.length,
      result = [],
      valuesLength = values.length;
  if (!length) {
    return result;
  }
  if (iteratee) {
    values = arrayMap(values, baseUnary(iteratee));
  }
  if (comparator) {
    includes = arrayIncludesWith;
    isCommon = false;
  }
  else if (values.length >= LARGE_ARRAY_SIZE) {
    includes = cacheHas;
    isCommon = false;
    values = new SetCache(values);
  }
  outer:
  while (++index < length) {
    var value = array[index],
        computed = iteratee == null ? value : iteratee(value);
    value = (comparator || value !== 0) ? value : 0;
    if (isCommon && computed === computed) {
      var valuesIndex = valuesLength;
      while (valuesIndex--) {
        if (values[valuesIndex] === computed) {
          continue outer;
        }
      }
      result.push(value);
    }
    else if (!includes(values, computed, comparator)) {
      result.push(value);
    }
  }
  return result;
 }
 module.exports = baseDifference;
@@ -0,0 +1,14 @@
 var baseForOwn = require('./_baseForOwn'),
    createBaseEach = require('./_createBaseEach');
 /**
 * The base implementation of `_.forEach` without support for iteratee shorthands.
 *
 * @private
 * @param {Array|Object} collection The collection to iterate over.
 * @param {Function} iteratee The function invoked per iteration.
 * @returns {Array|Object} Returns `collection`.
 */
 var baseEach = createBaseEach(baseForOwn);
 module.exports = baseEach;
@@ -0,0 +1,14 @@
 var baseForOwnRight = require('./_baseForOwnRight'),
    createBaseEach = require('./_createBaseEach');
 /**
 * The base implementation of `_.forEachRight` without support for iteratee shorthands.
 *
 * @private
 * @param {Array|Object} collection The collection to iterate over.
 * @param {Function} iteratee The function invoked per iteration.
 * @returns {Array|Object} Returns `collection`.
 */
 var baseEachRight = createBaseEach(baseForOwnRight, true);
 module.exports = baseEachRight;
@@ -0,0 +1,21 @@
 var baseEach = require('./_baseEach');
 /**
 * The base implementation of `_.every` without support for iteratee shorthands.
 *
 * @private
 * @param {Array|Object} collection The collection to iterate over.
 * @param {Function} predicate The function invoked per iteration.
 * @returns {boolean} Returns `true` if all elements pass the predicate check,
 *  else `false`
 */
 function baseEvery(collection, predicate) {
  var result = true;
  baseEach(collection, function(value, index, collection) {
    result = !!predicate(value, index, collection);
    return result;
  });
  return result;
 }
 module.exports = baseEvery;
@@ -0,0 +1,32 @@
 var isSymbol = require('./isSymbol');
 /**
 * The base implementation of methods like `_.max` and `_.min` which accepts a
 * `comparator` to determine the extremum value.
 *
 * @private
 * @param {Array} array The array to iterate over.
 * @param {Function} iteratee The iteratee invoked per iteration.
 * @param {Function} comparator The comparator used to compare values.
 * @returns {*} Returns the extremum value.
 */
 function baseExtremum(array, iteratee, comparator) {
  var index = -1,
      length = array.length;
  while (++index < length) {
    var value = array[index],
        current = iteratee(value);
    if (current != null && (computed === undefined
          ? (current === current && !isSymbol(current))
          : comparator(current, computed)
        )) {
      var computed = current,
          result = value;
    }
  }
  return result;
 }
 module.exports = baseExtremum;
@@ -0,0 +1,32 @@
 var toInteger = require('./toInteger'),
    toLength = require('./toLength');
 /**
 * The base implementation of `_.fill` without an iteratee call guard.
 *
 * @private
 * @param {Array} array The array to fill.
 * @param {*} value The value to fill `array` with.
 * @param {number} [start=0] The start position.
 * @param {number} [end=array.length] The end position.
 * @returns {Array} Returns `array`.
 */
 function baseFill(array, value, start, end) {
  var length = array.length;
  start = toInteger(start);
  if (start < 0) {
    start = -start > length ? 0 : (length + start);
  }
  end = (end === undefined || end > length) ? length : toInteger(end);
  if (end < 0) {
    end += length;
  }
  end = start > end ? 0 : toLength(end);
  while (start < end) {
    array[start++] = value;
  }
  return array;
 }
 module.exports = baseFill;
@@ -0,0 +1,21 @@
 var baseEach = require('./_baseEach');
 /**
 * The base implementation of `_.filter` without support for iteratee shorthands.
 *
 * @private
 * @param {Array|Object} collection The collection to iterate over.
 * @param {Function} predicate The function invoked per iteration.
 * @returns {Array} Returns the new filtered array.
 */
 function baseFilter(collection, predicate) {
  var result = [];
  baseEach(collection, function(value, index, collection) {
    if (predicate(value, index, collection)) {
      result.push(value);
    }
  });
  return result;
 }
 module.exports = baseFilter;
@@ -0,0 +1,24 @@
 /**
 * The base implementation of `_.findIndex` and `_.findLastIndex` without
 * support for iteratee shorthands.
 *
 * @private
 * @param {Array} array The array to inspect.
 * @param {Function} predicate The function invoked per iteration.
 * @param {number} fromIndex The index to search from.
 * @param {boolean} [fromRight] Specify iterating from right to left.
 * @returns {number} Returns the index of the matched value, else `-1`.
 */
 function baseFindIndex(array, predicate, fromIndex, fromRight) {
  var length = array.length,
      index = fromIndex + (fromRight ? 1 : -1);
  while ((fromRight ? index-- : ++index < length)) {
    if (predicate(array[index], index, array)) {
      return index;
    }
  }
  return -1;
 }
 module.exports = baseFindIndex;
@@ -0,0 +1,23 @@
 /**
 * The base implementation of methods like `_.findKey` and `_.findLastKey`,
 * without support for iteratee shorthands, which iterates over `collection`
 * using `eachFunc`.
 *
 * @private
 * @param {Array|Object} collection The collection to inspect.
 * @param {Function} predicate The function invoked per iteration.
 * @param {Function} eachFunc The function to iterate over `collection`.
 * @returns {*} Returns the found element or its key, else `undefined`.
 */
 function baseFindKey(collection, predicate, eachFunc) {
  var result;
  eachFunc(collection, function(value, key, collection) {
    if (predicate(value, key, collection)) {
      result = key;
      return false;
    }
  });
  return result;
 }
 module.exports = baseFindKey;
@@ -0,0 +1,38 @@
 var arrayPush = require('./_arrayPush'),
    isFlattenable = require('./_isFlattenable');
 /**
 * The base implementation of `_.flatten` with support for restricting flattening.
 *
 * @private
 * @param {Array} array The array to flatten.
 * @param {number} depth The maximum recursion depth.
 * @param {boolean} [predicate=isFlattenable] The function invoked per iteration.
 * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks.
 * @param {Array} [result=[]] The initial result value.
 * @returns {Array} Returns the new flattened array.
 */
 function baseFlatten(array, depth, predicate, isStrict, result) {
  var index = -1,
      length = array.length;
  predicate || (predicate = isFlattenable);
  result || (result = []);
  while (++index < length) {
    var value = array[index];
    if (depth > 0 && predicate(value)) {
      if (depth > 1) {
        // Recursively flatten arrays (susceptible to call stack limits).
        baseFlatten(value, depth - 1, predicate, isStrict, result);
      } else {
        arrayPush(result, value);
      }
    } else if (!isStrict) {
      result[result.length] = value;
    }
  }
  return result;
 }
 module.exports = baseFlatten;
@@ -0,0 +1,16 @@
 var createBaseFor = require('./_createBaseFor');
 /**
 * The base implementation of `baseForOwn` which iterates over `object`
 * properties returned by `keysFunc` and invokes `iteratee` for each property.
 * Iteratee functions may exit iteration early by explicitly returning `false`.
 *
 * @private
 * @param {Object} object The object to iterate over.
 * @param {Function} iteratee The function invoked per iteration.
 * @param {Function} keysFunc The function to get the keys of `object`.
 * @returns {Object} Returns `object`.
 */
 var baseFor = createBaseFor();
 module.exports = baseFor;
@@ -0,0 +1,16 @@
 var baseFor = require('./_baseFor'),
    keys = require('./keys');
 /**
 * The base implementation of `_.forOwn` without support for iteratee shorthands.
 *
 * @private
 * @param {Object} object The object to iterate over.
 * @param {Function} iteratee The function invoked per iteration.
 * @returns {Object} Returns `object`.
 */
 function baseForOwn(object, iteratee) {
  return object && baseFor(object, iteratee, keys);
 }
 module.exports = baseForOwn;
@@ -0,0 +1,16 @@
 var baseForRight = require('./_baseForRight'),
    keys = require('./keys');
 /**
 * The base implementation of `_.forOwnRight` without support for iteratee shorthands.
 *
 * @private
 * @param {Object} object The object to iterate over.
 * @param {Function} iteratee The function invoked per iteration.
 * @returns {Object} Returns `object`.
 */
 function baseForOwnRight(object, iteratee) {
  return object && baseForRight(object, iteratee, keys);
 }
 module.exports = baseForOwnRight;
@@ -0,0 +1,15 @@
 var createBaseFor = require('./_createBaseFor');
 /**
 * This function is like `baseFor` except that it iterates over properties
 * in the opposite order.
 *
 * @private
 * @param {Object} object The object to iterate over.
 * @param {Function} iteratee The function invoked per iteration.
 * @param {Function} keysFunc The function to get the keys of `object`.
 * @returns {Object} Returns `object`.
 */
 var baseForRight = createBaseFor(true);
 module.exports = baseForRight;
@@ -0,0 +1,19 @@
 var arrayFilter = require('./_arrayFilter'),
    isFunction = require('./isFunction');
 /**
 * The base implementation of `_.functions` which creates an array of
 * `object` function property names filtered from `props`.
 *
 * @private
 * @param {Object} object The object to inspect.
 * @param {Array} props The property names to filter.
 * @returns {Array} Returns the function names.
 */
 function baseFunctions(object, props) {
  return arrayFilter(props, function(key) {
    return isFunction(object[key]);
  });
 }
 module.exports = baseFunctions;
@@ -0,0 +1,24 @@
 var castPath = require('./_castPath'),
    toKey = require('./_toKey');
 /**
 * The base implementation of `_.get` without support for default values.
 *
 * @private
 * @param {Object} object The object to query.
 * @param {Array|string} path The path of the property to get.
 * @returns {*} Returns the resolved value.
 */
 function baseGet(object, path) {
  path = castPath(path, object);
  var index = 0,
      length = path.length;
  while (object != null && index < length) {
    object = object[toKey(path[index++])];
  }
  return (index && index == length) ? object : undefined;
 }
 module.exports = baseGet;
@@ -0,0 +1,20 @@
 var arrayPush = require('./_arrayPush'),
    isArray = require('./isArray');
 /**
 * The base implementation of `getAllKeys` and `getAllKeysIn` which uses
 * `keysFunc` and `symbolsFunc` to get the enumerable property names and
 * symbols of `object`.
 *
 * @private
 * @param {Object} object The object to query.
 * @param {Function} keysFunc The function to get the keys of `object`.
 * @param {Function} symbolsFunc The function to get the symbols of `object`.
 * @returns {Array} Returns the array of property names and symbols.
 */
 function baseGetAllKeys(object, keysFunc, symbolsFunc) {
  var result = keysFunc(object);
  return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
 }
 module.exports = baseGetAllKeys;
@@ -0,0 +1,28 @@
 var Symbol = require('./_Symbol'),
    getRawTag = require('./_getRawTag'),
    objectToString = require('./_objectToString');
 /** `Object#toString` result references. */
 var nullTag = '[object Null]',
    undefinedTag = '[object Undefined]';
 /** Built-in value references. */
 var symToStringTag = Symbol ? Symbol.toStringTag : undefined;
 /**
 * The base implementation of `getTag` without fallbacks for buggy environments.
 *
 * @private
 * @param {*} value The value to query.
 * @returns {string} Returns the `toStringTag`.
 */
 function baseGetTag(value) {
  if (value == null) {
    return value === undefined ? undefinedTag : nullTag;
  }
  return (symToStringTag && symToStringTag in Object(value))
    ? getRawTag(value)
    : objectToString(value);
 }
 module.exports = baseGetTag;
@@ -0,0 +1,14 @@
 /**
 * The base implementation of `_.gt` which doesn't coerce arguments.
 *
 * @private
 * @param {*} value The value to compare.
 * @param {*} other The other value to compare.
 * @returns {boolean} Returns `true` if `value` is greater than `other`,
 *  else `false`.
 */
 function baseGt(value, other) {
  return value > other;
 }
 module.exports = baseGt;
@@ -0,0 +1,19 @@
 /** Used for built-in method references. */
 var objectProto = Object.prototype;
 /** Used to check objects for own properties. */
 var hasOwnProperty = objectProto.hasOwnProperty;
 /**
 * The base implementation of `_.has` without support for deep paths.
 *
 * @private
 * @param {Object} [object] The object to query.
 * @param {Array|string} key The key to check.
 * @returns {boolean} Returns `true` if `key` exists, else `false`.
 */
 function baseHas(object, key) {
  return object != null && hasOwnProperty.call(object, key);
 }
 module.exports = baseHas;
@@ -0,0 +1,13 @@
 /**
 * The base implementation of `_.hasIn` without support for deep paths.
 *
 * @private
 * @param {Object} [object] The object to query.
 * @param {Array|string} key The key to check.
 * @returns {boolean} Returns `true` if `key` exists, else `false`.
 */
 function baseHasIn(object, key) {
  return object != null && key in Object(object);
 }
 module.exports = baseHasIn;
@@ -0,0 +1,18 @@
 /* Built-in method references for those with the same name as other `lodash` methods. */
 var nativeMax = Math.max,
    nativeMin = Math.min;
 /**
 * The base implementation of `_.inRange` which doesn't coerce arguments.
 *
 * @private
 * @param {number} number The number to check.
 * @param {number} start The start of the range.
 * @param {number} end The end of the range.
 * @returns {boolean} Returns `true` if `number` is in the range, else `false`.
 */
 function baseInRange(number, start, end) {
  return number >= nativeMin(start, end) && number < nativeMax(start, end);
 }
 module.exports = baseInRange;
@@ -0,0 +1,20 @@
 var baseFindIndex = require('./_baseFindIndex'),
    baseIsNaN = require('./_baseIsNaN'),
    strictIndexOf = require('./_strictIndexOf');
 /**
 * The base implementation of `_.indexOf` without `fromIndex` bounds checks.
 *
 * @private
 * @param {Array} array The array to inspect.
 * @param {*} value The value to search for.
 * @param {number} fromIndex The index to search from.
 * @returns {number} Returns the index of the matched value, else `-1`.
 */
 function baseIndexOf(array, value, fromIndex) {
  return value === value
    ? strictIndexOf(array, value, fromIndex)
    : baseFindIndex(array, baseIsNaN, fromIndex);
 }
 module.exports = baseIndexOf;
@@ -0,0 +1,23 @@
 /**
 * This function is like `baseIndexOf` except that it accepts a comparator.
 *
 * @private
 * @param {Array} array The array to inspect.
 * @param {*} value The value to search for.
 * @param {number} fromIndex The index to search from.
 * @param {Function} comparator The comparator invoked per element.
 * @returns {number} Returns the index of the matched value, else `-1`.
 */
 function baseIndexOfWith(array, value, fromIndex, comparator) {
  var index = fromIndex - 1,
      length = array.length;
  while (++index < length) {
    if (comparator(array[index], value)) {
      return index;
    }
  }
  return -1;
 }
 module.exports = baseIndexOfWith;
@@ -0,0 +1,74 @@
 var SetCache = require('./_SetCache'),
    arrayIncludes = require('./_arrayIncludes'),
    arrayIncludesWith = require('./_arrayIncludesWith'),
    arrayMap = require('./_arrayMap'),
    baseUnary = require('./_baseUnary'),
    cacheHas = require('./_cacheHas');
 /* Built-in method references for those with the same name as other `lodash` methods. */
 var nativeMin = Math.min;
 /**
 * The base implementation of methods like `_.intersection`, without support
 * for iteratee shorthands, that accepts an array of arrays to inspect.
 *
 * @private
 * @param {Array} arrays The arrays to inspect.
 * @param {Function} [iteratee] The iteratee invoked per element.
 * @param {Function} [comparator] The comparator invoked per element.
 * @returns {Array} Returns the new array of shared values.
 */
 function baseIntersection(arrays, iteratee, comparator) {
  var includes = comparator ? arrayIncludesWith : arrayIncludes,
      length = arrays[0].length,
      othLength = arrays.length,
      othIndex = othLength,
      caches = Array(othLength),
      maxLength = Infinity,
      result = [];
  while (othIndex--) {
    var array = arrays[othIndex];
    if (othIndex && iteratee) {
      array = arrayMap(array, baseUnary(iteratee));
    }
    maxLength = nativeMin(array.length, maxLength);
    caches[othIndex] = !comparator && (iteratee || (length >= 120 && array.length >= 120))
      ? new SetCache(othIndex && array)
      : undefined;
  }
  array = arrays[0];
  var index = -1,
      seen = caches[0];
  outer:
  while (++index < length && result.length < maxLength) {
    var value = array[index],
        computed = iteratee ? iteratee(value) : value;
    value = (comparator || value !== 0) ? value : 0;
    if (!(seen
          ? cacheHas(seen, computed)
          : includes(result, computed, comparator)
        )) {
      othIndex = othLength;
      while (--othIndex) {
        var cache = caches[othIndex];
        if (!(cache
              ? cacheHas(cache, computed)
              : includes(arrays[othIndex], computed, comparator))
            ) {
          continue outer;
        }
      }
      if (seen) {
        seen.push(computed);
      }
      result.push(value);
    }
  }
  return result;
 }
 module.exports = baseIntersection;
@@ -0,0 +1,21 @@
 var baseForOwn = require('./_baseForOwn');
 /**
 * The base implementation of `_.invert` and `_.invertBy` which inverts
 * `object` with values transformed by `iteratee` and set by `setter`.
 *
 * @private
 * @param {Object} object The object to iterate over.
 * @param {Function} setter The function to set `accumulator` values.
 * @param {Function} iteratee The iteratee to transform values.
 * @param {Object} accumulator The initial inverted object.
 * @returns {Function} Returns `accumulator`.
 */
 function baseInverter(object, setter, iteratee, accumulator) {
  baseForOwn(object, function(value, key, object) {
    setter(accumulator, iteratee(value), key, object);
  });
  return accumulator;
 }
 module.exports = baseInverter;
@@ -0,0 +1,24 @@
 var apply = require('./_apply'),
    castPath = require('./_castPath'),
    last = require('./last'),
    parent = require('./_parent'),
    toKey = require('./_toKey');
 /**
 * The base implementation of `_.invoke` without support for individual
 * method arguments.
 *
 * @private
 * @param {Object} object The object to query.
 * @param {Array|string} path The path of the method to invoke.
 * @param {Array} args The arguments to invoke the method with.
 * @returns {*} Returns the result of the invoked method.
 */
 function baseInvoke(object, path, args) {
  path = castPath(path, object);
  object = parent(object, path);
  var func = object == null ? object : object[toKey(last(path))];
  return func == null ? undefined : apply(func, object, args);
 }
 module.exports = baseInvoke;
@@ -0,0 +1,18 @@
 var baseGetTag = require('./_baseGetTag'),
    isObjectLike = require('./isObjectLike');
 /** `Object#toString` result references. */
 var argsTag = '[object Arguments]';
 /**
 * The base implementation of `_.isArguments`.
 *
 * @private
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is an `arguments` object,
 */
 function baseIsArguments(value) {
  return isObjectLike(value) && baseGetTag(value) == argsTag;
 }
 module.exports = baseIsArguments;
@@ -0,0 +1,17 @@
 var baseGetTag = require('./_baseGetTag'),
    isObjectLike = require('./isObjectLike');
 var arrayBufferTag = '[object ArrayBuffer]';
 /**
 * The base implementation of `_.isArrayBuffer` without Node.js optimizations.
 *
 * @private
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`.
 */
 function baseIsArrayBuffer(value) {
  return isObjectLike(value) && baseGetTag(value) == arrayBufferTag;
 }
 module.exports = baseIsArrayBuffer;
@@ -0,0 +1,18 @@
 var baseGetTag = require('./_baseGetTag'),
    isObjectLike = require('./isObjectLike');
 /** `Object#toString` result references. */
 var dateTag = '[object Date]';
 /**
 * The base implementation of `_.isDate` without Node.js optimizations.
 *
 * @private
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a date object, else `false`.
 */
 function baseIsDate(value) {
  return isObjectLike(value) && baseGetTag(value) == dateTag;
 }
 module.exports = baseIsDate;
@@ -0,0 +1,28 @@
 var baseIsEqualDeep = require('./_baseIsEqualDeep'),
    isObjectLike = require('./isObjectLike');
 /**
 * The base implementation of `_.isEqual` which supports partial comparisons
 * and tracks traversed objects.
 *
 * @private
 * @param {*} value The value to compare.
 * @param {*} other The other value to compare.
 * @param {boolean} bitmask The bitmask flags.
 *  1 - Unordered comparison
 *  2 - Partial comparison
 * @param {Function} [customizer] The function to customize comparisons.
 * @param {Object} [stack] Tracks traversed `value` and `other` objects.
 * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
 */
 function baseIsEqual(value, other, bitmask, customizer, stack) {
  if (value === other) {
    return true;
  }
  if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) {
    return value !== value && other !== other;
  }
  return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
 }
 module.exports = baseIsEqual;
@@ -0,0 +1,83 @@
 var Stack = require('./_Stack'),
    equalArrays = require('./_equalArrays'),
    equalByTag = require('./_equalByTag'),
    equalObjects = require('./_equalObjects'),
    getTag = require('./_getTag'),
    isArray = require('./isArray'),
    isBuffer = require('./isBuffer'),
    isTypedArray = require('./isTypedArray');
 /** Used to compose bitmasks for value comparisons. */
 var COMPARE_PARTIAL_FLAG = 1;
 /** `Object#toString` result references. */
 var argsTag = '[object Arguments]',
    arrayTag = '[object Array]',
    objectTag = '[object Object]';
 /** Used for built-in method references. */
 var objectProto = Object.prototype;
 /** Used to check objects for own properties. */
 var hasOwnProperty = objectProto.hasOwnProperty;
 /**
 * A specialized version of `baseIsEqual` for arrays and objects which performs
 * deep comparisons and tracks traversed objects enabling objects with circular
 * references to be compared.
 *
 * @private
 * @param {Object} object The object to compare.
 * @param {Object} other The other object to compare.
 * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
 * @param {Function} customizer The function to customize comparisons.
 * @param {Function} equalFunc The function to determine equivalents of values.
 * @param {Object} [stack] Tracks traversed `object` and `other` objects.
 * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
 */
 function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
  var objIsArr = isArray(object),
      othIsArr = isArray(other),
      objTag = objIsArr ? arrayTag : getTag(object),
      othTag = othIsArr ? arrayTag : getTag(other);
  objTag = objTag == argsTag ? objectTag : objTag;
  othTag = othTag == argsTag ? objectTag : othTag;
  var objIsObj = objTag == objectTag,
      othIsObj = othTag == objectTag,
      isSameTag = objTag == othTag;
  if (isSameTag && isBuffer(object)) {
    if (!isBuffer(other)) {
      return false;
    }
    objIsArr = true;
    objIsObj = false;
  }
  if (isSameTag && !objIsObj) {
    stack || (stack = new Stack);
    return (objIsArr || isTypedArray(object))
      ? equalArrays(object, other, bitmask, customizer, equalFunc, stack)
      : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
  }
  if (!(bitmask & COMPARE_PARTIAL_FLAG)) {
    var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),
        othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');
    if (objIsWrapped || othIsWrapped) {
      var objUnwrapped = objIsWrapped ? object.value() : object,
          othUnwrapped = othIsWrapped ? other.value() : other;
      stack || (stack = new Stack);
      return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
    }
  }
  if (!isSameTag) {
    return false;
  }
  stack || (stack = new Stack);
  return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
 }
 module.exports = baseIsEqualDeep;
@@ -0,0 +1,18 @@
 var getTag = require('./_getTag'),
    isObjectLike = require('./isObjectLike');
 /** `Object#toString` result references. */
 var mapTag = '[object Map]';
 /**
 * The base implementation of `_.isMap` without Node.js optimizations.
 *
 * @private
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a map, else `false`.
 */
 function baseIsMap(value) {
  return isObjectLike(value) && getTag(value) == mapTag;
 }
 module.exports = baseIsMap;
@@ -0,0 +1,62 @@
 var Stack = require('./_Stack'),
    baseIsEqual = require('./_baseIsEqual');
 /** Used to compose bitmasks for value comparisons. */
 var COMPARE_PARTIAL_FLAG = 1,
    COMPARE_UNORDERED_FLAG = 2;
 /**
 * The base implementation of `_.isMatch` without support for iteratee shorthands.
 *
 * @private
 * @param {Object} object The object to inspect.
 * @param {Object} source The object of property values to match.
 * @param {Array} matchData The property names, values, and compare flags to match.
 * @param {Function} [customizer] The function to customize comparisons.
 * @returns {boolean} Returns `true` if `object` is a match, else `false`.
 */
 function baseIsMatch(object, source, matchData, customizer) {
  var index = matchData.length,
      length = index,
      noCustomizer = !customizer;
  if (object == null) {
    return !length;
  }
  object = Object(object);
  while (index--) {
    var data = matchData[index];
    if ((noCustomizer && data[2])
          ? data[1] !== object[data[0]]
          : !(data[0] in object)
        ) {
      return false;
    }
  }
  while (++index < length) {
    data = matchData[index];
    var key = data[0],
        objValue = object[key],
        srcValue = data[1];
    if (noCustomizer && data[2]) {
      if (objValue === undefined && !(key in object)) {
        return false;
      }
    } else {
      var stack = new Stack;
      if (customizer) {
        var result = customizer(objValue, srcValue, key, object, source, stack);
      }
      if (!(result === undefined
            ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack)
            : result
          )) {
        return false;
      }
    }
  }
  return true;
 }
 module.exports = baseIsMatch;
@@ -0,0 +1,12 @@
 /**
 * The base implementation of `_.isNaN` without support for number objects.
 *
 * @private
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.
 */
 function baseIsNaN(value) {
  return value !== value;
 }
 module.exports = baseIsNaN;
@@ -0,0 +1,47 @@
 var isFunction = require('./isFunction'),
    isMasked = require('./_isMasked'),
    isObject = require('./isObject'),
    toSource = require('./_toSource');
 /**
 * Used to match `RegExp`
 * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
 */
 var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
 /** Used to detect host constructors (Safari). */
 var reIsHostCtor = /^\[object .+?Constructor\]$/;
 /** Used for built-in method references. */
 var funcProto = Function.prototype,
    objectProto = Object.prototype;
 /** Used to resolve the decompiled source of functions. */
 var funcToString = funcProto.toString;
 /** Used to check objects for own properties. */
 var hasOwnProperty = objectProto.hasOwnProperty;
 /** Used to detect if a method is native. */
 var reIsNative = RegExp('^' +
  funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&')
  .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
 );
 /**
 * The base implementation of `_.isNative` without bad shim checks.
 *
 * @private
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a native function,
 *  else `false`.
 */
 function baseIsNative(value) {
  if (!isObject(value) || isMasked(value)) {
    return false;
  }
  var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
  return pattern.test(toSource(value));
 }
 module.exports = baseIsNative;
@@ -0,0 +1,18 @@
 var baseGetTag = require('./_baseGetTag'),
    isObjectLike = require('./isObjectLike');
 /** `Object#toString` result references. */
 var regexpTag = '[object RegExp]';
 /**
 * The base implementation of `_.isRegExp` without Node.js optimizations.
 *
 * @private
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a regexp, else `false`.
 */
 function baseIsRegExp(value) {
  return isObjectLike(value) && baseGetTag(value) == regexpTag;
 }
 module.exports = baseIsRegExp;
@@ -0,0 +1,18 @@
 var getTag = require('./_getTag'),
    isObjectLike = require('./isObjectLike');
 /** `Object#toString` result references. */
 var setTag = '[object Set]';
 /**
 * The base implementation of `_.isSet` without Node.js optimizations.
 *
 * @private
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a set, else `false`.
 */
 function baseIsSet(value) {
  return isObjectLike(value) && getTag(value) == setTag;
 }
 module.exports = baseIsSet;
@@ -0,0 +1,60 @@
 var baseGetTag = require('./_baseGetTag'),
    isLength = require('./isLength'),
    isObjectLike = require('./isObjectLike');
 /** `Object#toString` result references. */
 var argsTag = '[object Arguments]',
    arrayTag = '[object Array]',
    boolTag = '[object Boolean]',
    dateTag = '[object Date]',
    errorTag = '[object Error]',
    funcTag = '[object Function]',
    mapTag = '[object Map]',
    numberTag = '[object Number]',
    objectTag = '[object Object]',
    regexpTag = '[object RegExp]',
    setTag = '[object Set]',
    stringTag = '[object String]',
    weakMapTag = '[object WeakMap]';
 var arrayBufferTag = '[object ArrayBuffer]',
    dataViewTag = '[object DataView]',
    float32Tag = '[object Float32Array]',
    float64Tag = '[object Float64Array]',
    int8Tag = '[object Int8Array]',
    int16Tag = '[object Int16Array]',
    int32Tag = '[object Int32Array]',
    uint8Tag = '[object Uint8Array]',
    uint8ClampedTag = '[object Uint8ClampedArray]',
    uint16Tag = '[object Uint16Array]',
    uint32Tag = '[object Uint32Array]';
 /** Used to identify `toStringTag` values of typed arrays. */
 var typedArrayTags = {};
 typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =
 typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =
 typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =
 typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =
 typedArrayTags[uint32Tag] = true;
 typedArrayTags[argsTag] = typedArrayTags[arrayTag] =
 typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =
 typedArrayTags[dataViewTag] = typedArrayTags[dateTag] =
 typedArrayTags[errorTag] = typedArrayTags[funcTag] =
 typedArrayTags[mapTag] = typedArrayTags[numberTag] =
 typedArrayTags[objectTag] = typedArrayTags[regexpTag] =
 typedArrayTags[setTag] = typedArrayTags[stringTag] =
 typedArrayTags[weakMapTag] = false;
 /**
 * The base implementation of `_.isTypedArray` without Node.js optimizations.
 *
 * @private
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
 */
 function baseIsTypedArray(value) {
  return isObjectLike(value) &&
    isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
 }
 module.exports = baseIsTypedArray;
@@ -0,0 +1,31 @@
 var baseMatches = require('./_baseMatches'),
    baseMatchesProperty = require('./_baseMatchesProperty'),
    identity = require('./identity'),
    isArray = require('./isArray'),
    property = require('./property');
 /**
 * The base implementation of `_.iteratee`.
 *
 * @private
 * @param {*} [value=_.identity] The value to convert to an iteratee.
 * @returns {Function} Returns the iteratee.
 */
 function baseIteratee(value) {
  // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9.
  // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details.
  if (typeof value == 'function') {
    return value;
  }
  if (value == null) {
    return identity;
  }
  if (typeof value == 'object') {
    return isArray(value)
      ? baseMatchesProperty(value[0], value[1])
      : baseMatches(value);
  }
  return property(value);
 }
 module.exports = baseIteratee;
@@ -0,0 +1,30 @@
 var isPrototype = require('./_isPrototype'),
    nativeKeys = require('./_nativeKeys');
 /** Used for built-in method references. */
 var objectProto = Object.prototype;
 /** Used to check objects for own properties. */
 var hasOwnProperty = objectProto.hasOwnProperty;
 /**
 * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
 *
 * @private
 * @param {Object} object The object to query.
 * @returns {Array} Returns the array of property names.
 */
 function baseKeys(object) {
  if (!isPrototype(object)) {
    return nativeKeys(object);
  }
  var result = [];
  for (var key in Object(object)) {
    if (hasOwnProperty.call(object, key) && key != 'constructor') {
      result.push(key);
    }
  }
  return result;
 }
 module.exports = baseKeys;
@@ -0,0 +1,33 @@
 var isObject = require('./isObject'),
    isPrototype = require('./_isPrototype'),
    nativeKeysIn = require('./_nativeKeysIn');
 /** Used for built-in method references. */
 var objectProto = Object.prototype;
 /** Used to check objects for own properties. */
 var hasOwnProperty = objectProto.hasOwnProperty;
 /**
 * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.
 *
 * @private
 * @param {Object} object The object to query.
 * @returns {Array} Returns the array of property names.
 */
 function baseKeysIn(object) {
  if (!isObject(object)) {
    return nativeKeysIn(object);
  }
  var isProto = isPrototype(object),
      result = [];
  for (var key in object) {
    if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {
      result.push(key);
    }
  }
  return result;
 }
 module.exports = baseKeysIn;
--- a/Show More
+++ b/Show More