node_modules

45 files changed, 8756 insertions, 0 deletions

diff --git a/node_modules/buffer/.npmignore b/node_modules/buffer/.npmignore
new file mode 100644
index 000000000..a27403560
--- /dev/null
+++ b/node_modules/buffer/.npmignore
@@ -0,0 +1,2 @@
+.zuul.yml
+perf/
diff --git a/node_modules/buffer/.travis.yml b/node_modules/buffer/.travis.yml
new file mode 100644
index 000000000..6789094e0
--- /dev/null
+++ b/node_modules/buffer/.travis.yml
@@ -0,0 +1,8 @@
+language: node_js
+node_js:
+- 'node'
+sudo: false
+env:
+  global:
+  - secure: AUsK+8fYSpwIMHcVt8Mu9SpG9RPHp4XDAwCQfpU3d5U65q8OVVC6C+XjvnNmEd2PoEJRHem8ZXEyRVfGM1sttKZLZP70TEKZOpOiRQnZiTQCAJ92TfGsDj/F4LoWSjUZUpfeg9b3iSp8G5dVw3+q9QZPIu6eykASK6bfcg//Cyg=
+  - secure: eQBKJWu7XbhAN4ZvOOhMenC0IPpoYj+wZVVzzsLwUppfJqlrHV0CUW8rJdvZNiaGhYhoyHTnAcynpTE5kZfg3XjevOvF8PGY5wUYCki9BI+rp+pvVPZE/DNUAQpFR2gd2nxMJ4kYv7GVb6i/DfuqJa0h8IuY4zcMuKWwbQd3Az8=
diff --git a/node_modules/buffer/AUTHORS.md b/node_modules/buffer/AUTHORS.md
new file mode 100644
index 000000000..8df343a60
--- /dev/null
+++ b/node_modules/buffer/AUTHORS.md
@@ -0,0 +1,44 @@
+# Authors
+
+#### Ordered by first contribution.
+
+- Romain Beauxis (toots@rastageeks.org)
+- Tobias Koppers (tobias.koppers@googlemail.com)
+- Janus (ysangkok@gmail.com)
+- Rainer Dreyer (rdrey1@gmail.com)
+- Tõnis Tiigi (tonistiigi@gmail.com)
+- James Halliday (mail@substack.net)
+- Michael Williamson (mike@zwobble.org)
+- elliottcable (github@elliottcable.name)
+- rafael (rvalle@livelens.net)
+- Andrew Kelley (superjoe30@gmail.com)
+- Andreas Madsen (amwebdk@gmail.com)
+- Mike Brevoort (mike.brevoort@pearson.com)
+- Brian White (mscdex@mscdex.net)
+- Feross Aboukhadijeh (feross@feross.org)
+- Ruben Verborgh (ruben@verborgh.org)
+- eliang (eliang.cs@gmail.com)
+- Jesse Tane (jesse.tane@gmail.com)
+- Alfonso Boza (alfonso@cloud.com)
+- Mathias Buus (mathiasbuus@gmail.com)
+- Devon Govett (devongovett@gmail.com)
+- Daniel Cousens (github@dcousens.com)
+- Joseph Dykstra (josephdykstra@gmail.com)
+- Parsha Pourkhomami (parshap+git@gmail.com)
+- Damjan Košir (damjan.kosir@gmail.com)
+- daverayment (dave.rayment@gmail.com)
+- kawanet (u-suke@kawa.net)
+- Linus Unnebäck (linus@folkdatorn.se)
+- Nolan Lawson (nolan.lawson@gmail.com)
+- Calvin Metcalf (calvin.metcalf@gmail.com)
+- Koki Takahashi (hakatasiloving@gmail.com)
+- Guy Bedford (guybedford@gmail.com)
+- Jan Schär (jscissr@gmail.com)
+- RaulTsc (tomescu.raul@gmail.com)
+- Matthieu Monsch (monsch@alum.mit.edu)
+- Dan Ehrenberg (littledan@chromium.org)
+- Kirill Fomichev (fanatid@ya.ru)
+- Yusuke Kawasaki (u-suke@kawa.net)
+- DC (dcposch@dcpos.ch)
+
+#### Generated by bin/update-authors.sh.
diff --git a/node_modules/buffer/LICENSE b/node_modules/buffer/LICENSE
new file mode 100644
index 000000000..d6bf75dcf
--- /dev/null
+++ b/node_modules/buffer/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Feross Aboukhadijeh, and other contributors.
+
+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.
diff --git a/node_modules/buffer/README.md b/node_modules/buffer/README.md
new file mode 100644
index 000000000..d3b82f66a
--- /dev/null
+++ b/node_modules/buffer/README.md
@@ -0,0 +1,378 @@
+# buffer [![travis][travis-image]][travis-url] [![npm][npm-image]][npm-url] [![downloads][downloads-image]][npm-url]
+
+#### The buffer module from [node.js](https://nodejs.org/), for the browser.
+
+[![saucelabs][saucelabs-image]][saucelabs-url]
+
+[travis-image]: https://img.shields.io/travis/feross/buffer/master.svg
+[travis-url]: https://travis-ci.org/feross/buffer
+[npm-image]: https://img.shields.io/npm/v/buffer.svg
+[npm-url]: https://npmjs.org/package/buffer
+[downloads-image]: https://img.shields.io/npm/dm/buffer.svg
+[saucelabs-image]: https://saucelabs.com/browser-matrix/buffer.svg
+[saucelabs-url]: https://saucelabs.com/u/buffer
+
+With [browserify](http://browserify.org), simply `require('buffer')` or use the `Buffer` global and you will get this module.
+
+The goal is to provide an API that is 100% identical to
+[node's Buffer API](https://nodejs.org/api/buffer.html). Read the
+[official docs](https://nodejs.org/api/buffer.html) for the full list of properties,
+instance methods, and class methods that are supported.
+
+## features
+
+- Manipulate binary data like a boss, in all browsers -- even IE6!
+- Super fast. Backed by Typed Arrays (`Uint8Array`/`ArrayBuffer`, not `Object`)
+- Extremely small bundle size (**5.04KB minified + gzipped**, 35.5KB with comments)
+- Excellent browser support (IE 6+, Chrome 4+, Firefox 3+, Safari 5.1+, Opera 11+, iOS, etc.)
+- Preserves Node API exactly, with one minor difference (see below)
+- Square-bracket `buf[4]` notation works, even in old browsers like IE6!
+- Does not modify any browser prototypes or put anything on `window`
+- Comprehensive test suite (including all buffer tests from node.js core)
+
+
+## install
+
+To use this module directly (without browserify), install it:
+
+```bash
+npm install buffer
+```
+
+This module was previously called **native-buffer-browserify**, but please use **buffer**
+from now on.
+
+A standalone bundle is available [here](https://wzrd.in/standalone/buffer), for non-browserify users.
+
+
+## usage
+
+The module's API is identical to node's `Buffer` API. Read the
+[official docs](https://nodejs.org/api/buffer.html) for the full list of properties,
+instance methods, and class methods that are supported.
+
+As mentioned above, `require('buffer')` or use the `Buffer` global with
+[browserify](http://browserify.org) and this module will automatically be included
+in your bundle. Almost any npm module will work in the browser, even if it assumes that
+the node `Buffer` API will be available.
+
+To depend on this module explicitly (without browserify), require it like this:
+
+```js
+var Buffer = require('buffer/').Buffer  // note: the trailing slash is important!
+```
+
+To require this module explicitly, use `require('buffer/')` which tells the node.js module
+lookup algorithm (also used by browserify) to use the **npm module** named `buffer`
+instead of the **node.js core** module named `buffer`!
+
+
+## how does it work?
+
+The Buffer constructor returns instances of `Uint8Array` that have their prototype
+changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of `Uint8Array`,
+so the returned instances will have all the node `Buffer` methods and the
+`Uint8Array` methods. Square bracket notation works as expected -- it returns a
+single octet.
+
+The `Uint8Array` prototype remains unmodified.
+
+
+## one minor difference
+
+#### In old browsers, `buf.slice()` does not modify parent buffer's memory
+
+If you only support modern browsers (specifically, those with typed array support),
+then this issue does not affect you. If you support super old browsers, then read on.
+
+In node, the `slice()` method returns a new `Buffer` that shares underlying memory
+with the original Buffer. When you modify one buffer, you modify the other.
+[Read more.](https://nodejs.org/api/buffer.html#buffer_buf_slice_start_end)
+
+In browsers with typed array support, this `Buffer` implementation supports this
+behavior. In browsers without typed arrays, an alternate buffer implementation is
+used that is based on `Object` which has no mechanism to point separate
+`Buffer`s to the same underlying slab of memory.
+
+You can see which browser versions lack typed array support
+[here](https://github.com/feross/buffer/blob/master/index.js#L22-L48).
+
+
+## tracking the latest node api
+
+This module tracks the Buffer API in the latest (unstable) version of node.js. The Buffer
+API is considered **stable** in the
+[node stability index](https://nodejs.org/docs/latest/api/documentation.html#documentation_stability_index),
+so it is unlikely that there will ever be breaking changes.
+Nonetheless, when/if the Buffer API changes in node, this module's API will change
+accordingly.
+
+## related packages
+
+- [`buffer-equals`](https://www.npmjs.com/package/buffer-equals) - Node.js 0.12 buffer.equals() ponyfill
+- [`buffer-reverse`](https://www.npmjs.com/package/buffer-reverse) - A lite module for reverse-operations on buffers
+- [`buffer-xor`](https://www.npmjs.com/package/buffer-xor) - A simple module for bitwise-xor on buffers
+- [`is-buffer`](https://www.npmjs.com/package/is-buffer) - Determine if an object is a Buffer without including the whole `Buffer` package
+- [`typedarray-to-buffer`](https://www.npmjs.com/package/typedarray-to-buffer) - Convert a typed array to a Buffer without a copy
+
+## performance
+
+See perf tests in `/perf`.
+
+`BrowserBuffer` is the browser `buffer` module (this repo). `Uint8Array` is included as a
+sanity check (since `BrowserBuffer` uses `Uint8Array` under the hood, `Uint8Array` will
+always be at least a bit faster). Finally, `NodeBuffer` is the node.js buffer module,
+which is included to compare against.
+
+NOTE: Performance has improved since these benchmarks were taken. PR welcoem to update the README.
+
+### Chrome 38
+
+| Method | Operations | Accuracy | Sampled | Fastest |
+|:-------|:-----------|:---------|:--------|:-------:|
+| BrowserBuffer#bracket-notation | 11,457,464 ops/sec | ±0.86% | 66 | ✓ |
+| Uint8Array#bracket-notation | 10,824,332 ops/sec | ±0.74% | 65 | |
+| | | | |
+| BrowserBuffer#concat | 450,532 ops/sec | ±0.76% | 68 | |
+| Uint8Array#concat | 1,368,911 ops/sec | ±1.50% | 62 | ✓ |
+| | | | |
+| BrowserBuffer#copy(16000) | 903,001 ops/sec | ±0.96% | 67 | |
+| Uint8Array#copy(16000) | 1,422,441 ops/sec | ±1.04% | 66 | ✓ |
+| | | | |
+| BrowserBuffer#copy(16) | 11,431,358 ops/sec | ±0.46% | 69 | |
+| Uint8Array#copy(16) | 13,944,163 ops/sec | ±1.12% | 68 | ✓ |
+| | | | |
+| BrowserBuffer#new(16000) | 106,329 ops/sec | ±6.70% | 44 | |
+| Uint8Array#new(16000) | 131,001 ops/sec | ±2.85% | 31 | ✓ |
+| | | | |
+| BrowserBuffer#new(16) | 1,554,491 ops/sec | ±1.60% | 65 | |
+| Uint8Array#new(16) | 6,623,930 ops/sec | ±1.66% | 65 | ✓ |
+| | | | |
+| BrowserBuffer#readDoubleBE | 112,830 ops/sec | ±0.51% | 69 | ✓ |
+| DataView#getFloat64 | 93,500 ops/sec | ±0.57% | 68 | |
+| | | | |
+| BrowserBuffer#readFloatBE | 146,678 ops/sec | ±0.95% | 68 | ✓ |
+| DataView#getFloat32 | 99,311 ops/sec | ±0.41% | 67 | |
+| | | | |
+| BrowserBuffer#readUInt32LE | 843,214 ops/sec | ±0.70% | 69 | ✓ |
+| DataView#getUint32 | 103,024 ops/sec | ±0.64% | 67 | |
+| | | | |
+| BrowserBuffer#slice | 1,013,941 ops/sec | ±0.75% | 67 | |
+| Uint8Array#subarray | 1,903,928 ops/sec | ±0.53% | 67 | ✓ |
+| | | | |
+| BrowserBuffer#writeFloatBE | 61,387 ops/sec | ±0.90% | 67 | |
+| DataView#setFloat32 | 141,249 ops/sec | ±0.40% | 66 | ✓ |
+
+
+### Firefox 33
+
+| Method | Operations | Accuracy | Sampled | Fastest |
+|:-------|:-----------|:---------|:--------|:-------:|
+| BrowserBuffer#bracket-notation | 20,800,421 ops/sec | ±1.84% | 60 | |
+| Uint8Array#bracket-notation | 20,826,235 ops/sec | ±2.02% | 61 | ✓ |
+| | | | |
+| BrowserBuffer#concat | 153,076 ops/sec | ±2.32% | 61 | |
+| Uint8Array#concat | 1,255,674 ops/sec | ±8.65% | 52 | ✓ |
+| | | | |
+| BrowserBuffer#copy(16000) | 1,105,312 ops/sec | ±1.16% | 63 | |
+| Uint8Array#copy(16000) | 1,615,911 ops/sec | ±0.55% | 66 | ✓ |
+| | | | |
+| BrowserBuffer#copy(16) | 16,357,599 ops/sec | ±0.73% | 68 | |
+| Uint8Array#copy(16) | 31,436,281 ops/sec | ±1.05% | 68 | ✓ |
+| | | | |
+| BrowserBuffer#new(16000) | 52,995 ops/sec | ±6.01% | 35 | |
+| Uint8Array#new(16000) | 87,686 ops/sec | ±5.68% | 45 | ✓ |
+| | | | |
+| BrowserBuffer#new(16) | 252,031 ops/sec | ±1.61% | 66 | |
+| Uint8Array#new(16) | 8,477,026 ops/sec | ±0.49% | 68 | ✓ |
+| | | | |
+| BrowserBuffer#readDoubleBE | 99,871 ops/sec | ±0.41% | 69 | |
+| DataView#getFloat64 | 285,663 ops/sec | ±0.70% | 68 | ✓ |
+| | | | |
+| BrowserBuffer#readFloatBE | 115,540 ops/sec | ±0.42% | 69 | |
+| DataView#getFloat32 | 288,722 ops/sec | ±0.82% | 68 | ✓ |
+| | | | |
+| BrowserBuffer#readUInt32LE | 633,926 ops/sec | ±1.08% | 67 | ✓ |
+| DataView#getUint32 | 294,808 ops/sec | ±0.79% | 64 | |
+| | | | |
+| BrowserBuffer#slice | 349,425 ops/sec | ±0.46% | 69 | |
+| Uint8Array#subarray | 5,965,819 ops/sec | ±0.60% | 65 | ✓ |
+| | | | |
+| BrowserBuffer#writeFloatBE | 59,980 ops/sec | ±0.41% | 67 | |
+| DataView#setFloat32 | 317,634 ops/sec | ±0.63% | 68 | ✓ |
+
+### Safari 8
+
+| Method | Operations | Accuracy | Sampled | Fastest |
+|:-------|:-----------|:---------|:--------|:-------:|
+| BrowserBuffer#bracket-notation | 10,279,729 ops/sec | ±2.25% | 56 | ✓ |
+| Uint8Array#bracket-notation | 10,030,767 ops/sec | ±2.23% | 59 | |
+| | | | |
+| BrowserBuffer#concat | 144,138 ops/sec | ±1.38% | 65 | |
+| Uint8Array#concat | 4,950,764 ops/sec | ±1.70% | 63 | ✓ |
+| | | | |
+| BrowserBuffer#copy(16000) | 1,058,548 ops/sec | ±1.51% | 64 | |
+| Uint8Array#copy(16000) | 1,409,666 ops/sec | ±1.17% | 65 | ✓ |
+| | | | |
+| BrowserBuffer#copy(16) | 6,282,529 ops/sec | ±1.88% | 58 | |
+| Uint8Array#copy(16) | 11,907,128 ops/sec | ±2.87% | 58 | ✓ |
+| | | | |
+| BrowserBuffer#new(16000) | 101,663 ops/sec | ±3.89% | 57 | |
+| Uint8Array#new(16000) | 22,050,818 ops/sec | ±6.51% | 46 | ✓ |
+| | | | |
+| BrowserBuffer#new(16) | 176,072 ops/sec | ±2.13% | 64 | |
+| Uint8Array#new(16) | 24,385,731 ops/sec | ±5.01% | 51 | ✓ |
+| | | | |
+| BrowserBuffer#readDoubleBE | 41,341 ops/sec | ±1.06% | 67 | |
+| DataView#getFloat64 | 322,280 ops/sec | ±0.84% | 68 | ✓ |
+| | | | |
+| BrowserBuffer#readFloatBE | 46,141 ops/sec | ±1.06% | 65 | |
+| DataView#getFloat32 | 337,025 ops/sec | ±0.43% | 69 | ✓ |
+| | | | |
+| BrowserBuffer#readUInt32LE | 151,551 ops/sec | ±1.02% | 66 | |
+| DataView#getUint32 | 308,278 ops/sec | ±0.94% | 67 | ✓ |
+| | | | |
+| BrowserBuffer#slice | 197,365 ops/sec | ±0.95% | 66 | |
+| Uint8Array#subarray | 9,558,024 ops/sec | ±3.08% | 58 | ✓ |
+| | | | |
+| BrowserBuffer#writeFloatBE | 17,518 ops/sec | ±1.03% | 63 | |
+| DataView#setFloat32 | 319,751 ops/sec | ±0.48% | 68 | ✓ |
+
+
+### Node 0.11.14
+
+| Method | Operations | Accuracy | Sampled | Fastest |
+|:-------|:-----------|:---------|:--------|:-------:|
+| BrowserBuffer#bracket-notation | 10,489,828 ops/sec | ±3.25% | 90 | |
+| Uint8Array#bracket-notation | 10,534,884 ops/sec | ±0.81% | 92 | ✓ |
+| NodeBuffer#bracket-notation | 10,389,910 ops/sec | ±0.97% | 87 | |
+| | | | |
+| BrowserBuffer#concat | 487,830 ops/sec | ±2.58% | 88 | |
+| Uint8Array#concat | 1,814,327 ops/sec | ±1.28% | 88 | ✓ |
+| NodeBuffer#concat | 1,636,523 ops/sec | ±1.88% | 73 | |
+| | | | |
+| BrowserBuffer#copy(16000) | 1,073,665 ops/sec | ±0.77% | 90 | |
+| Uint8Array#copy(16000) | 1,348,517 ops/sec | ±0.84% | 89 | ✓ |
+| NodeBuffer#copy(16000) | 1,289,533 ops/sec | ±0.82% | 93 | |
+| | | | |
+| BrowserBuffer#copy(16) | 12,782,706 ops/sec | ±0.74% | 85 | |
+| Uint8Array#copy(16) | 14,180,427 ops/sec | ±0.93% | 92 | ✓ |
+| NodeBuffer#copy(16) | 11,083,134 ops/sec | ±1.06% | 89 | |
+| | | | |
+| BrowserBuffer#new(16000) | 141,678 ops/sec | ±3.30% | 67 | |
+| Uint8Array#new(16000) | 161,491 ops/sec | ±2.96% | 60 | |
+| NodeBuffer#new(16000) | 292,699 ops/sec | ±3.20% | 55 | ✓ |
+| | | | |
+| BrowserBuffer#new(16) | 1,655,466 ops/sec | ±2.41% | 82 | |
+| Uint8Array#new(16) | 14,399,926 ops/sec | ±0.91% | 94 | ✓ |
+| NodeBuffer#new(16) | 3,894,696 ops/sec | ±0.88% | 92 | |
+| | | | |
+| BrowserBuffer#readDoubleBE | 109,582 ops/sec | ±0.75% | 93 | ✓ |
+| DataView#getFloat64 | 91,235 ops/sec | ±0.81% | 90 | |
+| NodeBuffer#readDoubleBE | 88,593 ops/sec | ±0.96% | 81 | |
+| | | | |
+| BrowserBuffer#readFloatBE | 139,854 ops/sec | ±1.03% | 85 | ✓ |
+| DataView#getFloat32 | 98,744 ops/sec | ±0.80% | 89 | |
+| NodeBuffer#readFloatBE | 92,769 ops/sec | ±0.94% | 93 | |
+| | | | |
+| BrowserBuffer#readUInt32LE | 710,861 ops/sec | ±0.82% | 92 | |
+| DataView#getUint32 | 117,893 ops/sec | ±0.84% | 91 | |
+| NodeBuffer#readUInt32LE | 851,412 ops/sec | ±0.72% | 93 | ✓ |
+| | | | |
+| BrowserBuffer#slice | 1,673,877 ops/sec | ±0.73% | 94 | |
+| Uint8Array#subarray | 6,919,243 ops/sec | ±0.67% | 90 | ✓ |
+| NodeBuffer#slice | 4,617,604 ops/sec | ±0.79% | 93 | |
+| | | | |
+| BrowserBuffer#writeFloatBE | 66,011 ops/sec | ±0.75% | 93 | |
+| DataView#setFloat32 | 127,760 ops/sec | ±0.72% | 93 | ✓ |
+| NodeBuffer#writeFloatBE | 103,352 ops/sec | ±0.83% | 93 | |
+
+### iojs 1.8.1
+
+| Method | Operations | Accuracy | Sampled | Fastest |
+|:-------|:-----------|:---------|:--------|:-------:|
+| BrowserBuffer#bracket-notation | 10,990,488 ops/sec | ±1.11% | 91 | |
+| Uint8Array#bracket-notation | 11,268,757 ops/sec | ±0.65% | 97 | |
+| NodeBuffer#bracket-notation | 11,353,260 ops/sec | ±0.83% | 94 | ✓ |
+| | | | |
+| BrowserBuffer#concat | 378,954 ops/sec | ±0.74% | 94 | |
+| Uint8Array#concat | 1,358,288 ops/sec | ±0.97% | 87 | |
+| NodeBuffer#concat | 1,934,050 ops/sec | ±1.11% | 78 | ✓ |
+| | | | |
+| BrowserBuffer#copy(16000) | 894,538 ops/sec | ±0.56% | 84 | |
+| Uint8Array#copy(16000) | 1,442,656 ops/sec | ±0.71% | 96 | |
+| NodeBuffer#copy(16000) | 1,457,898 ops/sec | ±0.53% | 92 | ✓ |
+| | | | |
+| BrowserBuffer#copy(16) | 12,870,457 ops/sec | ±0.67% | 95 | |
+| Uint8Array#copy(16) | 16,643,989 ops/sec | ±0.61% | 93 | ✓ |
+| NodeBuffer#copy(16) | 14,885,848 ops/sec | ±0.74% | 94 | |
+| | | | |
+| BrowserBuffer#new(16000) | 109,264 ops/sec | ±4.21% | 63 | |
+| Uint8Array#new(16000) | 138,916 ops/sec | ±1.87% | 61 | |
+| NodeBuffer#new(16000) | 281,449 ops/sec | ±3.58% | 51 | ✓ |
+| | | | |
+| BrowserBuffer#new(16) | 1,362,935 ops/sec | ±0.56% | 99 | |
+| Uint8Array#new(16) | 6,193,090 ops/sec | ±0.64% | 95 | ✓ |
+| NodeBuffer#new(16) | 4,745,425 ops/sec | ±1.56% | 90 | |
+| | | | |
+| BrowserBuffer#readDoubleBE | 118,127 ops/sec | ±0.59% | 93 | ✓ |
+| DataView#getFloat64 | 107,332 ops/sec | ±0.65% | 91 | |
+| NodeBuffer#readDoubleBE | 116,274 ops/sec | ±0.94% | 95 | |
+| | | | |
+| BrowserBuffer#readFloatBE | 150,326 ops/sec | ±0.58% | 95 | ✓ |
+| DataView#getFloat32 | 110,541 ops/sec | ±0.57% | 98 | |
+| NodeBuffer#readFloatBE | 121,599 ops/sec | ±0.60% | 87 | |
+| | | | |
+| BrowserBuffer#readUInt32LE | 814,147 ops/sec | ±0.62% | 93 | |
+| DataView#getUint32 | 137,592 ops/sec | ±0.64% | 90 | |
+| NodeBuffer#readUInt32LE | 931,650 ops/sec | ±0.71% | 96 | ✓ |
+| | | | |
+| BrowserBuffer#slice | 878,590 ops/sec | ±0.68% | 93 | |
+| Uint8Array#subarray | 2,843,308 ops/sec | ±1.02% | 90 | |
+| NodeBuffer#slice | 4,998,316 ops/sec | ±0.68% | 90 | ✓ |
+| | | | |
+| BrowserBuffer#writeFloatBE | 65,927 ops/sec | ±0.74% | 93 | |
+| DataView#setFloat32 | 139,823 ops/sec | ±0.97% | 89 | ✓ |
+| NodeBuffer#writeFloatBE | 135,763 ops/sec | ±0.65% | 96 | |
+| | | | |
+
+## Testing the project
+
+First, install the project:
+
+    npm install
+
+Then, to run tests in Node.js, run:
+
+    npm run test-node
+
+To test locally in a browser, you can run:
+
+    npm run test-browser-local
+
+This will print out a URL that you can then open in a browser to run the tests, using [Zuul](https://github.com/defunctzombie/zuul).
+
+To run automated browser tests using Saucelabs, ensure that your `SAUCE_USERNAME` and `SAUCE_ACCESS_KEY` environment variables are set, then run:
+
+    npm test
+
+This is what's run in Travis, to check against various browsers. The list of browsers is kept in the `.zuul.yml` file.
+
+## JavaScript Standard Style
+
+This module uses [JavaScript Standard Style](https://github.com/feross/standard).
+
+[![JavaScript Style Guide](https://cdn.rawgit.com/feross/standard/master/badge.svg)](https://github.com/feross/standard)
+
+To test that the code conforms to the style, `npm install` and run:
+
+    ./node_modules/.bin/standard
+
+## credit
+
+This was originally forked from [buffer-browserify](https://github.com/toots/buffer-browserify).
+
+
+## license
+
+MIT. Copyright (C) [Feross Aboukhadijeh](http://feross.org), and other contributors. Originally forked from an MIT-licensed module by Romain Beauxis.
diff --git a/node_modules/buffer/bin/download-node-tests.js b/node_modules/buffer/bin/download-node-tests.js
new file mode 100755
index 000000000..97efde02f
--- /dev/null
+++ b/node_modules/buffer/bin/download-node-tests.js
@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+
+var concat = require('concat-stream')
+var cp = require('child_process')
+var fs = require('fs')
+var hyperquest = require('hyperquest')
+var path = require('path')
+var split = require('split')
+var through = require('through2')
+
+var url = 'https://api.github.com/repos/nodejs/node/contents'
+var dirs = [
+  '/test/parallel',
+  '/test/pummel'
+]
+
+cp.execSync('rm -rf node/*.js', { cwd: path.join(__dirname, '../test') })
+
+var httpOpts = {
+  headers: {
+    'User-Agent': null
+    // auth if github rate-limits you...
+    // 'Authorization': 'Basic ' + Buffer('username:password').toString('base64'),
+  }
+}
+
+dirs.forEach(function (dir) {
+  var req = hyperquest(url + dir, httpOpts)
+  req.pipe(concat(function (data) {
+    if (req.response.statusCode !== 200) {
+      throw new Error(url + dir + ': ' + data.toString())
+    }
+    downloadBufferTests(dir, JSON.parse(data))
+  }))
+})
+
+function downloadBufferTests (dir, files) {
+  files.forEach(function (file) {
+    if (!/test-buffer.*/.test(file.name)) return
+
+    if (file.name === 'test-buffer-fakes.js') {
+      // These teses only apply to node, where they're calling into C++ and need to
+      // ensure the prototype can't be faked, or else there will be a segfault.
+      return
+    }
+
+    console.log(file.download_url)
+
+    var out = path.join(__dirname, '../test/node', file.name)
+    hyperquest(file.download_url, httpOpts)
+      .pipe(split())
+      .pipe(testfixer(file.name))
+      .pipe(fs.createWriteStream(out))
+      .on('finish', function () {
+        console.log('wrote ' + file.name)
+      })
+  })
+}
+
+function testfixer (filename) {
+  var firstline = true
+
+  return through(function (line, enc, cb) {
+    line = line.toString()
+
+    if (firstline) {
+      // require buffer explicitly
+      var preamble = 'var Buffer = require(\'../../\').Buffer;\n'
+      if (/use strict/.test(line)) line += '\n' + preamble
+      else line + preamble + '\n' + line
+      firstline = false
+    }
+
+    // use `var` instead of `const`/`let`
+    line = line.replace(/(const|let) /g, 'var ')
+
+    // make `var common = require('common')` work
+    line = line.replace(/(var common = require.*)/g, 'var common = { skip: function () {} };')
+
+    // make `require('../common')` work
+    line = line.replace(/require\('\.\.\/common'\);/g, '')
+
+    // require browser buffer
+    line = line.replace(/(.*)require\('buffer'\)(.*)/g, '$1require(\'../../\')$2')
+
+    // comment out console logs
+    line = line.replace(/(.*console\..*)/g, '// $1')
+
+    // we can't reliably test typed array max-sizes in the browser
+    if (filename === 'test-buffer-big.js') {
+      line = line.replace(/(.*new Int8Array.*RangeError.*)/, '// $1')
+      line = line.replace(/(.*new ArrayBuffer.*RangeError.*)/, '// $1')
+      line = line.replace(/(.*new Float64Array.*RangeError.*)/, '// $1')
+    }
+
+    // https://github.com/nodejs/node/blob/v0.12/test/parallel/test-buffer.js#L1138
+    // unfortunately we can't run this because crypto-browserify doesn't work in old
+    // versions of ie
+    if (filename === 'test-buffer.js') {
+      line = line.replace(/^(\s*)(var crypto = require.*)/, '$1// $2')
+      line = line.replace(/(crypto.createHash.*\))/, '1 /*$1*/')
+    }
+
+    cb(null, line + '\n')
+  })
+}
diff --git a/node_modules/buffer/bin/test.js b/node_modules/buffer/bin/test.js
new file mode 100644
index 000000000..5a86f1b2c
--- /dev/null
+++ b/node_modules/buffer/bin/test.js
@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+
+var cp = require('child_process')
+var fs = require('fs')
+var path = require('path')
+
+var shouldRunBrowserTests = !process.env.TRAVIS_PULL_REQUEST ||
+  process.env.TRAVIS_PULL_REQUEST === 'false'
+
+var node = cp.spawn('npm', ['run', 'test-node'], { stdio: 'inherit' })
+node.on('close', function (code) {
+  if (code === 0 && shouldRunBrowserTests) {
+    runBrowserTests()
+  } else {
+    process.exit(code)
+  }
+})
+
+function runBrowserTests () {
+  var zuulYmlPath = path.join(__dirname, '..', '.zuul.yml')
+
+  writeES5ZuulYml()
+  cp.spawn('npm', ['run', 'test-browser-es5'], { stdio: 'inherit' })
+    .on('close', function (code) {
+      if (code !== 0) process.exit(code)
+      writeES6ZuulYml()
+      cp.spawn('npm', ['run', 'test-browser-es6'], { stdio: 'inherit' })
+        .on('close', function (code) {
+          process.exit(code)
+        })
+    })
+
+  function writeES5ZuulYml () {
+    fs.writeFileSync(zuulYmlPath, fs.readFileSync(path.join(__dirname, 'zuul-es5.yml')))
+  }
+
+  function writeES6ZuulYml () {
+    fs.writeFileSync(zuulYmlPath, fs.readFileSync(path.join(__dirname, 'zuul-es6.yml')))
+  }
+}
+
diff --git a/node_modules/buffer/bin/update-authors.sh b/node_modules/buffer/bin/update-authors.sh
new file mode 100755
index 000000000..efcbc7807
--- /dev/null
+++ b/node_modules/buffer/bin/update-authors.sh
@@ -0,0 +1,21 @@
+#!/bin/sh
+# Update AUTHORS.md based on git history.
+
+git log --reverse --format='%aN (%aE)' | perl -we '
+BEGIN {
+  %seen = (), @authors = ();
+}
+while (<>) {
+  next if $seen{$_};
+  next if /(support\@greenkeeper.io)/;
+  next if /(dcousens\@users.noreply.github.com)/;
+  next if /(cmetcalf\@appgeo.com)/;
+  $seen{$_} = push @authors, "- ", $_;
+}
+END {
+  print "# Authors\n\n";
+  print "#### Ordered by first contribution.\n\n";
+  print @authors, "\n";
+  print "#### Generated by bin/update-authors.sh.\n";
+}
+' > AUTHORS.md
diff --git a/node_modules/buffer/bin/zuul-es5.yml b/node_modules/buffer/bin/zuul-es5.yml
new file mode 100644
index 000000000..3673bccf1
--- /dev/null
+++ b/node_modules/buffer/bin/zuul-es5.yml
@@ -0,0 +1,14 @@
+ui: tape
+scripts:
+  - ./test/_polyfill.js
+browsers:
+  - name: safari
+    version: latest
+  - name: ie
+    version: 8..latest
+  - name: microsoftedge
+    version: 13..latest
+  - name: android
+    version: 4.4..latest
+  - name: iphone
+    version: latest
diff --git a/node_modules/buffer/bin/zuul-es6.yml b/node_modules/buffer/bin/zuul-es6.yml
new file mode 100644
index 000000000..8054ad652
--- /dev/null
+++ b/node_modules/buffer/bin/zuul-es6.yml
@@ -0,0 +1,6 @@
+ui: tape
+browsers:
+  - name: chrome
+    version: '-1..latest'
+  - name: firefox
+    version: '-1..latest'
diff --git a/node_modules/buffer/index.js b/node_modules/buffer/index.js
new file mode 100644
index 000000000..0fcd80ad7
--- /dev/null
+++ b/node_modules/buffer/index.js
@@ -0,0 +1,1789 @@
+/*!
+ * The buffer module from node.js, for the browser.
+ *
+ * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
+ * @license  MIT
+ */
+/* eslint-disable no-proto */
+
+'use strict'
+
+var base64 = require('base64-js')
+var ieee754 = require('ieee754')
+var isArray = require('isarray')
+
+exports.Buffer = Buffer
+exports.SlowBuffer = SlowBuffer
+exports.INSPECT_MAX_BYTES = 50
+
+/**
+ * If `Buffer.TYPED_ARRAY_SUPPORT`:
+ *   === true    Use Uint8Array implementation (fastest)
+ *   === false   Use Object implementation (most compatible, even IE6)
+ *
+ * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
+ * Opera 11.6+, iOS 4.2+.
+ *
+ * Due to various browser bugs, sometimes the Object implementation will be used even
+ * when the browser supports typed arrays.
+ *
+ * Note:
+ *
+ *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,
+ *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.
+ *
+ *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.
+ *
+ *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of
+ *     incorrect length in some situations.
+
+ * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they
+ * get the Object implementation, which is slower but behaves correctly.
+ */
+Buffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined
+  ? global.TYPED_ARRAY_SUPPORT
+  : typedArraySupport()
+
+/*
+ * Export kMaxLength after typed array support is determined.
+ */
+exports.kMaxLength = kMaxLength()
+
+function typedArraySupport () {
+  try {
+    var arr = new Uint8Array(1)
+    arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}
+    return arr.foo() === 42 && // typed array instances can be augmented
+        typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`
+        arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`
+  } catch (e) {
+    return false
+  }
+}
+
+function kMaxLength () {
+  return Buffer.TYPED_ARRAY_SUPPORT
+    ? 0x7fffffff
+    : 0x3fffffff
+}
+
+function createBuffer (that, length) {
+  if (kMaxLength() < length) {
+    throw new RangeError('Invalid typed array length')
+  }
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
+    // Return an augmented `Uint8Array` instance, for best performance
+    that = new Uint8Array(length)
+    that.__proto__ = Buffer.prototype
+  } else {
+    // Fallback: Return an object instance of the Buffer class
+    if (that === null) {
+      that = new Buffer(length)
+    }
+    that.length = length
+  }
+
+  return that
+}
+
+/**
+ * The Buffer constructor returns instances of `Uint8Array` that have their
+ * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
+ * `Uint8Array`, so the returned instances will have all the node `Buffer` methods
+ * and the `Uint8Array` methods. Square bracket notation works as expected -- it
+ * returns a single octet.
+ *
+ * The `Uint8Array` prototype remains unmodified.
+ */
+
+function Buffer (arg, encodingOrOffset, length) {
+  if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {
+    return new Buffer(arg, encodingOrOffset, length)
+  }
+
+  // Common case.
+  if (typeof arg === 'number') {
+    if (typeof encodingOrOffset === 'string') {
+      throw new Error(
+        'If encoding is specified then the first argument must be a string'
+      )
+    }
+    return allocUnsafe(this, arg)
+  }
+  return from(this, arg, encodingOrOffset, length)
+}
+
+Buffer.poolSize = 8192 // not used by this implementation
+
+// TODO: Legacy, not needed anymore. Remove in next major version.
+Buffer._augment = function (arr) {
+  arr.__proto__ = Buffer.prototype
+  return arr
+}
+
+function from (that, value, encodingOrOffset, length) {
+  if (typeof value === 'number') {
+    throw new TypeError('"value" argument must not be a number')
+  }
+
+  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {
+    return fromArrayBuffer(that, value, encodingOrOffset, length)
+  }
+
+  if (typeof value === 'string') {
+    return fromString(that, value, encodingOrOffset)
+  }
+
+  return fromObject(that, value)
+}
+
+/**
+ * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
+ * if value is a number.
+ * Buffer.from(str[, encoding])
+ * Buffer.from(array)
+ * Buffer.from(buffer)
+ * Buffer.from(arrayBuffer[, byteOffset[, length]])
+ **/
+Buffer.from = function (value, encodingOrOffset, length) {
+  return from(null, value, encodingOrOffset, length)
+}
+
+if (Buffer.TYPED_ARRAY_SUPPORT) {
+  Buffer.prototype.__proto__ = Uint8Array.prototype
+  Buffer.__proto__ = Uint8Array
+  if (typeof Symbol !== 'undefined' && Symbol.species &&
+      Buffer[Symbol.species] === Buffer) {
+    // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97
+    Object.defineProperty(Buffer, Symbol.species, {
+      value: null,
+      configurable: true
+    })
+  }
+}
+
+function assertSize (size) {
+  if (typeof size !== 'number') {
+    throw new TypeError('"size" argument must be a number')
+  } else if (size < 0) {
+    throw new RangeError('"size" argument must not be negative')
+  }
+}
+
+function alloc (that, size, fill, encoding) {
+  assertSize(size)
+  if (size <= 0) {
+    return createBuffer(that, size)
+  }
+  if (fill !== undefined) {
+    // Only pay attention to encoding if it's a string. This
+    // prevents accidentally sending in a number that would
+    // be interpretted as a start offset.
+    return typeof encoding === 'string'
+      ? createBuffer(that, size).fill(fill, encoding)
+      : createBuffer(that, size).fill(fill)
+  }
+  return createBuffer(that, size)
+}
+
+/**
+ * Creates a new filled Buffer instance.
+ * alloc(size[, fill[, encoding]])
+ **/
+Buffer.alloc = function (size, fill, encoding) {
+  return alloc(null, size, fill, encoding)
+}
+
+function allocUnsafe (that, size) {
+  assertSize(size)
+  that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)
+  if (!Buffer.TYPED_ARRAY_SUPPORT) {
+    for (var i = 0; i < size; ++i) {
+      that[i] = 0
+    }
+  }
+  return that
+}
+
+/**
+ * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
+ * */
+Buffer.allocUnsafe = function (size) {
+  return allocUnsafe(null, size)
+}
+/**
+ * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
+ */
+Buffer.allocUnsafeSlow = function (size) {
+  return allocUnsafe(null, size)
+}
+
+function fromString (that, string, encoding) {
+  if (typeof encoding !== 'string' || encoding === '') {
+    encoding = 'utf8'
+  }
+
+  if (!Buffer.isEncoding(encoding)) {
+    throw new TypeError('"encoding" must be a valid string encoding')
+  }
+
+  var length = byteLength(string, encoding) | 0
+  that = createBuffer(that, length)
+
+  var actual = that.write(string, encoding)
+
+  if (actual !== length) {
+    // Writing a hex string, for example, that contains invalid characters will
+    // cause everything after the first invalid character to be ignored. (e.g.
+    // 'abxxcd' will be treated as 'ab')
+    that = that.slice(0, actual)
+  }
+
+  return that
+}
+
+function fromArrayLike (that, array) {
+  var length = array.length < 0 ? 0 : checked(array.length) | 0
+  that = createBuffer(that, length)
+  for (var i = 0; i < length; i += 1) {
+    that[i] = array[i] & 255
+  }
+  return that
+}
+
+function fromArrayBuffer (that, array, byteOffset, length) {
+  array.byteLength // this throws if `array` is not a valid ArrayBuffer
+
+  if (byteOffset < 0 || array.byteLength < byteOffset) {
+    throw new RangeError('\'offset\' is out of bounds')
+  }
+
+  if (array.byteLength < byteOffset + (length || 0)) {
+    throw new RangeError('\'length\' is out of bounds')
+  }
+
+  if (byteOffset === undefined && length === undefined) {
+    array = new Uint8Array(array)
+  } else if (length === undefined) {
+    array = new Uint8Array(array, byteOffset)
+  } else {
+    array = new Uint8Array(array, byteOffset, length)
+  }
+
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
+    // Return an augmented `Uint8Array` instance, for best performance
+    that = array
+    that.__proto__ = Buffer.prototype
+  } else {
+    // Fallback: Return an object instance of the Buffer class
+    that = fromArrayLike(that, array)
+  }
+  return that
+}
+
+function fromObject (that, obj) {
+  if (Buffer.isBuffer(obj)) {
+    var len = checked(obj.length) | 0
+    that = createBuffer(that, len)
+
+    if (that.length === 0) {
+      return that
+    }
+
+    obj.copy(that, 0, 0, len)
+    return that
+  }
+
+  if (obj) {
+    if ((typeof ArrayBuffer !== 'undefined' &&
+        obj.buffer instanceof ArrayBuffer) || 'length' in obj) {
+      if (typeof obj.length !== 'number' || isnan(obj.length)) {
+        return createBuffer(that, 0)
+      }
+      return fromArrayLike(that, obj)
+    }
+
+    if (obj.type === 'Buffer' && isArray(obj.data)) {
+      return fromArrayLike(that, obj.data)
+    }
+  }
+
+  throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')
+}
+
+function checked (length) {
+  // Note: cannot use `length < kMaxLength()` here because that fails when
+  // length is NaN (which is otherwise coerced to zero.)
+  if (length >= kMaxLength()) {
+    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
+                         'size: 0x' + kMaxLength().toString(16) + ' bytes')
+  }
+  return length | 0
+}
+
+function SlowBuffer (length) {
+  if (+length != length) { // eslint-disable-line eqeqeq
+    length = 0
+  }
+  return Buffer.alloc(+length)
+}
+
+Buffer.isBuffer = function isBuffer (b) {
+  return !!(b != null && b._isBuffer)
+}
+
+Buffer.compare = function compare (a, b) {
+  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
+    throw new TypeError('Arguments must be Buffers')
+  }
+
+  if (a === b) return 0
+
+  var x = a.length
+  var y = b.length
+
+  for (var i = 0, len = Math.min(x, y); i < len; ++i) {
+    if (a[i] !== b[i]) {
+      x = a[i]
+      y = b[i]
+      break
+    }
+  }
+
+  if (x < y) return -1
+  if (y < x) return 1
+  return 0
+}
+
+Buffer.isEncoding = function isEncoding (encoding) {
+  switch (String(encoding).toLowerCase()) {
+    case 'hex':
+    case 'utf8':
+    case 'utf-8':
+    case 'ascii':
+    case 'latin1':
+    case 'binary':
+    case 'base64':
+    case 'ucs2':
+    case 'ucs-2':
+    case 'utf16le':
+    case 'utf-16le':
+      return true
+    default:
+      return false
+  }
+}
+
+Buffer.concat = function concat (list, length) {
+  if (!isArray(list)) {
+    throw new TypeError('"list" argument must be an Array of Buffers')
+  }
+
+  if (list.length === 0) {
+    return Buffer.alloc(0)
+  }
+
+  var i
+  if (length === undefined) {
+    length = 0
+    for (i = 0; i < list.length; ++i) {
+      length += list[i].length
+    }
+  }
+
+  var buffer = Buffer.allocUnsafe(length)
+  var pos = 0
+  for (i = 0; i < list.length; ++i) {
+    var buf = list[i]
+    if (!Buffer.isBuffer(buf)) {
+      throw new TypeError('"list" argument must be an Array of Buffers')
+    }
+    buf.copy(buffer, pos)
+    pos += buf.length
+  }
+  return buffer
+}
+
+function byteLength (string, encoding) {
+  if (Buffer.isBuffer(string)) {
+    return string.length
+  }
+  if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&
+      (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {
+    return string.byteLength
+  }
+  if (typeof string !== 'string') {
+    string = '' + string
+  }
+
+  var len = string.length
+  if (len === 0) return 0
+
+  // Use a for loop to avoid recursion
+  var loweredCase = false
+  for (;;) {
+    switch (encoding) {
+      case 'ascii':
+      case 'latin1':
+      case 'binary':
+        return len
+      case 'utf8':
+      case 'utf-8':
+      case undefined:
+        return utf8ToBytes(string).length
+      case 'ucs2':
+      case 'ucs-2':
+      case 'utf16le':
+      case 'utf-16le':
+        return len * 2
+      case 'hex':
+        return len >>> 1
+      case 'base64':
+        return base64ToBytes(string).length
+      default:
+        if (loweredCase) return utf8ToBytes(string).length // assume utf8
+        encoding = ('' + encoding).toLowerCase()
+        loweredCase = true
+    }
+  }
+}
+Buffer.byteLength = byteLength
+
+function slowToString (encoding, start, end) {
+  var loweredCase = false
+
+  // No need to verify that "this.length <= MAX_UINT32" since it's a read-only
+  // property of a typed array.
+
+  // This behaves neither like String nor Uint8Array in that we set start/end
+  // to their upper/lower bounds if the value passed is out of range.
+  // undefined is handled specially as per ECMA-262 6th Edition,
+  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.
+  if (start === undefined || start < 0) {
+    start = 0
+  }
+  // Return early if start > this.length. Done here to prevent potential uint32
+  // coercion fail below.
+  if (start > this.length) {
+    return ''
+  }
+
+  if (end === undefined || end > this.length) {
+    end = this.length
+  }
+
+  if (end <= 0) {
+    return ''
+  }
+
+  // Force coersion to uint32. This will also coerce falsey/NaN values to 0.
+  end >>>= 0
+  start >>>= 0
+
+  if (end <= start) {
+    return ''
+  }
+
+  if (!encoding) encoding = 'utf8'
+
+  while (true) {
+    switch (encoding) {
+      case 'hex':
+        return hexSlice(this, start, end)
+
+      case 'utf8':
+      case 'utf-8':
+        return utf8Slice(this, start, end)
+
+      case 'ascii':
+        return asciiSlice(this, start, end)
+
+      case 'latin1':
+      case 'binary':
+        return latin1Slice(this, start, end)
+
+      case 'base64':
+        return base64Slice(this, start, end)
+
+      case 'ucs2':
+      case 'ucs-2':
+      case 'utf16le':
+      case 'utf-16le':
+        return utf16leSlice(this, start, end)
+
+      default:
+        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
+        encoding = (encoding + '').toLowerCase()
+        loweredCase = true
+    }
+  }
+}
+
+// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect
+// Buffer instances.
+Buffer.prototype._isBuffer = true
+
+function swap (b, n, m) {
+  var i = b[n]
+  b[n] = b[m]
+  b[m] = i
+}
+
+Buffer.prototype.swap16 = function swap16 () {
+  var len = this.length
+  if (len % 2 !== 0) {
+    throw new RangeError('Buffer size must be a multiple of 16-bits')
+  }
+  for (var i = 0; i < len; i += 2) {
+    swap(this, i, i + 1)
+  }
+  return this
+}
+
+Buffer.prototype.swap32 = function swap32 () {
+  var len = this.length
+  if (len % 4 !== 0) {
+    throw new RangeError('Buffer size must be a multiple of 32-bits')
+  }
+  for (var i = 0; i < len; i += 4) {
+    swap(this, i, i + 3)
+    swap(this, i + 1, i + 2)
+  }
+  return this
+}
+
+Buffer.prototype.swap64 = function swap64 () {
+  var len = this.length
+  if (len % 8 !== 0) {
+    throw new RangeError('Buffer size must be a multiple of 64-bits')
+  }
+  for (var i = 0; i < len; i += 8) {
+    swap(this, i, i + 7)
+    swap(this, i + 1, i + 6)
+    swap(this, i + 2, i + 5)
+    swap(this, i + 3, i + 4)
+  }
+  return this
+}
+
+Buffer.prototype.toString = function toString () {
+  var length = this.length | 0
+  if (length === 0) return ''
+  if (arguments.length === 0) return utf8Slice(this, 0, length)
+  return slowToString.apply(this, arguments)
+}
+
+Buffer.prototype.equals = function equals (b) {
+  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
+  if (this === b) return true
+  return Buffer.compare(this, b) === 0
+}
+
+Buffer.prototype.inspect = function inspect () {
+  var str = ''
+  var max = exports.INSPECT_MAX_BYTES
+  if (this.length > 0) {
+    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')
+    if (this.length > max) str += ' ... '
+  }
+  return '<Buffer ' + str + '>'
+}
+
+Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {
+  if (!Buffer.isBuffer(target)) {
+    throw new TypeError('Argument must be a Buffer')
+  }
+
+  if (start === undefined) {
+    start = 0
+  }
+  if (end === undefined) {
+    end = target ? target.length : 0
+  }
+  if (thisStart === undefined) {
+    thisStart = 0
+  }
+  if (thisEnd === undefined) {
+    thisEnd = this.length
+  }
+
+  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
+    throw new RangeError('out of range index')
+  }
+
+  if (thisStart >= thisEnd && start >= end) {
+    return 0
+  }
+  if (thisStart >= thisEnd) {
+    return -1
+  }
+  if (start >= end) {
+    return 1
+  }
+
+  start >>>= 0
+  end >>>= 0
+  thisStart >>>= 0
+  thisEnd >>>= 0
+
+  if (this === target) return 0
+
+  var x = thisEnd - thisStart
+  var y = end - start
+  var len = Math.min(x, y)
+
+  var thisCopy = this.slice(thisStart, thisEnd)
+  var targetCopy = target.slice(start, end)
+
+  for (var i = 0; i < len; ++i) {
+    if (thisCopy[i] !== targetCopy[i]) {
+      x = thisCopy[i]
+      y = targetCopy[i]
+      break
+    }
+  }
+
+  if (x < y) return -1
+  if (y < x) return 1
+  return 0
+}
+
+// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
+// OR the last index of `val` in `buffer` at offset <= `byteOffset`.
+//
+// Arguments:
+// - buffer - a Buffer to search
+// - val - a string, Buffer, or number
+// - byteOffset - an index into `buffer`; will be clamped to an int32
+// - encoding - an optional encoding, relevant is val is a string
+// - dir - true for indexOf, false for lastIndexOf
+function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {
+  // Empty buffer means no match
+  if (buffer.length === 0) return -1
+
+  // Normalize byteOffset
+  if (typeof byteOffset === 'string') {
+    encoding = byteOffset
+    byteOffset = 0
+  } else if (byteOffset > 0x7fffffff) {
+    byteOffset = 0x7fffffff
+  } else if (byteOffset < -0x80000000) {
+    byteOffset = -0x80000000
+  }
+  byteOffset = +byteOffset  // Coerce to Number.
+  if (isNaN(byteOffset)) {
+    // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer
+    byteOffset = dir ? 0 : (buffer.length - 1)
+  }
+
+  // Normalize byteOffset: negative offsets start from the end of the buffer
+  if (byteOffset < 0) byteOffset = buffer.length + byteOffset
+  if (byteOffset >= buffer.length) {
+    if (dir) return -1
+    else byteOffset = buffer.length - 1
+  } else if (byteOffset < 0) {
+    if (dir) byteOffset = 0
+    else return -1
+  }
+
+  // Normalize val
+  if (typeof val === 'string') {
+    val = Buffer.from(val, encoding)
+  }
+
+  // Finally, search either indexOf (if dir is true) or lastIndexOf
+  if (Buffer.isBuffer(val)) {
+    // Special case: looking for empty string/buffer always fails
+    if (val.length === 0) {
+      return -1
+    }
+    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)
+  } else if (typeof val === 'number') {
+    val = val & 0xFF // Search for a byte value [0-255]
+    if (Buffer.TYPED_ARRAY_SUPPORT &&
+        typeof Uint8Array.prototype.indexOf === 'function') {
+      if (dir) {
+        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)
+      } else {
+        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)
+      }
+    }
+    return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)
+  }
+
+  throw new TypeError('val must be string, number or Buffer')
+}
+
+function arrayIndexOf (arr, val, byteOffset, encoding, dir) {
+  var indexSize = 1
+  var arrLength = arr.length
+  var valLength = val.length
+
+  if (encoding !== undefined) {
+    encoding = String(encoding).toLowerCase()
+    if (encoding === 'ucs2' || encoding === 'ucs-2' ||
+        encoding === 'utf16le' || encoding === 'utf-16le') {
+      if (arr.length < 2 || val.length < 2) {
+        return -1
+      }
+      indexSize = 2
+      arrLength /= 2
+      valLength /= 2
+      byteOffset /= 2
+    }
+  }
+
+  function read (buf, i) {
+    if (indexSize === 1) {
+      return buf[i]
+    } else {
+      return buf.readUInt16BE(i * indexSize)
+    }
+  }
+
+  var i
+  if (dir) {
+    var foundIndex = -1
+    for (i = byteOffset; i < arrLength; i++) {
+      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
+        if (foundIndex === -1) foundIndex = i
+        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize
+      } else {
+        if (foundIndex !== -1) i -= i - foundIndex
+        foundIndex = -1
+      }
+    }
+  } else {
+    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength
+    for (i = byteOffset; i >= 0; i--) {
+      var found = true
+      for (var j = 0; j < valLength; j++) {
+        if (read(arr, i + j) !== read(val, j)) {
+          found = false
+          break
+        }
+      }
+      if (found) return i
+    }
+  }
+
+  return -1
+}
+
+Buffer.prototype.includes = function includes (val, byteOffset, encoding) {
+  return this.indexOf(val, byteOffset, encoding) !== -1
+}
+
+Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {
+  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
+}
+
+Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {
+  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)
+}
+
+function hexWrite (buf, string, offset, length) {
+  offset = Number(offset) || 0
+  var remaining = buf.length - offset
+  if (!length) {
+    length = remaining
+  } else {
+    length = Number(length)
+    if (length > remaining) {
+      length = remaining
+    }
+  }
+
+  // must be an even number of digits
+  var strLen = string.length
+  if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')
+
+  if (length > strLen / 2) {
+    length = strLen / 2
+  }
+  for (var i = 0; i < length; ++i) {
+    var parsed = parseInt(string.substr(i * 2, 2), 16)
+    if (isNaN(parsed)) return i
+    buf[offset + i] = parsed
+  }
+  return i
+}
+
+function utf8Write (buf, string, offset, length) {
+  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
+}
+
+function asciiWrite (buf, string, offset, length) {
+  return blitBuffer(asciiToBytes(string), buf, offset, length)
+}
+
+function latin1Write (buf, string, offset, length) {
+  return asciiWrite(buf, string, offset, length)
+}
+
+function base64Write (buf, string, offset, length) {
+  return blitBuffer(base64ToBytes(string), buf, offset, length)
+}
+
+function ucs2Write (buf, string, offset, length) {
+  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
+}
+
+Buffer.prototype.write = function write (string, offset, length, encoding) {
+  // Buffer#write(string)
+  if (offset === undefined) {
+    encoding = 'utf8'
+    length = this.length
+    offset = 0
+  // Buffer#write(string, encoding)
+  } else if (length === undefined && typeof offset === 'string') {
+    encoding = offset
+    length = this.length
+    offset = 0
+  // Buffer#write(string, offset[, length][, encoding])
+  } else if (isFinite(offset)) {
+    offset = offset | 0
+    if (isFinite(length)) {
+      length = length | 0
+      if (encoding === undefined) encoding = 'utf8'
+    } else {
+      encoding = length
+      length = undefined
+    }
+  // legacy write(string, encoding, offset, length) - remove in v0.13
+  } else {
+    throw new Error(
+      'Buffer.write(string, encoding, offset[, length]) is no longer supported'
+    )
+  }
+
+  var remaining = this.length - offset
+  if (length === undefined || length > remaining) length = remaining
+
+  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
+    throw new RangeError('Attempt to write outside buffer bounds')
+  }
+
+  if (!encoding) encoding = 'utf8'
+
+  var loweredCase = false
+  for (;;) {
+    switch (encoding) {
+      case 'hex':
+        return hexWrite(this, string, offset, length)
+
+      case 'utf8':
+      case 'utf-8':
+        return utf8Write(this, string, offset, length)
+
+      case 'ascii':
+        return asciiWrite(this, string, offset, length)
+
+      case 'latin1':
+      case 'binary':
+        return latin1Write(this, string, offset, length)
+
+      case 'base64':
+        // Warning: maxLength not taken into account in base64Write
+        return base64Write(this, string, offset, length)
+
+      case 'ucs2':
+      case 'ucs-2':
+      case 'utf16le':
+      case 'utf-16le':
+        return ucs2Write(this, string, offset, length)
+
+      default:
+        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
+        encoding = ('' + encoding).toLowerCase()
+        loweredCase = true
+    }
+  }
+}
+
+Buffer.prototype.toJSON = function toJSON () {
+  return {
+    type: 'Buffer',
+    data: Array.prototype.slice.call(this._arr || this, 0)
+  }
+}
+
+function base64Slice (buf, start, end) {
+  if (start === 0 && end === buf.length) {
+    return base64.fromByteArray(buf)
+  } else {
+    return base64.fromByteArray(buf.slice(start, end))
+  }
+}
+
+function utf8Slice (buf, start, end) {
+  end = Math.min(buf.length, end)
+  var res = []
+
+  var i = start
+  while (i < end) {
+    var firstByte = buf[i]
+    var codePoint = null
+    var bytesPerSequence = (firstByte > 0xEF) ? 4
+      : (firstByte > 0xDF) ? 3
+      : (firstByte > 0xBF) ? 2
+      : 1
+
+    if (i + bytesPerSequence <= end) {
+      var secondByte, thirdByte, fourthByte, tempCodePoint
+
+      switch (bytesPerSequence) {
+        case 1:
+          if (firstByte < 0x80) {
+            codePoint = firstByte
+          }
+          break
+        case 2:
+          secondByte = buf[i + 1]
+          if ((secondByte & 0xC0) === 0x80) {
+            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)
+            if (tempCodePoint > 0x7F) {
+              codePoint = tempCodePoint
+            }
+          }
+          break
+        case 3:
+          secondByte = buf[i + 1]
+          thirdByte = buf[i + 2]
+          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
+            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)
+            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
+              codePoint = tempCodePoint
+            }
+          }
+          break
+        case 4:
+          secondByte = buf[i + 1]
+          thirdByte = buf[i + 2]
+          fourthByte = buf[i + 3]
+          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
+            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)
+            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
+              codePoint = tempCodePoint
+            }
+          }
+      }
+    }
+
+    if (codePoint === null) {
+      // we did not generate a valid codePoint so insert a
+      // replacement char (U+FFFD) and advance only 1 byte
+      codePoint = 0xFFFD
+      bytesPerSequence = 1
+    } else if (codePoint > 0xFFFF) {
+      // encode to utf16 (surrogate pair dance)
+      codePoint -= 0x10000
+      res.push(codePoint >>> 10 & 0x3FF | 0xD800)
+      codePoint = 0xDC00 | codePoint & 0x3FF
+    }
+
+    res.push(codePoint)
+    i += bytesPerSequence
+  }
+
+  return decodeCodePointsArray(res)
+}
+
+// Based on http://stackoverflow.com/a/22747272/680742, the browser with
+// the lowest limit is Chrome, with 0x10000 args.
+// We go 1 magnitude less, for safety
+var MAX_ARGUMENTS_LENGTH = 0x1000
+
+function decodeCodePointsArray (codePoints) {
+  var len = codePoints.length
+  if (len <= MAX_ARGUMENTS_LENGTH) {
+    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()
+  }
+
+  // Decode in chunks to avoid "call stack size exceeded".
+  var res = ''
+  var i = 0
+  while (i < len) {
+    res += String.fromCharCode.apply(
+      String,
+      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
+    )
+  }
+  return res
+}
+
+function asciiSlice (buf, start, end) {
+  var ret = ''
+  end = Math.min(buf.length, end)
+
+  for (var i = start; i < end; ++i) {
+    ret += String.fromCharCode(buf[i] & 0x7F)
+  }
+  return ret
+}
+
+function latin1Slice (buf, start, end) {
+  var ret = ''
+  end = Math.min(buf.length, end)
+
+  for (var i = start; i < end; ++i) {
+    ret += String.fromCharCode(buf[i])
+  }
+  return ret
+}
+
+function hexSlice (buf, start, end) {
+  var len = buf.length
+
+  if (!start || start < 0) start = 0
+  if (!end || end < 0 || end > len) end = len
+
+  var out = ''
+  for (var i = start; i < end; ++i) {
+    out += toHex(buf[i])
+  }
+  return out
+}
+
+function utf16leSlice (buf, start, end) {
+  var bytes = buf.slice(start, end)
+  var res = ''
+  for (var i = 0; i < bytes.length; i += 2) {
+    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)
+  }
+  return res
+}
+
+Buffer.prototype.slice = function slice (start, end) {
+  var len = this.length
+  start = ~~start
+  end = end === undefined ? len : ~~end
+
+  if (start < 0) {
+    start += len
+    if (start < 0) start = 0
+  } else if (start > len) {
+    start = len
+  }
+
+  if (end < 0) {
+    end += len
+    if (end < 0) end = 0
+  } else if (end > len) {
+    end = len
+  }
+
+  if (end < start) end = start
+
+  var newBuf
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
+    newBuf = this.subarray(start, end)
+    newBuf.__proto__ = Buffer.prototype
+  } else {
+    var sliceLen = end - start
+    newBuf = new Buffer(sliceLen, undefined)
+    for (var i = 0; i < sliceLen; ++i) {
+      newBuf[i] = this[i + start]
+    }
+  }
+
+  return newBuf
+}
+
+/*
+ * Need to make sure that buffer isn't trying to write out of bounds.
+ */
+function checkOffset (offset, ext, length) {
+  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')
+  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')
+}
+
+Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {
+  offset = offset | 0
+  byteLength = byteLength | 0
+  if (!noAssert) checkOffset(offset, byteLength, this.length)
+
+  var val = this[offset]
+  var mul = 1
+  var i = 0
+  while (++i < byteLength && (mul *= 0x100)) {
+    val += this[offset + i] * mul
+  }
+
+  return val
+}
+
+Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {
+  offset = offset | 0
+  byteLength = byteLength | 0
+  if (!noAssert) {
+    checkOffset(offset, byteLength, this.length)
+  }
+
+  var val = this[offset + --byteLength]
+  var mul = 1
+  while (byteLength > 0 && (mul *= 0x100)) {
+    val += this[offset + --byteLength] * mul
+  }
+
+  return val
+}
+
+Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {
+  if (!noAssert) checkOffset(offset, 1, this.length)
+  return this[offset]
+}
+
+Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
+  if (!noAssert) checkOffset(offset, 2, this.length)
+  return this[offset] | (this[offset + 1] << 8)
+}
+
+Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
+  if (!noAssert) checkOffset(offset, 2, this.length)
+  return (this[offset] << 8) | this[offset + 1]
+}
+
+Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
+  if (!noAssert) checkOffset(offset, 4, this.length)
+
+  return ((this[offset]) |
+      (this[offset + 1] << 8) |
+      (this[offset + 2] << 16)) +
+      (this[offset + 3] * 0x1000000)
+}
+
+Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {
+  if (!noAssert) checkOffset(offset, 4, this.length)
+
+  return (this[offset] * 0x1000000) +
+    ((this[offset + 1] << 16) |
+    (this[offset + 2] << 8) |
+    this[offset + 3])
+}
+
+Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {
+  offset = offset | 0
+  byteLength = byteLength | 0
+  if (!noAssert) checkOffset(offset, byteLength, this.length)
+
+  var val = this[offset]
+  var mul = 1
+  var i = 0
+  while (++i < byteLength && (mul *= 0x100)) {
+    val += this[offset + i] * mul
+  }
+  mul *= 0x80
+
+  if (val >= mul) val -= Math.pow(2, 8 * byteLength)
+
+  return val
+}
+
+Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {
+  offset = offset | 0
+  byteLength = byteLength | 0
+  if (!noAssert) checkOffset(offset, byteLength, this.length)
+
+  var i = byteLength
+  var mul = 1
+  var val = this[offset + --i]
+  while (i > 0 && (mul *= 0x100)) {
+    val += this[offset + --i] * mul
+  }
+  mul *= 0x80
+
+  if (val >= mul) val -= Math.pow(2, 8 * byteLength)
+
+  return val
+}
+
+Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) {
+  if (!noAssert) checkOffset(offset, 1, this.length)
+  if (!(this[offset] & 0x80)) return (this[offset])
+  return ((0xff - this[offset] + 1) * -1)
+}
+
+Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {
+  if (!noAssert) checkOffset(offset, 2, this.length)
+  var val = this[offset] | (this[offset + 1] << 8)
+  return (val & 0x8000) ? val | 0xFFFF0000 : val
+}
+
+Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {
+  if (!noAssert) checkOffset(offset, 2, this.length)
+  var val = this[offset + 1] | (this[offset] << 8)
+  return (val & 0x8000) ? val | 0xFFFF0000 : val
+}
+
+Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {
+  if (!noAssert) checkOffset(offset, 4, this.length)
+
+  return (this[offset]) |
+    (this[offset + 1] << 8) |
+    (this[offset + 2] << 16) |
+    (this[offset + 3] << 24)
+}
+
+Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {
+  if (!noAssert) checkOffset(offset, 4, this.length)
+
+  return (this[offset] << 24) |
+    (this[offset + 1] << 16) |
+    (this[offset + 2] << 8) |
+    (this[offset + 3])
+}
+
+Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {
+  if (!noAssert) checkOffset(offset, 4, this.length)
+  return ieee754.read(this, offset, true, 23, 4)
+}
+
+Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {
+  if (!noAssert) checkOffset(offset, 4, this.length)
+  return ieee754.read(this, offset, false, 23, 4)
+}
+
+Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {
+  if (!noAssert) checkOffset(offset, 8, this.length)
+  return ieee754.read(this, offset, true, 52, 8)
+}
+
+Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {
+  if (!noAssert) checkOffset(offset, 8, this.length)
+  return ieee754.read(this, offset, false, 52, 8)
+}
+
+function checkInt (buf, value, offset, ext, max, min) {
+  if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance')
+  if (value > max || value < min) throw new RangeError('"value" argument is out of bounds')
+  if (offset + ext > buf.length) throw new RangeError('Index out of range')
+}
+
+Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {
+  value = +value
+  offset = offset | 0
+  byteLength = byteLength | 0
+  if (!noAssert) {
+    var maxBytes = Math.pow(2, 8 * byteLength) - 1
+    checkInt(this, value, offset, byteLength, maxBytes, 0)
+  }
+
+  var mul = 1
+  var i = 0
+  this[offset] = value & 0xFF
+  while (++i < byteLength && (mul *= 0x100)) {
+    this[offset + i] = (value / mul) & 0xFF
+  }
+
+  return offset + byteLength
+}
+
+Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {
+  value = +value
+  offset = offset | 0
+  byteLength = byteLength | 0
+  if (!noAssert) {
+    var maxBytes = Math.pow(2, 8 * byteLength) - 1
+    checkInt(this, value, offset, byteLength, maxBytes, 0)
+  }
+
+  var i = byteLength - 1
+  var mul = 1
+  this[offset + i] = value & 0xFF
+  while (--i >= 0 && (mul *= 0x100)) {
+    this[offset + i] = (value / mul) & 0xFF
+  }
+
+  return offset + byteLength
+}
+
+Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {
+  value = +value
+  offset = offset | 0
+  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)
+  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
+  this[offset] = (value & 0xff)
+  return offset + 1
+}
+
+function objectWriteUInt16 (buf, value, offset, littleEndian) {
+  if (value < 0) value = 0xffff + value + 1
+  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {
+    buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>
+      (littleEndian ? i : 1 - i) * 8
+  }
+}
+
+Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {
+  value = +value
+  offset = offset | 0
+  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
+    this[offset] = (value & 0xff)
+    this[offset + 1] = (value >>> 8)
+  } else {
+    objectWriteUInt16(this, value, offset, true)
+  }
+  return offset + 2
+}
+
+Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {
+  value = +value
+  offset = offset | 0
+  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
+    this[offset] = (value >>> 8)
+    this[offset + 1] = (value & 0xff)
+  } else {
+    objectWriteUInt16(this, value, offset, false)
+  }
+  return offset + 2
+}
+
+function objectWriteUInt32 (buf, value, offset, littleEndian) {
+  if (value < 0) value = 0xffffffff + value + 1
+  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {
+    buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff
+  }
+}
+
+Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {
+  value = +value
+  offset = offset | 0
+  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
+    this[offset + 3] = (value >>> 24)
+    this[offset + 2] = (value >>> 16)
+    this[offset + 1] = (value >>> 8)
+    this[offset] = (value & 0xff)
+  } else {
+    objectWriteUInt32(this, value, offset, true)
+  }
+  return offset + 4
+}
+
+Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {
+  value = +value
+  offset = offset | 0
+  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
+    this[offset] = (value >>> 24)
+    this[offset + 1] = (value >>> 16)
+    this[offset + 2] = (value >>> 8)
+    this[offset + 3] = (value & 0xff)
+  } else {
+    objectWriteUInt32(this, value, offset, false)
+  }
+  return offset + 4
+}
+
+Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {
+  value = +value
+  offset = offset | 0
+  if (!noAssert) {
+    var limit = Math.pow(2, 8 * byteLength - 1)
+
+    checkInt(this, value, offset, byteLength, limit - 1, -limit)
+  }
+
+  var i = 0
+  var mul = 1
+  var sub = 0
+  this[offset] = value & 0xFF
+  while (++i < byteLength && (mul *= 0x100)) {
+    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
+      sub = 1
+    }
+    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
+  }
+
+  return offset + byteLength
+}
+
+Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {
+  value = +value
+  offset = offset | 0
+  if (!noAssert) {
+    var limit = Math.pow(2, 8 * byteLength - 1)
+
+    checkInt(this, value, offset, byteLength, limit - 1, -limit)
+  }
+
+  var i = byteLength - 1
+  var mul = 1
+  var sub = 0
+  this[offset + i] = value & 0xFF
+  while (--i >= 0 && (mul *= 0x100)) {
+    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
+      sub = 1
+    }
+    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
+  }
+
+  return offset + byteLength
+}
+
+Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {
+  value = +value
+  offset = offset | 0
+  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)
+  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
+  if (value < 0) value = 0xff + value + 1
+  this[offset] = (value & 0xff)
+  return offset + 1
+}
+
+Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {
+  value = +value
+  offset = offset | 0
+  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
+    this[offset] = (value & 0xff)
+    this[offset + 1] = (value >>> 8)
+  } else {
+    objectWriteUInt16(this, value, offset, true)
+  }
+  return offset + 2
+}
+
+Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {
+  value = +value
+  offset = offset | 0
+  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
+    this[offset] = (value >>> 8)
+    this[offset + 1] = (value & 0xff)
+  } else {
+    objectWriteUInt16(this, value, offset, false)
+  }
+  return offset + 2
+}
+
+Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {
+  value = +value
+  offset = offset | 0
+  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
+    this[offset] = (value & 0xff)
+    this[offset + 1] = (value >>> 8)
+    this[offset + 2] = (value >>> 16)
+    this[offset + 3] = (value >>> 24)
+  } else {
+    objectWriteUInt32(this, value, offset, true)
+  }
+  return offset + 4
+}
+
+Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {
+  value = +value
+  offset = offset | 0
+  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
+  if (value < 0) value = 0xffffffff + value + 1
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
+    this[offset] = (value >>> 24)
+    this[offset + 1] = (value >>> 16)
+    this[offset + 2] = (value >>> 8)
+    this[offset + 3] = (value & 0xff)
+  } else {
+    objectWriteUInt32(this, value, offset, false)
+  }
+  return offset + 4
+}
+
+function checkIEEE754 (buf, value, offset, ext, max, min) {
+  if (offset + ext > buf.length) throw new RangeError('Index out of range')
+  if (offset < 0) throw new RangeError('Index out of range')
+}
+
+function writeFloat (buf, value, offset, littleEndian, noAssert) {
+  if (!noAssert) {
+    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)
+  }
+  ieee754.write(buf, value, offset, littleEndian, 23, 4)
+  return offset + 4
+}
+
+Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {
+  return writeFloat(this, value, offset, true, noAssert)
+}
+
+Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {
+  return writeFloat(this, value, offset, false, noAssert)
+}
+
+function writeDouble (buf, value, offset, littleEndian, noAssert) {
+  if (!noAssert) {
+    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)
+  }
+  ieee754.write(buf, value, offset, littleEndian, 52, 8)
+  return offset + 8
+}
+
+Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {
+  return writeDouble(this, value, offset, true, noAssert)
+}
+
+Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {
+  return writeDouble(this, value, offset, false, noAssert)
+}
+
+// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
+Buffer.prototype.copy = function copy (target, targetStart, start, end) {
+  if (!start) start = 0
+  if (!end && end !== 0) end = this.length
+  if (targetStart >= target.length) targetStart = target.length
+  if (!targetStart) targetStart = 0
+  if (end > 0 && end < start) end = start
+
+  // Copy 0 bytes; we're done
+  if (end === start) return 0
+  if (target.length === 0 || this.length === 0) return 0
+
+  // Fatal error conditions
+  if (targetStart < 0) {
+    throw new RangeError('targetStart out of bounds')
+  }
+  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')
+  if (end < 0) throw new RangeError('sourceEnd out of bounds')
+
+  // Are we oob?
+  if (end > this.length) end = this.length
+  if (target.length - targetStart < end - start) {
+    end = target.length - targetStart + start
+  }
+
+  var len = end - start
+  var i
+
+  if (this === target && start < targetStart && targetStart < end) {
+    // descending copy from end
+    for (i = len - 1; i >= 0; --i) {
+      target[i + targetStart] = this[i + start]
+    }
+  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {
+    // ascending copy from start
+    for (i = 0; i < len; ++i) {
+      target[i + targetStart] = this[i + start]
+    }
+  } else {
+    Uint8Array.prototype.set.call(
+      target,
+      this.subarray(start, start + len),
+      targetStart
+    )
+  }
+
+  return len
+}
+
+// Usage:
+//    buffer.fill(number[, offset[, end]])
+//    buffer.fill(buffer[, offset[, end]])
+//    buffer.fill(string[, offset[, end]][, encoding])
+Buffer.prototype.fill = function fill (val, start, end, encoding) {
+  // Handle string cases:
+  if (typeof val === 'string') {
+    if (typeof start === 'string') {
+      encoding = start
+      start = 0
+      end = this.length
+    } else if (typeof end === 'string') {
+      encoding = end
+      end = this.length
+    }
+    if (val.length === 1) {
+      var code = val.charCodeAt(0)
+      if (code < 256) {
+        val = code
+      }
+    }
+    if (encoding !== undefined && typeof encoding !== 'string') {
+      throw new TypeError('encoding must be a string')
+    }
+    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {
+      throw new TypeError('Unknown encoding: ' + encoding)
+    }
+  } else if (typeof val === 'number') {
+    val = val & 255
+  }
+
+  // Invalid ranges are not set to a default, so can range check early.
+  if (start < 0 || this.length < start || this.length < end) {
+    throw new RangeError('Out of range index')
+  }
+
+  if (end <= start) {
+    return this
+  }
+
+  start = start >>> 0
+  end = end === undefined ? this.length : end >>> 0
+
+  if (!val) val = 0
+
+  var i
+  if (typeof val === 'number') {
+    for (i = start; i < end; ++i) {
+      this[i] = val
+    }
+  } else {
+    var bytes = Buffer.isBuffer(val)
+      ? val
+      : utf8ToBytes(new Buffer(val, encoding).toString())
+    var len = bytes.length
+    for (i = 0; i < end - start; ++i) {
+      this[i + start] = bytes[i % len]
+    }
+  }
+
+  return this
+}
+
+// HELPER FUNCTIONS
+// ================
+
+var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g
+
+function base64clean (str) {
+  // Node strips out invalid characters like \n and \t from the string, base64-js does not
+  str = stringtrim(str).replace(INVALID_BASE64_RE, '')
+  // Node converts strings with length < 2 to ''
+  if (str.length < 2) return ''
+  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
+  while (str.length % 4 !== 0) {
+    str = str + '='
+  }
+  return str
+}
+
+function stringtrim (str) {
+  if (str.trim) return str.trim()
+  return str.replace(/^\s+|\s+$/g, '')
+}
+
+function toHex (n) {
+  if (n < 16) return '0' + n.toString(16)
+  return n.toString(16)
+}
+
+function utf8ToBytes (string, units) {
+  units = units || Infinity
+  var codePoint
+  var length = string.length
+  var leadSurrogate = null
+  var bytes = []
+
+  for (var i = 0; i < length; ++i) {
+    codePoint = string.charCodeAt(i)
+
+    // is surrogate component
+    if (codePoint > 0xD7FF && codePoint < 0xE000) {
+      // last char was a lead
+      if (!leadSurrogate) {
+        // no lead yet
+        if (codePoint > 0xDBFF) {
+          // unexpected trail
+          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+          continue
+        } else if (i + 1 === length) {
+          // unpaired lead
+          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+          continue
+        }
+
+        // valid lead
+        leadSurrogate = codePoint
+
+        continue
+      }
+
+      // 2 leads in a row
+      if (codePoint < 0xDC00) {
+        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+        leadSurrogate = codePoint
+        continue
+      }
+
+      // valid surrogate pair
+      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000
+    } else if (leadSurrogate) {
+      // valid bmp char, but last char was a lead
+      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+    }
+
+    leadSurrogate = null
+
+    // encode utf8
+    if (codePoint < 0x80) {
+      if ((units -= 1) < 0) break
+      bytes.push(codePoint)
+    } else if (codePoint < 0x800) {
+      if ((units -= 2) < 0) break
+      bytes.push(
+        codePoint >> 0x6 | 0xC0,
+        codePoint & 0x3F | 0x80
+      )
+    } else if (codePoint < 0x10000) {
+      if ((units -= 3) < 0) break
+      bytes.push(
+        codePoint >> 0xC | 0xE0,
+        codePoint >> 0x6 & 0x3F | 0x80,
+        codePoint & 0x3F | 0x80
+      )
+    } else if (codePoint < 0x110000) {
+      if ((units -= 4) < 0) break
+      bytes.push(
+        codePoint >> 0x12 | 0xF0,
+        codePoint >> 0xC & 0x3F | 0x80,
+        codePoint >> 0x6 & 0x3F | 0x80,
+        codePoint & 0x3F | 0x80
+      )
+    } else {
+      throw new Error('Invalid code point')
+    }
+  }
+
+  return bytes
+}
+
+function asciiToBytes (str) {
+  var byteArray = []
+  for (var i = 0; i < str.length; ++i) {
+    // Node's code seems to be doing this and not & 0x7F..
+    byteArray.push(str.charCodeAt(i) & 0xFF)
+  }
+  return byteArray
+}
+
+function utf16leToBytes (str, units) {
+  var c, hi, lo
+  var byteArray = []
+  for (var i = 0; i < str.length; ++i) {
+    if ((units -= 2) < 0) break
+
+    c = str.charCodeAt(i)
+    hi = c >> 8
+    lo = c % 256
+    byteArray.push(lo)
+    byteArray.push(hi)
+  }
+
+  return byteArray
+}
+
+function base64ToBytes (str) {
+  return base64.toByteArray(base64clean(str))
+}
+
+function blitBuffer (src, dst, offset, length) {
+  for (var i = 0; i < length; ++i) {
+    if ((i + offset >= dst.length) || (i >= src.length)) break
+    dst[i + offset] = src[i]
+  }
+  return i
+}
+
+function isnan (val) {
+  return val !== val // eslint-disable-line no-self-compare
+}
diff --git a/node_modules/buffer/package.json b/node_modules/buffer/package.json
new file mode 100644
index 000000000..186a6b154
--- /dev/null
+++ b/node_modules/buffer/package.json
@@ -0,0 +1,77 @@
+{
+  "name": "buffer",
+  "description": "Node.js Buffer API, for the browser",
+  "version": "4.9.1",
+  "author": {
+    "name": "Feross Aboukhadijeh",
+    "email": "feross@feross.org",
+    "url": "http://feross.org"
+  },
+  "bugs": {
+    "url": "https://github.com/feross/buffer/issues"
+  },
+  "contributors": [
+    "Romain Beauxis <toots@rastageeks.org>",
+    "James Halliday <mail@substack.net>"
+  ],
+  "dependencies": {
+    "base64-js": "^1.0.2",
+    "ieee754": "^1.1.4",
+    "isarray": "^1.0.0"
+  },
+  "devDependencies": {
+    "benchmark": "^2.0.0",
+    "browserify": "^13.0.0",
+    "concat-stream": "^1.4.7",
+    "hyperquest": "^2.0.0",
+    "is-buffer": "^1.1.1",
+    "is-nan": "^1.0.1",
+    "split": "^1.0.0",
+    "standard": "^7.0.0",
+    "tape": "^4.0.0",
+    "through2": "^2.0.0",
+    "zuul": "^3.0.0"
+  },
+  "homepage": "https://github.com/feross/buffer",
+  "jspm": {
+    "map": {
+      "./index.js": {
+        "node": "@node/buffer"
+      }
+    }
+  },
+  "keywords": [
+    "arraybuffer",
+    "browser",
+    "browserify",
+    "buffer",
+    "compatible",
+    "dataview",
+    "uint8array"
+  ],
+  "license": "MIT",
+  "main": "index.js",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/feross/buffer.git"
+  },
+  "scripts": {
+    "perf": "browserify --debug perf/bracket-notation.js > perf/bundle.js && open perf/index.html",
+    "perf-node": "node perf/bracket-notation.js && node perf/concat.js && node perf/copy-big.js && node perf/copy.js && node perf/new-big.js && node perf/new.js && node perf/readDoubleBE.js && node perf/readFloatBE.js && node perf/readUInt32LE.js && node perf/slice.js && node perf/writeFloatBE.js",
+    "size": "browserify -r ./ | uglifyjs -c -m | gzip | wc -c",
+    "test": "standard && node ./bin/test.js",
+    "test-browser-es5": "zuul --ui tape -- test/*.js",
+    "test-browser-es5-local": "zuul --ui tape --local -- test/*.js",
+    "test-browser-es6": "zuul --ui tape -- test/*.js test/node/*.js",
+    "test-browser-es6-local": "zuul --ui tape --local -- test/*.js test/node/*.js",
+    "test-node": "tape test/*.js test/node/*.js && OBJECT_IMPL=true tape test/*.js",
+    "update-authors": "./bin/update-authors.sh"
+  },
+  "standard": {
+    "ignore": [
+      "test/node/*.js",
+      "test/_polyfill.js",
+      "perf/*.js"
+    ]
+  }
+}
diff --git a/node_modules/buffer/test/_polyfill.js b/node_modules/buffer/test/_polyfill.js
new file mode 100644
index 000000000..61f9c1801
--- /dev/null
+++ b/node_modules/buffer/test/_polyfill.js
@@ -0,0 +1,150 @@
+if (!Array.prototype.forEach) {
+
+  Array.prototype.forEach = function(callback, thisArg) {
+
+    var T, k;
+
+    if (this == null) {
+      throw new TypeError(' this is null or not defined');
+    }
+
+    // 1. Let O be the result of calling ToObject passing the |this| value as the argument.
+    var O = Object(this);
+
+    // 2. Let lenValue be the result of calling the Get internal method of O with the argument "length".
+    // 3. Let len be ToUint32(lenValue).
+    var len = O.length >>> 0;
+
+    // 4. If IsCallable(callback) is false, throw a TypeError exception.
+    // See: http://es5.github.com/#x9.11
+    if (typeof callback !== "function") {
+      throw new TypeError(callback + ' is not a function');
+    }
+
+    // 5. If thisArg was supplied, let T be thisArg; else let T be undefined.
+    if (arguments.length > 1) {
+      T = thisArg;
+    }
+
+    // 6. Let k be 0
+    k = 0;
+
+    // 7. Repeat, while k < len
+    while (k < len) {
+
+      var kValue;
+
+      // a. Let Pk be ToString(k).
+      //   This is implicit for LHS operands of the in operator
+      // b. Let kPresent be the result of calling the HasProperty internal method of O with argument Pk.
+      //   This step can be combined with c
+      // c. If kPresent is true, then
+      if (k in O) {
+
+        // i. Let kValue be the result of calling the Get internal method of O with argument Pk.
+        kValue = O[k];
+
+        // ii. Call the Call internal method of callback with T as the this value and
+        // argument list containing kValue, k, and O.
+        callback.call(T, kValue, k, O);
+      }
+      // d. Increase k by 1.
+      k++;
+    }
+    // 8. return undefined
+  };
+}
+
+if (!Array.isArray) {
+  Array.isArray = function(arg) {
+    return Object.prototype.toString.call(arg) === '[object Array]';
+  };
+}
+
+if (!Array.prototype.map) {
+
+  Array.prototype.map = function(callback, thisArg) {
+
+    var T, A, k;
+
+    if (this == null) {
+      throw new TypeError(' this is null or not defined');
+    }
+
+    // 1. Let O be the result of calling ToObject passing the |this|
+    //    value as the argument.
+    var O = Object(this);
+
+    // 2. Let lenValue be the result of calling the Get internal
+    //    method of O with the argument "length".
+    // 3. Let len be ToUint32(lenValue).
+    var len = O.length >>> 0;
+
+    // 4. If IsCallable(callback) is false, throw a TypeError exception.
+    // See: http://es5.github.com/#x9.11
+    if (typeof callback !== 'function') {
+      throw new TypeError(callback + ' is not a function');
+    }
+
+    // 5. If thisArg was supplied, let T be thisArg; else let T be undefined.
+    if (arguments.length > 1) {
+      T = thisArg;
+    }
+
+    // 6. Let A be a new array created as if by the expression new Array(len)
+    //    where Array is the standard built-in constructor with that name and
+    //    len is the value of len.
+    A = new Array(len);
+
+    // 7. Let k be 0
+    k = 0;
+
+    // 8. Repeat, while k < len
+    while (k < len) {
+
+      var kValue, mappedValue;
+
+      // a. Let Pk be ToString(k).
+      //   This is implicit for LHS operands of the in operator
+      // b. Let kPresent be the result of calling the HasProperty internal
+      //    method of O with argument Pk.
+      //   This step can be combined with c
+      // c. If kPresent is true, then
+      if (k in O) {
+
+        // i. Let kValue be the result of calling the Get internal
+        //    method of O with argument Pk.
+        kValue = O[k];
+
+        // ii. Let mappedValue be the result of calling the Call internal
+        //     method of callback with T as the this value and argument
+        //     list containing kValue, k, and O.
+        mappedValue = callback.call(T, kValue, k, O);
+
+        // iii. Call the DefineOwnProperty internal method of A with arguments
+        // Pk, Property Descriptor
+        // { Value: mappedValue,
+        //   Writable: true,
+        //   Enumerable: true,
+        //   Configurable: true },
+        // and false.
+
+        // In browsers that support Object.defineProperty, use the following:
+        // Object.defineProperty(A, k, {
+        //   value: mappedValue,
+        //   writable: true,
+        //   enumerable: true,
+        //   configurable: true
+        // });
+
+        // For best browser support, use the following:
+        A[k] = mappedValue;
+      }
+      // d. Increase k by 1.
+      k++;
+    }
+
+    // 9. return A
+    return A;
+  };
+}
diff --git a/node_modules/buffer/test/base64.js b/node_modules/buffer/test/base64.js
new file mode 100644
index 000000000..e4ecc56a9
--- /dev/null
+++ b/node_modules/buffer/test/base64.js
@@ -0,0 +1,47 @@
+if (process.env.OBJECT_IMPL) global.TYPED_ARRAY_SUPPORT = false
+var B = require('../').Buffer
+var test = require('tape')
+
+test('base64: ignore whitespace', function (t) {
+  var text = '\n   YW9ldQ==  '
+  var buf = new B(text, 'base64')
+  t.equal(buf.toString(), 'aoeu')
+  t.end()
+})
+
+test('base64: strings without padding', function (t) {
+  t.equal((new B('YW9ldQ', 'base64').toString()), 'aoeu')
+  t.end()
+})
+
+test('base64: newline in utf8 -- should not be an issue', function (t) {
+  t.equal(
+    new B('LS0tCnRpdGxlOiBUaHJlZSBkYXNoZXMgbWFya3MgdGhlIHNwb3QKdGFnczoK', 'base64').toString('utf8'),
+    '---\ntitle: Three dashes marks the spot\ntags:\n'
+  )
+  t.end()
+})
+
+test('base64: newline in base64 -- should get stripped', function (t) {
+  t.equal(
+    new B('LS0tCnRpdGxlOiBUaHJlZSBkYXNoZXMgbWFya3MgdGhlIHNwb3QKdGFnczoK\nICAtIHlhbWwKICAtIGZyb250LW1hdHRlcgogIC0gZGFzaGVzCmV4cGFuZWQt', 'base64').toString('utf8'),
+    '---\ntitle: Three dashes marks the spot\ntags:\n  - yaml\n  - front-matter\n  - dashes\nexpaned-'
+  )
+  t.end()
+})
+
+test('base64: tab characters in base64 - should get stripped', function (t) {
+  t.equal(
+    new B('LS0tCnRpdGxlOiBUaHJlZSBkYXNoZXMgbWFya3MgdGhlIHNwb3QKdGFnczoK\t\t\t\tICAtIHlhbWwKICAtIGZyb250LW1hdHRlcgogIC0gZGFzaGVzCmV4cGFuZWQt', 'base64').toString('utf8'),
+    '---\ntitle: Three dashes marks the spot\ntags:\n  - yaml\n  - front-matter\n  - dashes\nexpaned-'
+  )
+  t.end()
+})
+
+test('base64: invalid non-alphanumeric characters -- should be stripped', function (t) {
+  t.equal(
+    new B('!"#$%&\'()*,.:;<=>?@[\\]^`{|}~', 'base64').toString('utf8'),
+    ''
+  )
+  t.end()
+})
diff --git a/node_modules/buffer/test/basic.js b/node_modules/buffer/test/basic.js
new file mode 100644
index 000000000..0368ed919
--- /dev/null
+++ b/node_modules/buffer/test/basic.js
@@ -0,0 +1,85 @@
+if (process.env.OBJECT_IMPL) global.TYPED_ARRAY_SUPPORT = false
+var B = require('../').Buffer
+var test = require('tape')
+
+test('instanceof Buffer', function (t) {
+  var buf = new B([1, 2])
+  t.ok(buf instanceof B)
+  t.end()
+})
+
+test('convert to Uint8Array in modern browsers', function (t) {
+  if (B.TYPED_ARRAY_SUPPORT) {
+    var buf = new B([1, 2])
+    var uint8array = new Uint8Array(buf.buffer)
+    t.ok(uint8array instanceof Uint8Array)
+    t.equal(uint8array[0], 1)
+    t.equal(uint8array[1], 2)
+  } else {
+    t.pass('object impl: skipping test')
+  }
+  t.end()
+})
+
+test('indexes from a string', function (t) {
+  var buf = new B('abc')
+  t.equal(buf[0], 97)
+  t.equal(buf[1], 98)
+  t.equal(buf[2], 99)
+  t.end()
+})
+
+test('indexes from an array', function (t) {
+  var buf = new B([ 97, 98, 99 ])
+  t.equal(buf[0], 97)
+  t.equal(buf[1], 98)
+  t.equal(buf[2], 99)
+  t.end()
+})
+
+test('setting index value should modify buffer contents', function (t) {
+  var buf = new B([ 97, 98, 99 ])
+  t.equal(buf[2], 99)
+  t.equal(buf.toString(), 'abc')
+
+  buf[2] += 10
+  t.equal(buf[2], 109)
+  t.equal(buf.toString(), 'abm')
+  t.end()
+})
+
+test('storing negative number should cast to unsigned', function (t) {
+  var buf = new B(1)
+
+  if (B.TYPED_ARRAY_SUPPORT) {
+    // This does not work with the object implementation -- nothing we can do!
+    buf[0] = -3
+    t.equal(buf[0], 253)
+  }
+
+  buf = new B(1)
+  buf.writeInt8(-3, 0)
+  t.equal(buf[0], 253)
+
+  t.end()
+})
+
+test('test that memory is copied from array-like', function (t) {
+  if (B.TYPED_ARRAY_SUPPORT) {
+    var u = new Uint8Array(4)
+    var b = new B(u)
+    b[0] = 1
+    b[1] = 2
+    b[2] = 3
+    b[3] = 4
+
+    t.equal(u[0], 0)
+    t.equal(u[1], 0)
+    t.equal(u[2], 0)
+    t.equal(u[3], 0)
+  } else {
+    t.pass('object impl: skipping test')
+  }
+
+  t.end()
+})
diff --git a/node_modules/buffer/test/compare.js b/node_modules/buffer/test/compare.js
new file mode 100644
index 000000000..62b478c73
--- /dev/null
+++ b/node_modules/buffer/test/compare.js
@@ -0,0 +1,59 @@
+if (process.env.OBJECT_IMPL) global.TYPED_ARRAY_SUPPORT = false
+var B = require('../').Buffer
+var test = require('tape')
+
+test('buffer.compare', function (t) {
+  var b = new B(1).fill('a')
+  var c = new B(1).fill('c')
+  var d = new B(2).fill('aa')
+
+  t.equal(b.compare(c), -1)
+  t.equal(c.compare(d), 1)
+  t.equal(d.compare(b), 1)
+  t.equal(b.compare(d), -1)
+
+  // static method
+  t.equal(B.compare(b, c), -1)
+  t.equal(B.compare(c, d), 1)
+  t.equal(B.compare(d, b), 1)
+  t.equal(B.compare(b, d), -1)
+  t.end()
+})
+
+test('buffer.compare argument validation', function (t) {
+  t.throws(function () {
+    var b = new B(1)
+    B.compare(b, 'abc')
+  })
+
+  t.throws(function () {
+    var b = new B(1)
+    B.compare('abc', b)
+  })
+
+  t.throws(function () {
+    var b = new B(1)
+    b.compare('abc')
+  })
+  t.end()
+})
+
+test('buffer.equals', function (t) {
+  var b = new B(5).fill('abcdf')
+  var c = new B(5).fill('abcdf')
+  var d = new B(5).fill('abcde')
+  var e = new B(6).fill('abcdef')
+
+  t.ok(b.equals(c))
+  t.ok(!c.equals(d))
+  t.ok(!d.equals(e))
+  t.end()
+})
+
+test('buffer.equals argument validation', function (t) {
+  t.throws(function () {
+    var b = new B(1)
+    b.equals('abc')
+  })
+  t.end()
+})
diff --git a/node_modules/buffer/test/constructor.js b/node_modules/buffer/test/constructor.js
new file mode 100644
index 000000000..cec5cdcbe
--- /dev/null
+++ b/node_modules/buffer/test/constructor.js
@@ -0,0 +1,193 @@
+if (process.env.OBJECT_IMPL) global.TYPED_ARRAY_SUPPORT = false
+var B = require('../').Buffer
+var test = require('tape')
+
+test('new buffer from array', function (t) {
+  t.equal(
+    new B([1, 2, 3]).toString(),
+    '\u0001\u0002\u0003'
+  )
+  t.end()
+})
+
+test('new buffer from array w/ negatives', function (t) {
+  t.equal(
+    new B([-1, -2, -3]).toString('hex'),
+    'fffefd'
+  )
+  t.end()
+})
+
+test('new buffer from array with mixed signed input', function (t) {
+  t.equal(
+    new B([-255, 255, -128, 128, 512, -512, 511, -511]).toString('hex'),
+    '01ff80800000ff01'
+  )
+  t.end()
+})
+
+test('new buffer from string', function (t) {
+  t.equal(
+    new B('hey', 'utf8').toString(),
+    'hey'
+  )
+  t.end()
+})
+
+test('new buffer from buffer', function (t) {
+  var b1 = new B('asdf')
+  var b2 = new B(b1)
+  t.equal(b1.toString('hex'), b2.toString('hex'))
+  t.end()
+})
+
+test('new buffer from ArrayBuffer', function (t) {
+  if (typeof ArrayBuffer !== 'undefined') {
+    var arraybuffer = new Uint8Array([0, 1, 2, 3]).buffer
+    var b = new B(arraybuffer)
+    t.equal(b.length, 4)
+    t.equal(b[0], 0)
+    t.equal(b[1], 1)
+    t.equal(b[2], 2)
+    t.equal(b[3], 3)
+    t.equal(b[4], undefined)
+  }
+  t.end()
+})
+
+test('new buffer from ArrayBuffer, shares memory', function (t) {
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
+    var u = new Uint8Array([0, 1, 2, 3])
+    var arraybuffer = u.buffer
+    var b = new B(arraybuffer)
+    t.equal(b.length, 4)
+    t.equal(b[0], 0)
+    t.equal(b[1], 1)
+    t.equal(b[2], 2)
+    t.equal(b[3], 3)
+    t.equal(b[4], undefined)
+
+    // changing the Uint8Array (and thus the ArrayBuffer), changes the Buffer
+    u[0] = 10
+    t.equal(b[0], 10)
+    u[1] = 11
+    t.equal(b[1], 11)
+    u[2] = 12
+    t.equal(b[2], 12)
+    u[3] = 13
+    t.equal(b[3], 13)
+  }
+  t.end()
+})
+
+test('new buffer from Uint8Array', function (t) {
+  if (typeof Uint8Array !== 'undefined') {
+    var b1 = new Uint8Array([0, 1, 2, 3])
+    var b2 = new B(b1)
+    t.equal(b1.length, b2.length)
+    t.equal(b1[0], 0)
+    t.equal(b1[1], 1)
+    t.equal(b1[2], 2)
+    t.equal(b1[3], 3)
+    t.equal(b1[4], undefined)
+  }
+  t.end()
+})
+
+test('new buffer from Uint16Array', function (t) {
+  if (typeof Uint16Array !== 'undefined') {
+    var b1 = new Uint16Array([0, 1, 2, 3])
+    var b2 = new B(b1)
+    t.equal(b1.length, b2.length)
+    t.equal(b1[0], 0)
+    t.equal(b1[1], 1)
+    t.equal(b1[2], 2)
+    t.equal(b1[3], 3)
+    t.equal(b1[4], undefined)
+  }
+  t.end()
+})
+
+test('new buffer from Uint32Array', function (t) {
+  if (typeof Uint32Array !== 'undefined') {
+    var b1 = new Uint32Array([0, 1, 2, 3])
+    var b2 = new B(b1)
+    t.equal(b1.length, b2.length)
+    t.equal(b1[0], 0)
+    t.equal(b1[1], 1)
+    t.equal(b1[2], 2)
+    t.equal(b1[3], 3)
+    t.equal(b1[4], undefined)
+  }
+  t.end()
+})
+
+test('new buffer from Int16Array', function (t) {
+  if (typeof Int16Array !== 'undefined') {
+    var b1 = new Int16Array([0, 1, 2, 3])
+    var b2 = new B(b1)
+    t.equal(b1.length, b2.length)
+    t.equal(b1[0], 0)
+    t.equal(b1[1], 1)
+    t.equal(b1[2], 2)
+    t.equal(b1[3], 3)
+    t.equal(b1[4], undefined)
+  }
+  t.end()
+})
+
+test('new buffer from Int32Array', function (t) {
+  if (typeof Int32Array !== 'undefined') {
+    var b1 = new Int32Array([0, 1, 2, 3])
+    var b2 = new B(b1)
+    t.equal(b1.length, b2.length)
+    t.equal(b1[0], 0)
+    t.equal(b1[1], 1)
+    t.equal(b1[2], 2)
+    t.equal(b1[3], 3)
+    t.equal(b1[4], undefined)
+  }
+  t.end()
+})
+
+test('new buffer from Float32Array', function (t) {
+  if (typeof Float32Array !== 'undefined') {
+    var b1 = new Float32Array([0, 1, 2, 3])
+    var b2 = new B(b1)
+    t.equal(b1.length, b2.length)
+    t.equal(b1[0], 0)
+    t.equal(b1[1], 1)
+    t.equal(b1[2], 2)
+    t.equal(b1[3], 3)
+    t.equal(b1[4], undefined)
+  }
+  t.end()
+})
+
+test('new buffer from Float64Array', function (t) {
+  if (typeof Float64Array !== 'undefined') {
+    var b1 = new Float64Array([0, 1, 2, 3])
+    var b2 = new B(b1)
+    t.equal(b1.length, b2.length)
+    t.equal(b1[0], 0)
+    t.equal(b1[1], 1)
+    t.equal(b1[2], 2)
+    t.equal(b1[3], 3)
+    t.equal(b1[4], undefined)
+  }
+  t.end()
+})
+
+test('new buffer from buffer.toJSON() output', function (t) {
+  if (typeof JSON === 'undefined') {
+    // ie6, ie7 lack support
+    t.end()
+    return
+  }
+  var buf = new B('test')
+  var json = JSON.stringify(buf)
+  var obj = JSON.parse(json)
+  var copy = new B(obj)
+  t.ok(buf.equals(copy))
+  t.end()
+})
diff --git a/node_modules/buffer/test/from-string.js b/node_modules/buffer/test/from-string.js
new file mode 100644
index 000000000..e25db2699
--- /dev/null
+++ b/node_modules/buffer/test/from-string.js
@@ -0,0 +1,132 @@
+if (process.env.OBJECT_IMPL) global.TYPED_ARRAY_SUPPORT = false
+var B = require('../').Buffer
+var test = require('tape')
+
+test('detect utf16 surrogate pairs', function (t) {
+  var text = '\uD83D\uDE38' + '\uD83D\uDCAD' + '\uD83D\uDC4D'
+  var buf = new B(text)
+  t.equal(text, buf.toString())
+  t.end()
+})
+
+test('detect utf16 surrogate pairs over U+20000 until U+10FFFF', function (t) {
+  var text = '\uD842\uDFB7' + '\uD93D\uDCAD' + '\uDBFF\uDFFF'
+  var buf = new B(text)
+  t.equal(text, buf.toString())
+  t.end()
+})
+
+test('replace orphaned utf16 surrogate lead code point', function (t) {
+  var text = '\uD83D\uDE38' + '\uD83D' + '\uD83D\uDC4D'
+  var buf = new B(text)
+  t.deepEqual(buf, new B([ 0xf0, 0x9f, 0x98, 0xb8, 0xef, 0xbf, 0xbd, 0xf0, 0x9f, 0x91, 0x8d ]))
+  t.end()
+})
+
+test('replace orphaned utf16 surrogate trail code point', function (t) {
+  var text = '\uD83D\uDE38' + '\uDCAD' + '\uD83D\uDC4D'
+  var buf = new B(text)
+  t.deepEqual(buf, new B([ 0xf0, 0x9f, 0x98, 0xb8, 0xef, 0xbf, 0xbd, 0xf0, 0x9f, 0x91, 0x8d ]))
+  t.end()
+})
+
+test('do not write partial utf16 code units', function (t) {
+  var f = new B([0, 0, 0, 0, 0])
+  t.equal(f.length, 5)
+  var size = f.write('あいうえお', 'utf16le')
+  t.equal(size, 4)
+  t.deepEqual(f, new B([0x42, 0x30, 0x44, 0x30, 0x00]))
+  t.end()
+})
+
+test('handle partial utf16 code points when encoding to utf8 the way node does', function (t) {
+  var text = '\uD83D\uDE38' + '\uD83D\uDC4D'
+
+  var buf = new B(8)
+  buf.fill(0)
+  buf.write(text)
+  t.deepEqual(buf, new B([ 0xf0, 0x9f, 0x98, 0xb8, 0xf0, 0x9f, 0x91, 0x8d ]))
+
+  buf = new B(7)
+  buf.fill(0)
+  buf.write(text)
+  t.deepEqual(buf, new B([ 0xf0, 0x9f, 0x98, 0xb8, 0x00, 0x00, 0x00 ]))
+
+  buf = new B(6)
+  buf.fill(0)
+  buf.write(text)
+  t.deepEqual(buf, new B([ 0xf0, 0x9f, 0x98, 0xb8, 0x00, 0x00 ]))
+
+  buf = new B(5)
+  buf.fill(0)
+  buf.write(text)
+  t.deepEqual(buf, new B([ 0xf0, 0x9f, 0x98, 0xb8, 0x00 ]))
+
+  buf = new B(4)
+  buf.fill(0)
+  buf.write(text)
+  t.deepEqual(buf, new B([ 0xf0, 0x9f, 0x98, 0xb8 ]))
+
+  buf = new B(3)
+  buf.fill(0)
+  buf.write(text)
+  t.deepEqual(buf, new B([ 0x00, 0x00, 0x00 ]))
+
+  buf = new B(2)
+  buf.fill(0)
+  buf.write(text)
+  t.deepEqual(buf, new B([ 0x00, 0x00 ]))
+
+  buf = new B(1)
+  buf.fill(0)
+  buf.write(text)
+  t.deepEqual(buf, new B([ 0x00 ]))
+
+  t.end()
+})
+
+test('handle invalid utf16 code points when encoding to utf8 the way node does', function (t) {
+  var text = 'a' + '\uDE38\uD83D' + 'b'
+
+  var buf = new B(8)
+  buf.fill(0)
+  buf.write(text)
+  t.deepEqual(buf, new B([ 0x61, 0xef, 0xbf, 0xbd, 0xef, 0xbf, 0xbd, 0x62 ]))
+
+  buf = new B(7)
+  buf.fill(0)
+  buf.write(text)
+  t.deepEqual(buf, new B([ 0x61, 0xef, 0xbf, 0xbd, 0xef, 0xbf, 0xbd ]))
+
+  buf = new B(6)
+  buf.fill(0)
+  buf.write(text)
+  t.deepEqual(buf, new B([ 0x61, 0xef, 0xbf, 0xbd, 0x00, 0x00 ]))
+
+  buf = new B(5)
+  buf.fill(0)
+  buf.write(text)
+  t.deepEqual(buf, new B([ 0x61, 0xef, 0xbf, 0xbd, 0x00 ]))
+
+  buf = new B(4)
+  buf.fill(0)
+  buf.write(text)
+  t.deepEqual(buf, new B([ 0x61, 0xef, 0xbf, 0xbd ]))
+
+  buf = new B(3)
+  buf.fill(0)
+  buf.write(text)
+  t.deepEqual(buf, new B([ 0x61, 0x00, 0x00 ]))
+
+  buf = new B(2)
+  buf.fill(0)
+  buf.write(text)
+  t.deepEqual(buf, new B([ 0x61, 0x00 ]))
+
+  buf = new B(1)
+  buf.fill(0)
+  buf.write(text)
+  t.deepEqual(buf, new B([ 0x61 ]))
+
+  t.end()
+})
diff --git a/node_modules/buffer/test/is-buffer.js b/node_modules/buffer/test/is-buffer.js
new file mode 100644
index 000000000..3744b23a7
--- /dev/null
+++ b/node_modules/buffer/test/is-buffer.js
@@ -0,0 +1,22 @@
+if (process.env.OBJECT_IMPL) global.TYPED_ARRAY_SUPPORT = false
+var B = require('../').Buffer
+var isBuffer = require('is-buffer')
+var test = require('tape')
+
+test('is-buffer tests', function (t) {
+  t.ok(isBuffer(new B(4)), 'new Buffer(4)')
+
+  t.notOk(isBuffer(undefined), 'undefined')
+  t.notOk(isBuffer(null), 'null')
+  t.notOk(isBuffer(''), 'empty string')
+  t.notOk(isBuffer(true), 'true')
+  t.notOk(isBuffer(false), 'false')
+  t.notOk(isBuffer(0), '0')
+  t.notOk(isBuffer(1), '1')
+  t.notOk(isBuffer(1.0), '1.0')
+  t.notOk(isBuffer('string'), 'string')
+  t.notOk(isBuffer({}), '{}')
+  t.notOk(isBuffer(function foo () {}), 'function foo () {}')
+
+  t.end()
+})
diff --git a/node_modules/buffer/test/methods.js b/node_modules/buffer/test/methods.js
new file mode 100644
index 000000000..f4bd3f213
--- /dev/null
+++ b/node_modules/buffer/test/methods.js
@@ -0,0 +1,127 @@
+if (process.env.OBJECT_IMPL) global.TYPED_ARRAY_SUPPORT = false
+var B = require('../').Buffer
+var test = require('tape')
+
+test('buffer.toJSON', function (t) {
+  var data = [1, 2, 3, 4]
+  t.deepEqual(
+    new B(data).toJSON(),
+    { type: 'Buffer', data: [ 1, 2, 3, 4 ] }
+  )
+  t.end()
+})
+
+test('buffer.copy', function (t) {
+  // copied from nodejs.org example
+  var buf1 = new B(26)
+  var buf2 = new B(26)
+
+  for (var i = 0; i < 26; i++) {
+    buf1[i] = i + 97 // 97 is ASCII a
+    buf2[i] = 33 // ASCII !
+  }
+
+  buf1.copy(buf2, 8, 16, 20)
+
+  t.equal(
+    buf2.toString('ascii', 0, 25),
+    '!!!!!!!!qrst!!!!!!!!!!!!!'
+  )
+  t.end()
+})
+
+test('test offset returns are correct', function (t) {
+  var b = new B(16)
+  t.equal(4, b.writeUInt32LE(0, 0))
+  t.equal(6, b.writeUInt16LE(0, 4))
+  t.equal(7, b.writeUInt8(0, 6))
+  t.equal(8, b.writeInt8(0, 7))
+  t.equal(16, b.writeDoubleLE(0, 8))
+  t.end()
+})
+
+test('concat() a varying number of buffers', function (t) {
+  var zero = []
+  var one = [ new B('asdf') ]
+  var long = []
+  for (var i = 0; i < 10; i++) {
+    long.push(new B('asdf'))
+  }
+
+  var flatZero = B.concat(zero)
+  var flatOne = B.concat(one)
+  var flatLong = B.concat(long)
+  var flatLongLen = B.concat(long, 40)
+
+  t.equal(flatZero.length, 0)
+  t.equal(flatOne.toString(), 'asdf')
+  t.deepEqual(flatOne, one[0])
+  t.equal(flatLong.toString(), (new Array(10 + 1).join('asdf')))
+  t.equal(flatLongLen.toString(), (new Array(10 + 1).join('asdf')))
+  t.end()
+})
+
+test('fill', function (t) {
+  var b = new B(10)
+  b.fill(2)
+  t.equal(b.toString('hex'), '02020202020202020202')
+  t.end()
+})
+
+test('fill (string)', function (t) {
+  var b = new B(10)
+  b.fill('abc')
+  t.equal(b.toString(), 'abcabcabca')
+  b.fill('է')
+  t.equal(b.toString(), 'էէէէէ')
+  t.end()
+})
+
+test('copy() empty buffer with sourceEnd=0', function (t) {
+  var source = new B([42])
+  var destination = new B([43])
+  source.copy(destination, 0, 0, 0)
+  t.equal(destination.readUInt8(0), 43)
+  t.end()
+})
+
+test('copy() after slice()', function (t) {
+  var source = new B(200)
+  var dest = new B(200)
+  var expected = new B(200)
+  for (var i = 0; i < 200; i++) {
+    source[i] = i
+    dest[i] = 0
+  }
+
+  source.slice(2).copy(dest)
+  source.copy(expected, 0, 2)
+  t.deepEqual(dest, expected)
+  t.end()
+})
+
+test('copy() ascending', function (t) {
+  var b = new B('abcdefghij')
+  b.copy(b, 0, 3, 10)
+  t.equal(b.toString(), 'defghijhij')
+  t.end()
+})
+
+test('copy() descending', function (t) {
+  var b = new B('abcdefghij')
+  b.copy(b, 3, 0, 7)
+  t.equal(b.toString(), 'abcabcdefg')
+  t.end()
+})
+
+test('buffer.slice sets indexes', function (t) {
+  t.equal((new B('hallo')).slice(0, 5).toString(), 'hallo')
+  t.end()
+})
+
+test('buffer.slice out of range', function (t) {
+  t.plan(2)
+  t.equal((new B('hallo')).slice(0, 10).toString(), 'hallo')
+  t.equal((new B('hallo')).slice(10, 2).toString(), '')
+  t.end()
+})
diff --git a/node_modules/buffer/test/node/test-buffer-alloc.js b/node_modules/buffer/test/node/test-buffer-alloc.js
new file mode 100644
index 000000000..b524f51ef
--- /dev/null
+++ b/node_modules/buffer/test/node/test-buffer-alloc.js
@@ -0,0 +1,1501 @@
+'use strict';
+var Buffer = require('../../').Buffer;
+
+var common = { skip: function () {} };
+var assert = require('assert');
+
+var Buffer = require('../../').Buffer;
+
+// counter to ensure unique value is always copied
+var cntr = 0;
+
+var b = Buffer.allocUnsafe(1024);
+
+// console.log('b.length == %d', b.length);
+assert.strictEqual(1024, b.length);
+
+b[0] = -1;
+assert.strictEqual(b[0], 255);
+
+for (var i = 0; i < 1024; i++) {
+  b[i] = i % 256;
+}
+
+for (var i = 0; i < 1024; i++) {
+  assert.strictEqual(i % 256, b[i]);
+}
+
+var c = Buffer.allocUnsafe(512);
+// console.log('c.length == %d', c.length);
+assert.strictEqual(512, c.length);
+
+var d = Buffer.from([]);
+assert.strictEqual(0, d.length);
+
+var ui32 = new Uint32Array(4).fill(42);
+var e = Buffer.from(ui32);
+for (var [index, value] of e.entries()) {
+  assert.strictEqual(value, ui32[index]);
+}
+
+// First check Buffer#fill() works as expected.
+
+assert.throws(function() {
+  Buffer.allocUnsafe(8).fill('a', -1);
+});
+
+assert.throws(function() {
+  Buffer.allocUnsafe(8).fill('a', 0, 9);
+});
+
+// Make sure this doesn't hang indefinitely.
+Buffer.allocUnsafe(8).fill('');
+Buffer.alloc(8, '');
+
+{
+  var buf = Buffer.alloc(64, 10);
+  for (var i = 0; i < buf.length; i++)
+    assert.equal(buf[i], 10);
+
+  buf.fill(11, 0, buf.length >> 1);
+  for (var i = 0; i < buf.length >> 1; i++)
+    assert.equal(buf[i], 11);
+  for (var i = (buf.length >> 1) + 1; i < buf.length; i++)
+    assert.equal(buf[i], 10);
+
+  buf.fill('h');
+  for (var i = 0; i < buf.length; i++)
+    assert.equal('h'.charCodeAt(0), buf[i]);
+
+  buf.fill(0);
+  for (var i = 0; i < buf.length; i++)
+    assert.equal(0, buf[i]);
+
+  buf.fill(null);
+  for (var i = 0; i < buf.length; i++)
+    assert.equal(0, buf[i]);
+
+  buf.fill(1, 16, 32);
+  for (var i = 0; i < 16; i++)
+    assert.equal(0, buf[i]);
+  for (var i = 16; i < 32; i++)
+    assert.equal(1, buf[i]);
+  for (var i = 32; i < buf.length; i++)
+    assert.equal(0, buf[i]);
+}
+
+{
+  var buf = Buffer.alloc(10, 'abc');
+  assert.equal(buf.toString(), 'abcabcabca');
+  buf.fill('է');
+  assert.equal(buf.toString(), 'էէէէէ');
+}
+
+{
+  // copy 512 bytes, from 0 to 512.
+  b.fill(++cntr);
+  c.fill(++cntr);
+  var copied = b.copy(c, 0, 0, 512);
+//   console.log('copied %d bytes from b into c', copied);
+  assert.strictEqual(512, copied);
+  for (var i = 0; i < c.length; i++) {
+    assert.strictEqual(b[i], c[i]);
+  }
+}
+
+{
+  // copy c into b, without specifying sourceEnd
+  b.fill(++cntr);
+  c.fill(++cntr);
+  var copied = c.copy(b, 0, 0);
+//   console.log('copied %d bytes from c into b w/o sourceEnd', copied);
+  assert.strictEqual(c.length, copied);
+  for (var i = 0; i < c.length; i++) {
+    assert.strictEqual(c[i], b[i]);
+  }
+}
+
+{
+  // copy c into b, without specifying sourceStart
+  b.fill(++cntr);
+  c.fill(++cntr);
+  var copied = c.copy(b, 0);
+//   console.log('copied %d bytes from c into b w/o sourceStart', copied);
+  assert.strictEqual(c.length, copied);
+  for (var i = 0; i < c.length; i++) {
+    assert.strictEqual(c[i], b[i]);
+  }
+}
+
+{
+  // copy longer buffer b to shorter c without targetStart
+  b.fill(++cntr);
+  c.fill(++cntr);
+  var copied = b.copy(c);
+//   console.log('copied %d bytes from b into c w/o targetStart', copied);
+  assert.strictEqual(c.length, copied);
+  for (var i = 0; i < c.length; i++) {
+    assert.strictEqual(b[i], c[i]);
+  }
+}
+
+{
+  // copy starting near end of b to c
+  b.fill(++cntr);
+  c.fill(++cntr);
+  var copied = b.copy(c, 0, b.length - Math.floor(c.length / 2));
+//   console.log('copied %d bytes from end of b into beginning of c', copied);
+  assert.strictEqual(Math.floor(c.length / 2), copied);
+  for (var i = 0; i < Math.floor(c.length / 2); i++) {
+    assert.strictEqual(b[b.length - Math.floor(c.length / 2) + i], c[i]);
+  }
+  for (var i = Math.floor(c.length / 2) + 1; i < c.length; i++) {
+    assert.strictEqual(c[c.length - 1], c[i]);
+  }
+}
+
+{
+  // try to copy 513 bytes, and check we don't overrun c
+  b.fill(++cntr);
+  c.fill(++cntr);
+  var copied = b.copy(c, 0, 0, 513);
+//   console.log('copied %d bytes from b trying to overrun c', copied);
+  assert.strictEqual(c.length, copied);
+  for (var i = 0; i < c.length; i++) {
+    assert.strictEqual(b[i], c[i]);
+  }
+}
+
+{
+  // copy 768 bytes from b into b
+  b.fill(++cntr);
+  b.fill(++cntr, 256);
+  var copied = b.copy(b, 0, 256, 1024);
+//   console.log('copied %d bytes from b into b', copied);
+  assert.strictEqual(768, copied);
+  for (var i = 0; i < b.length; i++) {
+    assert.strictEqual(cntr, b[i]);
+  }
+}
+
+// copy string longer than buffer length (failure will segfault)
+var bb = Buffer.allocUnsafe(10);
+bb.fill('hello crazy world');
+
+
+// try to copy from before the beginning of b
+assert.doesNotThrow(() => { b.copy(c, 0, 100, 10); });
+
+// copy throws at negative sourceStart
+assert.throws(function() {
+  Buffer.allocUnsafe(5).copy(Buffer.allocUnsafe(5), 0, -1);
+}, RangeError);
+
+{
+  // check sourceEnd resets to targetEnd if former is greater than the latter
+  b.fill(++cntr);
+  c.fill(++cntr);
+  var copied = b.copy(c, 0, 0, 1025);
+//   console.log('copied %d bytes from b into c', copied);
+  for (var i = 0; i < c.length; i++) {
+    assert.strictEqual(b[i], c[i]);
+  }
+}
+
+// throw with negative sourceEnd
+// console.log('test copy at negative sourceEnd');
+assert.throws(function() {
+  b.copy(c, 0, 0, -1);
+}, RangeError);
+
+// when sourceStart is greater than sourceEnd, zero copied
+assert.equal(b.copy(c, 0, 100, 10), 0);
+
+// when targetStart > targetLength, zero copied
+assert.equal(b.copy(c, 512, 0, 10), 0);
+
+var caught_error;
+
+// invalid encoding for Buffer.toString
+caught_error = null;
+try {
+  b.toString('invalid');
+} catch (err) {
+  caught_error = err;
+}
+assert.strictEqual('Unknown encoding: invalid', caught_error.message);
+
+// invalid encoding for Buffer.write
+caught_error = null;
+try {
+  b.write('test string', 0, 5, 'invalid');
+} catch (err) {
+  caught_error = err;
+}
+assert.strictEqual('Unknown encoding: invalid', caught_error.message);
+
+// try to create 0-length buffers
+Buffer.from('');
+Buffer.from('', 'ascii');
+Buffer.from('', 'latin1');
+Buffer.alloc(0);
+Buffer.allocUnsafe(0);
+
+// try to write a 0-length string beyond the end of b
+assert.throws(function() {
+  b.write('', 2048);
+}, RangeError);
+
+// throw when writing to negative offset
+assert.throws(function() {
+  b.write('a', -1);
+}, RangeError);
+
+// throw when writing past bounds from the pool
+assert.throws(function() {
+  b.write('a', 2048);
+}, RangeError);
+
+// throw when writing to negative offset
+assert.throws(function() {
+  b.write('a', -1);
+}, RangeError);
+
+// try to copy 0 bytes worth of data into an empty buffer
+b.copy(Buffer.alloc(0), 0, 0, 0);
+
+// try to copy 0 bytes past the end of the target buffer
+b.copy(Buffer.alloc(0), 1, 1, 1);
+b.copy(Buffer.alloc(1), 1, 1, 1);
+
+// try to copy 0 bytes from past the end of the source buffer
+b.copy(Buffer.alloc(1), 0, 2048, 2048);
+
+var rangeBuffer = Buffer.from('abc');
+
+// if start >= buffer's length, empty string will be returned
+assert.equal(rangeBuffer.toString('ascii', 3), '');
+assert.equal(rangeBuffer.toString('ascii', +Infinity), '');
+assert.equal(rangeBuffer.toString('ascii', 3.14, 3), '');
+assert.equal(rangeBuffer.toString('ascii', 'Infinity', 3), '');
+
+// if end <= 0, empty string will be returned
+assert.equal(rangeBuffer.toString('ascii', 1, 0), '');
+assert.equal(rangeBuffer.toString('ascii', 1, -1.2), '');
+assert.equal(rangeBuffer.toString('ascii', 1, -100), '');
+assert.equal(rangeBuffer.toString('ascii', 1, -Infinity), '');
+
+// if start < 0, start will be taken as zero
+assert.equal(rangeBuffer.toString('ascii', -1, 3), 'abc');
+assert.equal(rangeBuffer.toString('ascii', -1.99, 3), 'abc');
+assert.equal(rangeBuffer.toString('ascii', -Infinity, 3), 'abc');
+assert.equal(rangeBuffer.toString('ascii', '-1', 3), 'abc');
+assert.equal(rangeBuffer.toString('ascii', '-1.99', 3), 'abc');
+assert.equal(rangeBuffer.toString('ascii', '-Infinity', 3), 'abc');
+
+// if start is an invalid integer, start will be taken as zero
+assert.equal(rangeBuffer.toString('ascii', 'node.js', 3), 'abc');
+assert.equal(rangeBuffer.toString('ascii', {}, 3), 'abc');
+assert.equal(rangeBuffer.toString('ascii', [], 3), 'abc');
+assert.equal(rangeBuffer.toString('ascii', NaN, 3), 'abc');
+assert.equal(rangeBuffer.toString('ascii', null, 3), 'abc');
+assert.equal(rangeBuffer.toString('ascii', undefined, 3), 'abc');
+assert.equal(rangeBuffer.toString('ascii', false, 3), 'abc');
+assert.equal(rangeBuffer.toString('ascii', '', 3), 'abc');
+
+// but, if start is an integer when coerced, then it will be coerced and used.
+assert.equal(rangeBuffer.toString('ascii', '-1', 3), 'abc');
+assert.equal(rangeBuffer.toString('ascii', '1', 3), 'bc');
+assert.equal(rangeBuffer.toString('ascii', '-Infinity', 3), 'abc');
+assert.equal(rangeBuffer.toString('ascii', '3', 3), '');
+assert.equal(rangeBuffer.toString('ascii', Number(3), 3), '');
+assert.equal(rangeBuffer.toString('ascii', '3.14', 3), '');
+assert.equal(rangeBuffer.toString('ascii', '1.99', 3), 'bc');
+assert.equal(rangeBuffer.toString('ascii', '-1.99', 3), 'abc');
+assert.equal(rangeBuffer.toString('ascii', 1.99, 3), 'bc');
+assert.equal(rangeBuffer.toString('ascii', true, 3), 'bc');
+
+// if end > buffer's length, end will be taken as buffer's length
+assert.equal(rangeBuffer.toString('ascii', 0, 5), 'abc');
+assert.equal(rangeBuffer.toString('ascii', 0, 6.99), 'abc');
+assert.equal(rangeBuffer.toString('ascii', 0, Infinity), 'abc');
+assert.equal(rangeBuffer.toString('ascii', 0, '5'), 'abc');
+assert.equal(rangeBuffer.toString('ascii', 0, '6.99'), 'abc');
+assert.equal(rangeBuffer.toString('ascii', 0, 'Infinity'), 'abc');
+
+// if end is an invalid integer, end will be taken as buffer's length
+assert.equal(rangeBuffer.toString('ascii', 0, 'node.js'), '');
+assert.equal(rangeBuffer.toString('ascii', 0, {}), '');
+assert.equal(rangeBuffer.toString('ascii', 0, NaN), '');
+assert.equal(rangeBuffer.toString('ascii', 0, undefined), 'abc');
+assert.equal(rangeBuffer.toString('ascii', 0), 'abc');
+assert.equal(rangeBuffer.toString('ascii', 0, null), '');
+assert.equal(rangeBuffer.toString('ascii', 0, []), '');
+assert.equal(rangeBuffer.toString('ascii', 0, false), '');
+assert.equal(rangeBuffer.toString('ascii', 0, ''), '');
+
+// but, if end is an integer when coerced, then it will be coerced and used.
+assert.equal(rangeBuffer.toString('ascii', 0, '-1'), '');
+assert.equal(rangeBuffer.toString('ascii', 0, '1'), 'a');
+assert.equal(rangeBuffer.toString('ascii', 0, '-Infinity'), '');
+assert.equal(rangeBuffer.toString('ascii', 0, '3'), 'abc');
+assert.equal(rangeBuffer.toString('ascii', 0, Number(3)), 'abc');
+assert.equal(rangeBuffer.toString('ascii', 0, '3.14'), 'abc');
+assert.equal(rangeBuffer.toString('ascii', 0, '1.99'), 'a');
+assert.equal(rangeBuffer.toString('ascii', 0, '-1.99'), '');
+assert.equal(rangeBuffer.toString('ascii', 0, 1.99), 'a');
+assert.equal(rangeBuffer.toString('ascii', 0, true), 'a');
+
+// try toString() with a object as a encoding
+assert.equal(rangeBuffer.toString({toString: function() {
+  return 'ascii';
+}}), 'abc');
+
+// testing for smart defaults and ability to pass string values as offset
+var writeTest = Buffer.from('abcdes');
+writeTest.write('n', 'ascii');
+writeTest.write('o', '1', 'ascii');
+writeTest.write('d', '2', 'ascii');
+writeTest.write('e', 3, 'ascii');
+writeTest.write('j', 4, 'ascii');
+assert.equal(writeTest.toString(), 'nodejs');
+
+// ASCII slice test
+{
+  var asciiString = 'hello world';
+
+  for (var i = 0; i < asciiString.length; i++) {
+    b[i] = asciiString.charCodeAt(i);
+  }
+  var asciiSlice = b.toString('ascii', 0, asciiString.length);
+  assert.equal(asciiString, asciiSlice);
+}
+
+{
+  var asciiString = 'hello world';
+  var offset = 100;
+
+  var written = b.write(asciiString, offset, 'ascii');
+  assert.equal(asciiString.length, written);
+  var asciiSlice = b.toString('ascii', offset, offset + asciiString.length);
+  assert.equal(asciiString, asciiSlice);
+}
+
+{
+  var asciiString = 'hello world';
+  var offset = 100;
+
+  var sliceA = b.slice(offset, offset + asciiString.length);
+  var sliceB = b.slice(offset, offset + asciiString.length);
+  for (var i = 0; i < asciiString.length; i++) {
+    assert.equal(sliceA[i], sliceB[i]);
+  }
+}
+
+// UTF-8 slice test
+
+var utf8String = '¡hέlló wôrld!';
+var offset = 100;
+
+b.write(utf8String, 0, Buffer.byteLength(utf8String), 'utf8');
+var utf8Slice = b.toString('utf8', 0, Buffer.byteLength(utf8String));
+assert.equal(utf8String, utf8Slice);
+
+var written = b.write(utf8String, offset, 'utf8');
+assert.equal(Buffer.byteLength(utf8String), written);
+utf8Slice = b.toString('utf8', offset, offset + Buffer.byteLength(utf8String));
+assert.equal(utf8String, utf8Slice);
+
+var sliceA = b.slice(offset, offset + Buffer.byteLength(utf8String));
+var sliceB = b.slice(offset, offset + Buffer.byteLength(utf8String));
+for (var i = 0; i < Buffer.byteLength(utf8String); i++) {
+  assert.equal(sliceA[i], sliceB[i]);
+}
+
+{
+  var slice = b.slice(100, 150);
+  assert.equal(50, slice.length);
+  for (var i = 0; i < 50; i++) {
+    assert.equal(b[100 + i], slice[i]);
+  }
+}
+
+{
+  // make sure only top level parent propagates from allocPool
+  var b = Buffer.allocUnsafe(5);
+  var c = b.slice(0, 4);
+  var d = c.slice(0, 2);
+  assert.equal(b.parent, c.parent);
+  assert.equal(b.parent, d.parent);
+}
+
+{
+  // also from a non-pooled instance
+  var b = Buffer.allocUnsafeSlow(5);
+  var c = b.slice(0, 4);
+  var d = c.slice(0, 2);
+  assert.equal(c.parent, d.parent);
+}
+
+{
+  // Bug regression test
+  var testValue = '\u00F6\u65E5\u672C\u8A9E'; // ö日本語
+  var buffer = Buffer.allocUnsafe(32);
+  var size = buffer.write(testValue, 0, 'utf8');
+//   console.log('bytes written to buffer: ' + size);
+  var slice = buffer.toString('utf8', 0, size);
+  assert.equal(slice, testValue);
+}
+
+{
+  // Test triple  slice
+  var a = Buffer.allocUnsafe(8);
+  for (var i = 0; i < 8; i++) a[i] = i;
+  var b = a.slice(4, 8);
+  assert.equal(4, b[0]);
+  assert.equal(5, b[1]);
+  assert.equal(6, b[2]);
+  assert.equal(7, b[3]);
+  var c = b.slice(2, 4);
+  assert.equal(6, c[0]);
+  assert.equal(7, c[1]);
+}
+
+{
+  var d = Buffer.from([23, 42, 255]);
+  assert.equal(d.length, 3);
+  assert.equal(d[0], 23);
+  assert.equal(d[1], 42);
+  assert.equal(d[2], 255);
+  assert.deepStrictEqual(d, Buffer.from(d));
+}
+
+{
+  var e = Buffer.from('über');
+//   console.error('uber: \'%s\'', e.toString());
+  assert.deepStrictEqual(e, Buffer.from([195, 188, 98, 101, 114]));
+}
+
+{
+  var f = Buffer.from('über', 'ascii');
+//   console.error('f.length: %d     (should be 4)', f.length);
+  assert.deepStrictEqual(f, Buffer.from([252, 98, 101, 114]));
+}
+
+['ucs2', 'ucs-2', 'utf16le', 'utf-16le'].forEach(function(encoding) {
+  {
+    var f = Buffer.from('über', encoding);
+//     console.error('f.length: %d     (should be 8)', f.length);
+    assert.deepStrictEqual(f, Buffer.from([252, 0, 98, 0, 101, 0, 114, 0]));
+  }
+
+  {
+    var f = Buffer.from('привет', encoding);
+//     console.error('f.length: %d     (should be 12)', f.length);
+    assert.deepStrictEqual(f,
+      Buffer.from([63, 4, 64, 4, 56, 4, 50, 4, 53, 4, 66, 4]));
+    assert.equal(f.toString(encoding), 'привет');
+  }
+
+  {
+    var f = Buffer.from([0, 0, 0, 0, 0]);
+    assert.equal(f.length, 5);
+    var size = f.write('あいうえお', encoding);
+//     console.error('bytes written to buffer: %d     (should be 4)', size);
+    assert.equal(size, 4);
+    assert.deepStrictEqual(f, Buffer.from([0x42, 0x30, 0x44, 0x30, 0x00]));
+  }
+});
+
+{
+  var f = Buffer.from('\uD83D\uDC4D', 'utf-16le'); // THUMBS UP SIGN (U+1F44D)
+  assert.equal(f.length, 4);
+  assert.deepStrictEqual(f, Buffer.from('3DD84DDC', 'hex'));
+}
+
+
+var arrayIsh = {0: 0, 1: 1, 2: 2, 3: 3, length: 4};
+var g = Buffer.from(arrayIsh);
+assert.deepStrictEqual(g, Buffer.from([0, 1, 2, 3]));
+var strArrayIsh = {0: '0', 1: '1', 2: '2', 3: '3', length: 4};
+g = Buffer.from(strArrayIsh);
+assert.deepStrictEqual(g, Buffer.from([0, 1, 2, 3]));
+
+
+//
+// Test toString('base64')
+//
+assert.equal('TWFu', (Buffer.from('Man')).toString('base64'));
+
+{
+  // test that regular and URL-safe base64 both work
+  var expected = [0xff, 0xff, 0xbe, 0xff, 0xef, 0xbf, 0xfb, 0xef, 0xff];
+  assert.deepStrictEqual(Buffer.from('//++/++/++//', 'base64'),
+                         Buffer.from(expected));
+  assert.deepStrictEqual(Buffer.from('__--_--_--__', 'base64'),
+                         Buffer.from(expected));
+}
+
+{
+  // big example
+  var quote = 'Man is distinguished, not only by his reason, but by this ' +
+                'singular passion from other animals, which is a lust ' +
+                'of the mind, that by a perseverance of delight in the ' +
+                'continued and indefatigable generation of knowledge, ' +
+                'exceeds the short vehemence of any carnal pleasure.';
+  var expected = 'TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb' +
+                   '24sIGJ1dCBieSB0aGlzIHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlci' +
+                   'BhbmltYWxzLCB3aGljaCBpcyBhIGx1c3Qgb2YgdGhlIG1pbmQsIHRoYXQ' +
+                   'gYnkgYSBwZXJzZXZlcmFuY2Ugb2YgZGVsaWdodCBpbiB0aGUgY29udGlu' +
+                   'dWVkIGFuZCBpbmRlZmF0aWdhYmxlIGdlbmVyYXRpb24gb2Yga25vd2xlZ' +
+                   'GdlLCBleGNlZWRzIHRoZSBzaG9ydCB2ZWhlbWVuY2Ugb2YgYW55IGNhcm' +
+                   '5hbCBwbGVhc3VyZS4=';
+  assert.equal(expected, (Buffer.from(quote)).toString('base64'));
+
+  var b = Buffer.allocUnsafe(1024);
+  var bytesWritten = b.write(expected, 0, 'base64');
+  assert.equal(quote.length, bytesWritten);
+  assert.equal(quote, b.toString('ascii', 0, quote.length));
+
+  // check that the base64 decoder ignores whitespace
+  var expectedWhite = expected.slice(0, 60) + ' \n' +
+                        expected.slice(60, 120) + ' \n' +
+                        expected.slice(120, 180) + ' \n' +
+                        expected.slice(180, 240) + ' \n' +
+                        expected.slice(240, 300) + '\n' +
+                        expected.slice(300, 360) + '\n';
+  b = Buffer.allocUnsafe(1024);
+  bytesWritten = b.write(expectedWhite, 0, 'base64');
+  assert.equal(quote.length, bytesWritten);
+  assert.equal(quote, b.toString('ascii', 0, quote.length));
+
+  // check that the base64 decoder on the constructor works
+  // even in the presence of whitespace.
+  b = Buffer.from(expectedWhite, 'base64');
+  assert.equal(quote.length, b.length);
+  assert.equal(quote, b.toString('ascii', 0, quote.length));
+
+  // check that the base64 decoder ignores illegal chars
+  var expectedIllegal = expected.slice(0, 60) + ' \x80' +
+                          expected.slice(60, 120) + ' \xff' +
+                          expected.slice(120, 180) + ' \x00' +
+                          expected.slice(180, 240) + ' \x98' +
+                          expected.slice(240, 300) + '\x03' +
+                          expected.slice(300, 360);
+  b = Buffer.from(expectedIllegal, 'base64');
+  assert.equal(quote.length, b.length);
+  assert.equal(quote, b.toString('ascii', 0, quote.length));
+}
+
+assert.equal(Buffer.from('', 'base64').toString(), '');
+assert.equal(Buffer.from('K', 'base64').toString(), '');
+
+// multiple-of-4 with padding
+assert.equal(Buffer.from('Kg==', 'base64').toString(), '*');
+assert.equal(Buffer.from('Kio=', 'base64').toString(), '**');
+assert.equal(Buffer.from('Kioq', 'base64').toString(), '***');
+assert.equal(Buffer.from('KioqKg==', 'base64').toString(), '****');
+assert.equal(Buffer.from('KioqKio=', 'base64').toString(), '*****');
+assert.equal(Buffer.from('KioqKioq', 'base64').toString(), '******');
+assert.equal(Buffer.from('KioqKioqKg==', 'base64').toString(), '*******');
+assert.equal(Buffer.from('KioqKioqKio=', 'base64').toString(), '********');
+assert.equal(Buffer.from('KioqKioqKioq', 'base64').toString(), '*********');
+assert.equal(Buffer.from('KioqKioqKioqKg==', 'base64').toString(),
+             '**********');
+assert.equal(Buffer.from('KioqKioqKioqKio=', 'base64').toString(),
+             '***********');
+assert.equal(Buffer.from('KioqKioqKioqKioq', 'base64').toString(),
+             '************');
+assert.equal(Buffer.from('KioqKioqKioqKioqKg==', 'base64').toString(),
+             '*************');
+assert.equal(Buffer.from('KioqKioqKioqKioqKio=', 'base64').toString(),
+             '**************');
+assert.equal(Buffer.from('KioqKioqKioqKioqKioq', 'base64').toString(),
+             '***************');
+assert.equal(Buffer.from('KioqKioqKioqKioqKioqKg==', 'base64').toString(),
+             '****************');
+assert.equal(Buffer.from('KioqKioqKioqKioqKioqKio=', 'base64').toString(),
+             '*****************');
+assert.equal(Buffer.from('KioqKioqKioqKioqKioqKioq', 'base64').toString(),
+             '******************');
+assert.equal(Buffer.from('KioqKioqKioqKioqKioqKioqKg==', 'base64').toString(),
+             '*******************');
+assert.equal(Buffer.from('KioqKioqKioqKioqKioqKioqKio=', 'base64').toString(),
+             '********************');
+
+// no padding, not a multiple of 4
+assert.equal(Buffer.from('Kg', 'base64').toString(), '*');
+assert.equal(Buffer.from('Kio', 'base64').toString(), '**');
+assert.equal(Buffer.from('KioqKg', 'base64').toString(), '****');
+assert.equal(Buffer.from('KioqKio', 'base64').toString(), '*****');
+assert.equal(Buffer.from('KioqKioqKg', 'base64').toString(), '*******');
+assert.equal(Buffer.from('KioqKioqKio', 'base64').toString(), '********');
+assert.equal(Buffer.from('KioqKioqKioqKg', 'base64').toString(), '**********');
+assert.equal(Buffer.from('KioqKioqKioqKio', 'base64').toString(),
+             '***********');
+assert.equal(Buffer.from('KioqKioqKioqKioqKg', 'base64').toString(),
+             '*************');
+assert.equal(Buffer.from('KioqKioqKioqKioqKio', 'base64').toString(),
+             '**************');
+assert.equal(Buffer.from('KioqKioqKioqKioqKioqKg', 'base64').toString(),
+             '****************');
+assert.equal(Buffer.from('KioqKioqKioqKioqKioqKio', 'base64').toString(),
+             '*****************');
+assert.equal(Buffer.from('KioqKioqKioqKioqKioqKioqKg', 'base64').toString(),
+             '*******************');
+assert.equal(Buffer.from('KioqKioqKioqKioqKioqKioqKio', 'base64').toString(),
+             '********************');
+
+// handle padding graciously, multiple-of-4 or not
+assert.equal(
+  Buffer.from('72INjkR5fchcxk9+VgdGPFJDxUBFR5/rMFsghgxADiw==', 'base64').length,
+  32
+);
+assert.equal(
+  Buffer.from('72INjkR5fchcxk9+VgdGPFJDxUBFR5/rMFsghgxADiw=', 'base64').length,
+  32
+);
+assert.equal(
+  Buffer.from('72INjkR5fchcxk9+VgdGPFJDxUBFR5/rMFsghgxADiw', 'base64').length,
+  32
+);
+assert.equal(
+  Buffer.from('w69jACy6BgZmaFvv96HG6MYksWytuZu3T1FvGnulPg==', 'base64').length,
+  31
+);
+assert.equal(
+  Buffer.from('w69jACy6BgZmaFvv96HG6MYksWytuZu3T1FvGnulPg=', 'base64').length,
+  31
+);
+assert.equal(
+  Buffer.from('w69jACy6BgZmaFvv96HG6MYksWytuZu3T1FvGnulPg', 'base64').length,
+  31
+);
+
+// This string encodes single '.' character in UTF-16
+var dot = Buffer.from('//4uAA==', 'base64');
+assert.equal(dot[0], 0xff);
+assert.equal(dot[1], 0xfe);
+assert.equal(dot[2], 0x2e);
+assert.equal(dot[3], 0x00);
+assert.equal(dot.toString('base64'), '//4uAA==');
+
+{
+  // Writing base64 at a position > 0 should not mangle the result.
+  //
+  // https://github.com/joyent/node/issues/402
+  var segments = ['TWFkbmVzcz8h', 'IFRoaXM=', 'IGlz', 'IG5vZGUuanMh'];
+  var b = Buffer.allocUnsafe(64);
+  var pos = 0;
+
+  for (var i = 0; i < segments.length; ++i) {
+    pos += b.write(segments[i], pos, 'base64');
+  }
+  assert.equal(b.toString('latin1', 0, pos), 'Madness?! This is node.js!');
+}
+
+// Regression test for https://github.com/nodejs/node/issues/3496.
+// assert.equal(Buffer.from('=bad'.repeat(1e4), 'base64').length, 0);
+
+{
+  // Creating buffers larger than pool size.
+  var l = Buffer.poolSize + 5;
+  var s = '';
+  for (var i = 0; i < l; i++) {
+    s += 'h';
+  }
+
+  var b = Buffer.from(s);
+
+  for (var i = 0; i < l; i++) {
+    assert.equal('h'.charCodeAt(0), b[i]);
+  }
+
+  var sb = b.toString();
+  assert.equal(sb.length, s.length);
+  assert.equal(sb, s);
+}
+
+{
+  // Single argument slice
+  var b = Buffer.from('abcde');
+  assert.equal('bcde', b.slice(1).toString());
+}
+
+// slice(0,0).length === 0
+assert.equal(0, Buffer.from('hello').slice(0, 0).length);
+
+// test hex toString
+// console.log('Create hex string from buffer');
+var hexb = Buffer.allocUnsafe(256);
+for (var i = 0; i < 256; i++) {
+  hexb[i] = i;
+}
+var hexStr = hexb.toString('hex');
+assert.equal(hexStr,
+             '000102030405060708090a0b0c0d0e0f' +
+             '101112131415161718191a1b1c1d1e1f' +
+             '202122232425262728292a2b2c2d2e2f' +
+             '303132333435363738393a3b3c3d3e3f' +
+             '404142434445464748494a4b4c4d4e4f' +
+             '505152535455565758595a5b5c5d5e5f' +
+             '606162636465666768696a6b6c6d6e6f' +
+             '707172737475767778797a7b7c7d7e7f' +
+             '808182838485868788898a8b8c8d8e8f' +
+             '909192939495969798999a9b9c9d9e9f' +
+             'a0a1a2a3a4a5a6a7a8a9aaabacadaeaf' +
+             'b0b1b2b3b4b5b6b7b8b9babbbcbdbebf' +
+             'c0c1c2c3c4c5c6c7c8c9cacbcccdcecf' +
+             'd0d1d2d3d4d5d6d7d8d9dadbdcdddedf' +
+             'e0e1e2e3e4e5e6e7e8e9eaebecedeeef' +
+             'f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff');
+
+// console.log('Create buffer from hex string');
+var hexb2 = Buffer.from(hexStr, 'hex');
+for (var i = 0; i < 256; i++) {
+  assert.equal(hexb2[i], hexb[i]);
+}
+
+{
+  // test an invalid slice end.
+//   console.log('Try to slice off the end of the buffer');
+  var b = Buffer.from([1, 2, 3, 4, 5]);
+  var b2 = b.toString('hex', 1, 10000);
+  var b3 = b.toString('hex', 1, 5);
+  var b4 = b.toString('hex', 1);
+  assert.equal(b2, b3);
+  assert.equal(b2, b4);
+}
+
+function buildBuffer(data) {
+  if (Array.isArray(data)) {
+    var buffer = Buffer.allocUnsafe(data.length);
+    data.forEach(function(v, k) {
+      buffer[k] = v;
+    });
+    return buffer;
+  }
+  return null;
+}
+
+var x = buildBuffer([0x81, 0xa3, 0x66, 0x6f, 0x6f, 0xa3, 0x62, 0x61, 0x72]);
+
+// console.log(x.inspect());
+assert.equal('<Buffer 81 a3 66 6f 6f a3 62 61 72>', x.inspect());
+
+{
+  var z = x.slice(4);
+//   console.log(z.inspect());
+//   console.log(z.length);
+  assert.equal(5, z.length);
+  assert.equal(0x6f, z[0]);
+  assert.equal(0xa3, z[1]);
+  assert.equal(0x62, z[2]);
+  assert.equal(0x61, z[3]);
+  assert.equal(0x72, z[4]);
+}
+
+{
+  var z = x.slice(0);
+//   console.log(z.inspect());
+//   console.log(z.length);
+  assert.equal(z.length, x.length);
+}
+
+{
+  var z = x.slice(0, 4);
+//   console.log(z.inspect());
+//   console.log(z.length);
+  assert.equal(4, z.length);
+  assert.equal(0x81, z[0]);
+  assert.equal(0xa3, z[1]);
+}
+
+{
+  var z = x.slice(0, 9);
+//   console.log(z.inspect());
+//   console.log(z.length);
+  assert.equal(9, z.length);
+}
+
+{
+  var z = x.slice(1, 4);
+//   console.log(z.inspect());
+//   console.log(z.length);
+  assert.equal(3, z.length);
+  assert.equal(0xa3, z[0]);
+}
+
+{
+  var z = x.slice(2, 4);
+//   console.log(z.inspect());
+//   console.log(z.length);
+  assert.equal(2, z.length);
+  assert.equal(0x66, z[0]);
+  assert.equal(0x6f, z[1]);
+}
+
+assert.equal(0, Buffer.from('hello').slice(0, 0).length);
+
+['ucs2', 'ucs-2', 'utf16le', 'utf-16le'].forEach(function(encoding) {
+  var b = Buffer.allocUnsafe(10);
+  b.write('あいうえお', encoding);
+  assert.equal(b.toString(encoding), 'あいうえお');
+});
+
+{
+  // Binary encoding should write only one byte per character.
+  var b = Buffer.from([0xde, 0xad, 0xbe, 0xef]);
+  var s = String.fromCharCode(0xffff);
+  b.write(s, 0, 'latin1');
+  assert.equal(0xff, b[0]);
+  assert.equal(0xad, b[1]);
+  assert.equal(0xbe, b[2]);
+  assert.equal(0xef, b[3]);
+  s = String.fromCharCode(0xaaee);
+  b.write(s, 0, 'latin1');
+  assert.equal(0xee, b[0]);
+  assert.equal(0xad, b[1]);
+  assert.equal(0xbe, b[2]);
+  assert.equal(0xef, b[3]);
+}
+
+{
+  // #1210 Test UTF-8 string includes null character
+  var buf = Buffer.from('\0');
+  assert.equal(buf.length, 1);
+  buf = Buffer.from('\0\0');
+  assert.equal(buf.length, 2);
+}
+
+{
+  var buf = Buffer.allocUnsafe(2);
+  var written = buf.write(''); // 0byte
+  assert.equal(written, 0);
+  written = buf.write('\0'); // 1byte (v8 adds null terminator)
+  assert.equal(written, 1);
+  written = buf.write('a\0'); // 1byte * 2
+  assert.equal(written, 2);
+  written = buf.write('あ'); // 3bytes
+  assert.equal(written, 0);
+  written = buf.write('\0あ'); // 1byte + 3bytes
+  assert.equal(written, 1);
+  written = buf.write('\0\0あ'); // 1byte * 2 + 3bytes
+  assert.equal(written, 2);
+}
+
+{
+  var buf = Buffer.allocUnsafe(10);
+  written = buf.write('あいう'); // 3bytes * 3 (v8 adds null terminator)
+  assert.equal(written, 9);
+  written = buf.write('あいう\0'); // 3bytes * 3 + 1byte
+  assert.equal(written, 10);
+}
+
+{
+  // #243 Test write() with maxLength
+  var buf = Buffer.allocUnsafe(4);
+  buf.fill(0xFF);
+  var written = buf.write('abcd', 1, 2, 'utf8');
+//   console.log(buf);
+  assert.equal(written, 2);
+  assert.equal(buf[0], 0xFF);
+  assert.equal(buf[1], 0x61);
+  assert.equal(buf[2], 0x62);
+  assert.equal(buf[3], 0xFF);
+
+  buf.fill(0xFF);
+  written = buf.write('abcd', 1, 4);
+//   console.log(buf);
+  assert.equal(written, 3);
+  assert.equal(buf[0], 0xFF);
+  assert.equal(buf[1], 0x61);
+  assert.equal(buf[2], 0x62);
+  assert.equal(buf[3], 0x63);
+
+  buf.fill(0xFF);
+  written = buf.write('abcd', 1, 2, 'utf8');
+//   console.log(buf);
+  assert.equal(written, 2);
+  assert.equal(buf[0], 0xFF);
+  assert.equal(buf[1], 0x61);
+  assert.equal(buf[2], 0x62);
+  assert.equal(buf[3], 0xFF);
+
+  buf.fill(0xFF);
+  written = buf.write('abcdef', 1, 2, 'hex');
+//   console.log(buf);
+  assert.equal(written, 2);
+  assert.equal(buf[0], 0xFF);
+  assert.equal(buf[1], 0xAB);
+  assert.equal(buf[2], 0xCD);
+  assert.equal(buf[3], 0xFF);
+
+  ['ucs2', 'ucs-2', 'utf16le', 'utf-16le'].forEach(function(encoding) {
+    buf.fill(0xFF);
+    written = buf.write('abcd', 0, 2, encoding);
+//     console.log(buf);
+    assert.equal(written, 2);
+    assert.equal(buf[0], 0x61);
+    assert.equal(buf[1], 0x00);
+    assert.equal(buf[2], 0xFF);
+    assert.equal(buf[3], 0xFF);
+  });
+}
+
+{
+  // test offset returns are correct
+  var b = Buffer.allocUnsafe(16);
+  assert.equal(4, b.writeUInt32LE(0, 0));
+  assert.equal(6, b.writeUInt16LE(0, 4));
+  assert.equal(7, b.writeUInt8(0, 6));
+  assert.equal(8, b.writeInt8(0, 7));
+  assert.equal(16, b.writeDoubleLE(0, 8));
+}
+
+{
+  // test unmatched surrogates not producing invalid utf8 output
+  // ef bf bd = utf-8 representation of unicode replacement character
+  // see https://codereview.chromium.org/121173009/
+  var buf = Buffer.from('ab\ud800cd', 'utf8');
+  assert.equal(buf[0], 0x61);
+  assert.equal(buf[1], 0x62);
+  assert.equal(buf[2], 0xef);
+  assert.equal(buf[3], 0xbf);
+  assert.equal(buf[4], 0xbd);
+  assert.equal(buf[5], 0x63);
+  assert.equal(buf[6], 0x64);
+}
+
+{
+  // test for buffer overrun
+  var buf = Buffer.from([0, 0, 0, 0, 0]); // length: 5
+  var sub = buf.slice(0, 4);         // length: 4
+  written = sub.write('12345', 'latin1');
+  assert.equal(written, 4);
+  assert.equal(buf[4], 0);
+}
+
+// Check for fractional length args, junk length args, etc.
+// https://github.com/joyent/node/issues/1758
+
+// Call .fill() first, stops valgrind warning about uninitialized memory reads.
+Buffer.allocUnsafe(3.3).fill().toString();
+  // throws bad argument error in commit 43cb4ec
+Buffer.alloc(3.3).fill().toString();
+assert.equal(Buffer.allocUnsafe(NaN).length, 0);
+assert.equal(Buffer.allocUnsafe(3.3).length, 3);
+assert.equal(Buffer.from({length: 3.3}).length, 3);
+assert.equal(Buffer.from({length: 'BAM'}).length, 0);
+
+// Make sure that strings are not coerced to numbers.
+assert.equal(Buffer.from('99').length, 2);
+assert.equal(Buffer.from('13.37').length, 5);
+
+// Ensure that the length argument is respected.
+'ascii utf8 hex base64 latin1'.split(' ').forEach(function(enc) {
+  assert.equal(Buffer.allocUnsafe(1).write('aaaaaa', 0, 1, enc), 1);
+});
+
+{
+  // Regression test, guard against buffer overrun in the base64 decoder.
+  var a = Buffer.allocUnsafe(3);
+  var b = Buffer.from('xxx');
+  a.write('aaaaaaaa', 'base64');
+  assert.equal(b.toString(), 'xxx');
+}
+
+// issue GH-3416
+Buffer.from(Buffer.allocUnsafe(0), 0, 0);
+
+[ 'hex',
+  'utf8',
+  'utf-8',
+  'ascii',
+  'latin1',
+  'binary',
+  'base64',
+  'ucs2',
+  'ucs-2',
+  'utf16le',
+  'utf-16le' ].forEach(function(enc) {
+    assert.equal(Buffer.isEncoding(enc), true);
+  });
+
+[ 'utf9',
+  'utf-7',
+  'Unicode-FTW',
+  'new gnu gun',
+  false,
+  NaN,
+  {},
+  Infinity,
+  [],
+  1,
+  0,
+  -1 ].forEach(function(enc) {
+    assert.equal(Buffer.isEncoding(enc), false);
+  });
+
+
+// GH-5110
+{
+  var buffer = Buffer.from('test');
+  var string = JSON.stringify(buffer);
+
+  assert.strictEqual(string, '{"type":"Buffer","data":[116,101,115,116]}');
+
+  assert.deepStrictEqual(buffer, JSON.parse(string, function(key, value) {
+    return value && value.type === 'Buffer'
+      ? Buffer.from(value.data)
+      : value;
+  }));
+}
+
+// issue GH-7849
+{
+  var buf = Buffer.from('test');
+  var json = JSON.stringify(buf);
+  var obj = JSON.parse(json);
+  var copy = Buffer.from(obj);
+
+  assert(buf.equals(copy));
+}
+
+// issue GH-4331
+assert.throws(function() {
+  Buffer.allocUnsafe(0xFFFFFFFF);
+}, RangeError);
+assert.throws(function() {
+  Buffer.allocUnsafe(0xFFFFFFFFF);
+}, RangeError);
+
+
+// attempt to overflow buffers, similar to previous bug in array buffers
+assert.throws(function() {
+  var buf = Buffer.allocUnsafe(8);
+  buf.readFloatLE(0xffffffff);
+}, RangeError);
+
+assert.throws(function() {
+  var buf = Buffer.allocUnsafe(8);
+  buf.writeFloatLE(0.0, 0xffffffff);
+}, RangeError);
+
+assert.throws(function() {
+  var buf = Buffer.allocUnsafe(8);
+  buf.readFloatLE(0xffffffff);
+}, RangeError);
+
+assert.throws(function() {
+  var buf = Buffer.allocUnsafe(8);
+  buf.writeFloatLE(0.0, 0xffffffff);
+}, RangeError);
+
+
+// ensure negative values can't get past offset
+assert.throws(function() {
+  var buf = Buffer.allocUnsafe(8);
+  buf.readFloatLE(-1);
+}, RangeError);
+
+assert.throws(function() {
+  var buf = Buffer.allocUnsafe(8);
+  buf.writeFloatLE(0.0, -1);
+}, RangeError);
+
+assert.throws(function() {
+  var buf = Buffer.allocUnsafe(8);
+  buf.readFloatLE(-1);
+}, RangeError);
+
+assert.throws(function() {
+  var buf = Buffer.allocUnsafe(8);
+  buf.writeFloatLE(0.0, -1);
+}, RangeError);
+
+// offset checks
+{
+  var buf = Buffer.allocUnsafe(0);
+
+  assert.throws(function() { buf.readUInt8(0); }, RangeError);
+  assert.throws(function() { buf.readInt8(0); }, RangeError);
+}
+
+{
+  var buf = Buffer.from([0xFF]);
+
+  assert.equal(buf.readUInt8(0), 255);
+  assert.equal(buf.readInt8(0), -1);
+}
+
+[16, 32].forEach(function(bits) {
+  var buf = Buffer.allocUnsafe(bits / 8 - 1);
+
+  assert.throws(function() { buf['readUInt' + bits + 'BE'](0); },
+                RangeError,
+                'readUInt' + bits + 'BE');
+
+  assert.throws(function() { buf['readUInt' + bits + 'LE'](0); },
+                RangeError,
+                'readUInt' + bits + 'LE');
+
+  assert.throws(function() { buf['readInt' + bits + 'BE'](0); },
+                RangeError,
+                'readInt' + bits + 'BE()');
+
+  assert.throws(function() { buf['readInt' + bits + 'LE'](0); },
+                RangeError,
+                'readInt' + bits + 'LE()');
+});
+
+[16, 32].forEach(function(bits) {
+  var buf = Buffer.from([0xFF, 0xFF, 0xFF, 0xFF]);
+
+  assert.equal(buf['readUInt' + bits + 'BE'](0),
+                (0xFFFFFFFF >>> (32 - bits)));
+
+  assert.equal(buf['readUInt' + bits + 'LE'](0),
+                (0xFFFFFFFF >>> (32 - bits)));
+
+  assert.equal(buf['readInt' + bits + 'BE'](0),
+                (0xFFFFFFFF >> (32 - bits)));
+
+  assert.equal(buf['readInt' + bits + 'LE'](0),
+                (0xFFFFFFFF >> (32 - bits)));
+});
+
+// test for common read(U)IntLE/BE
+{
+  var buf = Buffer.from([0x01, 0x02, 0x03, 0x04, 0x05, 0x06]);
+
+  assert.strictEqual(buf.readUIntLE(0, 1), 0x01);
+  assert.strictEqual(buf.readUIntBE(0, 1), 0x01);
+  assert.strictEqual(buf.readUIntLE(0, 3), 0x030201);
+  assert.strictEqual(buf.readUIntBE(0, 3), 0x010203);
+  assert.strictEqual(buf.readUIntLE(0, 5), 0x0504030201);
+  assert.strictEqual(buf.readUIntBE(0, 5), 0x0102030405);
+  assert.strictEqual(buf.readUIntLE(0, 6), 0x060504030201);
+  assert.strictEqual(buf.readUIntBE(0, 6), 0x010203040506);
+  assert.strictEqual(buf.readIntLE(0, 1), 0x01);
+  assert.strictEqual(buf.readIntBE(0, 1), 0x01);
+  assert.strictEqual(buf.readIntLE(0, 3), 0x030201);
+  assert.strictEqual(buf.readIntBE(0, 3), 0x010203);
+  assert.strictEqual(buf.readIntLE(0, 5), 0x0504030201);
+  assert.strictEqual(buf.readIntBE(0, 5), 0x0102030405);
+  assert.strictEqual(buf.readIntLE(0, 6), 0x060504030201);
+  assert.strictEqual(buf.readIntBE(0, 6), 0x010203040506);
+}
+
+// test for common write(U)IntLE/BE
+{
+  var buf = Buffer.allocUnsafe(3);
+  buf.writeUIntLE(0x123456, 0, 3);
+  assert.deepStrictEqual(buf.toJSON().data, [0x56, 0x34, 0x12]);
+  assert.equal(buf.readUIntLE(0, 3), 0x123456);
+
+  buf = Buffer.allocUnsafe(3);
+  buf.writeUIntBE(0x123456, 0, 3);
+  assert.deepStrictEqual(buf.toJSON().data, [0x12, 0x34, 0x56]);
+  assert.equal(buf.readUIntBE(0, 3), 0x123456);
+
+  buf = Buffer.allocUnsafe(3);
+  buf.writeIntLE(0x123456, 0, 3);
+  assert.deepStrictEqual(buf.toJSON().data, [0x56, 0x34, 0x12]);
+  assert.equal(buf.readIntLE(0, 3), 0x123456);
+
+  buf = Buffer.allocUnsafe(3);
+  buf.writeIntBE(0x123456, 0, 3);
+  assert.deepStrictEqual(buf.toJSON().data, [0x12, 0x34, 0x56]);
+  assert.equal(buf.readIntBE(0, 3), 0x123456);
+
+  buf = Buffer.allocUnsafe(3);
+  buf.writeIntLE(-0x123456, 0, 3);
+  assert.deepStrictEqual(buf.toJSON().data, [0xaa, 0xcb, 0xed]);
+  assert.equal(buf.readIntLE(0, 3), -0x123456);
+
+  buf = Buffer.allocUnsafe(3);
+  buf.writeIntBE(-0x123456, 0, 3);
+  assert.deepStrictEqual(buf.toJSON().data, [0xed, 0xcb, 0xaa]);
+  assert.equal(buf.readIntBE(0, 3), -0x123456);
+
+  buf = Buffer.allocUnsafe(3);
+  buf.writeIntLE(-0x123400, 0, 3);
+  assert.deepStrictEqual(buf.toJSON().data, [0x00, 0xcc, 0xed]);
+  assert.equal(buf.readIntLE(0, 3), -0x123400);
+
+  buf = Buffer.allocUnsafe(3);
+  buf.writeIntBE(-0x123400, 0, 3);
+  assert.deepStrictEqual(buf.toJSON().data, [0xed, 0xcc, 0x00]);
+  assert.equal(buf.readIntBE(0, 3), -0x123400);
+
+  buf = Buffer.allocUnsafe(3);
+  buf.writeIntLE(-0x120000, 0, 3);
+  assert.deepStrictEqual(buf.toJSON().data, [0x00, 0x00, 0xee]);
+  assert.equal(buf.readIntLE(0, 3), -0x120000);
+
+  buf = Buffer.allocUnsafe(3);
+  buf.writeIntBE(-0x120000, 0, 3);
+  assert.deepStrictEqual(buf.toJSON().data, [0xee, 0x00, 0x00]);
+  assert.equal(buf.readIntBE(0, 3), -0x120000);
+
+  buf = Buffer.allocUnsafe(5);
+  buf.writeUIntLE(0x1234567890, 0, 5);
+  assert.deepStrictEqual(buf.toJSON().data, [0x90, 0x78, 0x56, 0x34, 0x12]);
+  assert.equal(buf.readUIntLE(0, 5), 0x1234567890);
+
+  buf = Buffer.allocUnsafe(5);
+  buf.writeUIntBE(0x1234567890, 0, 5);
+  assert.deepStrictEqual(buf.toJSON().data, [0x12, 0x34, 0x56, 0x78, 0x90]);
+  assert.equal(buf.readUIntBE(0, 5), 0x1234567890);
+
+  buf = Buffer.allocUnsafe(5);
+  buf.writeIntLE(0x1234567890, 0, 5);
+  assert.deepStrictEqual(buf.toJSON().data, [0x90, 0x78, 0x56, 0x34, 0x12]);
+  assert.equal(buf.readIntLE(0, 5), 0x1234567890);
+
+  buf = Buffer.allocUnsafe(5);
+  buf.writeIntBE(0x1234567890, 0, 5);
+  assert.deepStrictEqual(buf.toJSON().data, [0x12, 0x34, 0x56, 0x78, 0x90]);
+  assert.equal(buf.readIntBE(0, 5), 0x1234567890);
+
+  buf = Buffer.allocUnsafe(5);
+  buf.writeIntLE(-0x1234567890, 0, 5);
+  assert.deepStrictEqual(buf.toJSON().data, [0x70, 0x87, 0xa9, 0xcb, 0xed]);
+  assert.equal(buf.readIntLE(0, 5), -0x1234567890);
+
+  buf = Buffer.allocUnsafe(5);
+  buf.writeIntBE(-0x1234567890, 0, 5);
+  assert.deepStrictEqual(buf.toJSON().data, [0xed, 0xcb, 0xa9, 0x87, 0x70]);
+  assert.equal(buf.readIntBE(0, 5), -0x1234567890);
+
+  buf = Buffer.allocUnsafe(5);
+  buf.writeIntLE(-0x0012000000, 0, 5);
+  assert.deepStrictEqual(buf.toJSON().data, [0x00, 0x00, 0x00, 0xee, 0xff]);
+  assert.equal(buf.readIntLE(0, 5), -0x0012000000);
+
+  buf = Buffer.allocUnsafe(5);
+  buf.writeIntBE(-0x0012000000, 0, 5);
+  assert.deepStrictEqual(buf.toJSON().data, [0xff, 0xee, 0x00, 0x00, 0x00]);
+  assert.equal(buf.readIntBE(0, 5), -0x0012000000);
+}
+
+// test Buffer slice
+{
+  var buf = Buffer.from('0123456789');
+  assert.equal(buf.slice(-10, 10), '0123456789');
+  assert.equal(buf.slice(-20, 10), '0123456789');
+  assert.equal(buf.slice(-20, -10), '');
+  assert.equal(buf.slice(), '0123456789');
+  assert.equal(buf.slice(0), '0123456789');
+  assert.equal(buf.slice(0, 0), '');
+  assert.equal(buf.slice(undefined), '0123456789');
+  assert.equal(buf.slice('foobar'), '0123456789');
+  assert.equal(buf.slice(undefined, undefined), '0123456789');
+
+  assert.equal(buf.slice(2), '23456789');
+  assert.equal(buf.slice(5), '56789');
+  assert.equal(buf.slice(10), '');
+  assert.equal(buf.slice(5, 8), '567');
+  assert.equal(buf.slice(8, -1), '8');
+  assert.equal(buf.slice(-10), '0123456789');
+  assert.equal(buf.slice(0, -9), '0');
+  assert.equal(buf.slice(0, -10), '');
+  assert.equal(buf.slice(0, -1), '012345678');
+  assert.equal(buf.slice(2, -2), '234567');
+  assert.equal(buf.slice(0, 65536), '0123456789');
+  assert.equal(buf.slice(65536, 0), '');
+  assert.equal(buf.slice(-5, -8), '');
+  assert.equal(buf.slice(-5, -3), '56');
+  assert.equal(buf.slice(-10, 10), '0123456789');
+  for (var i = 0, s = buf.toString(); i < buf.length; ++i) {
+    assert.equal(buf.slice(i), s.slice(i));
+    assert.equal(buf.slice(0, i), s.slice(0, i));
+    assert.equal(buf.slice(-i), s.slice(-i));
+    assert.equal(buf.slice(0, -i), s.slice(0, -i));
+  }
+
+  var utf16Buf = Buffer.from('0123456789', 'utf16le');
+  // assert.deepStrictEqual(utf16Buf.slice(0, 6), Buffer.from('012', 'utf16le'));
+
+  assert.equal(buf.slice('0', '1'), '0');
+  assert.equal(buf.slice('-5', '10'), '56789');
+  assert.equal(buf.slice('-10', '10'), '0123456789');
+  assert.equal(buf.slice('-10', '-5'), '01234');
+  assert.equal(buf.slice('-10', '-0'), '');
+  assert.equal(buf.slice('111'), '');
+  assert.equal(buf.slice('0', '-111'), '');
+
+  // try to slice a zero length Buffer
+  // see https://github.com/joyent/node/issues/5881
+  Buffer.alloc(0).slice(0, 1);
+}
+
+// Regression test for #5482: should throw but not assert in C++ land.
+assert.throws(function() {
+  Buffer.from('', 'buffer');
+}, TypeError);
+
+// Regression test for #6111. Constructing a buffer from another buffer
+// should a) work, and b) not corrupt the source buffer.
+{
+  var a = [0];
+  for (var i = 0; i < 7; ++i) a = a.concat(a);
+  a = a.map(function(_, i) { return i; });
+  var b = Buffer.from(a);
+  var c = Buffer.from(b);
+  assert.strictEqual(b.length, a.length);
+  assert.strictEqual(c.length, a.length);
+  for (var i = 0, k = a.length; i < k; ++i) {
+    assert.strictEqual(a[i], i);
+    assert.strictEqual(b[i], i);
+    assert.strictEqual(c[i], i);
+  }
+}
+
+
+assert.throws(function() {
+  Buffer.allocUnsafe((-1 >>> 0) + 1);
+}, RangeError);
+
+assert.throws(function() {
+  Buffer.allocUnsafeSlow((-1 >>> 0) + 1);
+}, RangeError);
+
+if (common.hasCrypto) {
+  // Test truncation after decode
+  var crypto = require('crypto');
+
+  var b1 = Buffer.from('YW55=======', 'base64');
+  var b2 = Buffer.from('YW55', 'base64');
+
+  assert.equal(
+    crypto.createHash('sha1').update(b1).digest('hex'),
+    crypto.createHash('sha1').update(b2).digest('hex')
+  );
+} else {
+  common.skip('missing crypto');
+}
+
+// Test Compare
+{
+  var b = Buffer.alloc(1, 'a');
+  var c = Buffer.alloc(1, 'c');
+  var d = Buffer.alloc(2, 'aa');
+
+  assert.equal(b.compare(c), -1);
+  assert.equal(c.compare(d), 1);
+  assert.equal(d.compare(b), 1);
+  assert.equal(b.compare(d), -1);
+  assert.equal(b.compare(b), 0);
+
+  assert.equal(Buffer.compare(b, c), -1);
+  assert.equal(Buffer.compare(c, d), 1);
+  assert.equal(Buffer.compare(d, b), 1);
+  assert.equal(Buffer.compare(b, d), -1);
+  assert.equal(Buffer.compare(c, c), 0);
+
+  assert.equal(Buffer.compare(Buffer.alloc(0), Buffer.alloc(0)), 0);
+  assert.equal(Buffer.compare(Buffer.alloc(0), Buffer.alloc(1)), -1);
+  assert.equal(Buffer.compare(Buffer.alloc(1), Buffer.alloc(0)), 1);
+}
+
+assert.throws(function() {
+  var b = Buffer.allocUnsafe(1);
+  Buffer.compare(b, 'abc');
+});
+
+assert.throws(function() {
+  var b = Buffer.allocUnsafe(1);
+  Buffer.compare('abc', b);
+});
+
+assert.throws(function() {
+  var b = Buffer.allocUnsafe(1);
+  b.compare('abc');
+});
+
+// Test Equals
+{
+  var b = Buffer.alloc(5, 'abcdf');
+  var c = Buffer.alloc(5, 'abcdf');
+  var d = Buffer.alloc(5, 'abcde');
+  var e = Buffer.alloc(6, 'abcdef');
+
+  assert.ok(b.equals(c));
+  assert.ok(!c.equals(d));
+  assert.ok(!d.equals(e));
+  assert.ok(d.equals(d));
+}
+
+assert.throws(function() {
+  var b = Buffer.allocUnsafe(1);
+  b.equals('abc');
+});
+
+// Regression test for https://github.com/nodejs/node/issues/649.
+assert.throws(() => { Buffer.allocUnsafe(1422561062959).toString('utf8');});
+
+var ps = Buffer.poolSize;
+Buffer.poolSize = 0;
+assert.equal(Buffer.allocUnsafe(1).parent, undefined);
+Buffer.poolSize = ps;
+
+// Test Buffer.copy() segfault
+assert.throws(function() {
+  Buffer.allocUnsafe(10).copy();
+});
+
+var regErrorMsg = new RegExp('First argument must be a string, Buffer, ' +
+                               'ArrayBuffer, Array, or array-like object.');
+
+assert.throws(function() {
+  Buffer.from();
+}, regErrorMsg);
+
+assert.throws(function() {
+  Buffer.from(null);
+}, regErrorMsg);
+
+
+// Test that ParseArrayIndex handles full uint32
+assert.throws(function() {
+  Buffer.from(new ArrayBuffer(0), -1 >>> 0);
+}, /RangeError: 'offset' is out of bounds/);
+
+// ParseArrayIndex() should reject values that don't fit in a 32 bits size_t.
+assert.throws(() => {
+  var a = Buffer(1).fill(0);
+  var b = Buffer(1).fill(0);
+  a.copy(b, 0, 0x100000000, 0x100000001);
+}), /out of range index/;
+
+// Unpooled buffer (replaces SlowBuffer)
+var ubuf = Buffer.allocUnsafeSlow(10);
+assert(ubuf);
+assert(ubuf.buffer);
+assert.equal(ubuf.buffer.byteLength, 10);
+
+// Regression test
+assert.doesNotThrow(() => {
+  Buffer.from(new ArrayBuffer());
+});
+
+assert.throws(() => Buffer.alloc(-Buffer.poolSize),
+              '"size" argument must not be negative');
+assert.throws(() => Buffer.alloc(-100),
+              '"size" argument must not be negative');
+assert.throws(() => Buffer.allocUnsafe(-Buffer.poolSize),
+              '"size" argument must not be negative');
+assert.throws(() => Buffer.allocUnsafe(-100),
+              '"size" argument must not be negative');
+assert.throws(() => Buffer.allocUnsafeSlow(-Buffer.poolSize),
+              '"size" argument must not be negative');
+assert.throws(() => Buffer.allocUnsafeSlow(-100),
+              '"size" argument must not be negative');
+
+assert.throws(() => Buffer.alloc({ valueOf: () => 1 }),
+              /"size" argument must be a number/);
+assert.throws(() => Buffer.alloc({ valueOf: () => -1 }),
+              /"size" argument must be a number/);
+
diff --git a/node_modules/buffer/test/node/test-buffer-arraybuffer.js b/node_modules/buffer/test/node/test-buffer-arraybuffer.js
new file mode 100644
index 000000000..a418752ba
--- /dev/null
+++ b/node_modules/buffer/test/node/test-buffer-arraybuffer.js
@@ -0,0 +1,112 @@
+'use strict';
+var Buffer = require('../../').Buffer;
+
+
+
+var assert = require('assert');
+
+var Buffer = require('../../').Buffer;
+var LENGTH = 16;
+
+var ab = new ArrayBuffer(LENGTH);
+var dv = new DataView(ab);
+var ui = new Uint8Array(ab);
+var buf = Buffer.from(ab);
+
+
+assert.ok(buf instanceof Buffer);
+// For backwards compatibility of old .parent property test that if buf is not
+// a slice then .parent should be undefined.
+assert.equal(buf.parent, undefined);
+assert.equal(buf.buffer, ab);
+assert.equal(buf.length, ab.byteLength);
+
+
+buf.fill(0xC);
+for (var i = 0; i < LENGTH; i++) {
+  assert.equal(ui[i], 0xC);
+  ui[i] = 0xF;
+  assert.equal(buf[i], 0xF);
+}
+
+buf.writeUInt32LE(0xF00, 0);
+buf.writeUInt32BE(0xB47, 4);
+buf.writeDoubleLE(3.1415, 8);
+
+assert.equal(dv.getUint32(0, true), 0xF00);
+assert.equal(dv.getUint32(4), 0xB47);
+assert.equal(dv.getFloat64(8, true), 3.1415);
+
+
+// Now test protecting users from doing stupid things
+
+assert.throws(function() {
+  function AB() { }
+  Object.setPrototypeOf(AB, ArrayBuffer);
+  Object.setPrototypeOf(AB.prototype, ArrayBuffer.prototype);
+  Buffer.from(new AB());
+}, TypeError);
+
+// write{Double,Float}{LE,BE} with noAssert should not crash, cf. #3766
+var b = Buffer.allocUnsafe(1);
+b.writeFloatLE(11.11, 0, true);
+b.writeFloatBE(11.11, 0, true);
+b.writeDoubleLE(11.11, 0, true);
+b.writeDoubleBE(11.11, 0, true);
+
+// Test the byteOffset and length arguments
+{
+  var ab = new Uint8Array(5);
+  ab[0] = 1;
+  ab[1] = 2;
+  ab[2] = 3;
+  ab[3] = 4;
+  ab[4] = 5;
+  var buf = Buffer.from(ab.buffer, 1, 3);
+  assert.equal(buf.length, 3);
+  assert.equal(buf[0], 2);
+  assert.equal(buf[1], 3);
+  assert.equal(buf[2], 4);
+  buf[0] = 9;
+  assert.equal(ab[1], 9);
+
+  assert.throws(() => Buffer.from(ab.buffer, 6), (err) => {
+    assert(err instanceof RangeError);
+    assert(/'offset' is out of bounds/.test(err.message));
+    return true;
+  });
+  assert.throws(() => Buffer.from(ab.buffer, 3, 6), (err) => {
+    assert(err instanceof RangeError);
+    assert(/'length' is out of bounds/.test(err.message));
+    return true;
+  });
+}
+
+// Test the deprecated Buffer() version also
+{
+  var ab = new Uint8Array(5);
+  ab[0] = 1;
+  ab[1] = 2;
+  ab[2] = 3;
+  ab[3] = 4;
+  ab[4] = 5;
+  var buf = Buffer(ab.buffer, 1, 3);
+  assert.equal(buf.length, 3);
+  assert.equal(buf[0], 2);
+  assert.equal(buf[1], 3);
+  assert.equal(buf[2], 4);
+  buf[0] = 9;
+  assert.equal(ab[1], 9);
+
+  assert.throws(() => Buffer(ab.buffer, 6), (err) => {
+    assert(err instanceof RangeError);
+    assert(/'offset' is out of bounds/.test(err.message));
+    return true;
+  });
+  assert.throws(() => Buffer(ab.buffer, 3, 6), (err) => {
+    assert(err instanceof RangeError);
+    assert(/'length' is out of bounds/.test(err.message));
+    return true;
+  });
+}
+
diff --git a/node_modules/buffer/test/node/test-buffer-ascii.js b/node_modules/buffer/test/node/test-buffer-ascii.js
new file mode 100644
index 000000000..4a06098ab
--- /dev/null
+++ b/node_modules/buffer/test/node/test-buffer-ascii.js
@@ -0,0 +1,28 @@
+'use strict';
+var Buffer = require('../../').Buffer;
+
+
+var assert = require('assert');
+
+// ASCII conversion in node.js simply masks off the high bits,
+// it doesn't do transliteration.
+assert.equal(Buffer.from('hérité').toString('ascii'), 'hC)ritC)');
+
+// 71 characters, 78 bytes. The ’ character is a triple-byte sequence.
+var input = 'C’est, graphiquement, la réunion d’un accent aigu ' +
+            'et d’un accent grave.';
+
+var expected = 'Cb\u0000\u0019est, graphiquement, la rC)union ' +
+               'db\u0000\u0019un accent aigu et db\u0000\u0019un ' +
+               'accent grave.';
+
+var buf = Buffer.from(input);
+
+for (var i = 0; i < expected.length; ++i) {
+  assert.equal(buf.slice(i).toString('ascii'), expected.slice(i));
+
+  // Skip remainder of multi-byte sequence.
+  if (input.charCodeAt(i) > 65535) ++i;
+  if (input.charCodeAt(i) > 127) ++i;
+}
+
diff --git a/node_modules/buffer/test/node/test-buffer-bad-overload.js b/node_modules/buffer/test/node/test-buffer-bad-overload.js
new file mode 100644
index 000000000..282227d73
--- /dev/null
+++ b/node_modules/buffer/test/node/test-buffer-bad-overload.js
@@ -0,0 +1,18 @@
+'use strict';
+var Buffer = require('../../').Buffer;
+
+
+var assert = require('assert');
+
+assert.doesNotThrow(function() {
+  Buffer.allocUnsafe(10);
+});
+
+assert.throws(function() {
+  Buffer.from(10, 'hex');
+});
+
+assert.doesNotThrow(function() {
+  Buffer.from('deadbeaf', 'hex');
+});
+
diff --git a/node_modules/buffer/test/node/test-buffer-badhex.js b/node_modules/buffer/test/node/test-buffer-badhex.js
new file mode 100644
index 000000000..fd7851d96
--- /dev/null
+++ b/node_modules/buffer/test/node/test-buffer-badhex.js
@@ -0,0 +1,46 @@
+'use strict';
+var Buffer = require('../../').Buffer;
+
+
+var assert = require('assert');
+var Buffer = require('../../').Buffer;
+
+// Test hex strings and bad hex strings
+{
+  var buf1 = Buffer.alloc(4);
+  assert.strictEqual(buf1.length, 4);
+  assert.deepStrictEqual(buf1, new Buffer([0, 0, 0, 0]));
+  assert.strictEqual(buf1.write('abcdxx', 0, 'hex'), 2);
+  assert.deepStrictEqual(buf1, new Buffer([0xab, 0xcd, 0x00, 0x00]));
+  assert.strictEqual(buf1.toString('hex'), 'abcd0000');
+  assert.strictEqual(buf1.write('abcdef01', 0, 'hex'), 4);
+  assert.deepStrictEqual(buf1, new Buffer([0xab, 0xcd, 0xef, 0x01]));
+  assert.strictEqual(buf1.toString('hex'), 'abcdef01');
+
+  var buf2 = Buffer.from(buf1.toString('hex'), 'hex');
+  assert.strictEqual(buf1.toString('hex'), buf2.toString('hex'));
+
+  var buf3 = Buffer.alloc(5);
+  assert.strictEqual(buf3.write('abcdxx', 1, 'hex'), 2);
+  assert.strictEqual(buf3.toString('hex'), '00abcd0000');
+
+  var buf4 = Buffer.alloc(4);
+  assert.deepStrictEqual(buf4, new Buffer([0, 0, 0, 0]));
+  assert.strictEqual(buf4.write('xxabcd', 0, 'hex'), 0);
+  assert.deepStrictEqual(buf4, new Buffer([0, 0, 0, 0]));
+  assert.strictEqual(buf4.write('xxab', 1, 'hex'), 0);
+  assert.deepStrictEqual(buf4, new Buffer([0, 0, 0, 0]));
+  assert.strictEqual(buf4.write('cdxxab', 0, 'hex'), 1);
+  assert.deepStrictEqual(buf4, new Buffer([0xcd, 0, 0, 0]));
+
+  var buf5 = Buffer.alloc(256);
+  for (var i = 0; i < 256; i++)
+    buf5[i] = i;
+
+  var hex = buf5.toString('hex');
+  assert.deepStrictEqual(Buffer.from(hex, 'hex'), buf5);
+
+  var badHex = hex.slice(0, 256) + 'xx' + hex.slice(256, 510);
+  assert.deepStrictEqual(Buffer.from(badHex, 'hex'), buf5.slice(0, 128));
+}
+
diff --git a/node_modules/buffer/test/node/test-buffer-bytelength.js b/node_modules/buffer/test/node/test-buffer-bytelength.js
new file mode 100644
index 000000000..8d7dc35b9
--- /dev/null
+++ b/node_modules/buffer/test/node/test-buffer-bytelength.js
@@ -0,0 +1,90 @@
+'use strict';
+var Buffer = require('../../').Buffer;
+
+
+
+var assert = require('assert');
+var Buffer = require('../../').Buffer;
+var SlowBuffer = require('../../').SlowBuffer;
+
+// coerce values to string
+assert.equal(Buffer.byteLength(32, 'latin1'), 2);
+assert.equal(Buffer.byteLength(NaN, 'utf8'), 3);
+assert.equal(Buffer.byteLength({}, 'latin1'), 15);
+assert.equal(Buffer.byteLength(), 9);
+
+var buff = new Buffer(10);
+assert(ArrayBuffer.isView(buff));
+var slowbuff = new SlowBuffer(10);
+assert(ArrayBuffer.isView(slowbuff));
+
+// buffer
+var incomplete = Buffer.from([0xe4, 0xb8, 0xad, 0xe6, 0x96]);
+assert.equal(Buffer.byteLength(incomplete), 5);
+var ascii = Buffer.from('abc');
+assert.equal(Buffer.byteLength(ascii), 3);
+
+// ArrayBuffer
+var buffer = new ArrayBuffer(8);
+assert.equal(Buffer.byteLength(buffer), 8);
+
+// TypedArray
+var int8 = new Int8Array(8);
+assert.equal(Buffer.byteLength(int8), 8);
+var uint8 = new Uint8Array(8);
+assert.equal(Buffer.byteLength(uint8), 8);
+var uintc8 = new Uint8ClampedArray(2);
+assert.equal(Buffer.byteLength(uintc8), 2);
+var int16 = new Int16Array(8);
+assert.equal(Buffer.byteLength(int16), 16);
+var uint16 = new Uint16Array(8);
+assert.equal(Buffer.byteLength(uint16), 16);
+var int32 = new Int32Array(8);
+assert.equal(Buffer.byteLength(int32), 32);
+var uint32 = new Uint32Array(8);
+assert.equal(Buffer.byteLength(uint32), 32);
+var float32 = new Float32Array(8);
+assert.equal(Buffer.byteLength(float32), 32);
+var float64 = new Float64Array(8);
+assert.equal(Buffer.byteLength(float64), 64);
+
+// DataView
+var dv = new DataView(new ArrayBuffer(2));
+assert.equal(Buffer.byteLength(dv), 2);
+
+// special case: zero length string
+assert.equal(Buffer.byteLength('', 'ascii'), 0);
+assert.equal(Buffer.byteLength('', 'HeX'), 0);
+
+// utf8
+assert.equal(Buffer.byteLength('∑éllö wørl∂!', 'utf-8'), 19);
+assert.equal(Buffer.byteLength('κλμνξο', 'utf8'), 12);
+assert.equal(Buffer.byteLength('挵挶挷挸挹', 'utf-8'), 15);
+assert.equal(Buffer.byteLength('𠝹𠱓𠱸', 'UTF8'), 12);
+// without an encoding, utf8 should be assumed
+assert.equal(Buffer.byteLength('hey there'), 9);
+assert.equal(Buffer.byteLength('𠱸挶νξ#xx :)'), 17);
+assert.equal(Buffer.byteLength('hello world', ''), 11);
+// it should also be assumed with unrecognized encoding
+assert.equal(Buffer.byteLength('hello world', 'abc'), 11);
+assert.equal(Buffer.byteLength('ßœ∑≈', 'unkn0wn enc0ding'), 10);
+
+// base64
+assert.equal(Buffer.byteLength('aGVsbG8gd29ybGQ=', 'base64'), 11);
+assert.equal(Buffer.byteLength('bm9kZS5qcyByb2NrcyE=', 'base64'), 14);
+assert.equal(Buffer.byteLength('aGkk', 'base64'), 3);
+assert.equal(Buffer.byteLength('bHNrZGZsa3NqZmtsc2xrZmFqc2RsZmtqcw==',
+    'base64'), 25);
+// special padding
+assert.equal(Buffer.byteLength('aaa=', 'base64'), 2);
+assert.equal(Buffer.byteLength('aaaa==', 'base64'), 3);
+
+assert.equal(Buffer.byteLength('Il était tué'), 14);
+assert.equal(Buffer.byteLength('Il était tué', 'utf8'), 14);
+assert.equal(Buffer.byteLength('Il était tué', 'ascii'), 12);
+assert.equal(Buffer.byteLength('Il était tué', 'latin1'), 12);
+assert.equal(Buffer.byteLength('Il était tué', 'binary'), 12);
+['ucs2', 'ucs-2', 'utf16le', 'utf-16le'].forEach(function(encoding) {
+  assert.equal(24, Buffer.byteLength('Il était tué', encoding));
+});
+
diff --git a/node_modules/buffer/test/node/test-buffer-compare-offset.js b/node_modules/buffer/test/node/test-buffer-compare-offset.js
new file mode 100644
index 000000000..f1984ed91
--- /dev/null
+++ b/node_modules/buffer/test/node/test-buffer-compare-offset.js
@@ -0,0 +1,66 @@
+'use strict';
+var Buffer = require('../../').Buffer;
+
+
+
+var assert = require('assert');
+
+var a = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8, 9, 0]);
+var b = Buffer.from([5, 6, 7, 8, 9, 0, 1, 2, 3, 4]);
+
+assert.equal(-1, a.compare(b));
+
+// Equivalent to a.compare(b).
+assert.equal(-1, a.compare(b, 0));
+assert.equal(-1, a.compare(b, '0'));
+
+// Equivalent to a.compare(b).
+assert.equal(-1, a.compare(b, 0, undefined, 0));
+
+// Zero-length targer, return 1
+assert.equal(1, a.compare(b, 0, 0, 0));
+assert.equal(1, a.compare(b, '0', '0', '0'));
+
+// Equivalent to Buffer.compare(a, b.slice(6, 10))
+assert.equal(1, a.compare(b, 6, 10));
+
+// Zero-length source, return -1
+assert.equal(-1, a.compare(b, 6, 10, 0, 0));
+
+// Equivalent to Buffer.compare(a.slice(4), b.slice(0, 5))
+assert.equal(1, a.compare(b, 0, 5, 4));
+
+// Equivalent to Buffer.compare(a.slice(1), b.slice(5))
+assert.equal(1, a.compare(b, 5, undefined, 1));
+
+// Equivalent to Buffer.compare(a.slice(2), b.slice(2, 4))
+assert.equal(-1, a.compare(b, 2, 4, 2));
+
+// Equivalent to Buffer.compare(a.slice(4), b.slice(0, 7))
+assert.equal(-1, a.compare(b, 0, 7, 4));
+
+// Equivalent to Buffer.compare(a.slice(4, 6), b.slice(0, 7));
+assert.equal(-1, a.compare(b, 0, 7, 4, 6));
+
+// zero length target
+assert.equal(1, a.compare(b, 0, null));
+
+// coerces to targetEnd == 5
+assert.equal(-1, a.compare(b, 0, {valueOf: () => 5}));
+
+// zero length target
+assert.equal(1, a.compare(b, Infinity, -Infinity));
+
+// zero length target because default for targetEnd <= targetSource
+assert.equal(1, a.compare(b, '0xff'));
+
+var oor = /out of range index/;
+
+assert.throws(() => a.compare(b, 0, 100, 0), oor);
+assert.throws(() => a.compare(b, 0, 1, 0, 100), oor);
+assert.throws(() => a.compare(b, -1), oor);
+assert.throws(() => a.compare(b, 0, '0xff'), oor);
+assert.throws(() => a.compare(b, 0, Infinity), oor);
+assert.throws(() => a.compare(b, -Infinity, Infinity), oor);
+assert.throws(() => a.compare(), /Argument must be a Buffer/);
+
diff --git a/node_modules/buffer/test/node/test-buffer-concat.js b/node_modules/buffer/test/node/test-buffer-concat.js
new file mode 100644
index 000000000..c0dc4da09
--- /dev/null
+++ b/node_modules/buffer/test/node/test-buffer-concat.js
@@ -0,0 +1,40 @@
+'use strict';
+var Buffer = require('../../').Buffer;
+
+
+var assert = require('assert');
+
+var zero = [];
+var one = [ Buffer.from('asdf') ];
+var long = [];
+for (var i = 0; i < 10; i++) long.push(Buffer.from('asdf'));
+
+var flatZero = Buffer.concat(zero);
+var flatOne = Buffer.concat(one);
+var flatLong = Buffer.concat(long);
+var flatLongLen = Buffer.concat(long, 40);
+
+assert(flatZero.length === 0);
+assert(flatOne.toString() === 'asdf');
+// A special case where concat used to return the first item,
+// if the length is one. This check is to make sure that we don't do that.
+assert(flatOne !== one[0]);
+assert(flatLong.toString() === (new Array(10 + 1).join('asdf')));
+assert(flatLongLen.toString() === (new Array(10 + 1).join('asdf')));
+
+assertWrongList();
+assertWrongList(null);
+assertWrongList(Buffer.from('hello'));
+assertWrongList([42]);
+assertWrongList(['hello', 'world']);
+assertWrongList(['hello', Buffer.from('world')]);
+
+function assertWrongList(value) {
+  assert.throws(function() {
+    Buffer.concat(value);
+  }, function(err) {
+    return err instanceof TypeError &&
+           err.message === '"list" argument must be an Array of Buffers';
+  });
+}
+
diff --git a/node_modules/buffer/test/node/test-buffer-fill.js b/node_modules/buffer/test/node/test-buffer-fill.js
new file mode 100644
index 000000000..7138094a7
--- /dev/null
+++ b/node_modules/buffer/test/node/test-buffer-fill.js
@@ -0,0 +1,272 @@
+'use strict';
+var Buffer = require('../../').Buffer;
+
+
+
+var assert = require('assert');
+var os = require('os');
+var SIZE = 28;
+
+var buf1 = Buffer.allocUnsafe(SIZE);
+var buf2 = Buffer.allocUnsafe(SIZE);
+
+
+// Default encoding
+testBufs('abc');
+testBufs('\u0222aa');
+testBufs('a\u0234b\u0235c\u0236');
+testBufs('abc', 4);
+testBufs('abc', 5);
+testBufs('abc', SIZE);
+testBufs('\u0222aa', 2);
+testBufs('\u0222aa', 8);
+testBufs('a\u0234b\u0235c\u0236', 4);
+testBufs('a\u0234b\u0235c\u0236', 12);
+testBufs('abc', 4, -1);
+testBufs('abc', 4, 1);
+testBufs('abc', 5, 1);
+testBufs('\u0222aa', 2, -1);
+testBufs('\u0222aa', 8, 1);
+testBufs('a\u0234b\u0235c\u0236', 4, -1);
+testBufs('a\u0234b\u0235c\u0236', 4, 1);
+testBufs('a\u0234b\u0235c\u0236', 12, 1);
+
+
+// UTF8
+testBufs('abc', 'utf8');
+testBufs('\u0222aa', 'utf8');
+testBufs('a\u0234b\u0235c\u0236', 'utf8');
+testBufs('abc', 4, 'utf8');
+testBufs('abc', 5, 'utf8');
+testBufs('abc', SIZE, 'utf8');
+testBufs('\u0222aa', 2, 'utf8');
+testBufs('\u0222aa', 8, 'utf8');
+testBufs('a\u0234b\u0235c\u0236', 4, 'utf8');
+testBufs('a\u0234b\u0235c\u0236', 12, 'utf8');
+testBufs('abc', 4, -1, 'utf8');
+testBufs('abc', 4, 1, 'utf8');
+testBufs('abc', 5, 1, 'utf8');
+testBufs('\u0222aa', 2, -1, 'utf8');
+testBufs('\u0222aa', 8, 1, 'utf8');
+testBufs('a\u0234b\u0235c\u0236', 4, -1, 'utf8');
+testBufs('a\u0234b\u0235c\u0236', 4, 1, 'utf8');
+testBufs('a\u0234b\u0235c\u0236', 12, 1, 'utf8');
+assert.equal(Buffer.allocUnsafe(1).fill(0).fill('\u0222')[0], 0xc8);
+
+
+// BINARY
+testBufs('abc', 'binary');
+testBufs('\u0222aa', 'binary');
+testBufs('a\u0234b\u0235c\u0236', 'binary');
+testBufs('abc', 4, 'binary');
+testBufs('abc', 5, 'binary');
+testBufs('abc', SIZE, 'binary');
+testBufs('\u0222aa', 2, 'binary');
+testBufs('\u0222aa', 8, 'binary');
+testBufs('a\u0234b\u0235c\u0236', 4, 'binary');
+testBufs('a\u0234b\u0235c\u0236', 12, 'binary');
+testBufs('abc', 4, -1, 'binary');
+testBufs('abc', 4, 1, 'binary');
+testBufs('abc', 5, 1, 'binary');
+testBufs('\u0222aa', 2, -1, 'binary');
+testBufs('\u0222aa', 8, 1, 'binary');
+testBufs('a\u0234b\u0235c\u0236', 4, -1, 'binary');
+testBufs('a\u0234b\u0235c\u0236', 4, 1, 'binary');
+testBufs('a\u0234b\u0235c\u0236', 12, 1, 'binary');
+
+
+// LATIN1
+testBufs('abc', 'latin1');
+testBufs('\u0222aa', 'latin1');
+testBufs('a\u0234b\u0235c\u0236', 'latin1');
+testBufs('abc', 4, 'latin1');
+testBufs('abc', 5, 'latin1');
+testBufs('abc', SIZE, 'latin1');
+testBufs('\u0222aa', 2, 'latin1');
+testBufs('\u0222aa', 8, 'latin1');
+testBufs('a\u0234b\u0235c\u0236', 4, 'latin1');
+testBufs('a\u0234b\u0235c\u0236', 12, 'latin1');
+testBufs('abc', 4, -1, 'latin1');
+testBufs('abc', 4, 1, 'latin1');
+testBufs('abc', 5, 1, 'latin1');
+testBufs('\u0222aa', 2, -1, 'latin1');
+testBufs('\u0222aa', 8, 1, 'latin1');
+testBufs('a\u0234b\u0235c\u0236', 4, -1, 'latin1');
+testBufs('a\u0234b\u0235c\u0236', 4, 1, 'latin1');
+testBufs('a\u0234b\u0235c\u0236', 12, 1, 'latin1');
+
+
+// UCS2
+testBufs('abc', 'ucs2');
+testBufs('\u0222aa', 'ucs2');
+testBufs('a\u0234b\u0235c\u0236', 'ucs2');
+testBufs('abc', 4, 'ucs2');
+testBufs('abc', SIZE, 'ucs2');
+testBufs('\u0222aa', 2, 'ucs2');
+testBufs('\u0222aa', 8, 'ucs2');
+testBufs('a\u0234b\u0235c\u0236', 4, 'ucs2');
+testBufs('a\u0234b\u0235c\u0236', 12, 'ucs2');
+testBufs('abc', 4, -1, 'ucs2');
+testBufs('abc', 4, 1, 'ucs2');
+testBufs('abc', 5, 1, 'ucs2');
+testBufs('\u0222aa', 2, -1, 'ucs2');
+testBufs('\u0222aa', 8, 1, 'ucs2');
+testBufs('a\u0234b\u0235c\u0236', 4, -1, 'ucs2');
+testBufs('a\u0234b\u0235c\u0236', 4, 1, 'ucs2');
+testBufs('a\u0234b\u0235c\u0236', 12, 1, 'ucs2');
+assert.equal(Buffer.allocUnsafe(1).fill('\u0222', 'ucs2')[0],
+             os.endianness() === 'LE' ? 0x22 : 0x02);
+
+
+// HEX
+testBufs('616263', 'hex');
+testBufs('c8a26161', 'hex');
+testBufs('61c8b462c8b563c8b6', 'hex');
+testBufs('616263', 4, 'hex');
+testBufs('616263', 5, 'hex');
+testBufs('616263', SIZE, 'hex');
+testBufs('c8a26161', 2, 'hex');
+testBufs('c8a26161', 8, 'hex');
+testBufs('61c8b462c8b563c8b6', 4, 'hex');
+testBufs('61c8b462c8b563c8b6', 12, 'hex');
+testBufs('616263', 4, -1, 'hex');
+testBufs('616263', 4, 1, 'hex');
+testBufs('616263', 5, 1, 'hex');
+testBufs('c8a26161', 2, -1, 'hex');
+testBufs('c8a26161', 8, 1, 'hex');
+testBufs('61c8b462c8b563c8b6', 4, -1, 'hex');
+testBufs('61c8b462c8b563c8b6', 4, 1, 'hex');
+testBufs('61c8b462c8b563c8b6', 12, 1, 'hex');
+// Make sure this operation doesn't go on forever
+buf1.fill('yKJh', 'hex');
+assert.throws(() => buf1.fill('\u0222', 'hex'));
+
+
+// BASE64
+testBufs('YWJj', 'ucs2');
+testBufs('yKJhYQ==', 'ucs2');
+testBufs('Yci0Ysi1Y8i2', 'ucs2');
+testBufs('YWJj', 4, 'ucs2');
+testBufs('YWJj', SIZE, 'ucs2');
+testBufs('yKJhYQ==', 2, 'ucs2');
+testBufs('yKJhYQ==', 8, 'ucs2');
+testBufs('Yci0Ysi1Y8i2', 4, 'ucs2');
+testBufs('Yci0Ysi1Y8i2', 12, 'ucs2');
+testBufs('YWJj', 4, -1, 'ucs2');
+testBufs('YWJj', 4, 1, 'ucs2');
+testBufs('YWJj', 5, 1, 'ucs2');
+testBufs('yKJhYQ==', 2, -1, 'ucs2');
+testBufs('yKJhYQ==', 8, 1, 'ucs2');
+testBufs('Yci0Ysi1Y8i2', 4, -1, 'ucs2');
+testBufs('Yci0Ysi1Y8i2', 4, 1, 'ucs2');
+testBufs('Yci0Ysi1Y8i2', 12, 1, 'ucs2');
+
+
+// Buffer
+function deepStrictEqualValues(buf, arr) {
+  for (var [index, value] of buf.entries()) {
+    assert.deepStrictEqual(value, arr[index]);
+  }
+}
+
+
+var buf2Fill = Buffer.allocUnsafe(1).fill(2);
+deepStrictEqualValues(genBuffer(4, [buf2Fill]), [2, 2, 2, 2]);
+deepStrictEqualValues(genBuffer(4, [buf2Fill, 1]), [0, 2, 2, 2]);
+deepStrictEqualValues(genBuffer(4, [buf2Fill, 1, 3]), [0, 2, 2, 0]);
+deepStrictEqualValues(genBuffer(4, [buf2Fill, 1, 1]), [0, 0, 0, 0]);
+deepStrictEqualValues(genBuffer(4, [buf2Fill, 1, -1]), [0, 0, 0, 0]);
+var hexBufFill = Buffer.allocUnsafe(2).fill(0).fill('0102', 'hex');
+deepStrictEqualValues(genBuffer(4, [hexBufFill]), [1, 2, 1, 2]);
+deepStrictEqualValues(genBuffer(4, [hexBufFill, 1]), [0, 1, 2, 1]);
+deepStrictEqualValues(genBuffer(4, [hexBufFill, 1, 3]), [0, 1, 2, 0]);
+deepStrictEqualValues(genBuffer(4, [hexBufFill, 1, 1]), [0, 0, 0, 0]);
+deepStrictEqualValues(genBuffer(4, [hexBufFill, 1, -1]), [0, 0, 0, 0]);
+
+
+// Check exceptions
+assert.throws(() => buf1.fill(0, -1));
+assert.throws(() => buf1.fill(0, 0, buf1.length + 1));
+assert.throws(() => buf1.fill('', -1));
+assert.throws(() => buf1.fill('', 0, buf1.length + 1));
+assert.throws(() => buf1.fill('a', 0, buf1.length, 'node rocks!'));
+assert.throws(() => buf1.fill('a', 0, 0, NaN));
+assert.throws(() => buf1.fill('a', 0, 0, null));
+assert.throws(() => buf1.fill('a', 0, 0, 'foo'));
+
+
+function genBuffer(size, args) {
+  var b = Buffer.allocUnsafe(size);
+  return b.fill(0).fill.apply(b, args);
+}
+
+
+function bufReset() {
+  buf1.fill(0);
+  buf2.fill(0);
+}
+
+
+// This is mostly accurate. Except write() won't write partial bytes to the
+// string while fill() blindly copies bytes into memory. To account for that an
+// error will be thrown if not all the data can be written, and the SIZE has
+// been massaged to work with the input characters.
+function writeToFill(string, offset, end, encoding) {
+  if (typeof offset === 'string') {
+    encoding = offset;
+    offset = 0;
+    end = buf2.length;
+  } else if (typeof end === 'string') {
+    encoding = end;
+    end = buf2.length;
+  } else if (end === undefined) {
+    end = buf2.length;
+  }
+
+  if (offset < 0 || end > buf2.length)
+    throw new RangeError('Out of range index');
+
+  if (end <= offset)
+    return buf2;
+
+  offset >>>= 0;
+  end >>>= 0;
+  assert(offset <= buf2.length);
+
+  // Convert "end" to "length" (which write understands).
+  var length = end - offset < 0 ? 0 : end - offset;
+
+  var wasZero = false;
+  do {
+    var written = buf2.write(string, offset, length, encoding);
+    offset += written;
+    // Safety check in case write falls into infinite loop.
+    if (written === 0) {
+      if (wasZero)
+        throw new Error('Could not write all data to Buffer');
+      else
+        wasZero = true;
+    }
+  } while (offset < buf2.length);
+
+  // Correction for UCS2 operations.
+  if (os.endianness() === 'BE' && encoding === 'ucs2') {
+    for (var i = 0; i < buf2.length; i += 2) {
+      var tmp = buf2[i];
+      buf2[i] = buf2[i + 1];
+      buf2[i + 1] = tmp;
+    }
+  }
+
+  return buf2;
+}
+
+
+function testBufs(string, offset, length, encoding) {
+  bufReset();
+  buf1.fill.apply(buf1, arguments);
+  // Swap bytes on BE archs for ucs2 encoding.
+  assert.deepStrictEqual(buf1.fill.apply(buf1, arguments),
+                         writeToFill.apply(null, arguments));
+}
+
diff --git a/node_modules/buffer/test/node/test-buffer-includes.js b/node_modules/buffer/test/node/test-buffer-includes.js
new file mode 100644
index 000000000..2096a34ba
--- /dev/null
+++ b/node_modules/buffer/test/node/test-buffer-includes.js
@@ -0,0 +1,305 @@
+'use strict';
+var Buffer = require('../../').Buffer;
+
+
+var assert = require('assert');
+
+var Buffer = require('../../').Buffer;
+
+var b = Buffer.from('abcdef');
+var buf_a = Buffer.from('a');
+var buf_bc = Buffer.from('bc');
+var buf_f = Buffer.from('f');
+var buf_z = Buffer.from('z');
+var buf_empty = Buffer.from('');
+
+assert(b.includes('a'));
+assert(!b.includes('a', 1));
+assert(!b.includes('a', -1));
+assert(!b.includes('a', -4));
+assert(b.includes('a', -b.length));
+assert(b.includes('a', NaN));
+assert(b.includes('a', -Infinity));
+assert(!b.includes('a', Infinity));
+assert(b.includes('bc'));
+assert(!b.includes('bc', 2));
+assert(!b.includes('bc', -1));
+assert(!b.includes('bc', -3));
+assert(b.includes('bc', -5));
+assert(b.includes('bc', NaN));
+assert(b.includes('bc', -Infinity));
+assert(!b.includes('bc', Infinity));
+assert(b.includes('f'), b.length - 1);
+assert(!b.includes('z'));
+assert(!b.includes(''));
+assert(!b.includes('', 1));
+assert(!b.includes('', b.length + 1));
+assert(!b.includes('', Infinity));
+assert(b.includes(buf_a));
+assert(!b.includes(buf_a, 1));
+assert(!b.includes(buf_a, -1));
+assert(!b.includes(buf_a, -4));
+assert(b.includes(buf_a, -b.length));
+assert(b.includes(buf_a, NaN));
+assert(b.includes(buf_a, -Infinity));
+assert(!b.includes(buf_a, Infinity));
+assert(b.includes(buf_bc));
+assert(!b.includes(buf_bc, 2));
+assert(!b.includes(buf_bc, -1));
+assert(!b.includes(buf_bc, -3));
+assert(b.includes(buf_bc, -5));
+assert(b.includes(buf_bc, NaN));
+assert(b.includes(buf_bc, -Infinity));
+assert(!b.includes(buf_bc, Infinity));
+assert(b.includes(buf_f), b.length - 1);
+assert(!b.includes(buf_z));
+assert(!b.includes(buf_empty));
+assert(!b.includes(buf_empty, 1));
+assert(!b.includes(buf_empty, b.length + 1));
+assert(!b.includes(buf_empty, Infinity));
+assert(b.includes(0x61));
+assert(!b.includes(0x61, 1));
+assert(!b.includes(0x61, -1));
+assert(!b.includes(0x61, -4));
+assert(b.includes(0x61, -b.length));
+assert(b.includes(0x61, NaN));
+assert(b.includes(0x61, -Infinity));
+assert(!b.includes(0x61, Infinity));
+assert(!b.includes(0x0));
+
+// test offsets
+assert(b.includes('d', 2));
+assert(b.includes('f', 5));
+assert(b.includes('f', -1));
+assert(!b.includes('f', 6));
+
+assert(b.includes(Buffer.from('d'), 2));
+assert(b.includes(Buffer.from('f'), 5));
+assert(b.includes(Buffer.from('f'), -1));
+assert(!b.includes(Buffer.from('f'), 6));
+
+assert(!Buffer.from('ff').includes(Buffer.from('f'), 1, 'ucs2'));
+
+// test hex encoding
+assert.strictEqual(
+  Buffer.from(b.toString('hex'), 'hex')
+    .includes('64', 0, 'hex'),
+  true
+);
+assert.strictEqual(
+  Buffer.from(b.toString('hex'), 'hex')
+    .includes(Buffer.from('64', 'hex'), 0, 'hex'),
+  true
+);
+
+// test base64 encoding
+assert.strictEqual(
+  Buffer.from(b.toString('base64'), 'base64')
+    .includes('ZA==', 0, 'base64'),
+  true
+);
+assert.strictEqual(
+  Buffer.from(b.toString('base64'), 'base64')
+    .includes(Buffer.from('ZA==', 'base64'), 0, 'base64'),
+  true
+);
+
+// test ascii encoding
+assert.strictEqual(
+  Buffer.from(b.toString('ascii'), 'ascii')
+    .includes('d', 0, 'ascii'),
+  true
+);
+assert.strictEqual(
+  Buffer.from(b.toString('ascii'), 'ascii')
+    .includes(Buffer.from('d', 'ascii'), 0, 'ascii'),
+  true
+);
+
+// test latin1 encoding
+assert.strictEqual(
+  Buffer.from(b.toString('latin1'), 'latin1')
+    .includes('d', 0, 'latin1'),
+  true
+);
+assert.strictEqual(
+  Buffer.from(b.toString('latin1'), 'latin1')
+    .includes(Buffer.from('d', 'latin1'), 0, 'latin1'),
+  true
+);
+
+// test binary encoding
+assert.strictEqual(
+  Buffer.from(b.toString('binary'), 'binary')
+    .includes('d', 0, 'binary'),
+  true
+);
+assert.strictEqual(
+  Buffer.from(b.toString('binary'), 'binary')
+    .includes(Buffer.from('d', 'binary'), 0, 'binary'),
+  true
+);
+
+
+// test usc2 encoding
+var twoByteString = Buffer.from('\u039a\u0391\u03a3\u03a3\u0395', 'ucs2');
+
+assert(twoByteString.includes('\u0395', 4, 'ucs2'));
+assert(twoByteString.includes('\u03a3', -4, 'ucs2'));
+assert(twoByteString.includes('\u03a3', -6, 'ucs2'));
+assert(twoByteString.includes(
+  Buffer.from('\u03a3', 'ucs2'), -6, 'ucs2'));
+assert(!twoByteString.includes('\u03a3', -2, 'ucs2'));
+
+var mixedByteStringUcs2 =
+    Buffer.from('\u039a\u0391abc\u03a3\u03a3\u0395', 'ucs2');
+assert(mixedByteStringUcs2.includes('bc', 0, 'ucs2'));
+assert(mixedByteStringUcs2.includes('\u03a3', 0, 'ucs2'));
+assert(!mixedByteStringUcs2.includes('\u0396', 0, 'ucs2'));
+
+assert(
+    6, mixedByteStringUcs2.includes(Buffer.from('bc', 'ucs2'), 0, 'ucs2'));
+assert(
+    10, mixedByteStringUcs2.includes(Buffer.from('\u03a3', 'ucs2'),
+    0, 'ucs2'));
+assert(
+    -1, mixedByteStringUcs2.includes(Buffer.from('\u0396', 'ucs2'),
+    0, 'ucs2'));
+
+twoByteString = Buffer.from('\u039a\u0391\u03a3\u03a3\u0395', 'ucs2');
+
+// Test single char pattern
+assert(twoByteString.includes('\u039a', 0, 'ucs2'));
+assert(twoByteString.includes('\u0391', 0, 'ucs2'), 'Alpha');
+assert(twoByteString.includes('\u03a3', 0, 'ucs2'), 'First Sigma');
+assert(twoByteString.includes('\u03a3', 6, 'ucs2'), 'Second Sigma');
+assert(twoByteString.includes('\u0395', 0, 'ucs2'), 'Epsilon');
+assert(!twoByteString.includes('\u0392', 0, 'ucs2'), 'Not beta');
+
+// Test multi-char pattern
+assert(twoByteString.includes('\u039a\u0391', 0, 'ucs2'), 'Lambda Alpha');
+assert(twoByteString.includes('\u0391\u03a3', 0, 'ucs2'), 'Alpha Sigma');
+assert(twoByteString.includes('\u03a3\u03a3', 0, 'ucs2'), 'Sigma Sigma');
+assert(twoByteString.includes('\u03a3\u0395', 0, 'ucs2'), 'Sigma Epsilon');
+
+var mixedByteStringUtf8 = Buffer.from('\u039a\u0391abc\u03a3\u03a3\u0395');
+assert(mixedByteStringUtf8.includes('bc'));
+assert(mixedByteStringUtf8.includes('bc', 5));
+assert(mixedByteStringUtf8.includes('bc', -8));
+assert(mixedByteStringUtf8.includes('\u03a3'));
+assert(!mixedByteStringUtf8.includes('\u0396'));
+
+
+// Test complex string includes algorithms. Only trigger for long strings.
+// Long string that isn't a simple repeat of a shorter string.
+var longString = 'A';
+for (var i = 66; i < 76; i++) {  // from 'B' to 'K'
+  longString = longString + String.fromCharCode(i) + longString;
+}
+
+var longBufferString = Buffer.from(longString);
+
+// pattern of 15 chars, repeated every 16 chars in long
+var pattern = 'ABACABADABACABA';
+for (var i = 0; i < longBufferString.length - pattern.length; i += 7) {
+  var includes = longBufferString.includes(pattern, i);
+  assert(includes, 'Long ABACABA...-string at index ' + i);
+}
+assert(longBufferString.includes('AJABACA'), 'Long AJABACA, First J');
+assert(longBufferString.includes('AJABACA', 511), 'Long AJABACA, Second J');
+
+pattern = 'JABACABADABACABA';
+assert(longBufferString.includes(pattern), 'Long JABACABA..., First J');
+assert(longBufferString.includes(pattern, 512), 'Long JABACABA..., Second J');
+
+// Search for a non-ASCII string in a pure ASCII string.
+var asciiString = Buffer.from(
+    'arglebargleglopglyfarglebargleglopglyfarglebargleglopglyf');
+assert(!asciiString.includes('\x2061'));
+assert(asciiString.includes('leb', 0));
+
+// Search in string containing many non-ASCII chars.
+var allCodePoints = [];
+for (var i = 0; i < 65536; i++) allCodePoints[i] = i;
+var allCharsString = String.fromCharCode.apply(String, allCodePoints);
+var allCharsBufferUtf8 = Buffer.from(allCharsString);
+var allCharsBufferUcs2 = Buffer.from(allCharsString, 'ucs2');
+
+// Search for string long enough to trigger complex search with ASCII pattern
+// and UC16 subject.
+assert(!allCharsBufferUtf8.includes('notfound'));
+assert(!allCharsBufferUcs2.includes('notfound'));
+
+// Find substrings in Utf8.
+var lengths = [1, 3, 15];  // Single char, simple and complex.
+var indices = [0x5, 0x60, 0x400, 0x680, 0x7ee, 0xFF02, 0x16610, 0x2f77b];
+for (var lengthIndex = 0; lengthIndex < lengths.length; lengthIndex++) {
+  for (var i = 0; i < indices.length; i++) {
+    var index = indices[i];
+    var length = lengths[lengthIndex];
+
+    if (index + length > 0x7F) {
+      length = 2 * length;
+    }
+
+    if (index + length > 0x7FF) {
+      length = 3 * length;
+    }
+
+    if (index + length > 0xFFFF) {
+      length = 4 * length;
+    }
+
+    var patternBufferUtf8 = allCharsBufferUtf8.slice(index, index + length);
+    assert(index, allCharsBufferUtf8.includes(patternBufferUtf8));
+
+    var patternStringUtf8 = patternBufferUtf8.toString();
+    assert(index, allCharsBufferUtf8.includes(patternStringUtf8));
+  }
+}
+
+// Find substrings in Usc2.
+lengths = [2, 4, 16];  // Single char, simple and complex.
+indices = [0x5, 0x65, 0x105, 0x205, 0x285, 0x2005, 0x2085, 0xfff0];
+for (var lengthIndex = 0; lengthIndex < lengths.length; lengthIndex++) {
+  for (var i = 0; i < indices.length; i++) {
+    var index = indices[i] * 2;
+    var length = lengths[lengthIndex];
+
+    var patternBufferUcs2 =
+        allCharsBufferUcs2.slice(index, index + length);
+    assert(
+        index, allCharsBufferUcs2.includes(patternBufferUcs2, 0, 'ucs2'));
+
+    var patternStringUcs2 = patternBufferUcs2.toString('ucs2');
+    assert(
+        index, allCharsBufferUcs2.includes(patternStringUcs2, 0, 'ucs2'));
+  }
+}
+
+assert.throws(function() {
+  b.includes(function() { });
+});
+assert.throws(function() {
+  b.includes({});
+});
+assert.throws(function() {
+  b.includes([]);
+});
+
+// test truncation of Number arguments to uint8
+{
+  var buf = Buffer.from('this is a test');
+  assert.ok(buf.includes(0x6973));
+  assert.ok(buf.includes(0x697320));
+  assert.ok(buf.includes(0x69732069));
+  assert.ok(buf.includes(0x697374657374));
+  assert.ok(buf.includes(0x69737374));
+  assert.ok(buf.includes(0x69737465));
+  assert.ok(buf.includes(0x69737465));
+  assert.ok(buf.includes(-140));
+  assert.ok(buf.includes(-152));
+  assert.ok(!buf.includes(0xff));
+  assert.ok(!buf.includes(0xffff));
+}
+
diff --git a/node_modules/buffer/test/node/test-buffer-indexof.js b/node_modules/buffer/test/node/test-buffer-indexof.js
new file mode 100644
index 000000000..24502c3f4
--- /dev/null
+++ b/node_modules/buffer/test/node/test-buffer-indexof.js
@@ -0,0 +1,523 @@
+'use strict';
+var Buffer = require('../../').Buffer;
+
+
+var assert = require('assert');
+
+var Buffer = require('../../').Buffer;
+
+var b = Buffer.from('abcdef');
+var buf_a = Buffer.from('a');
+var buf_bc = Buffer.from('bc');
+var buf_f = Buffer.from('f');
+var buf_z = Buffer.from('z');
+var buf_empty = Buffer.from('');
+
+assert.equal(b.indexOf('a'), 0);
+assert.equal(b.indexOf('a', 1), -1);
+assert.equal(b.indexOf('a', -1), -1);
+assert.equal(b.indexOf('a', -4), -1);
+assert.equal(b.indexOf('a', -b.length), 0);
+assert.equal(b.indexOf('a', NaN), 0);
+assert.equal(b.indexOf('a', -Infinity), 0);
+assert.equal(b.indexOf('a', Infinity), -1);
+assert.equal(b.indexOf('bc'), 1);
+assert.equal(b.indexOf('bc', 2), -1);
+assert.equal(b.indexOf('bc', -1), -1);
+assert.equal(b.indexOf('bc', -3), -1);
+assert.equal(b.indexOf('bc', -5), 1);
+assert.equal(b.indexOf('bc', NaN), 1);
+assert.equal(b.indexOf('bc', -Infinity), 1);
+assert.equal(b.indexOf('bc', Infinity), -1);
+assert.equal(b.indexOf('f'), b.length - 1);
+assert.equal(b.indexOf('z'), -1);
+assert.equal(b.indexOf(''), -1);
+assert.equal(b.indexOf('', 1), -1);
+assert.equal(b.indexOf('', b.length + 1), -1);
+assert.equal(b.indexOf('', Infinity), -1);
+assert.equal(b.indexOf(buf_a), 0);
+assert.equal(b.indexOf(buf_a, 1), -1);
+assert.equal(b.indexOf(buf_a, -1), -1);
+assert.equal(b.indexOf(buf_a, -4), -1);
+assert.equal(b.indexOf(buf_a, -b.length), 0);
+assert.equal(b.indexOf(buf_a, NaN), 0);
+assert.equal(b.indexOf(buf_a, -Infinity), 0);
+assert.equal(b.indexOf(buf_a, Infinity), -1);
+assert.equal(b.indexOf(buf_bc), 1);
+assert.equal(b.indexOf(buf_bc, 2), -1);
+assert.equal(b.indexOf(buf_bc, -1), -1);
+assert.equal(b.indexOf(buf_bc, -3), -1);
+assert.equal(b.indexOf(buf_bc, -5), 1);
+assert.equal(b.indexOf(buf_bc, NaN), 1);
+assert.equal(b.indexOf(buf_bc, -Infinity), 1);
+assert.equal(b.indexOf(buf_bc, Infinity), -1);
+assert.equal(b.indexOf(buf_f), b.length - 1);
+assert.equal(b.indexOf(buf_z), -1);
+assert.equal(b.indexOf(buf_empty), -1);
+assert.equal(b.indexOf(buf_empty, 1), -1);
+assert.equal(b.indexOf(buf_empty, b.length + 1), -1);
+assert.equal(b.indexOf(buf_empty, Infinity), -1);
+assert.equal(b.indexOf(0x61), 0);
+assert.equal(b.indexOf(0x61, 1), -1);
+assert.equal(b.indexOf(0x61, -1), -1);
+assert.equal(b.indexOf(0x61, -4), -1);
+assert.equal(b.indexOf(0x61, -b.length), 0);
+assert.equal(b.indexOf(0x61, NaN), 0);
+assert.equal(b.indexOf(0x61, -Infinity), 0);
+assert.equal(b.indexOf(0x61, Infinity), -1);
+assert.equal(b.indexOf(0x0), -1);
+
+// test offsets
+assert.equal(b.indexOf('d', 2), 3);
+assert.equal(b.indexOf('f', 5), 5);
+assert.equal(b.indexOf('f', -1), 5);
+assert.equal(b.indexOf('f', 6), -1);
+
+assert.equal(b.indexOf(Buffer.from('d'), 2), 3);
+assert.equal(b.indexOf(Buffer.from('f'), 5), 5);
+assert.equal(b.indexOf(Buffer.from('f'), -1), 5);
+assert.equal(b.indexOf(Buffer.from('f'), 6), -1);
+
+assert.equal(Buffer.from('ff').indexOf(Buffer.from('f'), 1, 'ucs2'), -1);
+
+// test hex encoding
+assert.strictEqual(
+  Buffer.from(b.toString('hex'), 'hex')
+    .indexOf('64', 0, 'hex'),
+  3
+);
+assert.strictEqual(
+  Buffer.from(b.toString('hex'), 'hex')
+    .indexOf(Buffer.from('64', 'hex'), 0, 'hex'),
+  3
+);
+
+// test base64 encoding
+assert.strictEqual(
+  Buffer.from(b.toString('base64'), 'base64')
+    .indexOf('ZA==', 0, 'base64'),
+  3
+);
+assert.strictEqual(
+  Buffer.from(b.toString('base64'), 'base64')
+    .indexOf(Buffer.from('ZA==', 'base64'), 0, 'base64'),
+  3
+);
+
+// test ascii encoding
+assert.strictEqual(
+  Buffer.from(b.toString('ascii'), 'ascii')
+    .indexOf('d', 0, 'ascii'),
+  3
+);
+assert.strictEqual(
+  Buffer.from(b.toString('ascii'), 'ascii')
+    .indexOf(Buffer.from('d', 'ascii'), 0, 'ascii'),
+  3
+);
+
+// test latin1 encoding
+assert.strictEqual(
+  Buffer.from(b.toString('latin1'), 'latin1')
+    .indexOf('d', 0, 'latin1'),
+  3
+);
+assert.strictEqual(
+  Buffer.from(b.toString('latin1'), 'latin1')
+    .indexOf(Buffer.from('d', 'latin1'), 0, 'latin1'),
+  3
+);
+assert.strictEqual(
+  Buffer.from('aa\u00e8aa', 'latin1')
+    .indexOf('\u00e8', 'latin1'),
+  2
+);
+assert.strictEqual(
+  Buffer.from('\u00e8', 'latin1')
+    .indexOf('\u00e8', 'latin1'),
+  0
+);
+assert.strictEqual(
+  Buffer.from('\u00e8', 'latin1')
+    .indexOf(Buffer.from('\u00e8', 'latin1'), 'latin1'),
+  0
+);
+
+// test binary encoding
+assert.strictEqual(
+  Buffer.from(b.toString('binary'), 'binary')
+    .indexOf('d', 0, 'binary'),
+  3
+);
+assert.strictEqual(
+  Buffer.from(b.toString('binary'), 'binary')
+    .indexOf(Buffer.from('d', 'binary'), 0, 'binary'),
+  3
+);
+assert.strictEqual(
+  Buffer.from('aa\u00e8aa', 'binary')
+    .indexOf('\u00e8', 'binary'),
+  2
+);
+assert.strictEqual(
+  Buffer.from('\u00e8', 'binary')
+    .indexOf('\u00e8', 'binary'),
+  0
+);
+assert.strictEqual(
+  Buffer.from('\u00e8', 'binary')
+    .indexOf(Buffer.from('\u00e8', 'binary'), 'binary'),
+  0
+);
+
+
+// test optional offset with passed encoding
+assert.equal(Buffer.from('aaaa0').indexOf('30', 'hex'), 4);
+assert.equal(Buffer.from('aaaa00a').indexOf('3030', 'hex'), 4);
+
+{
+  // test usc2 encoding
+  var twoByteString = Buffer.from('\u039a\u0391\u03a3\u03a3\u0395', 'ucs2');
+
+  assert.equal(8, twoByteString.indexOf('\u0395', 4, 'ucs2'));
+  assert.equal(6, twoByteString.indexOf('\u03a3', -4, 'ucs2'));
+  assert.equal(4, twoByteString.indexOf('\u03a3', -6, 'ucs2'));
+  assert.equal(4, twoByteString.indexOf(
+    Buffer.from('\u03a3', 'ucs2'), -6, 'ucs2'));
+  assert.equal(-1, twoByteString.indexOf('\u03a3', -2, 'ucs2'));
+}
+
+var mixedByteStringUcs2 =
+    Buffer.from('\u039a\u0391abc\u03a3\u03a3\u0395', 'ucs2');
+assert.equal(6, mixedByteStringUcs2.indexOf('bc', 0, 'ucs2'));
+assert.equal(10, mixedByteStringUcs2.indexOf('\u03a3', 0, 'ucs2'));
+assert.equal(-1, mixedByteStringUcs2.indexOf('\u0396', 0, 'ucs2'));
+
+assert.equal(
+    6, mixedByteStringUcs2.indexOf(Buffer.from('bc', 'ucs2'), 0, 'ucs2'));
+assert.equal(
+    10, mixedByteStringUcs2.indexOf(Buffer.from('\u03a3', 'ucs2'), 0, 'ucs2'));
+assert.equal(
+    -1, mixedByteStringUcs2.indexOf(Buffer.from('\u0396', 'ucs2'), 0, 'ucs2'));
+
+{
+  var twoByteString = Buffer.from('\u039a\u0391\u03a3\u03a3\u0395', 'ucs2');
+
+  // Test single char pattern
+  assert.equal(0, twoByteString.indexOf('\u039a', 0, 'ucs2'));
+  assert.equal(2, twoByteString.indexOf('\u0391', 0, 'ucs2'), 'Alpha');
+  assert.equal(4, twoByteString.indexOf('\u03a3', 0, 'ucs2'), 'First Sigma');
+  assert.equal(6, twoByteString.indexOf('\u03a3', 6, 'ucs2'), 'Second Sigma');
+  assert.equal(8, twoByteString.indexOf('\u0395', 0, 'ucs2'), 'Epsilon');
+  assert.equal(-1, twoByteString.indexOf('\u0392', 0, 'ucs2'), 'Not beta');
+
+  // Test multi-char pattern
+  assert.equal(
+      0, twoByteString.indexOf('\u039a\u0391', 0, 'ucs2'), 'Lambda Alpha');
+  assert.equal(
+      2, twoByteString.indexOf('\u0391\u03a3', 0, 'ucs2'), 'Alpha Sigma');
+  assert.equal(
+      4, twoByteString.indexOf('\u03a3\u03a3', 0, 'ucs2'), 'Sigma Sigma');
+  assert.equal(
+      6, twoByteString.indexOf('\u03a3\u0395', 0, 'ucs2'), 'Sigma Epsilon');
+}
+
+var mixedByteStringUtf8 = Buffer.from('\u039a\u0391abc\u03a3\u03a3\u0395');
+assert.equal(5, mixedByteStringUtf8.indexOf('bc'));
+assert.equal(5, mixedByteStringUtf8.indexOf('bc', 5));
+assert.equal(5, mixedByteStringUtf8.indexOf('bc', -8));
+assert.equal(7, mixedByteStringUtf8.indexOf('\u03a3'));
+assert.equal(-1, mixedByteStringUtf8.indexOf('\u0396'));
+
+
+// Test complex string indexOf algorithms. Only trigger for long strings.
+// Long string that isn't a simple repeat of a shorter string.
+var longString = 'A';
+for (var i = 66; i < 76; i++) {  // from 'B' to 'K'
+  longString = longString + String.fromCharCode(i) + longString;
+}
+
+var longBufferString = Buffer.from(longString);
+
+// pattern of 15 chars, repeated every 16 chars in long
+var pattern = 'ABACABADABACABA';
+for (var i = 0; i < longBufferString.length - pattern.length; i += 7) {
+  var index = longBufferString.indexOf(pattern, i);
+  assert.equal((i + 15) & ~0xf, index, 'Long ABACABA...-string at index ' + i);
+}
+assert.equal(510, longBufferString.indexOf('AJABACA'), 'Long AJABACA, First J');
+assert.equal(
+    1534, longBufferString.indexOf('AJABACA', 511), 'Long AJABACA, Second J');
+
+pattern = 'JABACABADABACABA';
+assert.equal(
+    511, longBufferString.indexOf(pattern), 'Long JABACABA..., First J');
+assert.equal(
+    1535, longBufferString.indexOf(pattern, 512), 'Long JABACABA..., Second J');
+
+// Search for a non-ASCII string in a pure ASCII string.
+var asciiString = Buffer.from(
+    'arglebargleglopglyfarglebargleglopglyfarglebargleglopglyf');
+assert.equal(-1, asciiString.indexOf('\x2061'));
+assert.equal(3, asciiString.indexOf('leb', 0));
+
+// Search in string containing many non-ASCII chars.
+var allCodePoints = [];
+for (var i = 0; i < 65536; i++) allCodePoints[i] = i;
+var allCharsString = String.fromCharCode.apply(String, allCodePoints);
+var allCharsBufferUtf8 = Buffer.from(allCharsString);
+var allCharsBufferUcs2 = Buffer.from(allCharsString, 'ucs2');
+
+// Search for string long enough to trigger complex search with ASCII pattern
+// and UC16 subject.
+assert.equal(-1, allCharsBufferUtf8.indexOf('notfound'));
+assert.equal(-1, allCharsBufferUcs2.indexOf('notfound'));
+
+// Needle is longer than haystack, but only because it's encoded as UTF-16
+assert.strictEqual(Buffer.from('aaaa').indexOf('a'.repeat(4), 'ucs2'), -1);
+
+assert.strictEqual(Buffer.from('aaaa').indexOf('a'.repeat(4), 'utf8'), 0);
+assert.strictEqual(Buffer.from('aaaa').indexOf('你好', 'ucs2'), -1);
+
+// Haystack has odd length, but the needle is UCS2.
+// assert.strictEqual(Buffer.from('aaaaa').indexOf('b', 'ucs2'), -1);
+
+{
+  // Find substrings in Utf8.
+  var lengths = [1, 3, 15];  // Single char, simple and complex.
+  var indices = [0x5, 0x60, 0x400, 0x680, 0x7ee, 0xFF02, 0x16610, 0x2f77b];
+  for (var lengthIndex = 0; lengthIndex < lengths.length; lengthIndex++) {
+    for (var i = 0; i < indices.length; i++) {
+      var index = indices[i];
+      var length = lengths[lengthIndex];
+
+      if (index + length > 0x7F) {
+        length = 2 * length;
+      }
+
+      if (index + length > 0x7FF) {
+        length = 3 * length;
+      }
+
+      if (index + length > 0xFFFF) {
+        length = 4 * length;
+      }
+
+      var patternBufferUtf8 = allCharsBufferUtf8.slice(index, index + length);
+      assert.equal(index, allCharsBufferUtf8.indexOf(patternBufferUtf8));
+
+      var patternStringUtf8 = patternBufferUtf8.toString();
+      assert.equal(index, allCharsBufferUtf8.indexOf(patternStringUtf8));
+    }
+  }
+}
+
+{
+  // Find substrings in Usc2.
+  var lengths = [2, 4, 16];  // Single char, simple and complex.
+  var indices = [0x5, 0x65, 0x105, 0x205, 0x285, 0x2005, 0x2085, 0xfff0];
+  for (var lengthIndex = 0; lengthIndex < lengths.length; lengthIndex++) {
+    for (var i = 0; i < indices.length; i++) {
+      var index = indices[i] * 2;
+      var length = lengths[lengthIndex];
+
+      var patternBufferUcs2 =
+          allCharsBufferUcs2.slice(index, index + length);
+      assert.equal(
+          index, allCharsBufferUcs2.indexOf(patternBufferUcs2, 0, 'ucs2'));
+
+      var patternStringUcs2 = patternBufferUcs2.toString('ucs2');
+      assert.equal(
+          index, allCharsBufferUcs2.indexOf(patternStringUcs2, 0, 'ucs2'));
+    }
+  }
+}
+
+assert.throws(function() {
+  b.indexOf(function() { });
+});
+assert.throws(function() {
+  b.indexOf({});
+});
+assert.throws(function() {
+  b.indexOf([]);
+});
+
+// All code for handling encodings is shared between Buffer.indexOf and
+// Buffer.lastIndexOf, so only testing the separate lastIndexOf semantics.
+
+// Test lastIndexOf basic functionality; Buffer b contains 'abcdef'.
+// lastIndexOf string:
+assert.equal(b.lastIndexOf('a'), 0);
+assert.equal(b.lastIndexOf('a', 1), 0);
+assert.equal(b.lastIndexOf('b', 1), 1);
+assert.equal(b.lastIndexOf('c', 1), -1);
+assert.equal(b.lastIndexOf('a', -1), 0);
+assert.equal(b.lastIndexOf('a', -4), 0);
+assert.equal(b.lastIndexOf('a', -b.length), 0);
+assert.equal(b.lastIndexOf('a', -b.length - 1), -1);
+assert.equal(b.lastIndexOf('a', NaN), 0);
+assert.equal(b.lastIndexOf('a', -Infinity), -1);
+assert.equal(b.lastIndexOf('a', Infinity), 0);
+// lastIndexOf Buffer:
+assert.equal(b.lastIndexOf(buf_a), 0);
+assert.equal(b.lastIndexOf(buf_a, 1), 0);
+assert.equal(b.lastIndexOf(buf_a, -1), 0);
+assert.equal(b.lastIndexOf(buf_a, -4), 0);
+assert.equal(b.lastIndexOf(buf_a, -b.length), 0);
+assert.equal(b.lastIndexOf(buf_a, -b.length - 1), -1);
+assert.equal(b.lastIndexOf(buf_a, NaN), 0);
+assert.equal(b.lastIndexOf(buf_a, -Infinity), -1);
+assert.equal(b.lastIndexOf(buf_a, Infinity), 0);
+assert.equal(b.lastIndexOf(buf_bc), 1);
+assert.equal(b.lastIndexOf(buf_bc, 2), 1);
+assert.equal(b.lastIndexOf(buf_bc, -1), 1);
+assert.equal(b.lastIndexOf(buf_bc, -3), 1);
+assert.equal(b.lastIndexOf(buf_bc, -5), 1);
+assert.equal(b.lastIndexOf(buf_bc, -6), -1);
+assert.equal(b.lastIndexOf(buf_bc, NaN), 1);
+assert.equal(b.lastIndexOf(buf_bc, -Infinity), -1);
+assert.equal(b.lastIndexOf(buf_bc, Infinity), 1);
+assert.equal(b.lastIndexOf(buf_f), b.length - 1);
+assert.equal(b.lastIndexOf(buf_z), -1);
+assert.equal(b.lastIndexOf(buf_empty), -1);
+assert.equal(b.lastIndexOf(buf_empty, 1), -1);
+assert.equal(b.lastIndexOf(buf_empty, b.length + 1), -1);
+assert.equal(b.lastIndexOf(buf_empty, Infinity), -1);
+// lastIndexOf number:
+assert.equal(b.lastIndexOf(0x61), 0);
+assert.equal(b.lastIndexOf(0x61, 1), 0);
+assert.equal(b.lastIndexOf(0x61, -1), 0);
+assert.equal(b.lastIndexOf(0x61, -4), 0);
+assert.equal(b.lastIndexOf(0x61, -b.length), 0);
+assert.equal(b.lastIndexOf(0x61, -b.length - 1), -1);
+assert.equal(b.lastIndexOf(0x61, NaN), 0);
+assert.equal(b.lastIndexOf(0x61, -Infinity), -1);
+assert.equal(b.lastIndexOf(0x61, Infinity), 0);
+assert.equal(b.lastIndexOf(0x0), -1);
+
+// Test weird offset arguments.
+// Behaviour should match String.lastIndexOf:
+assert.equal(b.lastIndexOf('b', 0), -1);
+assert.equal(b.lastIndexOf('b', undefined), 1);
+assert.equal(b.lastIndexOf('b', null), -1);
+assert.equal(b.lastIndexOf('b', {}), 1);
+assert.equal(b.lastIndexOf('b', []), -1);
+assert.equal(b.lastIndexOf('b', [2]), 1);
+
+// Test needles longer than the haystack.
+assert.strictEqual(b.lastIndexOf('aaaaaaaaaaaaaaa', 'ucs2'), -1);
+assert.strictEqual(b.lastIndexOf('aaaaaaaaaaaaaaa', 'utf8'), -1);
+assert.strictEqual(b.lastIndexOf('aaaaaaaaaaaaaaa', 'latin1'), -1);
+assert.strictEqual(b.lastIndexOf('aaaaaaaaaaaaaaa', 'binary'), -1);
+assert.strictEqual(b.lastIndexOf(Buffer.from('aaaaaaaaaaaaaaa')), -1);
+assert.strictEqual(b.lastIndexOf('aaaaaaaaaaaaaaa', 2, 'ucs2'), -1);
+assert.strictEqual(b.lastIndexOf('aaaaaaaaaaaaaaa', 3, 'utf8'), -1);
+assert.strictEqual(b.lastIndexOf('aaaaaaaaaaaaaaa', 5, 'latin1'), -1);
+assert.strictEqual(b.lastIndexOf('aaaaaaaaaaaaaaa', 5, 'binary'), -1);
+assert.strictEqual(b.lastIndexOf(Buffer.from('aaaaaaaaaaaaaaa'), 7), -1);
+
+// 你好 expands to a total of 6 bytes using UTF-8 and 4 bytes using UTF-16
+assert.strictEqual(buf_bc.lastIndexOf('你好', 'ucs2'), -1);
+assert.strictEqual(buf_bc.lastIndexOf('你好', 'utf8'), -1);
+assert.strictEqual(buf_bc.lastIndexOf('你好', 'latin1'), -1);
+assert.strictEqual(buf_bc.lastIndexOf('你好', 'binary'), -1);
+assert.strictEqual(buf_bc.lastIndexOf(Buffer.from('你好')), -1);
+assert.strictEqual(buf_bc.lastIndexOf('你好', 2, 'ucs2'), -1);
+assert.strictEqual(buf_bc.lastIndexOf('你好', 3, 'utf8'), -1);
+assert.strictEqual(buf_bc.lastIndexOf('你好', 5, 'latin1'), -1);
+assert.strictEqual(buf_bc.lastIndexOf('你好', 5, 'binary'), -1);
+assert.strictEqual(buf_bc.lastIndexOf(Buffer.from('你好'), 7), -1);
+
+// Test lastIndexOf on a longer buffer:
+var bufferString = new Buffer('a man a plan a canal panama');
+assert.equal(15, bufferString.lastIndexOf('canal'));
+assert.equal(21, bufferString.lastIndexOf('panama'));
+assert.equal(0, bufferString.lastIndexOf('a man a plan a canal panama'));
+assert.equal(-1, bufferString.lastIndexOf('a man a plan a canal mexico'));
+assert.equal(-1, bufferString.lastIndexOf('a man a plan a canal mexico city'));
+assert.equal(-1, bufferString.lastIndexOf(Buffer.from('a'.repeat(1000))));
+assert.equal(0, bufferString.lastIndexOf('a man a plan', 4));
+assert.equal(13, bufferString.lastIndexOf('a '));
+assert.equal(13, bufferString.lastIndexOf('a ', 13));
+assert.equal(6, bufferString.lastIndexOf('a ', 12));
+assert.equal(0, bufferString.lastIndexOf('a ', 5));
+assert.equal(13, bufferString.lastIndexOf('a ', -1));
+assert.equal(0, bufferString.lastIndexOf('a ', -27));
+assert.equal(-1, bufferString.lastIndexOf('a ', -28));
+
+// Test lastIndexOf for the case that the first character can be found,
+// but in a part of the buffer that does not make search to search
+// due do length constraints.
+var abInUCS2 = Buffer.from('ab', 'ucs2');
+assert.strictEqual(-1, Buffer.from('µaaaa¶bbbb', 'latin1').lastIndexOf('µ'));
+assert.strictEqual(-1, Buffer.from('µaaaa¶bbbb', 'binary').lastIndexOf('µ'));
+assert.strictEqual(-1, Buffer.from('bc').lastIndexOf('ab'));
+assert.strictEqual(-1, Buffer.from('abc').lastIndexOf('qa'));
+assert.strictEqual(-1, Buffer.from('abcdef').lastIndexOf('qabc'));
+assert.strictEqual(-1, Buffer.from('bc').lastIndexOf(Buffer.from('ab')));
+assert.strictEqual(-1, Buffer.from('bc', 'ucs2').lastIndexOf('ab', 'ucs2'));
+assert.strictEqual(-1, Buffer.from('bc', 'ucs2').lastIndexOf(abInUCS2));
+
+assert.strictEqual(0, Buffer.from('abc').lastIndexOf('ab'));
+assert.strictEqual(0, Buffer.from('abc').lastIndexOf('ab', 1));
+assert.strictEqual(0, Buffer.from('abc').lastIndexOf('ab', 2));
+assert.strictEqual(0, Buffer.from('abc').lastIndexOf('ab', 3));
+
+// The above tests test the LINEAR and SINGLE-CHAR strategies.
+// Now, we test the BOYER-MOORE-HORSPOOL strategy.
+// Test lastIndexOf on a long buffer w multiple matches:
+pattern = 'JABACABADABACABA';
+assert.equal(1535, longBufferString.lastIndexOf(pattern));
+assert.equal(1535, longBufferString.lastIndexOf(pattern, 1535));
+assert.equal(511, longBufferString.lastIndexOf(pattern, 1534));
+
+// Finally, give it a really long input to trigger fallback from BMH to
+// regular BOYER-MOORE (which has better worst-case complexity).
+
+// Generate a really long Thue-Morse sequence of 'yolo' and 'swag',
+// "yolo swag swag yolo swag yolo yolo swag" ..., goes on for about 5MB.
+// This is hard to search because it all looks similar, but never repeats.
+
+// countBits returns the number of bits in the binary reprsentation of n.
+function countBits(n) {
+  for (var count = 0; n > 0; count++) {
+    n = n & (n - 1); // remove top bit
+  }
+  return count;
+}
+var parts = [];
+for (var i = 0; i < 1000000; i++) {
+  parts.push((countBits(i) % 2 === 0) ? 'yolo' : 'swag');
+}
+var reallyLong = new Buffer(parts.join(' '));
+assert.equal('yolo swag swag yolo', reallyLong.slice(0, 19).toString());
+
+// Expensive reverse searches. Stress test lastIndexOf:
+pattern = reallyLong.slice(0, 100000);  // First 1/50th of the pattern.
+assert.equal(4751360, reallyLong.lastIndexOf(pattern));
+assert.equal(3932160, reallyLong.lastIndexOf(pattern, 4000000));
+assert.equal(2949120, reallyLong.lastIndexOf(pattern, 3000000));
+pattern = reallyLong.slice(100000, 200000);  // Second 1/50th.
+assert.equal(4728480, reallyLong.lastIndexOf(pattern));
+pattern = reallyLong.slice(0, 1000000);  // First 1/5th.
+assert.equal(3932160, reallyLong.lastIndexOf(pattern));
+pattern = reallyLong.slice(0, 2000000);  // first 2/5ths.
+assert.equal(0, reallyLong.lastIndexOf(pattern));
+
+// test truncation of Number arguments to uint8
+{
+  var buf = Buffer.from('this is a test');
+  assert.strictEqual(buf.indexOf(0x6973), 3);
+  assert.strictEqual(buf.indexOf(0x697320), 4);
+  assert.strictEqual(buf.indexOf(0x69732069), 2);
+  assert.strictEqual(buf.indexOf(0x697374657374), 0);
+  assert.strictEqual(buf.indexOf(0x69737374), 0);
+  assert.strictEqual(buf.indexOf(0x69737465), 11);
+  assert.strictEqual(buf.indexOf(0x69737465), 11);
+  assert.strictEqual(buf.indexOf(-140), 0);
+  assert.strictEqual(buf.indexOf(-152), 1);
+  assert.strictEqual(buf.indexOf(0xff), -1);
+  assert.strictEqual(buf.indexOf(0xffff), -1);
+}
+
diff --git a/node_modules/buffer/test/node/test-buffer-inheritance.js b/node_modules/buffer/test/node/test-buffer-inheritance.js
new file mode 100644
index 000000000..711d9f23f
--- /dev/null
+++ b/node_modules/buffer/test/node/test-buffer-inheritance.js
@@ -0,0 +1,42 @@
+'use strict';
+var Buffer = require('../../').Buffer;
+
+
+
+var assert = require('assert');
+
+
+function T(n) {
+  var ui8 = new Uint8Array(n);
+  Object.setPrototypeOf(ui8, T.prototype);
+  return ui8;
+}
+Object.setPrototypeOf(T.prototype, Buffer.prototype);
+Object.setPrototypeOf(T, Buffer);
+
+T.prototype.sum = function sum() {
+  var cntr = 0;
+  for (var i = 0; i < this.length; i++)
+    cntr += this[i];
+  return cntr;
+};
+
+
+var vals = [new T(4), T(4)];
+
+vals.forEach(function(t) {
+  assert.equal(t.constructor, T);
+  assert.equal(Object.getPrototypeOf(t), T.prototype);
+  assert.equal(Object.getPrototypeOf(Object.getPrototypeOf(t)),
+    Buffer.prototype);
+
+  t.fill(5);
+  var cntr = 0;
+  for (var i = 0; i < t.length; i++)
+    cntr += t[i];
+  assert.equal(t.length * 5, cntr);
+
+  // Check this does not throw
+  t.toString();
+});
+
diff --git a/node_modules/buffer/test/node/test-buffer-inspect.js b/node_modules/buffer/test/node/test-buffer-inspect.js
new file mode 100644
index 000000000..d0ed590d4
--- /dev/null
+++ b/node_modules/buffer/test/node/test-buffer-inspect.js
@@ -0,0 +1,41 @@
+'use strict';
+var Buffer = require('../../').Buffer;
+
+
+var assert = require('assert');
+
+var util = require('util');
+
+var buffer = require('../../');
+
+buffer.INSPECT_MAX_BYTES = 2;
+
+var b = Buffer.allocUnsafe(4);
+b.fill('1234');
+
+var s = buffer.SlowBuffer(4);
+s.fill('1234');
+
+var expected = '<Buffer 31 32 ... >';
+
+assert.strictEqual(util.inspect(b), expected);
+assert.strictEqual(util.inspect(s), expected);
+
+b = Buffer.allocUnsafe(2);
+b.fill('12');
+
+s = buffer.SlowBuffer(2);
+s.fill('12');
+
+expected = '<Buffer 31 32>';
+
+assert.strictEqual(util.inspect(b), expected);
+assert.strictEqual(util.inspect(s), expected);
+
+buffer.INSPECT_MAX_BYTES = Infinity;
+
+assert.doesNotThrow(function() {
+  assert.strictEqual(util.inspect(b), expected);
+  assert.strictEqual(util.inspect(s), expected);
+});
+
diff --git a/node_modules/buffer/test/node/test-buffer-iterator.js b/node_modules/buffer/test/node/test-buffer-iterator.js
new file mode 100644
index 000000000..f27709f31
--- /dev/null
+++ b/node_modules/buffer/test/node/test-buffer-iterator.js
@@ -0,0 +1,65 @@
+'use strict';
+var Buffer = require('../../').Buffer;
+
+
+var assert = require('assert');
+
+var buffer = Buffer.from([1, 2, 3, 4, 5]);
+var arr;
+var b;
+
+// buffers should be iterable
+
+arr = [];
+
+for (b of buffer)
+  arr.push(b);
+
+assert.deepStrictEqual(arr, [1, 2, 3, 4, 5]);
+
+
+// buffer iterators should be iterable
+
+arr = [];
+
+for (b of buffer[Symbol.iterator]())
+  arr.push(b);
+
+assert.deepStrictEqual(arr, [1, 2, 3, 4, 5]);
+
+
+// buffer#values() should return iterator for values
+
+arr = [];
+
+for (b of buffer.values())
+  arr.push(b);
+
+assert.deepStrictEqual(arr, [1, 2, 3, 4, 5]);
+
+
+// buffer#keys() should return iterator for keys
+
+arr = [];
+
+for (b of buffer.keys())
+  arr.push(b);
+
+assert.deepStrictEqual(arr, [0, 1, 2, 3, 4]);
+
+
+// buffer#entries() should return iterator for entries
+
+arr = [];
+
+for (b of buffer.entries())
+  arr.push(b);
+
+assert.deepStrictEqual(arr, [
+  [0, 1],
+  [1, 2],
+  [2, 3],
+  [3, 4],
+  [4, 5]
+]);
+
diff --git a/node_modules/buffer/test/node/test-buffer-safe-unsafe.js b/node_modules/buffer/test/node/test-buffer-safe-unsafe.js
new file mode 100644
index 000000000..22ba29e85
--- /dev/null
+++ b/node_modules/buffer/test/node/test-buffer-safe-unsafe.js
@@ -0,0 +1,27 @@
+'use strict';
+var Buffer = require('../../').Buffer;
+
+
+
+var assert = require('assert');
+
+var safe = Buffer.alloc(10);
+
+function isZeroFilled(buf) {
+  for (var n = 0; n < buf.length; n++)
+    if (buf[n] !== 0) return false;
+  return true;
+}
+
+assert(isZeroFilled(safe));
+
+// Test that unsafe allocations doesn't affect subsequent safe allocations
+Buffer.allocUnsafe(10);
+assert(isZeroFilled(new Float64Array(10)));
+
+new Buffer(10);
+assert(isZeroFilled(new Float64Array(10)));
+
+Buffer.allocUnsafe(10);
+assert(isZeroFilled(Buffer.alloc(10)));
+
diff --git a/node_modules/buffer/test/node/test-buffer-slow.js b/node_modules/buffer/test/node/test-buffer-slow.js
new file mode 100644
index 000000000..65cea21ed
--- /dev/null
+++ b/node_modules/buffer/test/node/test-buffer-slow.js
@@ -0,0 +1,63 @@
+'use strict';
+var Buffer = require('../../').Buffer;
+
+
+
+var assert = require('assert');
+var buffer = require('../../');
+var Buffer = buffer.Buffer;
+var SlowBuffer = buffer.SlowBuffer;
+
+var ones = [1, 1, 1, 1];
+
+// should create a Buffer
+var sb = SlowBuffer(4);
+assert(sb instanceof Buffer);
+assert.strictEqual(sb.length, 4);
+sb.fill(1);
+for (var [key, value] of sb.entries()) {
+  assert.deepStrictEqual(value, ones[key]);
+}
+
+// underlying ArrayBuffer should have the same length
+assert.strictEqual(sb.buffer.byteLength, 4);
+
+// should work without new
+sb = SlowBuffer(4);
+assert(sb instanceof Buffer);
+assert.strictEqual(sb.length, 4);
+sb.fill(1);
+for (var [key, value] of sb.entries()) {
+  assert.deepStrictEqual(value, ones[key]);
+}
+
+// should work with edge cases
+assert.strictEqual(SlowBuffer(0).length, 0);
+try {
+  assert.strictEqual(
+    SlowBuffer(buffer.kMaxLength).length, buffer.kMaxLength);
+} catch (e) {
+  assert.equal(e.message, 'Array buffer allocation failed');
+}
+
+// should work with number-coercible values
+assert.strictEqual(SlowBuffer('6').length, 6);
+assert.strictEqual(SlowBuffer(true).length, 1);
+
+// should create zero-length buffer if parameter is not a number
+assert.strictEqual(SlowBuffer().length, 0);
+assert.strictEqual(SlowBuffer(NaN).length, 0);
+assert.strictEqual(SlowBuffer({}).length, 0);
+assert.strictEqual(SlowBuffer('string').length, 0);
+
+// should throw with invalid length
+assert.throws(function() {
+  SlowBuffer(Infinity);
+}, 'invalid Buffer length');
+assert.throws(function() {
+  SlowBuffer(-1);
+}, 'invalid Buffer length');
+assert.throws(function() {
+  SlowBuffer(buffer.kMaxLength + 1);
+}, 'invalid Buffer length');
+
diff --git a/node_modules/buffer/test/node/test-buffer-swap.js b/node_modules/buffer/test/node/test-buffer-swap.js
new file mode 100644
index 000000000..2ec1a7aac
--- /dev/null
+++ b/node_modules/buffer/test/node/test-buffer-swap.js
@@ -0,0 +1,141 @@
+'use strict';
+var Buffer = require('../../').Buffer;
+
+
+
+var assert = require('assert');
+
+// Test buffers small enough to use the JS implementation
+var buf = Buffer.from([0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
+                         0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10]);
+
+assert.strictEqual(buf, buf.swap16());
+assert.deepStrictEqual(buf, Buffer.from([0x02, 0x01, 0x04, 0x03, 0x06, 0x05,
+                                         0x08, 0x07, 0x0a, 0x09, 0x0c, 0x0b,
+                                         0x0e, 0x0d, 0x10, 0x0f]));
+buf.swap16(); // restore
+
+assert.strictEqual(buf, buf.swap32());
+assert.deepStrictEqual(buf, Buffer.from([0x04, 0x03, 0x02, 0x01, 0x08, 0x07,
+                                         0x06, 0x05, 0x0c, 0x0b, 0x0a, 0x09,
+                                         0x10, 0x0f, 0x0e, 0x0d]));
+buf.swap32(); // restore
+
+assert.strictEqual(buf, buf.swap64());
+assert.deepStrictEqual(buf, Buffer.from([0x08, 0x07, 0x06, 0x05, 0x04, 0x03,
+                                         0x02, 0x01, 0x10, 0x0f, 0x0e, 0x0d,
+                                         0x0c, 0x0b, 0x0a, 0x09]));
+
+// Operates in-place
+var buf3 = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]);
+buf3.slice(1, 5).swap32();
+assert.deepStrictEqual(buf3, Buffer.from([0x1, 0x5, 0x4, 0x3, 0x2, 0x6, 0x7]));
+
+buf3.slice(1, 5).swap16();
+assert.deepStrictEqual(buf3, Buffer.from([0x1, 0x4, 0x5, 0x2, 0x3, 0x6, 0x7]));
+
+var buf3_64 = Buffer.from([0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+                             0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
+                             0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+                             0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10]);
+buf3_64.slice(2, 18).swap64();
+assert.deepStrictEqual(buf3_64, Buffer.from([0x01, 0x02, 0x0a, 0x09, 0x08, 0x07,
+                                             0x06, 0x05, 0x04, 0x03, 0x02, 0x01,
+                                             0x10, 0x0f, 0x0e, 0x0d, 0x0c, 0x0b,
+                                             0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+                                             0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
+                                             0x0f, 0x10]));
+
+// Force use of native code (Buffer size above threshold limit for js impl)
+var buf4A = new Uint32Array(256).fill(0x04030201);
+var buf4 = Buffer.from(buf4A.buffer, buf4A.byteOffset);
+var buf5A = new Uint32Array(256).fill(0x03040102);
+var buf5 = Buffer.from(buf5A.buffer, buf5A.byteOffset);
+
+buf4.swap16();
+assert.deepStrictEqual(buf4, buf5);
+
+var buf6A = new Uint32Array(256).fill(0x04030201);
+var buf6 = Buffer.from(buf6A.buffer);
+var bu7A = new Uint32Array(256).fill(0x01020304);
+var buf7 = Buffer.from(bu7A.buffer, bu7A.byteOffset);
+
+buf6.swap32();
+assert.deepStrictEqual(buf6, buf7);
+
+var buf8A = new Uint8Array(256 * 8);
+var buf9A = new Uint8Array(256 * 8);
+for (var i = 0; i < buf8A.length; i++) {
+  buf8A[i] = i % 8;
+  buf9A[buf9A.length - i - 1] = i % 8;
+}
+var buf8 = Buffer.from(buf8A.buffer, buf8A.byteOffset);
+var buf9 = Buffer.from(buf9A.buffer, buf9A.byteOffset);
+
+buf8.swap64();
+assert.deepStrictEqual(buf8, buf9);
+
+// Test native code with buffers that are not memory-aligned
+var buf10A = new Uint8Array(256 * 8);
+var buf11A = new Uint8Array(256 * 8 - 2);
+for (var i = 0; i < buf10A.length; i++) {
+  buf10A[i] = i % 2;
+}
+for (var i = 1; i < buf11A.length; i++) {
+  buf11A[buf11A.length - i] = (i + 1) % 2;
+}
+var buf10 = Buffer.from(buf10A.buffer, buf10A.byteOffset);
+// 0|1 0|1 0|1...
+var buf11 = Buffer.from(buf11A.buffer, buf11A.byteOffset);
+// 0|0 1|0 1|0...
+
+buf10.slice(1, buf10.length - 1).swap16();
+assert.deepStrictEqual(buf10.slice(0, buf11.length), buf11);
+
+
+var buf12A = new Uint8Array(256 * 8);
+var buf13A = new Uint8Array(256 * 8 - 4);
+for (var i = 0; i < buf12A.length; i++) {
+  buf12A[i] = i % 4;
+}
+for (var i = 1; i < buf13A.length; i++) {
+  buf13A[buf13A.length - i] = (i + 1) % 4;
+}
+var buf12 = Buffer.from(buf12A.buffer, buf12A.byteOffset);
+// 0|1 2 3 0|1 2 3...
+var buf13 = Buffer.from(buf13A.buffer, buf13A.byteOffset);
+// 0|0 3 2 1|0 3 2...
+
+buf12.slice(1, buf12.length - 3).swap32();
+assert.deepStrictEqual(buf12.slice(0, buf13.length), buf13);
+
+
+var buf14A = new Uint8Array(256 * 8);
+var buf15A = new Uint8Array(256 * 8 - 8);
+for (var i = 0; i < buf14A.length; i++) {
+  buf14A[i] = i % 8;
+}
+for (var i = 1; i < buf15A.length; i++) {
+  buf15A[buf15A.length - i] = (i + 1) % 8;
+}
+var buf14 = Buffer.from(buf14A.buffer, buf14A.byteOffset);
+// 0|1 2 3 4 5 6 7 0|1 2 3 4...
+var buf15 = Buffer.from(buf15A.buffer, buf15A.byteOffset);
+// 0|0 7 6 5 4 3 2 1|0 7 6 5...
+
+buf14.slice(1, buf14.length - 7).swap64();
+assert.deepStrictEqual(buf14.slice(0, buf15.length), buf15);
+
+// Length assertions
+var re16 = /Buffer size must be a multiple of 16-bits/;
+var re32 = /Buffer size must be a multiple of 32-bits/;
+var re64 = /Buffer size must be a multiple of 64-bits/;
+
+assert.throws(() => Buffer.from(buf3).swap16(), re16);
+assert.throws(() => Buffer.alloc(1025).swap16(), re16);
+assert.throws(() => Buffer.from(buf3).swap32(), re32);
+assert.throws(() => buf3.slice(1, 3).swap32(), re32);
+assert.throws(() => Buffer.alloc(1025).swap32(), re32);
+assert.throws(() => buf3.slice(1, 3).swap64(), re64);
+assert.throws(() => Buffer.alloc(1025).swap64(), re64);
+
diff --git a/node_modules/buffer/test/node/test-buffer-zero-fill-cli.js b/node_modules/buffer/test/node/test-buffer-zero-fill-cli.js
new file mode 100644
index 000000000..744b33497
--- /dev/null
+++ b/node_modules/buffer/test/node/test-buffer-zero-fill-cli.js
@@ -0,0 +1,35 @@
+'use strict';
+var Buffer = require('../../').Buffer;
+
+// Flags: --zero-fill-buffers
+
+// when using --zero-fill-buffers, every Buffer and SlowBuffer
+// instance must be zero filled upon creation
+
+
+var SlowBuffer = require('../../').SlowBuffer;
+var assert = require('assert');
+
+function isZeroFilled(buf) {
+  for (var n = 0; n < buf.length; n++)
+    if (buf[n] > 0) return false;
+  return true;
+}
+
+// This can be somewhat unreliable because the
+// allocated memory might just already happen to
+// contain all zeroes. The test is run multiple
+// times to improve the reliability.
+for (var i = 0; i < 50; i++) {
+  var bufs = [
+    Buffer.alloc(20),
+    Buffer.allocUnsafe(20),
+    SlowBuffer(20),
+    Buffer(20),
+    new SlowBuffer(20)
+  ];
+  for (var buf of bufs) {
+    assert(isZeroFilled(buf));
+  }
+}
+
diff --git a/node_modules/buffer/test/node/test-buffer-zero-fill-reset.js b/node_modules/buffer/test/node/test-buffer-zero-fill-reset.js
new file mode 100644
index 000000000..b21a6b262
--- /dev/null
+++ b/node_modules/buffer/test/node/test-buffer-zero-fill-reset.js
@@ -0,0 +1,22 @@
+'use strict';
+var Buffer = require('../../').Buffer;
+
+
+
+var assert = require('assert');
+
+
+function testUint8Array(ui) {
+  var length = ui.length;
+  for (var i = 0; i < length; i++)
+    if (ui[i] !== 0) return false;
+  return true;
+}
+
+
+for (var i = 0; i < 100; i++) {
+  Buffer.alloc(0);
+  var ui = new Uint8Array(65);
+  assert.ok(testUint8Array(ui), 'Uint8Array is not zero-filled');
+}
+
diff --git a/node_modules/buffer/test/node/test-buffer.js b/node_modules/buffer/test/node/test-buffer.js
new file mode 100644
index 000000000..2e94de211
--- /dev/null
+++ b/node_modules/buffer/test/node/test-buffer.js
@@ -0,0 +1,1534 @@
+'use strict';
+var Buffer = require('../../').Buffer;
+
+var common = { skip: function () {} };
+var assert = require('assert');
+
+var Buffer = require('../../').Buffer;
+var SlowBuffer = require('../../').SlowBuffer;
+
+// counter to ensure unique value is always copied
+var cntr = 0;
+
+var b = Buffer(1024); // safe constructor
+
+// console.log('b.length == %d', b.length);
+assert.strictEqual(1024, b.length);
+
+b[0] = -1;
+assert.strictEqual(b[0], 255);
+
+for (var i = 0; i < 1024; i++) {
+  b[i] = i % 256;
+}
+
+for (var i = 0; i < 1024; i++) {
+  assert.strictEqual(i % 256, b[i]);
+}
+
+var c = Buffer(512);
+// console.log('c.length == %d', c.length);
+assert.strictEqual(512, c.length);
+
+var d = new Buffer([]);
+assert.strictEqual(0, d.length);
+
+var ui32 = new Uint32Array(4).fill(42);
+var e = Buffer(ui32);
+for (var [key, value] of e.entries()) {
+  assert.deepStrictEqual(value, ui32[key]);
+}
+
+// First check Buffer#fill() works as expected.
+
+assert.throws(function() {
+  Buffer(8).fill('a', -1);
+});
+
+assert.throws(function() {
+  Buffer(8).fill('a', 0, 9);
+});
+
+// Make sure this doesn't hang indefinitely.
+Buffer(8).fill('');
+
+{
+  var buf = new Buffer(64);
+  buf.fill(10);
+  for (var i = 0; i < buf.length; i++)
+    assert.equal(buf[i], 10);
+
+  buf.fill(11, 0, buf.length >> 1);
+  for (var i = 0; i < buf.length >> 1; i++)
+    assert.equal(buf[i], 11);
+  for (var i = (buf.length >> 1) + 1; i < buf.length; i++)
+    assert.equal(buf[i], 10);
+
+  buf.fill('h');
+  for (var i = 0; i < buf.length; i++)
+    assert.equal('h'.charCodeAt(0), buf[i]);
+
+  buf.fill(0);
+  for (var i = 0; i < buf.length; i++)
+    assert.equal(0, buf[i]);
+
+  buf.fill(null);
+  for (var i = 0; i < buf.length; i++)
+    assert.equal(0, buf[i]);
+
+  buf.fill(1, 16, 32);
+  for (var i = 0; i < 16; i++)
+    assert.equal(0, buf[i]);
+  for (var i = 16; i < 32; i++)
+    assert.equal(1, buf[i]);
+  for (var i = 32; i < buf.length; i++)
+    assert.equal(0, buf[i]);
+}
+
+{
+  var buf = new Buffer(10);
+  buf.fill('abc');
+  assert.equal(buf.toString(), 'abcabcabca');
+  buf.fill('է');
+  assert.equal(buf.toString(), 'էէէէէ');
+}
+
+{
+  // copy 512 bytes, from 0 to 512.
+  b.fill(++cntr);
+  c.fill(++cntr);
+  var copied = b.copy(c, 0, 0, 512);
+//   console.log('copied %d bytes from b into c', copied);
+  assert.strictEqual(512, copied);
+  for (var i = 0; i < c.length; i++) {
+    assert.strictEqual(b[i], c[i]);
+  }
+}
+
+{
+  // copy c into b, without specifying sourceEnd
+  b.fill(++cntr);
+  c.fill(++cntr);
+  var copied = c.copy(b, 0, 0);
+//   console.log('copied %d bytes from c into b w/o sourceEnd', copied);
+  assert.strictEqual(c.length, copied);
+  for (var i = 0; i < c.length; i++) {
+    assert.strictEqual(c[i], b[i]);
+  }
+}
+
+{
+  // copy c into b, without specifying sourceStart
+  b.fill(++cntr);
+  c.fill(++cntr);
+  var copied = c.copy(b, 0);
+//   console.log('copied %d bytes from c into b w/o sourceStart', copied);
+  assert.strictEqual(c.length, copied);
+  for (var i = 0; i < c.length; i++) {
+    assert.strictEqual(c[i], b[i]);
+  }
+}
+
+{
+  // copy longer buffer b to shorter c without targetStart
+  b.fill(++cntr);
+  c.fill(++cntr);
+  var copied = b.copy(c);
+//   console.log('copied %d bytes from b into c w/o targetStart', copied);
+  assert.strictEqual(c.length, copied);
+  for (var i = 0; i < c.length; i++) {
+    assert.strictEqual(b[i], c[i]);
+  }
+}
+
+{
+  // copy starting near end of b to c
+  b.fill(++cntr);
+  c.fill(++cntr);
+  var copied = b.copy(c, 0, b.length - Math.floor(c.length / 2));
+//   console.log('copied %d bytes from end of b into beginning of c', copied);
+  assert.strictEqual(Math.floor(c.length / 2), copied);
+  for (var i = 0; i < Math.floor(c.length / 2); i++) {
+    assert.strictEqual(b[b.length - Math.floor(c.length / 2) + i], c[i]);
+  }
+  for (var i = Math.floor(c.length / 2) + 1; i < c.length; i++) {
+    assert.strictEqual(c[c.length - 1], c[i]);
+  }
+}
+
+{
+  // try to copy 513 bytes, and check we don't overrun c
+  b.fill(++cntr);
+  c.fill(++cntr);
+  var copied = b.copy(c, 0, 0, 513);
+//   console.log('copied %d bytes from b trying to overrun c', copied);
+  assert.strictEqual(c.length, copied);
+  for (var i = 0; i < c.length; i++) {
+    assert.strictEqual(b[i], c[i]);
+  }
+}
+
+{
+  // copy 768 bytes from b into b
+  b.fill(++cntr);
+  b.fill(++cntr, 256);
+  var copied = b.copy(b, 0, 256, 1024);
+//   console.log('copied %d bytes from b into b', copied);
+  assert.strictEqual(768, copied);
+  for (var i = 0; i < b.length; i++) {
+    assert.strictEqual(cntr, b[i]);
+  }
+}
+
+// copy string longer than buffer length (failure will segfault)
+var bb = Buffer(10);
+bb.fill('hello crazy world');
+
+
+// try to copy from before the beginning of b
+assert.doesNotThrow(() => { b.copy(c, 0, 100, 10); });
+
+// copy throws at negative sourceStart
+assert.throws(function() {
+  Buffer(5).copy(Buffer(5), 0, -1);
+}, RangeError);
+
+{
+  // check sourceEnd resets to targetEnd if former is greater than the latter
+  b.fill(++cntr);
+  c.fill(++cntr);
+  var copied = b.copy(c, 0, 0, 1025);
+//   console.log('copied %d bytes from b into c', copied);
+  for (var i = 0; i < c.length; i++) {
+    assert.strictEqual(b[i], c[i]);
+  }
+}
+
+// throw with negative sourceEnd
+// console.log('test copy at negative sourceEnd');
+assert.throws(function() {
+  b.copy(c, 0, 0, -1);
+}, RangeError);
+
+// when sourceStart is greater than sourceEnd, zero copied
+assert.equal(b.copy(c, 0, 100, 10), 0);
+
+// when targetStart > targetLength, zero copied
+assert.equal(b.copy(c, 512, 0, 10), 0);
+
+var caught_error;
+
+// invalid encoding for Buffer.toString
+caught_error = null;
+try {
+  b.toString('invalid');
+} catch (err) {
+  caught_error = err;
+}
+assert.strictEqual('Unknown encoding: invalid', caught_error.message);
+
+// invalid encoding for Buffer.write
+caught_error = null;
+try {
+  b.write('test string', 0, 5, 'invalid');
+} catch (err) {
+  caught_error = err;
+}
+assert.strictEqual('Unknown encoding: invalid', caught_error.message);
+
+// try to create 0-length buffers
+new Buffer('');
+new Buffer('', 'ascii');
+new Buffer('', 'latin1');
+new Buffer('', 'binary');
+Buffer(0);
+
+// try to write a 0-length string beyond the end of b
+assert.throws(function() {
+  b.write('', 2048);
+}, RangeError);
+
+// throw when writing to negative offset
+assert.throws(function() {
+  b.write('a', -1);
+}, RangeError);
+
+// throw when writing past bounds from the pool
+assert.throws(function() {
+  b.write('a', 2048);
+}, RangeError);
+
+// throw when writing to negative offset
+assert.throws(function() {
+  b.write('a', -1);
+}, RangeError);
+
+// try to copy 0 bytes worth of data into an empty buffer
+b.copy(Buffer(0), 0, 0, 0);
+
+// try to copy 0 bytes past the end of the target buffer
+b.copy(Buffer(0), 1, 1, 1);
+b.copy(Buffer(1), 1, 1, 1);
+
+// try to copy 0 bytes from past the end of the source buffer
+b.copy(Buffer(1), 0, 2048, 2048);
+
+var rangeBuffer = new Buffer('abc');
+
+// if start >= buffer's length, empty string will be returned
+assert.equal(rangeBuffer.toString('ascii', 3), '');
+assert.equal(rangeBuffer.toString('ascii', +Infinity), '');
+assert.equal(rangeBuffer.toString('ascii', 3.14, 3), '');
+assert.equal(rangeBuffer.toString('ascii', 'Infinity', 3), '');
+
+// if end <= 0, empty string will be returned
+assert.equal(rangeBuffer.toString('ascii', 1, 0), '');
+assert.equal(rangeBuffer.toString('ascii', 1, -1.2), '');
+assert.equal(rangeBuffer.toString('ascii', 1, -100), '');
+assert.equal(rangeBuffer.toString('ascii', 1, -Infinity), '');
+
+// if start < 0, start will be taken as zero
+assert.equal(rangeBuffer.toString('ascii', -1, 3), 'abc');
+assert.equal(rangeBuffer.toString('ascii', -1.99, 3), 'abc');
+assert.equal(rangeBuffer.toString('ascii', -Infinity, 3), 'abc');
+assert.equal(rangeBuffer.toString('ascii', '-1', 3), 'abc');
+assert.equal(rangeBuffer.toString('ascii', '-1.99', 3), 'abc');
+assert.equal(rangeBuffer.toString('ascii', '-Infinity', 3), 'abc');
+
+// if start is an invalid integer, start will be taken as zero
+assert.equal(rangeBuffer.toString('ascii', 'node.js', 3), 'abc');
+assert.equal(rangeBuffer.toString('ascii', {}, 3), 'abc');
+assert.equal(rangeBuffer.toString('ascii', [], 3), 'abc');
+assert.equal(rangeBuffer.toString('ascii', NaN, 3), 'abc');
+assert.equal(rangeBuffer.toString('ascii', null, 3), 'abc');
+assert.equal(rangeBuffer.toString('ascii', undefined, 3), 'abc');
+assert.equal(rangeBuffer.toString('ascii', false, 3), 'abc');
+assert.equal(rangeBuffer.toString('ascii', '', 3), 'abc');
+
+// but, if start is an integer when coerced, then it will be coerced and used.
+assert.equal(rangeBuffer.toString('ascii', '-1', 3), 'abc');
+assert.equal(rangeBuffer.toString('ascii', '1', 3), 'bc');
+assert.equal(rangeBuffer.toString('ascii', '-Infinity', 3), 'abc');
+assert.equal(rangeBuffer.toString('ascii', '3', 3), '');
+assert.equal(rangeBuffer.toString('ascii', Number(3), 3), '');
+assert.equal(rangeBuffer.toString('ascii', '3.14', 3), '');
+assert.equal(rangeBuffer.toString('ascii', '1.99', 3), 'bc');
+assert.equal(rangeBuffer.toString('ascii', '-1.99', 3), 'abc');
+assert.equal(rangeBuffer.toString('ascii', 1.99, 3), 'bc');
+assert.equal(rangeBuffer.toString('ascii', true, 3), 'bc');
+
+// if end > buffer's length, end will be taken as buffer's length
+assert.equal(rangeBuffer.toString('ascii', 0, 5), 'abc');
+assert.equal(rangeBuffer.toString('ascii', 0, 6.99), 'abc');
+assert.equal(rangeBuffer.toString('ascii', 0, Infinity), 'abc');
+assert.equal(rangeBuffer.toString('ascii', 0, '5'), 'abc');
+assert.equal(rangeBuffer.toString('ascii', 0, '6.99'), 'abc');
+assert.equal(rangeBuffer.toString('ascii', 0, 'Infinity'), 'abc');
+
+// if end is an invalid integer, end will be taken as buffer's length
+assert.equal(rangeBuffer.toString('ascii', 0, 'node.js'), '');
+assert.equal(rangeBuffer.toString('ascii', 0, {}), '');
+assert.equal(rangeBuffer.toString('ascii', 0, NaN), '');
+assert.equal(rangeBuffer.toString('ascii', 0, undefined), 'abc');
+assert.equal(rangeBuffer.toString('ascii', 0), 'abc');
+assert.equal(rangeBuffer.toString('ascii', 0, null), '');
+assert.equal(rangeBuffer.toString('ascii', 0, []), '');
+assert.equal(rangeBuffer.toString('ascii', 0, false), '');
+assert.equal(rangeBuffer.toString('ascii', 0, ''), '');
+
+// but, if end is an integer when coerced, then it will be coerced and used.
+assert.equal(rangeBuffer.toString('ascii', 0, '-1'), '');
+assert.equal(rangeBuffer.toString('ascii', 0, '1'), 'a');
+assert.equal(rangeBuffer.toString('ascii', 0, '-Infinity'), '');
+assert.equal(rangeBuffer.toString('ascii', 0, '3'), 'abc');
+assert.equal(rangeBuffer.toString('ascii', 0, Number(3)), 'abc');
+assert.equal(rangeBuffer.toString('ascii', 0, '3.14'), 'abc');
+assert.equal(rangeBuffer.toString('ascii', 0, '1.99'), 'a');
+assert.equal(rangeBuffer.toString('ascii', 0, '-1.99'), '');
+assert.equal(rangeBuffer.toString('ascii', 0, 1.99), 'a');
+assert.equal(rangeBuffer.toString('ascii', 0, true), 'a');
+
+// try toString() with a object as a encoding
+assert.equal(rangeBuffer.toString({toString: function() {
+  return 'ascii';
+}}), 'abc');
+
+// testing for smart defaults and ability to pass string values as offset
+var writeTest = new Buffer('abcdes');
+writeTest.write('n', 'ascii');
+writeTest.write('o', '1', 'ascii');
+writeTest.write('d', '2', 'ascii');
+writeTest.write('e', 3, 'ascii');
+writeTest.write('j', 4, 'ascii');
+assert.equal(writeTest.toString(), 'nodejs');
+
+// ASCII slice test
+{
+  var asciiString = 'hello world';
+
+  for (var i = 0; i < asciiString.length; i++) {
+    b[i] = asciiString.charCodeAt(i);
+  }
+  var asciiSlice = b.toString('ascii', 0, asciiString.length);
+  assert.equal(asciiString, asciiSlice);
+}
+
+{
+  var asciiString = 'hello world';
+  var offset = 100;
+
+  var written = b.write(asciiString, offset, 'ascii');
+  assert.equal(asciiString.length, written);
+  var asciiSlice = b.toString('ascii', offset, offset + asciiString.length);
+  assert.equal(asciiString, asciiSlice);
+}
+
+{
+  var asciiString = 'hello world';
+  var offset = 100;
+
+  var sliceA = b.slice(offset, offset + asciiString.length);
+  var sliceB = b.slice(offset, offset + asciiString.length);
+  for (var i = 0; i < asciiString.length; i++) {
+    assert.equal(sliceA[i], sliceB[i]);
+  }
+}
+
+// UTF-8 slice test
+
+var utf8String = '¡hέlló wôrld!';
+var offset = 100;
+
+b.write(utf8String, 0, Buffer.byteLength(utf8String), 'utf8');
+var utf8Slice = b.toString('utf8', 0, Buffer.byteLength(utf8String));
+assert.equal(utf8String, utf8Slice);
+
+var written = b.write(utf8String, offset, 'utf8');
+assert.equal(Buffer.byteLength(utf8String), written);
+utf8Slice = b.toString('utf8', offset, offset + Buffer.byteLength(utf8String));
+assert.equal(utf8String, utf8Slice);
+
+var sliceA = b.slice(offset, offset + Buffer.byteLength(utf8String));
+var sliceB = b.slice(offset, offset + Buffer.byteLength(utf8String));
+for (var i = 0; i < Buffer.byteLength(utf8String); i++) {
+  assert.equal(sliceA[i], sliceB[i]);
+}
+
+{
+  var slice = b.slice(100, 150);
+  assert.equal(50, slice.length);
+  for (var i = 0; i < 50; i++) {
+    assert.equal(b[100 + i], slice[i]);
+  }
+}
+
+{
+  // make sure only top level parent propagates from allocPool
+  var b = new Buffer(5);
+  var c = b.slice(0, 4);
+  var d = c.slice(0, 2);
+  assert.equal(b.parent, c.parent);
+  assert.equal(b.parent, d.parent);
+}
+
+{
+  // also from a non-pooled instance
+  var b = new SlowBuffer(5);
+  var c = b.slice(0, 4);
+  var d = c.slice(0, 2);
+  assert.equal(c.parent, d.parent);
+}
+
+{
+  // Bug regression test
+  var testValue = '\u00F6\u65E5\u672C\u8A9E'; // ö日本語
+  var buffer = new Buffer(32);
+  var size = buffer.write(testValue, 0, 'utf8');
+//   console.log('bytes written to buffer: ' + size);
+  var slice = buffer.toString('utf8', 0, size);
+  assert.equal(slice, testValue);
+}
+
+{
+  // Test triple  slice
+  var a = new Buffer(8);
+  for (var i = 0; i < 8; i++) a[i] = i;
+  var b = a.slice(4, 8);
+  assert.equal(4, b[0]);
+  assert.equal(5, b[1]);
+  assert.equal(6, b[2]);
+  assert.equal(7, b[3]);
+  var c = b.slice(2, 4);
+  assert.equal(6, c[0]);
+  assert.equal(7, c[1]);
+}
+
+{
+  var d = new Buffer([23, 42, 255]);
+  assert.equal(d.length, 3);
+  assert.equal(d[0], 23);
+  assert.equal(d[1], 42);
+  assert.equal(d[2], 255);
+  assert.deepStrictEqual(d, new Buffer(d));
+}
+
+{
+  var e = new Buffer('über');
+//   console.error('uber: \'%s\'', e.toString());
+  assert.deepStrictEqual(e, new Buffer([195, 188, 98, 101, 114]));
+}
+
+{
+  var f = new Buffer('über', 'ascii');
+//   console.error('f.length: %d     (should be 4)', f.length);
+  assert.deepStrictEqual(f, new Buffer([252, 98, 101, 114]));
+}
+
+['ucs2', 'ucs-2', 'utf16le', 'utf-16le'].forEach(function(encoding) {
+  {
+    var f = new Buffer('über', encoding);
+//     console.error('f.length: %d     (should be 8)', f.length);
+    assert.deepStrictEqual(f, new Buffer([252, 0, 98, 0, 101, 0, 114, 0]));
+  }
+
+  {
+    var f = new Buffer('привет', encoding);
+//     console.error('f.length: %d     (should be 12)', f.length);
+    var expected = new Buffer([63, 4, 64, 4, 56, 4, 50, 4, 53, 4, 66, 4]);
+    assert.deepStrictEqual(f, expected);
+    assert.equal(f.toString(encoding), 'привет');
+  }
+
+  {
+    var f = new Buffer([0, 0, 0, 0, 0]);
+    assert.equal(f.length, 5);
+    var size = f.write('あいうえお', encoding);
+//     console.error('bytes written to buffer: %d     (should be 4)', size);
+    assert.equal(size, 4);
+    assert.deepStrictEqual(f, new Buffer([0x42, 0x30, 0x44, 0x30, 0x00]));
+  }
+});
+
+{
+  var f = new Buffer('\uD83D\uDC4D', 'utf-16le'); // THUMBS UP SIGN (U+1F44D)
+  assert.equal(f.length, 4);
+  assert.deepStrictEqual(f, new Buffer('3DD84DDC', 'hex'));
+}
+
+
+var arrayIsh = {0: 0, 1: 1, 2: 2, 3: 3, length: 4};
+var g = new Buffer(arrayIsh);
+assert.deepStrictEqual(g, new Buffer([0, 1, 2, 3]));
+var strArrayIsh = {0: '0', 1: '1', 2: '2', 3: '3', length: 4};
+g = new Buffer(strArrayIsh);
+assert.deepStrictEqual(g, new Buffer([0, 1, 2, 3]));
+
+
+//
+// Test toString('base64')
+//
+assert.equal('TWFu', (new Buffer('Man')).toString('base64'));
+
+{
+  // test that regular and URL-safe base64 both work
+  var expected = [0xff, 0xff, 0xbe, 0xff, 0xef, 0xbf, 0xfb, 0xef, 0xff];
+  assert.deepStrictEqual(Buffer('//++/++/++//', 'base64'), Buffer(expected));
+  assert.deepStrictEqual(Buffer('__--_--_--__', 'base64'), Buffer(expected));
+}
+
+{
+  // big example
+  var quote = 'Man is distinguished, not only by his reason, but by this ' +
+                'singular passion from other animals, which is a lust ' +
+                'of the mind, that by a perseverance of delight in the ' +
+                'continued and indefatigable generation of knowledge, ' +
+                'exceeds the short vehemence of any carnal pleasure.';
+  var expected = 'TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb' +
+                   '24sIGJ1dCBieSB0aGlzIHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlci' +
+                   'BhbmltYWxzLCB3aGljaCBpcyBhIGx1c3Qgb2YgdGhlIG1pbmQsIHRoYXQ' +
+                   'gYnkgYSBwZXJzZXZlcmFuY2Ugb2YgZGVsaWdodCBpbiB0aGUgY29udGlu' +
+                   'dWVkIGFuZCBpbmRlZmF0aWdhYmxlIGdlbmVyYXRpb24gb2Yga25vd2xlZ' +
+                   'GdlLCBleGNlZWRzIHRoZSBzaG9ydCB2ZWhlbWVuY2Ugb2YgYW55IGNhcm' +
+                   '5hbCBwbGVhc3VyZS4=';
+  assert.equal(expected, (new Buffer(quote)).toString('base64'));
+
+  var b = new Buffer(1024);
+  var bytesWritten = b.write(expected, 0, 'base64');
+  assert.equal(quote.length, bytesWritten);
+  assert.equal(quote, b.toString('ascii', 0, quote.length));
+
+  // check that the base64 decoder ignores whitespace
+  var expectedWhite = expected.slice(0, 60) + ' \n' +
+                        expected.slice(60, 120) + ' \n' +
+                        expected.slice(120, 180) + ' \n' +
+                        expected.slice(180, 240) + ' \n' +
+                        expected.slice(240, 300) + '\n' +
+                        expected.slice(300, 360) + '\n';
+  b = new Buffer(1024);
+  bytesWritten = b.write(expectedWhite, 0, 'base64');
+  assert.equal(quote.length, bytesWritten);
+  assert.equal(quote, b.toString('ascii', 0, quote.length));
+
+  // check that the base64 decoder on the constructor works
+  // even in the presence of whitespace.
+  b = new Buffer(expectedWhite, 'base64');
+  assert.equal(quote.length, b.length);
+  assert.equal(quote, b.toString('ascii', 0, quote.length));
+
+  // check that the base64 decoder ignores illegal chars
+  var expectedIllegal = expected.slice(0, 60) + ' \x80' +
+                          expected.slice(60, 120) + ' \xff' +
+                          expected.slice(120, 180) + ' \x00' +
+                          expected.slice(180, 240) + ' \x98' +
+                          expected.slice(240, 300) + '\x03' +
+                          expected.slice(300, 360);
+  b = new Buffer(expectedIllegal, 'base64');
+  assert.equal(quote.length, b.length);
+  assert.equal(quote, b.toString('ascii', 0, quote.length));
+}
+
+assert.equal(new Buffer('', 'base64').toString(), '');
+assert.equal(new Buffer('K', 'base64').toString(), '');
+
+// multiple-of-4 with padding
+assert.equal(new Buffer('Kg==', 'base64').toString(), '*');
+assert.equal(new Buffer('Kio=', 'base64').toString(), '**');
+assert.equal(new Buffer('Kioq', 'base64').toString(), '***');
+assert.equal(new Buffer('KioqKg==', 'base64').toString(), '****');
+assert.equal(new Buffer('KioqKio=', 'base64').toString(), '*****');
+assert.equal(new Buffer('KioqKioq', 'base64').toString(), '******');
+assert.equal(new Buffer('KioqKioqKg==', 'base64').toString(), '*******');
+assert.equal(new Buffer('KioqKioqKio=', 'base64').toString(), '********');
+assert.equal(new Buffer('KioqKioqKioq', 'base64').toString(), '*********');
+assert.equal(new Buffer('KioqKioqKioqKg==', 'base64').toString(),
+             '**********');
+assert.equal(new Buffer('KioqKioqKioqKio=', 'base64').toString(),
+             '***********');
+assert.equal(new Buffer('KioqKioqKioqKioq', 'base64').toString(),
+             '************');
+assert.equal(new Buffer('KioqKioqKioqKioqKg==', 'base64').toString(),
+             '*************');
+assert.equal(new Buffer('KioqKioqKioqKioqKio=', 'base64').toString(),
+             '**************');
+assert.equal(new Buffer('KioqKioqKioqKioqKioq', 'base64').toString(),
+             '***************');
+assert.equal(new Buffer('KioqKioqKioqKioqKioqKg==', 'base64').toString(),
+             '****************');
+assert.equal(new Buffer('KioqKioqKioqKioqKioqKio=', 'base64').toString(),
+             '*****************');
+assert.equal(new Buffer('KioqKioqKioqKioqKioqKioq', 'base64').toString(),
+             '******************');
+assert.equal(new Buffer('KioqKioqKioqKioqKioqKioqKg==', 'base64').toString(),
+             '*******************');
+assert.equal(new Buffer('KioqKioqKioqKioqKioqKioqKio=', 'base64').toString(),
+             '********************');
+
+// no padding, not a multiple of 4
+assert.equal(new Buffer('Kg', 'base64').toString(), '*');
+assert.equal(new Buffer('Kio', 'base64').toString(), '**');
+assert.equal(new Buffer('KioqKg', 'base64').toString(), '****');
+assert.equal(new Buffer('KioqKio', 'base64').toString(), '*****');
+assert.equal(new Buffer('KioqKioqKg', 'base64').toString(), '*******');
+assert.equal(new Buffer('KioqKioqKio', 'base64').toString(), '********');
+assert.equal(new Buffer('KioqKioqKioqKg', 'base64').toString(), '**********');
+assert.equal(new Buffer('KioqKioqKioqKio', 'base64').toString(), '***********');
+assert.equal(new Buffer('KioqKioqKioqKioqKg', 'base64').toString(),
+             '*************');
+assert.equal(new Buffer('KioqKioqKioqKioqKio', 'base64').toString(),
+             '**************');
+assert.equal(new Buffer('KioqKioqKioqKioqKioqKg', 'base64').toString(),
+             '****************');
+assert.equal(new Buffer('KioqKioqKioqKioqKioqKio', 'base64').toString(),
+             '*****************');
+assert.equal(new Buffer('KioqKioqKioqKioqKioqKioqKg', 'base64').toString(),
+             '*******************');
+assert.equal(new Buffer('KioqKioqKioqKioqKioqKioqKio', 'base64').toString(),
+             '********************');
+
+// handle padding graciously, multiple-of-4 or not
+assert.equal(
+  new Buffer('72INjkR5fchcxk9+VgdGPFJDxUBFR5/rMFsghgxADiw==', 'base64').length,
+  32
+);
+assert.equal(
+  new Buffer('72INjkR5fchcxk9+VgdGPFJDxUBFR5/rMFsghgxADiw=', 'base64').length,
+  32
+);
+assert.equal(
+  new Buffer('72INjkR5fchcxk9+VgdGPFJDxUBFR5/rMFsghgxADiw', 'base64').length,
+  32
+);
+assert.equal(
+  new Buffer('w69jACy6BgZmaFvv96HG6MYksWytuZu3T1FvGnulPg==', 'base64').length,
+  31
+);
+assert.equal(
+  new Buffer('w69jACy6BgZmaFvv96HG6MYksWytuZu3T1FvGnulPg=', 'base64').length,
+  31
+);
+assert.equal(
+  new Buffer('w69jACy6BgZmaFvv96HG6MYksWytuZu3T1FvGnulPg', 'base64').length,
+  31
+);
+
+// This string encodes single '.' character in UTF-16
+var dot = new Buffer('//4uAA==', 'base64');
+assert.equal(dot[0], 0xff);
+assert.equal(dot[1], 0xfe);
+assert.equal(dot[2], 0x2e);
+assert.equal(dot[3], 0x00);
+assert.equal(dot.toString('base64'), '//4uAA==');
+
+{
+  // Writing base64 at a position > 0 should not mangle the result.
+  //
+  // https://github.com/joyent/node/issues/402
+  var segments = ['TWFkbmVzcz8h', 'IFRoaXM=', 'IGlz', 'IG5vZGUuanMh'];
+  var b = new Buffer(64);
+  var pos = 0;
+
+  for (var i = 0; i < segments.length; ++i) {
+    pos += b.write(segments[i], pos, 'base64');
+  }
+  assert.equal(b.toString('latin1', 0, pos), 'Madness?! This is node.js!');
+  assert.equal(b.toString('binary', 0, pos), 'Madness?! This is node.js!');
+}
+
+// Regression test for https://github.com/nodejs/node/issues/3496.
+// assert.equal(Buffer('=bad'.repeat(1e4), 'base64').length, 0);
+
+{
+  // Creating buffers larger than pool size.
+  var l = Buffer.poolSize + 5;
+  var s = 'h'.repeat(l);
+
+  var b = new Buffer(s);
+
+  for (var i = 0; i < l; i++) {
+    assert.equal('h'.charCodeAt(0), b[i]);
+  }
+
+  var sb = b.toString();
+  assert.equal(sb.length, s.length);
+  assert.equal(sb, s);
+}
+
+{
+  // Single argument slice
+  var b = new Buffer('abcde');
+  assert.equal('bcde', b.slice(1).toString());
+}
+
+// slice(0,0).length === 0
+assert.equal(0, Buffer('hello').slice(0, 0).length);
+
+// test hex toString
+// console.log('Create hex string from buffer');
+var hexb = new Buffer(256);
+for (var i = 0; i < 256; i++) {
+  hexb[i] = i;
+}
+var hexStr = hexb.toString('hex');
+assert.equal(hexStr,
+             '000102030405060708090a0b0c0d0e0f' +
+             '101112131415161718191a1b1c1d1e1f' +
+             '202122232425262728292a2b2c2d2e2f' +
+             '303132333435363738393a3b3c3d3e3f' +
+             '404142434445464748494a4b4c4d4e4f' +
+             '505152535455565758595a5b5c5d5e5f' +
+             '606162636465666768696a6b6c6d6e6f' +
+             '707172737475767778797a7b7c7d7e7f' +
+             '808182838485868788898a8b8c8d8e8f' +
+             '909192939495969798999a9b9c9d9e9f' +
+             'a0a1a2a3a4a5a6a7a8a9aaabacadaeaf' +
+             'b0b1b2b3b4b5b6b7b8b9babbbcbdbebf' +
+             'c0c1c2c3c4c5c6c7c8c9cacbcccdcecf' +
+             'd0d1d2d3d4d5d6d7d8d9dadbdcdddedf' +
+             'e0e1e2e3e4e5e6e7e8e9eaebecedeeef' +
+             'f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff');
+
+// console.log('Create buffer from hex string');
+var hexb2 = new Buffer(hexStr, 'hex');
+for (var i = 0; i < 256; i++) {
+  assert.equal(hexb2[i], hexb[i]);
+}
+
+// Test single hex character throws TypeError
+// - https://github.com/nodejs/node/issues/6770
+assert.throws(function() {
+  Buffer.from('A', 'hex');
+}, TypeError);
+
+// Test single base64 char encodes as 0
+// assert.strictEqual(Buffer.from('A', 'base64').length, 0);
+
+{
+  // test an invalid slice end.
+//   console.log('Try to slice off the end of the buffer');
+  var b = new Buffer([1, 2, 3, 4, 5]);
+  var b2 = b.toString('hex', 1, 10000);
+  var b3 = b.toString('hex', 1, 5);
+  var b4 = b.toString('hex', 1);
+  assert.equal(b2, b3);
+  assert.equal(b2, b4);
+}
+
+function buildBuffer(data) {
+  if (Array.isArray(data)) {
+    var buffer = Buffer(data.length);
+    data.forEach(function(v, k) {
+      buffer[k] = v;
+    });
+    return buffer;
+  }
+  return null;
+}
+
+var x = buildBuffer([0x81, 0xa3, 0x66, 0x6f, 0x6f, 0xa3, 0x62, 0x61, 0x72]);
+
+// console.log(x.inspect());
+assert.equal('<Buffer 81 a3 66 6f 6f a3 62 61 72>', x.inspect());
+
+{
+  var z = x.slice(4);
+//   console.log(z.inspect());
+//   console.log(z.length);
+  assert.equal(5, z.length);
+  assert.equal(0x6f, z[0]);
+  assert.equal(0xa3, z[1]);
+  assert.equal(0x62, z[2]);
+  assert.equal(0x61, z[3]);
+  assert.equal(0x72, z[4]);
+}
+
+{
+  var z = x.slice(0);
+//   console.log(z.inspect());
+//   console.log(z.length);
+  assert.equal(z.length, x.length);
+}
+
+{
+  var z = x.slice(0, 4);
+//   console.log(z.inspect());
+//   console.log(z.length);
+  assert.equal(4, z.length);
+  assert.equal(0x81, z[0]);
+  assert.equal(0xa3, z[1]);
+}
+
+{
+  var z = x.slice(0, 9);
+//   console.log(z.inspect());
+//   console.log(z.length);
+  assert.equal(9, z.length);
+}
+
+{
+  var z = x.slice(1, 4);
+//   console.log(z.inspect());
+//   console.log(z.length);
+  assert.equal(3, z.length);
+  assert.equal(0xa3, z[0]);
+}
+
+{
+  var z = x.slice(2, 4);
+//   console.log(z.inspect());
+//   console.log(z.length);
+  assert.equal(2, z.length);
+  assert.equal(0x66, z[0]);
+  assert.equal(0x6f, z[1]);
+}
+
+assert.equal(0, Buffer('hello').slice(0, 0).length);
+
+['ucs2', 'ucs-2', 'utf16le', 'utf-16le'].forEach(function(encoding) {
+  var b = new Buffer(10);
+  b.write('あいうえお', encoding);
+  assert.equal(b.toString(encoding), 'あいうえお');
+});
+
+{
+  // latin1 encoding should write only one byte per character.
+  var b = Buffer([0xde, 0xad, 0xbe, 0xef]);
+  var s = String.fromCharCode(0xffff);
+  b.write(s, 0, 'latin1');
+  assert.equal(0xff, b[0]);
+  assert.equal(0xad, b[1]);
+  assert.equal(0xbe, b[2]);
+  assert.equal(0xef, b[3]);
+  s = String.fromCharCode(0xaaee);
+  b.write(s, 0, 'latin1');
+  assert.equal(0xee, b[0]);
+  assert.equal(0xad, b[1]);
+  assert.equal(0xbe, b[2]);
+  assert.equal(0xef, b[3]);
+}
+
+{
+  // Binary encoding should write only one byte per character.
+  var b = Buffer([0xde, 0xad, 0xbe, 0xef]);
+  var s = String.fromCharCode(0xffff);
+  b.write(s, 0, 'binary');
+  assert.equal(0xff, b[0]);
+  assert.equal(0xad, b[1]);
+  assert.equal(0xbe, b[2]);
+  assert.equal(0xef, b[3]);
+  s = String.fromCharCode(0xaaee);
+  b.write(s, 0, 'binary');
+  assert.equal(0xee, b[0]);
+  assert.equal(0xad, b[1]);
+  assert.equal(0xbe, b[2]);
+  assert.equal(0xef, b[3]);
+}
+
+{
+  // #1210 Test UTF-8 string includes null character
+  var buf = new Buffer('\0');
+  assert.equal(buf.length, 1);
+  buf = new Buffer('\0\0');
+  assert.equal(buf.length, 2);
+}
+
+{
+  var buf = new Buffer(2);
+  var written = buf.write(''); // 0byte
+  assert.equal(written, 0);
+  written = buf.write('\0'); // 1byte (v8 adds null terminator)
+  assert.equal(written, 1);
+  written = buf.write('a\0'); // 1byte * 2
+  assert.equal(written, 2);
+  written = buf.write('あ'); // 3bytes
+  assert.equal(written, 0);
+  written = buf.write('\0あ'); // 1byte + 3bytes
+  assert.equal(written, 1);
+  written = buf.write('\0\0あ'); // 1byte * 2 + 3bytes
+  assert.equal(written, 2);
+}
+
+{
+  var buf = new Buffer(10);
+  written = buf.write('あいう'); // 3bytes * 3 (v8 adds null terminator)
+  assert.equal(written, 9);
+  written = buf.write('あいう\0'); // 3bytes * 3 + 1byte
+  assert.equal(written, 10);
+}
+
+{
+  // #243 Test write() with maxLength
+  var buf = new Buffer(4);
+  buf.fill(0xFF);
+  var written = buf.write('abcd', 1, 2, 'utf8');
+//   console.log(buf);
+  assert.equal(written, 2);
+  assert.equal(buf[0], 0xFF);
+  assert.equal(buf[1], 0x61);
+  assert.equal(buf[2], 0x62);
+  assert.equal(buf[3], 0xFF);
+
+  buf.fill(0xFF);
+  written = buf.write('abcd', 1, 4);
+//   console.log(buf);
+  assert.equal(written, 3);
+  assert.equal(buf[0], 0xFF);
+  assert.equal(buf[1], 0x61);
+  assert.equal(buf[2], 0x62);
+  assert.equal(buf[3], 0x63);
+
+  buf.fill(0xFF);
+  written = buf.write('abcd', 1, 2, 'utf8');
+//   console.log(buf);
+  assert.equal(written, 2);
+  assert.equal(buf[0], 0xFF);
+  assert.equal(buf[1], 0x61);
+  assert.equal(buf[2], 0x62);
+  assert.equal(buf[3], 0xFF);
+
+  buf.fill(0xFF);
+  written = buf.write('abcdef', 1, 2, 'hex');
+//   console.log(buf);
+  assert.equal(written, 2);
+  assert.equal(buf[0], 0xFF);
+  assert.equal(buf[1], 0xAB);
+  assert.equal(buf[2], 0xCD);
+  assert.equal(buf[3], 0xFF);
+
+  ['ucs2', 'ucs-2', 'utf16le', 'utf-16le'].forEach(function(encoding) {
+    buf.fill(0xFF);
+    written = buf.write('abcd', 0, 2, encoding);
+//     console.log(buf);
+    assert.equal(written, 2);
+    assert.equal(buf[0], 0x61);
+    assert.equal(buf[1], 0x00);
+    assert.equal(buf[2], 0xFF);
+    assert.equal(buf[3], 0xFF);
+  });
+}
+
+{
+  // test offset returns are correct
+  var b = new Buffer(16);
+  assert.equal(4, b.writeUInt32LE(0, 0));
+  assert.equal(6, b.writeUInt16LE(0, 4));
+  assert.equal(7, b.writeUInt8(0, 6));
+  assert.equal(8, b.writeInt8(0, 7));
+  assert.equal(16, b.writeDoubleLE(0, 8));
+}
+
+{
+  // test unmatched surrogates not producing invalid utf8 output
+  // ef bf bd = utf-8 representation of unicode replacement character
+  // see https://codereview.chromium.org/121173009/
+  var buf = new Buffer('ab\ud800cd', 'utf8');
+  assert.equal(buf[0], 0x61);
+  assert.equal(buf[1], 0x62);
+  assert.equal(buf[2], 0xef);
+  assert.equal(buf[3], 0xbf);
+  assert.equal(buf[4], 0xbd);
+  assert.equal(buf[5], 0x63);
+  assert.equal(buf[6], 0x64);
+}
+
+{
+  // test for buffer overrun
+  var buf = new Buffer([0, 0, 0, 0, 0]); // length: 5
+  var sub = buf.slice(0, 4);         // length: 4
+  written = sub.write('12345', 'latin1');
+  assert.equal(written, 4);
+  assert.equal(buf[4], 0);
+  written = sub.write('12345', 'binary');
+  assert.equal(written, 4);
+  assert.equal(buf[4], 0);
+}
+
+// Check for fractional length args, junk length args, etc.
+// https://github.com/joyent/node/issues/1758
+
+// Call .fill() first, stops valgrind warning about uninitialized memory reads.
+Buffer(3.3).fill().toString(); // throws bad argument error in commit 43cb4ec
+assert.equal(Buffer(NaN).length, 0);
+assert.equal(Buffer(3.3).length, 3);
+assert.equal(Buffer({length: 3.3}).length, 3);
+assert.equal(Buffer({length: 'BAM'}).length, 0);
+
+// Make sure that strings are not coerced to numbers.
+assert.equal(Buffer('99').length, 2);
+assert.equal(Buffer('13.37').length, 5);
+
+// Ensure that the length argument is respected.
+'ascii utf8 hex base64 latin1 binary'.split(' ').forEach(function(enc) {
+  assert.equal(Buffer(1).write('aaaaaa', 0, 1, enc), 1);
+});
+
+{
+  // Regression test, guard against buffer overrun in the base64 decoder.
+  var a = Buffer(3);
+  var b = Buffer('xxx');
+  a.write('aaaaaaaa', 'base64');
+  assert.equal(b.toString(), 'xxx');
+}
+
+// issue GH-3416
+Buffer(Buffer(0), 0, 0);
+
+[ 'hex',
+  'utf8',
+  'utf-8',
+  'ascii',
+  'latin1',
+  'binary',
+  'base64',
+  'ucs2',
+  'ucs-2',
+  'utf16le',
+  'utf-16le' ].forEach(function(enc) {
+    assert.equal(Buffer.isEncoding(enc), true);
+  });
+
+[ 'utf9',
+  'utf-7',
+  'Unicode-FTW',
+  'new gnu gun' ].forEach(function(enc) {
+    assert.equal(Buffer.isEncoding(enc), false);
+  });
+
+
+// GH-5110
+{
+  var buffer = new Buffer('test');
+  var string = JSON.stringify(buffer);
+
+  assert.strictEqual(string, '{"type":"Buffer","data":[116,101,115,116]}');
+
+  assert.deepStrictEqual(buffer, JSON.parse(string, function(key, value) {
+    return value && value.type === 'Buffer'
+      ? new Buffer(value.data)
+      : value;
+  }));
+}
+
+// issue GH-7849
+{
+  var buf = new Buffer('test');
+  var json = JSON.stringify(buf);
+  var obj = JSON.parse(json);
+  var copy = new Buffer(obj);
+
+  assert(buf.equals(copy));
+}
+
+// issue GH-4331
+assert.throws(function() {
+  Buffer(0xFFFFFFFF);
+}, RangeError);
+assert.throws(function() {
+  Buffer(0xFFFFFFFFF);
+}, RangeError);
+
+// issue GH-5587
+assert.throws(function() {
+  var buf = new Buffer(8);
+  buf.writeFloatLE(0, 5);
+}, RangeError);
+assert.throws(function() {
+  var buf = new Buffer(16);
+  buf.writeDoubleLE(0, 9);
+}, RangeError);
+
+
+// attempt to overflow buffers, similar to previous bug in array buffers
+assert.throws(function() {
+  var buf = Buffer(8);
+  buf.readFloatLE(0xffffffff);
+}, RangeError);
+
+assert.throws(function() {
+  var buf = Buffer(8);
+  buf.writeFloatLE(0.0, 0xffffffff);
+}, RangeError);
+
+assert.throws(function() {
+  var buf = Buffer(8);
+  buf.readFloatLE(0xffffffff);
+}, RangeError);
+
+assert.throws(function() {
+  var buf = Buffer(8);
+  buf.writeFloatLE(0.0, 0xffffffff);
+}, RangeError);
+
+
+// ensure negative values can't get past offset
+assert.throws(function() {
+  var buf = Buffer(8);
+  buf.readFloatLE(-1);
+}, RangeError);
+
+assert.throws(function() {
+  var buf = Buffer(8);
+  buf.writeFloatLE(0.0, -1);
+}, RangeError);
+
+assert.throws(function() {
+  var buf = Buffer(8);
+  buf.readFloatLE(-1);
+}, RangeError);
+
+assert.throws(function() {
+  var buf = Buffer(8);
+  buf.writeFloatLE(0.0, -1);
+}, RangeError);
+
+// offset checks
+{
+  var buf = new Buffer(0);
+
+  assert.throws(function() { buf.readUInt8(0); }, RangeError);
+  assert.throws(function() { buf.readInt8(0); }, RangeError);
+}
+
+{
+  var buf = new Buffer([0xFF]);
+
+  assert.equal(buf.readUInt8(0), 255);
+  assert.equal(buf.readInt8(0), -1);
+}
+
+[16, 32].forEach(function(bits) {
+  var buf = new Buffer(bits / 8 - 1);
+
+  assert.throws(function() { buf['readUInt' + bits + 'BE'](0); },
+                RangeError,
+                'readUInt' + bits + 'BE');
+
+  assert.throws(function() { buf['readUInt' + bits + 'LE'](0); },
+                RangeError,
+                'readUInt' + bits + 'LE');
+
+  assert.throws(function() { buf['readInt' + bits + 'BE'](0); },
+                RangeError,
+                'readInt' + bits + 'BE()');
+
+  assert.throws(function() { buf['readInt' + bits + 'LE'](0); },
+                RangeError,
+                'readInt' + bits + 'LE()');
+});
+
+[16, 32].forEach(function(bits) {
+  var buf = new Buffer([0xFF, 0xFF, 0xFF, 0xFF]);
+
+  assert.equal(buf['readUInt' + bits + 'BE'](0),
+                (0xFFFFFFFF >>> (32 - bits)));
+
+  assert.equal(buf['readUInt' + bits + 'LE'](0),
+                (0xFFFFFFFF >>> (32 - bits)));
+
+  assert.equal(buf['readInt' + bits + 'BE'](0),
+                (0xFFFFFFFF >> (32 - bits)));
+
+  assert.equal(buf['readInt' + bits + 'LE'](0),
+                (0xFFFFFFFF >> (32 - bits)));
+});
+
+// test for common read(U)IntLE/BE
+{
+  var buf = new Buffer([0x01, 0x02, 0x03, 0x04, 0x05, 0x06]);
+
+  assert.strictEqual(buf.readUIntLE(0, 1), 0x01);
+  assert.strictEqual(buf.readUIntBE(0, 1), 0x01);
+  assert.strictEqual(buf.readUIntLE(0, 3), 0x030201);
+  assert.strictEqual(buf.readUIntBE(0, 3), 0x010203);
+  assert.strictEqual(buf.readUIntLE(0, 5), 0x0504030201);
+  assert.strictEqual(buf.readUIntBE(0, 5), 0x0102030405);
+  assert.strictEqual(buf.readUIntLE(0, 6), 0x060504030201);
+  assert.strictEqual(buf.readUIntBE(0, 6), 0x010203040506);
+  assert.strictEqual(buf.readIntLE(0, 1), 0x01);
+  assert.strictEqual(buf.readIntBE(0, 1), 0x01);
+  assert.strictEqual(buf.readIntLE(0, 3), 0x030201);
+  assert.strictEqual(buf.readIntBE(0, 3), 0x010203);
+  assert.strictEqual(buf.readIntLE(0, 5), 0x0504030201);
+  assert.strictEqual(buf.readIntBE(0, 5), 0x0102030405);
+  assert.strictEqual(buf.readIntLE(0, 6), 0x060504030201);
+  assert.strictEqual(buf.readIntBE(0, 6), 0x010203040506);
+}
+
+// test for common write(U)IntLE/BE
+{
+  var buf = Buffer(3);
+  buf.writeUIntLE(0x123456, 0, 3);
+  assert.deepStrictEqual(buf.toJSON().data, [0x56, 0x34, 0x12]);
+  assert.equal(buf.readUIntLE(0, 3), 0x123456);
+
+  buf = Buffer(3);
+  buf.writeUIntBE(0x123456, 0, 3);
+  assert.deepStrictEqual(buf.toJSON().data, [0x12, 0x34, 0x56]);
+  assert.equal(buf.readUIntBE(0, 3), 0x123456);
+
+  buf = Buffer(3);
+  buf.writeIntLE(0x123456, 0, 3);
+  assert.deepStrictEqual(buf.toJSON().data, [0x56, 0x34, 0x12]);
+  assert.equal(buf.readIntLE(0, 3), 0x123456);
+
+  buf = Buffer(3);
+  buf.writeIntBE(0x123456, 0, 3);
+  assert.deepStrictEqual(buf.toJSON().data, [0x12, 0x34, 0x56]);
+  assert.equal(buf.readIntBE(0, 3), 0x123456);
+
+  buf = Buffer(3);
+  buf.writeIntLE(-0x123456, 0, 3);
+  assert.deepStrictEqual(buf.toJSON().data, [0xaa, 0xcb, 0xed]);
+  assert.equal(buf.readIntLE(0, 3), -0x123456);
+
+  buf = Buffer(3);
+  buf.writeIntBE(-0x123456, 0, 3);
+  assert.deepStrictEqual(buf.toJSON().data, [0xed, 0xcb, 0xaa]);
+  assert.equal(buf.readIntBE(0, 3), -0x123456);
+
+  buf = Buffer(3);
+  buf.writeIntLE(-0x123400, 0, 3);
+  assert.deepStrictEqual(buf.toJSON().data, [0x00, 0xcc, 0xed]);
+  assert.equal(buf.readIntLE(0, 3), -0x123400);
+
+  buf = Buffer(3);
+  buf.writeIntBE(-0x123400, 0, 3);
+  assert.deepStrictEqual(buf.toJSON().data, [0xed, 0xcc, 0x00]);
+  assert.equal(buf.readIntBE(0, 3), -0x123400);
+
+  buf = Buffer(3);
+  buf.writeIntLE(-0x120000, 0, 3);
+  assert.deepStrictEqual(buf.toJSON().data, [0x00, 0x00, 0xee]);
+  assert.equal(buf.readIntLE(0, 3), -0x120000);
+
+  buf = Buffer(3);
+  buf.writeIntBE(-0x120000, 0, 3);
+  assert.deepStrictEqual(buf.toJSON().data, [0xee, 0x00, 0x00]);
+  assert.equal(buf.readIntBE(0, 3), -0x120000);
+
+  buf = Buffer(5);
+  buf.writeUIntLE(0x1234567890, 0, 5);
+  assert.deepStrictEqual(buf.toJSON().data, [0x90, 0x78, 0x56, 0x34, 0x12]);
+  assert.equal(buf.readUIntLE(0, 5), 0x1234567890);
+
+  buf = Buffer(5);
+  buf.writeUIntBE(0x1234567890, 0, 5);
+  assert.deepStrictEqual(buf.toJSON().data, [0x12, 0x34, 0x56, 0x78, 0x90]);
+  assert.equal(buf.readUIntBE(0, 5), 0x1234567890);
+
+  buf = Buffer(5);
+  buf.writeIntLE(0x1234567890, 0, 5);
+  assert.deepStrictEqual(buf.toJSON().data, [0x90, 0x78, 0x56, 0x34, 0x12]);
+  assert.equal(buf.readIntLE(0, 5), 0x1234567890);
+
+  buf = Buffer(5);
+  buf.writeIntBE(0x1234567890, 0, 5);
+  assert.deepStrictEqual(buf.toJSON().data, [0x12, 0x34, 0x56, 0x78, 0x90]);
+  assert.equal(buf.readIntBE(0, 5), 0x1234567890);
+
+  buf = Buffer(5);
+  buf.writeIntLE(-0x1234567890, 0, 5);
+  assert.deepStrictEqual(buf.toJSON().data, [0x70, 0x87, 0xa9, 0xcb, 0xed]);
+  assert.equal(buf.readIntLE(0, 5), -0x1234567890);
+
+  buf = Buffer(5);
+  buf.writeIntBE(-0x1234567890, 0, 5);
+  assert.deepStrictEqual(buf.toJSON().data, [0xed, 0xcb, 0xa9, 0x87, 0x70]);
+  assert.equal(buf.readIntBE(0, 5), -0x1234567890);
+
+  buf = Buffer(5);
+  buf.writeIntLE(-0x0012000000, 0, 5);
+  assert.deepStrictEqual(buf.toJSON().data, [0x00, 0x00, 0x00, 0xee, 0xff]);
+  assert.equal(buf.readIntLE(0, 5), -0x0012000000);
+
+  buf = Buffer(5);
+  buf.writeIntBE(-0x0012000000, 0, 5);
+  assert.deepStrictEqual(buf.toJSON().data, [0xff, 0xee, 0x00, 0x00, 0x00]);
+  assert.equal(buf.readIntBE(0, 5), -0x0012000000);
+}
+
+// test Buffer slice
+{
+  var buf = new Buffer('0123456789');
+  assert.equal(buf.slice(-10, 10), '0123456789');
+  assert.equal(buf.slice(-20, 10), '0123456789');
+  assert.equal(buf.slice(-20, -10), '');
+  assert.equal(buf.slice(), '0123456789');
+  assert.equal(buf.slice(0), '0123456789');
+  assert.equal(buf.slice(0, 0), '');
+  assert.equal(buf.slice(undefined), '0123456789');
+  assert.equal(buf.slice('foobar'), '0123456789');
+  assert.equal(buf.slice(undefined, undefined), '0123456789');
+
+  assert.equal(buf.slice(2), '23456789');
+  assert.equal(buf.slice(5), '56789');
+  assert.equal(buf.slice(10), '');
+  assert.equal(buf.slice(5, 8), '567');
+  assert.equal(buf.slice(8, -1), '8');
+  assert.equal(buf.slice(-10), '0123456789');
+  assert.equal(buf.slice(0, -9), '0');
+  assert.equal(buf.slice(0, -10), '');
+  assert.equal(buf.slice(0, -1), '012345678');
+  assert.equal(buf.slice(2, -2), '234567');
+  assert.equal(buf.slice(0, 65536), '0123456789');
+  assert.equal(buf.slice(65536, 0), '');
+  assert.equal(buf.slice(-5, -8), '');
+  assert.equal(buf.slice(-5, -3), '56');
+  assert.equal(buf.slice(-10, 10), '0123456789');
+  for (var i = 0, s = buf.toString(); i < buf.length; ++i) {
+    assert.equal(buf.slice(i), s.slice(i));
+    assert.equal(buf.slice(0, i), s.slice(0, i));
+    assert.equal(buf.slice(-i), s.slice(-i));
+    assert.equal(buf.slice(0, -i), s.slice(0, -i));
+  }
+
+  var utf16Buf = new Buffer('0123456789', 'utf16le');
+  assert.deepStrictEqual(utf16Buf.slice(0, 6), Buffer('012', 'utf16le'));
+
+  assert.equal(buf.slice('0', '1'), '0');
+  assert.equal(buf.slice('-5', '10'), '56789');
+  assert.equal(buf.slice('-10', '10'), '0123456789');
+  assert.equal(buf.slice('-10', '-5'), '01234');
+  assert.equal(buf.slice('-10', '-0'), '');
+  assert.equal(buf.slice('111'), '');
+  assert.equal(buf.slice('0', '-111'), '');
+
+  // try to slice a zero length Buffer
+  // see https://github.com/joyent/node/issues/5881
+  SlowBuffer(0).slice(0, 1);
+}
+
+// Regression test for #5482: should throw but not assert in C++ land.
+assert.throws(function() {
+  Buffer('', 'buffer');
+}, TypeError);
+
+// Regression test for #6111. Constructing a buffer from another buffer
+// should a) work, and b) not corrupt the source buffer.
+{
+  var a = [0];
+  for (var i = 0; i < 7; ++i) a = a.concat(a);
+  a = a.map(function(_, i) { return i; });
+  var b = Buffer(a);
+  var c = Buffer(b);
+  assert.strictEqual(b.length, a.length);
+  assert.strictEqual(c.length, a.length);
+  for (var i = 0, k = a.length; i < k; ++i) {
+    assert.strictEqual(a[i], i);
+    assert.strictEqual(b[i], i);
+    assert.strictEqual(c[i], i);
+  }
+}
+
+
+assert.throws(function() {
+  new Buffer((-1 >>> 0) + 1);
+}, RangeError);
+
+assert.throws(function() {
+  SlowBuffer((-1 >>> 0) + 1);
+}, RangeError);
+
+if (common.hasCrypto) {
+  // Test truncation after decode
+  // var crypto = require('crypto');
+
+  var b1 = new Buffer('YW55=======', 'base64');
+  var b2 = new Buffer('YW55', 'base64');
+
+  assert.equal(
+    1 /*crypto.createHash('sha1').update(b1).digest('hex')*/,
+    1 /*crypto.createHash('sha1').update(b2).digest('hex')*/
+  );
+} else {
+  common.skip('missing crypto');
+}
+
+// Test Compare
+{
+  var b = new Buffer(1).fill('a');
+  var c = new Buffer(1).fill('c');
+  var d = new Buffer(2).fill('aa');
+
+  assert.equal(b.compare(c), -1);
+  assert.equal(c.compare(d), 1);
+  assert.equal(d.compare(b), 1);
+  assert.equal(b.compare(d), -1);
+  assert.equal(b.compare(b), 0);
+
+  assert.equal(Buffer.compare(b, c), -1);
+  assert.equal(Buffer.compare(c, d), 1);
+  assert.equal(Buffer.compare(d, b), 1);
+  assert.equal(Buffer.compare(b, d), -1);
+  assert.equal(Buffer.compare(c, c), 0);
+
+  assert.equal(Buffer.compare(Buffer(0), Buffer(0)), 0);
+  assert.equal(Buffer.compare(Buffer(0), Buffer(1)), -1);
+  assert.equal(Buffer.compare(Buffer(1), Buffer(0)), 1);
+}
+
+assert.throws(function() {
+  var b = Buffer(1);
+  Buffer.compare(b, 'abc');
+});
+
+assert.throws(function() {
+  var b = Buffer(1);
+  Buffer.compare('abc', b);
+});
+
+assert.throws(function() {
+  var b = Buffer(1);
+  b.compare('abc');
+});
+
+// Test Equals
+{
+  var b = new Buffer(5).fill('abcdf');
+  var c = new Buffer(5).fill('abcdf');
+  var d = new Buffer(5).fill('abcde');
+  var e = new Buffer(6).fill('abcdef');
+
+  assert.ok(b.equals(c));
+  assert.ok(!c.equals(d));
+  assert.ok(!d.equals(e));
+  assert.ok(d.equals(d));
+}
+
+assert.throws(function() {
+  var b = Buffer(1);
+  b.equals('abc');
+});
+
+// Regression test for https://github.com/nodejs/node/issues/649.
+assert.throws(function() { Buffer(1422561062959).toString('utf8'); });
+
+var ps = Buffer.poolSize;
+Buffer.poolSize = 0;
+assert.equal(Buffer(1).parent, undefined);
+Buffer.poolSize = ps;
+
+// Test Buffer.copy() segfault
+assert.throws(function() {
+  Buffer(10).copy();
+});
+
+var regErrorMsg = new RegExp('First argument must be a string, Buffer, ' +
+                               'ArrayBuffer, Array, or array-like object.');
+
+assert.throws(function() {
+  new Buffer();
+}, regErrorMsg);
+
+assert.throws(function() {
+  new Buffer(null);
+}, regErrorMsg);
+
+
+// Test prototype getters don't throw
+assert.equal(Buffer.prototype.parent, undefined);
+assert.equal(Buffer.prototype.offset, undefined);
+assert.equal(SlowBuffer.prototype.parent, undefined);
+assert.equal(SlowBuffer.prototype.offset, undefined);
+
+{
+  // Test that large negative Buffer length inputs don't affect the pool offset.
+  // Use the fromArrayLike() variant here because it's more lenient
+  // about its input and passes the length directly to allocate().
+  assert.deepStrictEqual(Buffer({ length: -Buffer.poolSize }), Buffer.from(''));
+  assert.deepStrictEqual(Buffer({ length: -100 }), Buffer.from(''));
+
+  // Check pool offset after that by trying to write string into the pool.
+  assert.doesNotThrow(() => Buffer.from('abc'));
+}
+
+
+// Test failed or zero-sized Buffer allocations not affecting typed arrays
+{
+  var zeroArray = new Uint32Array(10).fill(0);
+  var sizes = [1e10, 0, 0.1, -1, 'a', undefined, null, NaN];
+  var allocators = [
+    Buffer,
+    SlowBuffer,
+    Buffer.alloc,
+    Buffer.allocUnsafe,
+    Buffer.allocUnsafeSlow
+  ];
+  for (var allocator of allocators) {
+    for (var size of sizes) {
+      try {
+        allocator(size);
+      } catch (e) {
+        assert.deepStrictEqual(new Uint32Array(10), zeroArray);
+      }
+    }
+  }
+}
+
+// Test that large negative Buffer length inputs throw errors.
+assert.throws(() => Buffer(-Buffer.poolSize),
+              '"size" argument must not be negative');
+assert.throws(() => Buffer(-100),
+              '"size" argument must not be negative');
+assert.throws(() => Buffer(-1),
+              '"size" argument must not be negative');
+
diff --git a/node_modules/buffer/test/slice.js b/node_modules/buffer/test/slice.js
new file mode 100644
index 000000000..25c111c80
--- /dev/null
+++ b/node_modules/buffer/test/slice.js
@@ -0,0 +1,37 @@
+if (process.env.OBJECT_IMPL) global.TYPED_ARRAY_SUPPORT = false
+var B = require('../').Buffer
+var test = require('tape')
+
+test('modifying buffer created by .slice() modifies original memory', function (t) {
+  if (!B.TYPED_ARRAY_SUPPORT) return t.end()
+
+  var buf1 = new B(26)
+  for (var i = 0; i < 26; i++) {
+    buf1[i] = i + 97 // 97 is ASCII a
+  }
+
+  var buf2 = buf1.slice(0, 3)
+  t.equal(buf2.toString('ascii', 0, buf2.length), 'abc')
+
+  buf2[0] = '!'.charCodeAt(0)
+  t.equal(buf1.toString('ascii', 0, buf2.length), '!bc')
+
+  t.end()
+})
+
+test('modifying parent buffer modifies .slice() buffer\'s memory', function (t) {
+  if (!B.TYPED_ARRAY_SUPPORT) return t.end()
+
+  var buf1 = new B(26)
+  for (var i = 0; i < 26; i++) {
+    buf1[i] = i + 97 // 97 is ASCII a
+  }
+
+  var buf2 = buf1.slice(0, 3)
+  t.equal(buf2.toString('ascii', 0, buf2.length), 'abc')
+
+  buf1[0] = '!'.charCodeAt(0)
+  t.equal(buf2.toString('ascii', 0, buf2.length), '!bc')
+
+  t.end()
+})
diff --git a/node_modules/buffer/test/static.js b/node_modules/buffer/test/static.js
new file mode 100644
index 000000000..4de900bc7
--- /dev/null
+++ b/node_modules/buffer/test/static.js
@@ -0,0 +1,17 @@
+if (process.env.OBJECT_IMPL) global.TYPED_ARRAY_SUPPORT = false
+var B = require('../').Buffer
+var test = require('tape')
+
+test('Buffer.isEncoding', function (t) {
+  t.equal(B.isEncoding('HEX'), true)
+  t.equal(B.isEncoding('hex'), true)
+  t.equal(B.isEncoding('bad'), false)
+  t.end()
+})
+
+test('Buffer.isBuffer', function (t) {
+  t.equal(B.isBuffer(new B('hey', 'utf8')), true)
+  t.equal(B.isBuffer(new B([1, 2, 3], 'utf8')), true)
+  t.equal(B.isBuffer('hey'), false)
+  t.end()
+})
diff --git a/node_modules/buffer/test/to-string.js b/node_modules/buffer/test/to-string.js
new file mode 100644
index 000000000..2950d4d0d
--- /dev/null
+++ b/node_modules/buffer/test/to-string.js
@@ -0,0 +1,233 @@
+if (process.env.OBJECT_IMPL) global.TYPED_ARRAY_SUPPORT = false
+var B = require('../').Buffer
+var test = require('tape')
+
+test('utf8 buffer to base64', function (t) {
+  t.equal(
+    new B('Ձאab', 'utf8').toString('base64'),
+    '1YHXkGFi'
+  )
+  t.end()
+})
+
+test('utf8 buffer to hex', function (t) {
+  t.equal(
+    new B('Ձאab', 'utf8').toString('hex'),
+    'd581d7906162'
+  )
+  t.end()
+})
+
+test('utf8 to utf8', function (t) {
+  t.equal(
+    new B('öäüõÖÄÜÕ', 'utf8').toString('utf8'),
+    'öäüõÖÄÜÕ'
+  )
+  t.end()
+})
+
+test('utf16le to utf16', function (t) {
+  t.equal(
+    new B(new B('abcd', 'utf8').toString('utf16le'), 'utf16le').toString('utf8'),
+    'abcd'
+  )
+  t.end()
+})
+
+test('utf16le to hex', function (t) {
+  t.equal(
+    new B('abcd', 'utf16le').toString('hex'),
+    '6100620063006400'
+  )
+  t.end()
+})
+
+test('ascii buffer to base64', function (t) {
+  t.equal(
+    new B('123456!@#$%^', 'ascii').toString('base64'),
+    'MTIzNDU2IUAjJCVe'
+  )
+  t.end()
+})
+
+test('ascii buffer to hex', function (t) {
+  t.equal(
+    new B('123456!@#$%^', 'ascii').toString('hex'),
+    '31323334353621402324255e'
+  )
+  t.end()
+})
+
+test('base64 buffer to utf8', function (t) {
+  t.equal(
+    new B('1YHXkGFi', 'base64').toString('utf8'),
+    'Ձאab'
+  )
+  t.end()
+})
+
+test('hex buffer to utf8', function (t) {
+  t.equal(
+    new B('d581d7906162', 'hex').toString('utf8'),
+    'Ձאab'
+  )
+  t.end()
+})
+
+test('base64 buffer to ascii', function (t) {
+  t.equal(
+    new B('MTIzNDU2IUAjJCVe', 'base64').toString('ascii'),
+    '123456!@#$%^'
+  )
+  t.end()
+})
+
+test('hex buffer to ascii', function (t) {
+  t.equal(
+    new B('31323334353621402324255e', 'hex').toString('ascii'),
+    '123456!@#$%^'
+  )
+  t.end()
+})
+
+test('base64 buffer to binary', function (t) {
+  t.equal(
+    new B('MTIzNDU2IUAjJCVe', 'base64').toString('binary'),
+    '123456!@#$%^'
+  )
+  t.end()
+})
+
+test('hex buffer to binary', function (t) {
+  t.equal(
+    new B('31323334353621402324255e', 'hex').toString('binary'),
+    '123456!@#$%^'
+  )
+  t.end()
+})
+
+test('utf8 to binary', function (t) {
+  /* jshint -W100 */
+  t.equal(
+    new B('öäüõÖÄÜÕ', 'utf8').toString('binary'),
+    'öäüõÖÄÜÕ'
+  )
+  /* jshint +W100 */
+  t.end()
+})
+
+test('utf8 replacement chars (1 byte sequence)', function (t) {
+  t.equal(
+    new B([ 0x80 ]).toString(),
+    '\uFFFD'
+  )
+  t.equal(
+    new B([ 0x7F ]).toString(),
+    '\u007F'
+  )
+  t.end()
+})
+
+test('utf8 replacement chars (2 byte sequences)', function (t) {
+  t.equal(
+    new B([ 0xC7 ]).toString(),
+    '\uFFFD'
+  )
+  t.equal(
+    new B([ 0xC7, 0xB1 ]).toString(),
+    '\u01F1'
+  )
+  t.equal(
+    new B([ 0xC0, 0xB1 ]).toString(),
+    '\uFFFD\uFFFD'
+  )
+  t.equal(
+    new B([ 0xC1, 0xB1 ]).toString(),
+    '\uFFFD\uFFFD'
+  )
+  t.end()
+})
+
+test('utf8 replacement chars (3 byte sequences)', function (t) {
+  t.equal(
+    new B([ 0xE0 ]).toString(),
+    '\uFFFD'
+  )
+  t.equal(
+    new B([ 0xE0, 0xAC ]).toString(),
+    '\uFFFD\uFFFD'
+  )
+  t.equal(
+    new B([ 0xE0, 0xAC, 0xB9 ]).toString(),
+    '\u0B39'
+  )
+  t.end()
+})
+
+test('utf8 replacement chars (4 byte sequences)', function (t) {
+  t.equal(
+    new B([ 0xF4 ]).toString(),
+    '\uFFFD'
+  )
+  t.equal(
+    new B([ 0xF4, 0x8F ]).toString(),
+    '\uFFFD\uFFFD'
+  )
+  t.equal(
+    new B([ 0xF4, 0x8F, 0x80 ]).toString(),
+    '\uFFFD\uFFFD\uFFFD'
+  )
+  t.equal(
+    new B([ 0xF4, 0x8F, 0x80, 0x84 ]).toString(),
+    '\uDBFC\uDC04'
+  )
+  t.equal(
+    new B([ 0xFF ]).toString(),
+    '\uFFFD'
+  )
+  t.equal(
+    new B([ 0xFF, 0x8F, 0x80, 0x84 ]).toString(),
+    '\uFFFD\uFFFD\uFFFD\uFFFD'
+  )
+  t.end()
+})
+
+test('utf8 replacement chars on 256 random bytes', function (t) {
+  t.equal(
+    new B([ 152, 130, 206, 23, 243, 238, 197, 44, 27, 86, 208, 36, 163, 184, 164, 21, 94, 242, 178, 46, 25, 26, 253, 178, 72, 147, 207, 112, 236, 68, 179, 190, 29, 83, 239, 147, 125, 55, 143, 19, 157, 68, 157, 58, 212, 224, 150, 39, 128, 24, 94, 225, 120, 121, 75, 192, 112, 19, 184, 142, 203, 36, 43, 85, 26, 147, 227, 139, 242, 186, 57, 78, 11, 102, 136, 117, 180, 210, 241, 92, 3, 215, 54, 167, 249, 1, 44, 225, 146, 86, 2, 42, 68, 21, 47, 238, 204, 153, 216, 252, 183, 66, 222, 255, 15, 202, 16, 51, 134, 1, 17, 19, 209, 76, 238, 38, 76, 19, 7, 103, 249, 5, 107, 137, 64, 62, 170, 57, 16, 85, 179, 193, 97, 86, 166, 196, 36, 148, 138, 193, 210, 69, 187, 38, 242, 97, 195, 219, 252, 244, 38, 1, 197, 18, 31, 246, 53, 47, 134, 52, 105, 72, 43, 239, 128, 203, 73, 93, 199, 75, 222, 220, 166, 34, 63, 236, 11, 212, 76, 243, 171, 110, 78, 39, 205, 204, 6, 177, 233, 212, 243, 0, 33, 41, 122, 118, 92, 252, 0, 157, 108, 120, 70, 137, 100, 223, 243, 171, 232, 66, 126, 111, 142, 33, 3, 39, 117, 27, 107, 54, 1, 217, 227, 132, 13, 166, 3, 73, 53, 127, 225, 236, 134, 219, 98, 214, 125, 148, 24, 64, 142, 111, 231, 194, 42, 150, 185, 10, 182, 163, 244, 19, 4, 59, 135, 16 ]).toString(),
+    '\uFFFD\uFFFD\uFFFD\u0017\uFFFD\uFFFD\uFFFD\u002C\u001B\u0056\uFFFD\u0024\uFFFD\uFFFD\uFFFD\u0015\u005E\uFFFD\uFFFD\u002E\u0019\u001A\uFFFD\uFFFD\u0048\uFFFD\uFFFD\u0070\uFFFD\u0044\uFFFD\uFFFD\u001D\u0053\uFFFD\uFFFD\u007D\u0037\uFFFD\u0013\uFFFD\u0044\uFFFD\u003A\uFFFD\uFFFD\uFFFD\u0027\uFFFD\u0018\u005E\uFFFD\u0078\u0079\u004B\uFFFD\u0070\u0013\uFFFD\uFFFD\uFFFD\u0024\u002B\u0055\u001A\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u0039\u004E\u000B\u0066\uFFFD\u0075\uFFFD\uFFFD\uFFFD\u005C\u0003\uFFFD\u0036\uFFFD\uFFFD\u0001\u002C\uFFFD\uFFFD\u0056\u0002\u002A\u0044\u0015\u002F\uFFFD\u0319\uFFFD\uFFFD\uFFFD\u0042\uFFFD\uFFFD\u000F\uFFFD\u0010\u0033\uFFFD\u0001\u0011\u0013\uFFFD\u004C\uFFFD\u0026\u004C\u0013\u0007\u0067\uFFFD\u0005\u006B\uFFFD\u0040\u003E\uFFFD\u0039\u0010\u0055\uFFFD\uFFFD\u0061\u0056\uFFFD\uFFFD\u0024\uFFFD\uFFFD\uFFFD\uFFFD\u0045\uFFFD\u0026\uFFFD\u0061\uFFFD\uFFFD\uFFFD\uFFFD\u0026\u0001\uFFFD\u0012\u001F\uFFFD\u0035\u002F\uFFFD\u0034\u0069\u0048\u002B\uFFFD\uFFFD\uFFFD\u0049\u005D\uFFFD\u004B\uFFFD\u0726\u0022\u003F\uFFFD\u000B\uFFFD\u004C\uFFFD\uFFFD\u006E\u004E\u0027\uFFFD\uFFFD\u0006\uFFFD\uFFFD\uFFFD\uFFFD\u0000\u0021\u0029\u007A\u0076\u005C\uFFFD\u0000\uFFFD\u006C\u0078\u0046\uFFFD\u0064\uFFFD\uFFFD\uFFFD\uFFFD\u0042\u007E\u006F\uFFFD\u0021\u0003\u0027\u0075\u001B\u006B\u0036\u0001\uFFFD\uFFFD\uFFFD\u000D\uFFFD\u0003\u0049\u0035\u007F\uFFFD\uFFFD\uFFFD\uFFFD\u0062\uFFFD\u007D\uFFFD\u0018\u0040\uFFFD\u006F\uFFFD\uFFFD\u002A\uFFFD\uFFFD\u000A\uFFFD\uFFFD\uFFFD\u0013\u0004\u003B\uFFFD\u0010'
+  )
+  t.end()
+})
+
+test('utf8 replacement chars for anything in the surrogate pair range', function (t) {
+  t.equal(
+    new B([ 0xED, 0x9F, 0xBF ]).toString(),
+    '\uD7FF'
+  )
+  t.equal(
+    new B([ 0xED, 0xA0, 0x80 ]).toString(),
+    '\uFFFD\uFFFD\uFFFD'
+  )
+  t.equal(
+    new B([ 0xED, 0xBE, 0x8B ]).toString(),
+    '\uFFFD\uFFFD\uFFFD'
+  )
+  t.equal(
+    new B([ 0xED, 0xBF, 0xBF ]).toString(),
+    '\uFFFD\uFFFD\uFFFD'
+  )
+  t.equal(
+    new B([ 0xEE, 0x80, 0x80 ]).toString(),
+    '\uE000'
+  )
+  t.end()
+})
+
+test('utf8 don\'t replace the replacement char', function (t) {
+  t.equal(
+    new B('\uFFFD').toString(),
+    '\uFFFD'
+  )
+  t.end()
+})
diff --git a/node_modules/buffer/test/write.js b/node_modules/buffer/test/write.js
new file mode 100644
index 000000000..584180634
--- /dev/null
+++ b/node_modules/buffer/test/write.js
@@ -0,0 +1,131 @@
+if (process.env.OBJECT_IMPL) global.TYPED_ARRAY_SUPPORT = false
+var B = require('../').Buffer
+var test = require('tape')
+var isnan = require('is-nan')
+
+test('buffer.write string should get parsed as number', function (t) {
+  var b = new B(64)
+  b.writeUInt16LE('1003', 0)
+  t.equal(b.readUInt16LE(0), 1003)
+  t.end()
+})
+
+test('buffer.writeUInt8 a fractional number will get Math.floored', function (t) {
+  // Some extra work is necessary to make this test pass with the Object implementation
+
+  var b = new B(1)
+  b.writeInt8(5.5, 0)
+  t.equal(b[0], 5)
+  t.end()
+})
+
+test('writeUint8 with a negative number throws', function (t) {
+  var buf = new B(1)
+
+  t.throws(function () {
+    buf.writeUInt8(-3, 0)
+  })
+
+  t.end()
+})
+
+test('hex of write{Uint,Int}{8,16,32}{LE,BE}', function (t) {
+  t.plan(2 * (2 * 2 * 2 + 2))
+  var hex = [
+    '03', '0300', '0003', '03000000', '00000003',
+    'fd', 'fdff', 'fffd', 'fdffffff', 'fffffffd'
+  ]
+  var reads = [ 3, 3, 3, 3, 3, -3, -3, -3, -3, -3 ]
+  var xs = ['UInt', 'Int']
+  var ys = [8, 16, 32]
+  for (var i = 0; i < xs.length; i++) {
+    var x = xs[i]
+    for (var j = 0; j < ys.length; j++) {
+      var y = ys[j]
+      var endianesses = (y === 8) ? [''] : ['LE', 'BE']
+      for (var k = 0; k < endianesses.length; k++) {
+        var z = endianesses[k]
+
+        var v1 = new B(y / 8)
+        var writefn = 'write' + x + y + z
+        var val = (x === 'Int') ? -3 : 3
+        v1[writefn](val, 0)
+        t.equal(
+          v1.toString('hex'),
+          hex.shift()
+        )
+        var readfn = 'read' + x + y + z
+        t.equal(
+          v1[readfn](0),
+          reads.shift()
+        )
+      }
+    }
+  }
+  t.end()
+})
+
+test('hex of write{Uint,Int}{8,16,32}{LE,BE} with overflow', function (t) {
+  if (!B.TYPED_ARRAY_SUPPORT) {
+    t.pass('object impl: skipping overflow test')
+    t.end()
+    return
+  }
+
+  t.plan(3 * (2 * 2 * 2 + 2))
+  var hex = [
+    '', '03', '00', '030000', '000000',
+    '', 'fd', 'ff', 'fdffff', 'ffffff'
+  ]
+  var reads = [
+    undefined, 3, 0, NaN, 0,
+    undefined, 253, -256, 16777213, -256
+  ]
+  var xs = ['UInt', 'Int']
+  var ys = [8, 16, 32]
+  for (var i = 0; i < xs.length; i++) {
+    var x = xs[i]
+    for (var j = 0; j < ys.length; j++) {
+      var y = ys[j]
+      var endianesses = (y === 8) ? [''] : ['LE', 'BE']
+      for (var k = 0; k < endianesses.length; k++) {
+        var z = endianesses[k]
+
+        var v1 = new B(y / 8 - 1)
+        var next = new B(4)
+        next.writeUInt32BE(0, 0)
+        var writefn = 'write' + x + y + z
+        var val = (x === 'Int') ? -3 : 3
+        v1[writefn](val, 0, true)
+        t.equal(
+          v1.toString('hex'),
+          hex.shift()
+        )
+        // check that nothing leaked to next buffer.
+        t.equal(next.readUInt32BE(0), 0)
+        // check that no bytes are read from next buffer.
+        next.writeInt32BE(~0, 0)
+        var readfn = 'read' + x + y + z
+        var r = reads.shift()
+        if (isnan(r)) t.pass('equal')
+        else t.equal(v1[readfn](0, true), r)
+      }
+    }
+  }
+  t.end()
+})
+test('large values do not improperly roll over (ref #80)', function (t) {
+  var nums = [-25589992, -633756690, -898146932]
+  var out = new B(12)
+  out.fill(0)
+  out.writeInt32BE(nums[0], 0)
+  var newNum = out.readInt32BE(0)
+  t.equal(nums[0], newNum)
+  out.writeInt32BE(nums[1], 4)
+  newNum = out.readInt32BE(4)
+  t.equal(nums[1], newNum)
+  out.writeInt32BE(nums[2], 8)
+  newNum = out.readInt32BE(8)
+  t.equal(nums[2], newNum)
+  t.end()
+})
diff --git a/node_modules/buffer/test/write_infinity.js b/node_modules/buffer/test/write_infinity.js
new file mode 100644
index 000000000..17d606a1c
--- /dev/null
+++ b/node_modules/buffer/test/write_infinity.js
@@ -0,0 +1,45 @@
+if (process.env.OBJECT_IMPL) global.TYPED_ARRAY_SUPPORT = false
+var B = require('../').Buffer
+var test = require('tape')
+
+test('write/read Infinity as a float', function (t) {
+  var buf = new B(4)
+  t.equal(buf.writeFloatBE(Infinity, 0), 4)
+  t.equal(buf.readFloatBE(0), Infinity)
+  t.end()
+})
+
+test('write/read -Infinity as a float', function (t) {
+  var buf = new B(4)
+  t.equal(buf.writeFloatBE(-Infinity, 0), 4)
+  t.equal(buf.readFloatBE(0), -Infinity)
+  t.end()
+})
+
+test('write/read Infinity as a double', function (t) {
+  var buf = new B(8)
+  t.equal(buf.writeDoubleBE(Infinity, 0), 8)
+  t.equal(buf.readDoubleBE(0), Infinity)
+  t.end()
+})
+
+test('write/read -Infinity as a double', function (t) {
+  var buf = new B(8)
+  t.equal(buf.writeDoubleBE(-Infinity, 0), 8)
+  t.equal(buf.readDoubleBE(0), -Infinity)
+  t.end()
+})
+
+test('write/read float greater than max', function (t) {
+  var buf = new B(4)
+  t.equal(buf.writeFloatBE(4e38, 0), 4)
+  t.equal(buf.readFloatBE(0), Infinity)
+  t.end()
+})
+
+test('write/read float less than min', function (t) {
+  var buf = new B(4)
+  t.equal(buf.writeFloatBE(-4e40, 0), 4)
+  t.equal(buf.readFloatBE(0), -Infinity)
+  t.end()
+})