module changed

+import {voicoding} from './voicoding.js'
+
+const start = voicoding()
\ No newline at end of file

+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  "$basedir/node"  "$basedir/../mkdirp/bin/cmd.js" "$@"
+  ret=$?
+else 
+  node  "$basedir/../mkdirp/bin/cmd.js" "$@"
+  ret=$?
+fi
+exit $ret

+@ECHO off
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+"%_prog%"  "%dp0%\..\mkdirp\bin\cmd.js" %*
+ENDLOCAL
+EXIT /b %errorlevel%
+:find_dp0
+SET dp0=%~dp0
+EXIT /b

+#!/usr/bin/env pwsh
+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+
+$exe=""
+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
+  # Fix case when both the Windows and Linux builds of Node
+  # are installed in the same directory
+  $exe=".exe"
+}
+$ret=0
+if (Test-Path "$basedir/node$exe") {
+  & "$basedir/node$exe"  "$basedir/../mkdirp/bin/cmd.js" $args
+  $ret=$LASTEXITCODE
+} else {
+  & "node$exe"  "$basedir/../mkdirp/bin/cmd.js" $args
+  $ret=$LASTEXITCODE
+}
+exit $ret

@@ -8,7 +8,7 @@ This package contains type definitions for Node.js (http://nodejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node.
 
 ### Additional Details
- * Last updated: Fri, 21 May 2021 10:32:02 GMT
+ * Last updated: Wed, 02 Jun 2021 07:31:33 GMT
  * Dependencies: none
  * Global values: `AbortController`, `AbortSignal`, `Buffer`, `__dirname`, `__filename`, `clearImmediate`, `clearInterval`, `clearTimeout`, `console`, `exports`, `global`, `module`, `process`, `queueMicrotask`, `require`, `setImmediate`, `setInterval`, `setTimeout`
 

@@ -167,7 +167,7 @@ declare module 'http' {
         finished: boolean;
         headersSent: boolean;
         /**
-         * @deprecate Use `socket` instead.
+         * @deprecated Use `socket` instead.
          */
         connection: Socket | null;
         socket: Socket | null;

 {
   "_from": "@types/node@*",
-  "_id": "@types/node@15.6.0",
+  "_id": "@types/node@15.6.2",
   "_inBundle": false,
-  "_integrity": "sha512-gCYSfQpy+LYhOFTKAeE8BkyGqaxmlFxe+n4DKM6DR0wzw/HISUE/hAmkC/KT8Sw5PCJblqg062b3z9gucv3k0A==",
+  "_integrity": "sha512-dxcOx8801kMo3KlU+C+/ctWrzREAH7YvoF3aoVpRdqgs+Kf7flp+PJDN/EX5bME3suDUZHsxes9hpvBmzYlWbA==",
   "_location": "/@types/node",
   "_phantomChildren": {},
   "_requested": {
@@ -22,8 +22,8 @@
     "/@types/pumpify",
     "/protobufjs"
   ],
-  "_resolved": "https://registry.npmjs.org/@types/node/-/node-15.6.0.tgz",
-  "_shasum": "f0ddca5a61e52627c9dcb771a6039d44694597bc",
+  "_resolved": "https://registry.npmjs.org/@types/node/-/node-15.6.2.tgz",
+  "_shasum": "c61d49f38af70da32424b5322eee21f97e627175",
   "_spec": "@types/node@*",
   "_where": "C:\\Users\\1000c\\이것저것\\옾소\\Voicoding\\node_modules\\@types\\pumpify",
   "bugs": {
@@ -199,7 +199,7 @@
   "dependencies": {},
   "deprecated": false,
   "description": "TypeScript definitions for Node.js",
-  "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped#readme",
+  "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
   "license": "MIT",
   "main": "",
   "name": "@types/node",
@@ -209,9 +209,9 @@
     "directory": "types/node"
   },
   "scripts": {},
-  "typeScriptVersion": "3.5",
+  "typeScriptVersion": "3.6",
   "types": "index.d.ts",
-  "typesPublisherContentHash": "fe5d90fe4c06a65d482f400f205828b1280c7062026d5afdccc3b2bbccf4adcd",
+  "typesPublisherContentHash": "f62422deccbd466260cb63740d207022259eb7fc7b6e7c406be463b9d1b0cd19",
   "typesVersions": {
     "<=3.6": {
       "*": [
@@ -219,5 +219,5 @@
       ]
     }
   },
-  "version": "15.6.0"
+  "version": "15.6.2"
 }

@@ -88,7 +88,10 @@ declare module 'perf_hooks' {
      * @param util1 The result of a previous call to eventLoopUtilization()
      * @param util2 The result of a previous call to eventLoopUtilization() prior to util1
      */
-    type EventLoopUtilityFunction = (util1?: EventLoopUtilization, util2?: EventLoopUtilization) => EventLoopUtilization;
+    type EventLoopUtilityFunction = (
+        util1?: EventLoopUtilization,
+        util2?: EventLoopUtilization,
+    ) => EventLoopUtilization;
 
     interface Performance {
         /**
@@ -122,7 +125,7 @@ declare module 'perf_hooks' {
          * @param startMark
          * @param endMark
          */
-        measure(name: string, startMark: string, endMark: string): void;
+        measure(name: string, startMark?: string, endMark?: string): void;
 
         /**
          * An instance of the PerformanceNodeTiming class that provides performance metrics for specific Node.js operational milestones.

+node_modules/

+The MIT License (MIT)
+
+Copyright (c) 2015 Linus Unnebäck
+
+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.

+# `append-field`
+
+A [W3C HTML JSON forms spec](http://www.w3.org/TR/html-json-forms/) compliant
+field appender (for lack of a better name). Useful for people implementing
+`application/x-www-form-urlencoded` and `multipart/form-data` parsers.
+
+It works best on objects created with `Object.create(null)`. Otherwise it might
+conflict with variables from the prototype (e.g. `hasOwnProperty`).
+
+## Installation
+
+```sh
+npm install --save append-field
+```
+
+## Usage
+
+```javascript
+var appendField = require('append-field')
+var obj = Object.create(null)
+
+appendField(obj, 'pets[0][species]', 'Dahut')
+appendField(obj, 'pets[0][name]', 'Hypatia')
+appendField(obj, 'pets[1][species]', 'Felis Stultus')
+appendField(obj, 'pets[1][name]', 'Billie')
+
+console.log(obj)
+```
+
+```text
+{ pets:
+   [ { species: 'Dahut', name: 'Hypatia' },
+     { species: 'Felis Stultus', name: 'Billie' } ] }
+```
+
+## API
+
+### `appendField(store, key, value)`
+
+Adds the field named `key` with the value `value` to the object `store`.
+
+## License
+
+MIT

+var parsePath = require('./lib/parse-path')
+var setValue = require('./lib/set-value')
+
+function appendField (store, key, value) {
+  var steps = parsePath(key)
+
+  steps.reduce(function (context, step) {
+    return setValue(context, step, context[step.key], value)
+  }, store)
+}
+
+module.exports = appendField

+var reFirstKey = /^[^\[]*/
+var reDigitPath = /^\[(\d+)\]/
+var reNormalPath = /^\[([^\]]+)\]/
+
+function parsePath (key) {
+  function failure () {
+    return [{ type: 'object', key: key, last: true }]
+  }
+
+  var firstKey = reFirstKey.exec(key)[0]
+  if (!firstKey) return failure()
+
+  var len = key.length
+  var pos = firstKey.length
+  var tail = { type: 'object', key: firstKey }
+  var steps = [tail]
+
+  while (pos < len) {
+    var m
+
+    if (key[pos] === '[' && key[pos + 1] === ']') {
+      pos += 2
+      tail.append = true
+      if (pos !== len) return failure()
+      continue
+    }
+
+    m = reDigitPath.exec(key.substring(pos))
+    if (m !== null) {
+      pos += m[0].length
+      tail.nextType = 'array'
+      tail = { type: 'array', key: parseInt(m[1], 10) }
+      steps.push(tail)
+      continue
+    }
+
+    m = reNormalPath.exec(key.substring(pos))
+    if (m !== null) {
+      pos += m[0].length
+      tail.nextType = 'object'
+      tail = { type: 'object', key: m[1] }
+      steps.push(tail)
+      continue
+    }
+
+    return failure()
+  }
+
+  tail.last = true
+  return steps
+}
+
+module.exports = parsePath

+function valueType (value) {
+  if (value === undefined) return 'undefined'
+  if (Array.isArray(value)) return 'array'
+  if (typeof value === 'object') return 'object'
+  return 'scalar'
+}
+
+function setLastValue (context, step, currentValue, entryValue) {
+  switch (valueType(currentValue)) {
+    case 'undefined':
+      if (step.append) {
+        context[step.key] = [entryValue]
+      } else {
+        context[step.key] = entryValue
+      }
+      break
+    case 'array':
+      context[step.key].push(entryValue)
+      break
+    case 'object':
+      return setLastValue(currentValue, { type: 'object', key: '', last: true }, currentValue[''], entryValue)
+    case 'scalar':
+      context[step.key] = [context[step.key], entryValue]
+      break
+  }
+
+  return context
+}
+
+function setValue (context, step, currentValue, entryValue) {
+  if (step.last) return setLastValue(context, step, currentValue, entryValue)
+
+  var obj
+  switch (valueType(currentValue)) {
+    case 'undefined':
+      if (step.nextType === 'array') {
+        context[step.key] = []
+      } else {
+        context[step.key] = Object.create(null)
+      }
+      return context[step.key]
+    case 'object':
+      return context[step.key]
+    case 'array':
+      if (step.nextType === 'array') {
+        return currentValue
+      }
+
+      obj = Object.create(null)
+      context[step.key] = obj
+      currentValue.forEach(function (item, i) {
+        if (item !== undefined) obj['' + i] = item
+      })
+
+      return obj
+    case 'scalar':
+      obj = Object.create(null)
+      obj[''] = currentValue
+      context[step.key] = obj
+      return obj
+  }
+}
+
+module.exports = setValue

+{
+  "_from": "append-field@^1.0.0",
+  "_id": "append-field@1.0.0",
+  "_inBundle": false,
+  "_integrity": "sha1-HjRA6RXwsSA9I3SOeO3XubW0PlY=",
+  "_location": "/append-field",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "append-field@^1.0.0",
+    "name": "append-field",
+    "escapedName": "append-field",
+    "rawSpec": "^1.0.0",
+    "saveSpec": null,
+    "fetchSpec": "^1.0.0"
+  },
+  "_requiredBy": [
+    "/multer"
+  ],
+  "_resolved": "https://registry.npmjs.org/append-field/-/append-field-1.0.0.tgz",
+  "_shasum": "1e3440e915f0b1203d23748e78edd7b9b5b43e56",
+  "_spec": "append-field@^1.0.0",
+  "_where": "C:\\Users\\1000c\\이것저것\\옾소\\Voicoding\\node_modules\\multer",
+  "author": {
+    "name": "Linus Unnebäck",
+    "email": "linus@folkdatorn.se"
+  },
+  "bugs": {
+    "url": "https://github.com/LinusU/node-append-field/issues"
+  },
+  "bundleDependencies": false,
+  "deprecated": false,
+  "description": "A [W3C HTML JSON forms spec](http://www.w3.org/TR/html-json-forms/) compliant field appender (for lack of a better name). Useful for people implementing `application/x-www-form-urlencoded` and `multipart/form-data` parsers.",
+  "devDependencies": {
+    "mocha": "^2.2.4",
+    "standard": "^6.0.5",
+    "testdata-w3c-json-form": "^0.2.0"
+  },
+  "homepage": "https://github.com/LinusU/node-append-field#readme",
+  "license": "MIT",
+  "main": "index.js",
+  "name": "append-field",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/LinusU/node-append-field.git"
+  },
+  "scripts": {
+    "test": "standard && mocha"
+  },
+  "version": "1.0.0"
+}

+/* eslint-env mocha */
+
+var assert = require('assert')
+var appendField = require('../')
+var testData = require('testdata-w3c-json-form')
+
+describe('Append Field', function () {
+  for (var test of testData) {
+    it('handles ' + test.name, function () {
+      var store = Object.create(null)
+
+      for (var field of test.fields) {
+        appendField(store, field.key, field.value)
+      }
+
+      assert.deepEqual(store, test.expected)
+    })
+  }
+})

+MIT License
+
+Copyright (c) 2016, 2018 Linus Unnebäck
+
+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.

+var toString = Object.prototype.toString
+
+var isModern = (
+  typeof Buffer.alloc === 'function' &&
+  typeof Buffer.allocUnsafe === 'function' &&
+  typeof Buffer.from === 'function'
+)
+
+function isArrayBuffer (input) {
+  return toString.call(input).slice(8, -1) === 'ArrayBuffer'
+}
+
+function fromArrayBuffer (obj, byteOffset, length) {
+  byteOffset >>>= 0
+
+  var maxLength = obj.byteLength - byteOffset
+
+  if (maxLength < 0) {
+    throw new RangeError("'offset' is out of bounds")
+  }
+
+  if (length === undefined) {
+    length = maxLength
+  } else {
+    length >>>= 0
+
+    if (length > maxLength) {
+      throw new RangeError("'length' is out of bounds")
+    }
+  }
+
+  return isModern
+    ? Buffer.from(obj.slice(byteOffset, byteOffset + length))
+    : new Buffer(new Uint8Array(obj.slice(byteOffset, byteOffset + length)))
+}
+
+function fromString (string, encoding) {
+  if (typeof encoding !== 'string' || encoding === '') {
+    encoding = 'utf8'
+  }
+
+  if (!Buffer.isEncoding(encoding)) {
+    throw new TypeError('"encoding" must be a valid string encoding')
+  }
+
+  return isModern
+    ? Buffer.from(string, encoding)
+    : new Buffer(string, encoding)
+}
+
+function bufferFrom (value, encodingOrOffset, length) {
+  if (typeof value === 'number') {
+    throw new TypeError('"value" argument must not be a number')
+  }
+
+  if (isArrayBuffer(value)) {
+    return fromArrayBuffer(value, encodingOrOffset, length)
+  }
+
+  if (typeof value === 'string') {
+    return fromString(value, encodingOrOffset)
+  }
+
+  return isModern
+    ? Buffer.from(value)
+    : new Buffer(value)
+}
+
+module.exports = bufferFrom

+{
+  "_from": "buffer-from@^1.0.0",
+  "_id": "buffer-from@1.1.1",
+  "_inBundle": false,
+  "_integrity": "sha512-MQcXEUbCKtEo7bhqEs6560Hyd4XaovZlO/k9V3hjVUF/zwW7KBVdSK4gIt/bzwS9MbR5qob+F5jusZsb0YQK2A==",
+  "_location": "/buffer-from",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "buffer-from@^1.0.0",
+    "name": "buffer-from",
+    "escapedName": "buffer-from",
+    "rawSpec": "^1.0.0",
+    "saveSpec": null,
+    "fetchSpec": "^1.0.0"
+  },
+  "_requiredBy": [
+    "/concat-stream"
+  ],
+  "_resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.1.tgz",
+  "_shasum": "32713bc028f75c02fdb710d7c7bcec1f2c6070ef",
+  "_spec": "buffer-from@^1.0.0",
+  "_where": "C:\\Users\\1000c\\이것저것\\옾소\\Voicoding\\node_modules\\concat-stream",
+  "bugs": {
+    "url": "https://github.com/LinusU/buffer-from/issues"
+  },
+  "bundleDependencies": false,
+  "deprecated": false,
+  "description": "A [ponyfill](https://ponyfill.com) for `Buffer.from`, uses native implementation if available.",
+  "devDependencies": {
+    "standard": "^7.1.2"
+  },
+  "files": [
+    "index.js"
+  ],
+  "homepage": "https://github.com/LinusU/buffer-from#readme",
+  "keywords": [
+    "buffer",
+    "buffer from"
+  ],
+  "license": "MIT",
+  "name": "buffer-from",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/LinusU/buffer-from.git"
+  },
+  "scripts": {
+    "test": "standard && node test"
+  },
+  "version": "1.1.1"
+}

+# Buffer From
+
+A [ponyfill](https://ponyfill.com) for `Buffer.from`, uses native implementation if available.
+
+## Installation
+
+```sh
+npm install --save buffer-from
+```
+
+## Usage
+
+```js
+const bufferFrom = require('buffer-from')
+
+console.log(bufferFrom([1, 2, 3, 4]))
+//=> <Buffer 01 02 03 04>
+
+const arr = new Uint8Array([1, 2, 3, 4])
+console.log(bufferFrom(arr.buffer, 1, 2))
+//=> <Buffer 02 03>
+
+console.log(bufferFrom('test', 'utf8'))
+//=> <Buffer 74 65 73 74>
+
+const buf = bufferFrom('test')
+console.log(bufferFrom(buf))
+//=> <Buffer 74 65 73 74>
+```
+
+## API
+
+### bufferFrom(array)
+
+- `array` &lt;Array&gt;
+
+Allocates a new `Buffer` using an `array` of octets.
+
+### bufferFrom(arrayBuffer[, byteOffset[, length]])
+
+- `arrayBuffer` &lt;ArrayBuffer&gt; The `.buffer` property of a TypedArray or ArrayBuffer
+- `byteOffset` &lt;Integer&gt; Where to start copying from `arrayBuffer`. **Default:** `0`
+- `length` &lt;Integer&gt; How many bytes to copy from `arrayBuffer`. **Default:** `arrayBuffer.length - byteOffset`
+
+When passed a reference to the `.buffer` property of a TypedArray instance, the
+newly created `Buffer` will share the same allocated memory as the TypedArray.
+
+The optional `byteOffset` and `length` arguments specify a memory range within
+the `arrayBuffer` that will be shared by the `Buffer`.
+
+### bufferFrom(buffer)
+
+- `buffer` &lt;Buffer&gt; An existing `Buffer` to copy data from
+
+Copies the passed `buffer` data onto a new `Buffer` instance.
+
+### bufferFrom(string[, encoding])
+
+- `string` &lt;String&gt; A string to encode.
+- `encoding` &lt;String&gt; The encoding of `string`. **Default:** `'utf8'`
+
+Creates a new `Buffer` containing the given JavaScript string `string`. If
+provided, the `encoding` parameter identifies the character encoding of
+`string`.
+
+## See also
+
+- [buffer-alloc](https://github.com/LinusU/buffer-alloc) A ponyfill for `Buffer.alloc`
+- [buffer-alloc-unsafe](https://github.com/LinusU/buffer-alloc-unsafe) A ponyfill for `Buffer.allocUnsafe`

+sudo: false
+language: cpp
+notifications:
+  email: false
+env:
+  matrix:
+  - TRAVIS_NODE_VERSION="0.10"
+  - TRAVIS_NODE_VERSION="0.12"
+  - TRAVIS_NODE_VERSION="4"
+  - TRAVIS_NODE_VERSION="6"
+  - TRAVIS_NODE_VERSION="7"
+install:
+  - rm -rf ~/.nvm && git clone https://github.com/creationix/nvm.git ~/.nvm && source ~/.nvm/nvm.sh && nvm install $TRAVIS_NODE_VERSION
+  - node --version
+  - npm --version
+  - npm install
+script: npm test

+Copyright Brian White. All rights reserved.
+
+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.
\ No newline at end of file

+Description
+===========
+
+A node.js module for parsing incoming HTML form data.
+
+If you've found this module to be useful and wish to support it, you may do so by visiting this pledgie campaign:
+<a href='https://pledgie.com/campaigns/28774'><img alt='Click here to support busboy' src='https://pledgie.com/campaigns/28774.png?skin_name=chrome' border='0'></a>
+
+
+Requirements
+============
+
+* [node.js](http://nodejs.org/) -- v0.8.0 or newer
+
+
+Install
+=======
+
+    npm install busboy
+
+
+Examples
+========
+
+* Parsing (multipart) with default options:
+
+```javascript
+var http = require('http'),
+    inspect = require('util').inspect;
+
+var Busboy = require('busboy');
+
+http.createServer(function(req, res) {
+  if (req.method === 'POST') {
+    var busboy = new Busboy({ headers: req.headers });
+    busboy.on('file', function(fieldname, file, filename, encoding, mimetype) {
+      console.log('File [' + fieldname + ']: filename: ' + filename + ', encoding: ' + encoding + ', mimetype: ' + mimetype);
+      file.on('data', function(data) {
+        console.log('File [' + fieldname + '] got ' + data.length + ' bytes');
+      });
+      file.on('end', function() {
+        console.log('File [' + fieldname + '] Finished');
+      });
+    });
+    busboy.on('field', function(fieldname, val, fieldnameTruncated, valTruncated, encoding, mimetype) {
+      console.log('Field [' + fieldname + ']: value: ' + inspect(val));
+    });
+    busboy.on('finish', function() {
+      console.log('Done parsing form!');
+      res.writeHead(303, { Connection: 'close', Location: '/' });
+      res.end();
+    });
+    req.pipe(busboy);
+  } else if (req.method === 'GET') {
+    res.writeHead(200, { Connection: 'close' });
+    res.end('<html><head></head><body>\
+               <form method="POST" enctype="multipart/form-data">\
+                <input type="text" name="textfield"><br />\
+                <input type="file" name="filefield"><br />\
+                <input type="submit">\
+              </form>\
+            </body></html>');
+  }
+}).listen(8000, function() {
+  console.log('Listening for requests');
+});
+
+// Example output, using http://nodejs.org/images/ryan-speaker.jpg as the file:
+//
+// Listening for requests
+// File [filefield]: filename: ryan-speaker.jpg, encoding: binary
+// File [filefield] got 11971 bytes
+// Field [textfield]: value: 'testing! :-)'
+// File [filefield] Finished
+// Done parsing form!
+```
+
+* Save all incoming files to disk:
+
+```javascript
+var http = require('http'),
+    path = require('path'),
+    os = require('os'),
+    fs = require('fs');
+
+var Busboy = require('busboy');
+
+http.createServer(function(req, res) {
+  if (req.method === 'POST') {
+    var busboy = new Busboy({ headers: req.headers });
+    busboy.on('file', function(fieldname, file, filename, encoding, mimetype) {
+      var saveTo = path.join(os.tmpDir(), path.basename(fieldname));
+      file.pipe(fs.createWriteStream(saveTo));
+    });
+    busboy.on('finish', function() {
+      res.writeHead(200, { 'Connection': 'close' });
+      res.end("That's all folks!");
+    });
+    return req.pipe(busboy);
+  }
+  res.writeHead(404);
+  res.end();
+}).listen(8000, function() {
+  console.log('Listening for requests');
+});
+```
+
+* Parsing (urlencoded) with default options:
+
+```javascript
+var http = require('http'),
+    inspect = require('util').inspect;
+
+var Busboy = require('busboy');
+
+http.createServer(function(req, res) {
+  if (req.method === 'POST') {
+    var busboy = new Busboy({ headers: req.headers });
+    busboy.on('file', function(fieldname, file, filename, encoding, mimetype) {
+      console.log('File [' + fieldname + ']: filename: ' + filename);
+      file.on('data', function(data) {
+        console.log('File [' + fieldname + '] got ' + data.length + ' bytes');
+      });
+      file.on('end', function() {
+        console.log('File [' + fieldname + '] Finished');
+      });
+    });
+    busboy.on('field', function(fieldname, val, fieldnameTruncated, valTruncated) {
+      console.log('Field [' + fieldname + ']: value: ' + inspect(val));
+    });
+    busboy.on('finish', function() {
+      console.log('Done parsing form!');
+      res.writeHead(303, { Connection: 'close', Location: '/' });
+      res.end();
+    });
+    req.pipe(busboy);
+  } else if (req.method === 'GET') {
+    res.writeHead(200, { Connection: 'close' });
+    res.end('<html><head></head><body>\
+               <form method="POST">\
+                <input type="text" name="textfield"><br />\
+                <select name="selectfield">\
+                  <option value="1">1</option>\
+                  <option value="10">10</option>\
+                  <option value="100">100</option>\
+                  <option value="9001">9001</option>\
+                </select><br />\
+                <input type="checkbox" name="checkfield">Node.js rules!<br />\
+                <input type="submit">\
+              </form>\
+            </body></html>');
+  }
+}).listen(8000, function() {
+  console.log('Listening for requests');
+});
+
+// Example output:
+//
+// Listening for requests
+// Field [textfield]: value: 'testing! :-)'
+// Field [selectfield]: value: '9001'
+// Field [checkfield]: value: 'on'
+// Done parsing form!
+```
+
+
+API
+===
+
+_Busboy_ is a _Writable_ stream
+
+Busboy (special) events
+-----------------------
+
+* **file**(< _string_ >fieldname, < _ReadableStream_ >stream, < _string_ >filename, < _string_ >transferEncoding, < _string_ >mimeType) - Emitted for each new file form field found. `transferEncoding` contains the 'Content-Transfer-Encoding' value for the file stream. `mimeType` contains the 'Content-Type' value for the file stream.
+    * Note: if you listen for this event, you should always handle the `stream` no matter if you care about the file contents or not (e.g. you can simply just do `stream.resume();` if you want to discard the contents), otherwise the 'finish' event will never fire on the Busboy instance. However, if you don't care about **any** incoming files, you can simply not listen for the 'file' event at all and any/all files will be automatically and safely discarded (these discarded files do still count towards `files` and `parts` limits).
+    * If a configured file size limit was reached, `stream` will both have a boolean property `truncated` (best checked at the end of the stream) and emit a 'limit' event to notify you when this happens.
+
+* **field**(< _string_ >fieldname, < _string_ >value, < _boolean_ >fieldnameTruncated, < _boolean_ >valueTruncated, < _string_ >transferEncoding, < _string_ >mimeType) - Emitted for each new non-file field found.
+
+* **partsLimit**() - Emitted when specified `parts` limit has been reached. No more 'file' or 'field' events will be emitted.
+
+* **filesLimit**() - Emitted when specified `files` limit has been reached. No more 'file' events will be emitted.
+
+* **fieldsLimit**() - Emitted when specified `fields` limit has been reached. No more 'field' events will be emitted.
+
+
+Busboy methods
+--------------
+
+* **(constructor)**(< _object_ >config) - Creates and returns a new Busboy instance.
+
+    * The constructor takes the following valid `config` settings:
+
+        * **headers** - _object_ - These are the HTTP headers of the incoming request, which are used by individual parsers.
+
+        * **highWaterMark** - _integer_ - highWaterMark to use for this Busboy instance (Default: WritableStream default).
+
+        * **fileHwm** - _integer_ - highWaterMark to use for file streams (Default: ReadableStream default).
+
+        * **defCharset** - _string_ - Default character set to use when one isn't defined (Default: 'utf8').
+
+        * **preservePath** - _boolean_ - If paths in the multipart 'filename' field shall be preserved. (Default: false).
+
+        * **limits** - _object_ - Various limits on incoming data. Valid properties are:
+
+            * **fieldNameSize** - _integer_ - Max field name size (in bytes) (Default: 100 bytes).
+
+            * **fieldSize** - _integer_ - Max field value size (in bytes) (Default: 1MB).
+
+            * **fields** - _integer_ - Max number of non-file fields (Default: Infinity).
+
+            * **fileSize** - _integer_ - For multipart forms, the max file size (in bytes) (Default: Infinity).
+
+            * **files** - _integer_ - For multipart forms, the max number of file fields (Default: Infinity).
+
+            * **parts** - _integer_ - For multipart forms, the max number of parts (fields + files) (Default: Infinity).
+
+            * **headerPairs** - _integer_ - For multipart forms, the max number of header key=>value pairs to parse **Default:** 2000 (same as node's http).
+
+    * The constructor can throw errors:
+
+        * **Unsupported content type: $type** - The `Content-Type` isn't one Busboy can parse.
+
+        * **Missing Content-Type** - The provided headers don't include `Content-Type` at all.

+var fs = require('fs'),
+    WritableStream = require('stream').Writable
+                     || require('readable-stream').Writable,
+    inherits = require('util').inherits;
+
+var parseParams = require('./utils').parseParams;
+
+function Busboy(opts) {
+  if (!(this instanceof Busboy))
+    return new Busboy(opts);
+  if (opts.highWaterMark !== undefined)
+    WritableStream.call(this, { highWaterMark: opts.highWaterMark });
+  else
+    WritableStream.call(this);
+
+  this._done = false;
+  this._parser = undefined;
+  this._finished = false;
+
+  this.opts = opts;
+  if (opts.headers && typeof opts.headers['content-type'] === 'string')
+    this.parseHeaders(opts.headers);
+  else
+    throw new Error('Missing Content-Type');
+}
+inherits(Busboy, WritableStream);
+
+Busboy.prototype.emit = function(ev) {
+  if (ev === 'finish') {
+    if (!this._done) {
+      this._parser && this._parser.end();
+      return;
+    } else if (this._finished) {
+      return;
+    }
+    this._finished = true;
+  }
+  WritableStream.prototype.emit.apply(this, arguments);
+};
+
+Busboy.prototype.parseHeaders = function(headers) {
+  this._parser = undefined;
+  if (headers['content-type']) {
+    var parsed = parseParams(headers['content-type']),
+        matched, type;
+    for (var i = 0; i < TYPES.length; ++i) {
+      type = TYPES[i];
+      if (typeof type.detect === 'function')
+        matched = type.detect(parsed);
+      else
+        matched = type.detect.test(parsed[0]);
+      if (matched)
+        break;
+    }
+    if (matched) {
+      var cfg = {
+        limits: this.opts.limits,
+        headers: headers,
+        parsedConType: parsed,
+        highWaterMark: undefined,
+        fileHwm: undefined,
+        defCharset: undefined,
+        preservePath: false
+      };
+      if (this.opts.highWaterMark)
+        cfg.highWaterMark = this.opts.highWaterMark;
+      if (this.opts.fileHwm)
+        cfg.fileHwm = this.opts.fileHwm;
+      cfg.defCharset = this.opts.defCharset;
+      cfg.preservePath = this.opts.preservePath;
+      this._parser = type(this, cfg);
+      return;
+    }
+  }
+  throw new Error('Unsupported content type: ' + headers['content-type']);
+};
+
+Busboy.prototype._write = function(chunk, encoding, cb) {
+  if (!this._parser)
+    return cb(new Error('Not ready to parse. Missing Content-Type?'));
+  this._parser.write(chunk, cb);
+};
+
+var TYPES = [
+  require('./types/multipart'),
+  require('./types/urlencoded'),
+];
+
+module.exports = Busboy;

+// TODO:
+//  * support 1 nested multipart level
+//    (see second multipart example here:
+//     http://www.w3.org/TR/html401/interact/forms.html#didx-multipartform-data)
+//  * support limits.fieldNameSize
+//     -- this will require modifications to utils.parseParams
+
+var ReadableStream = require('stream').Readable || require('readable-stream'),
+    inherits = require('util').inherits;
+
+var Dicer = require('dicer');
+
+var parseParams = require('../utils').parseParams,
+    decodeText = require('../utils').decodeText,
+    basename = require('../utils').basename;
+
+var RE_BOUNDARY = /^boundary$/i,
+    RE_FIELD = /^form-data$/i,
+    RE_CHARSET = /^charset$/i,
+    RE_FILENAME = /^filename$/i,
+    RE_NAME = /^name$/i;
+
+Multipart.detect = /^multipart\/form-data/i;
+function Multipart(boy, cfg) {
+  if (!(this instanceof Multipart))
+    return new Multipart(boy, cfg);
+  var i,
+      len,
+      self = this,
+      boundary,
+      limits = cfg.limits,
+      parsedConType = cfg.parsedConType || [],
+      defCharset = cfg.defCharset || 'utf8',
+      preservePath = cfg.preservePath,
+      fileopts = (typeof cfg.fileHwm === 'number'
+                  ? { highWaterMark: cfg.fileHwm }
+                  : {});
+
+  for (i = 0, len = parsedConType.length; i < len; ++i) {
+    if (Array.isArray(parsedConType[i])
+        && RE_BOUNDARY.test(parsedConType[i][0])) {
+      boundary = parsedConType[i][1];
+      break;
+    }
+  }
+
+  function checkFinished() {
+    if (nends === 0 && finished && !boy._done) {
+      finished = false;
+      process.nextTick(function() {
+        boy._done = true;
+        boy.emit('finish');
+      });
+    }
+  }
+
+  if (typeof boundary !== 'string')
+    throw new Error('Multipart: Boundary not found');
+
+  var fieldSizeLimit = (limits && typeof limits.fieldSize === 'number'
+                        ? limits.fieldSize
+                        : 1 * 1024 * 1024),
+      fileSizeLimit = (limits && typeof limits.fileSize === 'number'
+                       ? limits.fileSize
+                       : Infinity),
+      filesLimit = (limits && typeof limits.files === 'number'
+                    ? limits.files
+                    : Infinity),
+      fieldsLimit = (limits && typeof limits.fields === 'number'
+                     ? limits.fields
+                     : Infinity),
+      partsLimit = (limits && typeof limits.parts === 'number'
+                    ? limits.parts
+                    : Infinity);
+
+  var nfiles = 0,
+      nfields = 0,
+      nends = 0,
+      curFile,
+      curField,
+      finished = false;
+
+  this._needDrain = false;
+  this._pause = false;
+  this._cb = undefined;
+  this._nparts = 0;
+  this._boy = boy;
+
+  var parserCfg = {
+    boundary: boundary,
+    maxHeaderPairs: (limits && limits.headerPairs)
+  };
+  if (fileopts.highWaterMark)
+    parserCfg.partHwm = fileopts.highWaterMark;
+  if (cfg.highWaterMark)
+    parserCfg.highWaterMark = cfg.highWaterMark;
+
+  this.parser = new Dicer(parserCfg);
+  this.parser.on('drain', function() {
+    self._needDrain = false;
+    if (self._cb && !self._pause) {
+      var cb = self._cb;
+      self._cb = undefined;
+      cb();
+    }
+  }).on('part', function onPart(part) {
+    if (++self._nparts > partsLimit) {
+      self.parser.removeListener('part', onPart);
+      self.parser.on('part', skipPart);
+      boy.hitPartsLimit = true;
+      boy.emit('partsLimit');
+      return skipPart(part);
+    }
+
+    // hack because streams2 _always_ doesn't emit 'end' until nextTick, so let
+    // us emit 'end' early since we know the part has ended if we are already
+    // seeing the next part
+    if (curField) {
+      var field = curField;
+      field.emit('end');
+      field.removeAllListeners('end');
+    }
+
+    part.on('header', function(header) {
+      var contype,
+          fieldname,
+          parsed,
+          charset,
+          encoding,
+          filename,
+          nsize = 0;
+
+      if (header['content-type']) {
+        parsed = parseParams(header['content-type'][0]);
+        if (parsed[0]) {
+          contype = parsed[0].toLowerCase();
+          for (i = 0, len = parsed.length; i < len; ++i) {
+            if (RE_CHARSET.test(parsed[i][0])) {
+              charset = parsed[i][1].toLowerCase();
+              break;
+            }
+          }
+        }
+      }
+
+      if (contype === undefined)
+        contype = 'text/plain';
+      if (charset === undefined)
+        charset = defCharset;
+
+      if (header['content-disposition']) {
+        parsed = parseParams(header['content-disposition'][0]);
+        if (!RE_FIELD.test(parsed[0]))
+          return skipPart(part);
+        for (i = 0, len = parsed.length; i < len; ++i) {
+          if (RE_NAME.test(parsed[i][0])) {
+            fieldname = decodeText(parsed[i][1], 'binary', 'utf8');
+          } else if (RE_FILENAME.test(parsed[i][0])) {
+            filename = decodeText(parsed[i][1], 'binary', 'utf8');
+            if (!preservePath)
+              filename = basename(filename);
+          }
+        }
+      } else
+        return skipPart(part);
+
+      if (header['content-transfer-encoding'])
+        encoding = header['content-transfer-encoding'][0].toLowerCase();
+      else
+        encoding = '7bit';
+
+      var onData,
+          onEnd;
+      if (contype === 'application/octet-stream' || filename !== undefined) {
+        // file/binary field
+        if (nfiles === filesLimit) {
+          if (!boy.hitFilesLimit) {
+            boy.hitFilesLimit = true;
+            boy.emit('filesLimit');
+          }
+          return skipPart(part);
+        }
+
+        ++nfiles;
+
+        if (!boy._events.file) {
+          self.parser._ignore();
+          return;
+        }
+
+        ++nends;
+        var file = new FileStream(fileopts);
+        curFile = file;
+        file.on('end', function() {
+          --nends;
+          checkFinished();
+          if (self._cb && !self._needDrain) {
+            var cb = self._cb;
+            self._cb = undefined;
+            cb();
+          }
+        });
+        file._read = function(n) {
+          if (!self._pause)
+            return;
+          self._pause = false;
+          if (self._cb && !self._needDrain) {
+            var cb = self._cb;
+            self._cb = undefined;
+            cb();
+          }
+        };
+        boy.emit('file', fieldname, file, filename, encoding, contype);
+
+        onData = function(data) {
+          if ((nsize += data.length) > fileSizeLimit) {
+            var extralen = (fileSizeLimit - (nsize - data.length));
+            if (extralen > 0)
+              file.push(data.slice(0, extralen));
+            file.emit('limit');
+            file.truncated = true;
+            part.removeAllListeners('data');
+          } else if (!file.push(data))
+            self._pause = true;
+        };
+
+        onEnd = function() {
+          curFile = undefined;
+          file.push(null);
+        };
+      } else {
+        // non-file field
+        if (nfields === fieldsLimit) {
+          if (!boy.hitFieldsLimit) {
+            boy.hitFieldsLimit = true;
+            boy.emit('fieldsLimit');
+          }
+          return skipPart(part);
+        }
+
+        ++nfields;
+        ++nends;
+        var buffer = '',
+            truncated = false;
+        curField = part;
+
+        onData = function(data) {
+          if ((nsize += data.length) > fieldSizeLimit) {
+            var extralen = (fieldSizeLimit - (nsize - data.length));
+            buffer += data.toString('binary', 0, extralen);
+            truncated = true;
+            part.removeAllListeners('data');
+          } else
+            buffer += data.toString('binary');
+        };
+
+        onEnd = function() {
+          curField = undefined;
+          if (buffer.length)
+            buffer = decodeText(buffer, 'binary', charset);
+          boy.emit('field', fieldname, buffer, false, truncated, encoding, contype);
+          --nends;
+          checkFinished();
+        };
+      }
+
+      /* As of node@2efe4ab761666 (v0.10.29+/v0.11.14+), busboy had become
+         broken. Streams2/streams3 is a huge black box of confusion, but
+         somehow overriding the sync state seems to fix things again (and still
+         seems to work for previous node versions).
+      */
+      part._readableState.sync = false;
+
+      part.on('data', onData);
+      part.on('end', onEnd);
+    }).on('error', function(err) {
+      if (curFile)
+        curFile.emit('error', err);
+    });
+  }).on('error', function(err) {
+    boy.emit('error', err);
+  }).on('finish', function() {
+    finished = true;
+    checkFinished();
+  });
+}
+
+Multipart.prototype.write = function(chunk, cb) {
+  var r;
+  if ((r = this.parser.write(chunk)) && !this._pause)
+    cb();
+  else {
+    this._needDrain = !r;
+    this._cb = cb;
+  }
+};
+
+Multipart.prototype.end = function() {
+  var self = this;
+  if (this._nparts === 0 && !self._boy._done) {
+    process.nextTick(function() {
+      self._boy._done = true;
+      self._boy.emit('finish');
+    });
+  } else if (this.parser.writable)
+    this.parser.end();
+};
+
+function skipPart(part) {
+  part.resume();
+}
+
+function FileStream(opts) {
+  if (!(this instanceof FileStream))
+    return new FileStream(opts);
+  ReadableStream.call(this, opts);
+
+  this.truncated = false;
+}
+inherits(FileStream, ReadableStream);
+
+FileStream.prototype._read = function(n) {};
+
+module.exports = Multipart;

+var Decoder = require('../utils').Decoder,
+    decodeText = require('../utils').decodeText;
+
+var RE_CHARSET = /^charset$/i;
+
+UrlEncoded.detect = /^application\/x-www-form-urlencoded/i;
+function UrlEncoded(boy, cfg) {
+  if (!(this instanceof UrlEncoded))
+    return new UrlEncoded(boy, cfg);
+  var limits = cfg.limits,
+      headers = cfg.headers,
+      parsedConType = cfg.parsedConType;
+  this.boy = boy;
+
+  this.fieldSizeLimit = (limits && typeof limits.fieldSize === 'number'
+                         ? limits.fieldSize
+                         : 1 * 1024 * 1024);
+  this.fieldNameSizeLimit = (limits && typeof limits.fieldNameSize === 'number'
+                             ? limits.fieldNameSize
+                             : 100);
+  this.fieldsLimit = (limits && typeof limits.fields === 'number'
+                      ? limits.fields
+                      : Infinity);
+
+  var charset;
+  for (var i = 0, len = parsedConType.length; i < len; ++i) {
+    if (Array.isArray(parsedConType[i])
+        && RE_CHARSET.test(parsedConType[i][0])) {
+      charset = parsedConType[i][1].toLowerCase();
+      break;
+    }
+  }
+
+  if (charset === undefined)
+    charset = cfg.defCharset || 'utf8';
+
+  this.decoder = new Decoder();
+  this.charset = charset;
+  this._fields = 0;
+  this._state = 'key';
+  this._checkingBytes = true;
+  this._bytesKey = 0;
+  this._bytesVal = 0;
+  this._key = '';
+  this._val = '';
+  this._keyTrunc = false;
+  this._valTrunc = false;
+  this._hitlimit = false;
+}
+
+UrlEncoded.prototype.write = function(data, cb) {
+  if (this._fields === this.fieldsLimit) {
+    if (!this.boy.hitFieldsLimit) {
+      this.boy.hitFieldsLimit = true;
+      this.boy.emit('fieldsLimit');
+    }
+    return cb();
+  }
+
+  var idxeq, idxamp, i, p = 0, len = data.length;
+
+  while (p < len) {
+    if (this._state === 'key') {
+      idxeq = idxamp = undefined;
+      for (i = p; i < len; ++i) {
+        if (!this._checkingBytes)
+          ++p;
+        if (data[i] === 0x3D/*=*/) {
+          idxeq = i;
+          break;
+        } else if (data[i] === 0x26/*&*/) {
+          idxamp = i;
+          break;
+        }
+        if (this._checkingBytes && this._bytesKey === this.fieldNameSizeLimit) {
+          this._hitLimit = true;
+          break;
+        } else if (this._checkingBytes)
+          ++this._bytesKey;
+      }
+
+      if (idxeq !== undefined) {
+        // key with assignment
+        if (idxeq > p)
+          this._key += this.decoder.write(data.toString('binary', p, idxeq));
+        this._state = 'val';
+
+        this._hitLimit = false;
+        this._checkingBytes = true;
+        this._val = '';
+        this._bytesVal = 0;
+        this._valTrunc = false;
+        this.decoder.reset();
+
+        p = idxeq + 1;
+      } else if (idxamp !== undefined) {
+        // key with no assignment
+        ++this._fields;
+        var key, keyTrunc = this._keyTrunc;
+        if (idxamp > p)
+          key = (this._key += this.decoder.write(data.toString('binary', p, idxamp)));
+        else
+          key = this._key;
+
+        this._hitLimit = false;
+        this._checkingBytes = true;
+        this._key = '';
+        this._bytesKey = 0;
+        this._keyTrunc = false;
+        this.decoder.reset();
+
+        if (key.length) {
+          this.boy.emit('field', decodeText(key, 'binary', this.charset),
+                                 '',
+                                 keyTrunc,
+                                 false);
+        }
+
+        p = idxamp + 1;
+        if (this._fields === this.fieldsLimit)
+          return cb();
+      } else if (this._hitLimit) {
+        // we may not have hit the actual limit if there are encoded bytes...
+        if (i > p)
+          this._key += this.decoder.write(data.toString('binary', p, i));
+        p = i;
+        if ((this._bytesKey = this._key.length) === this.fieldNameSizeLimit) {
+          // yep, we actually did hit the limit
+          this._checkingBytes = false;
+          this._keyTrunc = true;
+        }
+      } else {
+        if (p < len)
+          this._key += this.decoder.write(data.toString('binary', p));
+        p = len;
+      }
+    } else {
+      idxamp = undefined;
+      for (i = p; i < len; ++i) {
+        if (!this._checkingBytes)
+          ++p;
+        if (data[i] === 0x26/*&*/) {
+          idxamp = i;
+          break;
+        }
+        if (this._checkingBytes && this._bytesVal === this.fieldSizeLimit) {
+          this._hitLimit = true;
+          break;
+        }
+        else if (this._checkingBytes)
+          ++this._bytesVal;
+      }
+
+      if (idxamp !== undefined) {
+        ++this._fields;
+        if (idxamp > p)
+          this._val += this.decoder.write(data.toString('binary', p, idxamp));
+        this.boy.emit('field', decodeText(this._key, 'binary', this.charset),
+                               decodeText(this._val, 'binary', this.charset),
+                               this._keyTrunc,
+                               this._valTrunc);
+        this._state = 'key';
+
+        this._hitLimit = false;
+        this._checkingBytes = true;
+        this._key = '';
+        this._bytesKey = 0;
+        this._keyTrunc = false;
+        this.decoder.reset();
+
+        p = idxamp + 1;
+        if (this._fields === this.fieldsLimit)
+          return cb();
+      } else if (this._hitLimit) {
+        // we may not have hit the actual limit if there are encoded bytes...
+        if (i > p)
+          this._val += this.decoder.write(data.toString('binary', p, i));
+        p = i;
+        if ((this._val === '' && this.fieldSizeLimit === 0)
+            || (this._bytesVal = this._val.length) === this.fieldSizeLimit) {
+          // yep, we actually did hit the limit
+          this._checkingBytes = false;
+          this._valTrunc = true;
+        }
+      } else {
+        if (p < len)
+          this._val += this.decoder.write(data.toString('binary', p));
+        p = len;
+      }
+    }
+  }
+  cb();
+};
+
+UrlEncoded.prototype.end = function() {
+  if (this.boy._done)
+    return;
+
+  if (this._state === 'key' && this._key.length > 0) {
+    this.boy.emit('field', decodeText(this._key, 'binary', this.charset),
+                           '',
+                           this._keyTrunc,
+                           false);
+  } else if (this._state === 'val') {
+    this.boy.emit('field', decodeText(this._key, 'binary', this.charset),
+                           decodeText(this._val, 'binary', this.charset),
+                           this._keyTrunc,
+                           this._valTrunc);
+  }
+  this.boy._done = true;
+  this.boy.emit('finish');
+};
+
+module.exports = UrlEncoded;

+var jsencoding = require('../deps/encoding/encoding');
+
+var RE_ENCODED = /%([a-fA-F0-9]{2})/g;
+function encodedReplacer(match, byte) {
+  return String.fromCharCode(parseInt(byte, 16));
+}
+function parseParams(str) {
+  var res = [],
+      state = 'key',
+      charset = '',
+      inquote = false,
+      escaping = false,
+      p = 0,
+      tmp = '';
+
+  for (var i = 0, len = str.length; i < len; ++i) {
+    if (str[i] === '\\' && inquote) {
+      if (escaping)
+        escaping = false;
+      else {
+        escaping = true;
+        continue;
+      }
+    } else if (str[i] === '"') {
+      if (!escaping) {
+        if (inquote) {
+          inquote = false;
+          state = 'key';
+        } else
+          inquote = true;
+        continue;
+      } else
+        escaping = false;
+    } else {
+      if (escaping && inquote)
+        tmp += '\\';
+      escaping = false;
+      if ((state === 'charset' || state === 'lang') && str[i] === "'") {
+        if (state === 'charset') {
+          state = 'lang';
+          charset = tmp.substring(1);
+        } else
+          state = 'value';
+        tmp = '';
+        continue;
+      } else if (state === 'key'
+                 && (str[i] === '*' || str[i] === '=')
+                 && res.length) {
+        if (str[i] === '*')
+          state = 'charset';
+        else
+          state = 'value';
+        res[p] = [tmp, undefined];
+        tmp = '';
+        continue;
+      } else if (!inquote && str[i] === ';') {
+        state = 'key';
+        if (charset) {
+          if (tmp.length) {
+            tmp = decodeText(tmp.replace(RE_ENCODED, encodedReplacer),
+                             'binary',
+                             charset);
+          }
+          charset = '';
+        }
+        if (res[p] === undefined)
+          res[p] = tmp;
+        else
+          res[p][1] = tmp;
+        tmp = '';
+        ++p;
+        continue;
+      } else if (!inquote && (str[i] === ' ' || str[i] === '\t'))
+        continue;
+    }
+    tmp += str[i];
+  }
+  if (charset && tmp.length) {
+    tmp = decodeText(tmp.replace(RE_ENCODED, encodedReplacer),
+                     'binary',
+                     charset);
+  }
+
+  if (res[p] === undefined) {
+    if (tmp)
+      res[p] = tmp;
+  } else
+    res[p][1] = tmp;
+
+  return res;
+};
+exports.parseParams = parseParams;
+
+
+function decodeText(text, textEncoding, destEncoding) {
+  var ret;
+  if (text && jsencoding.encodingExists(destEncoding)) {
+    try {
+      ret = jsencoding.TextDecoder(destEncoding)
+                      .decode(new Buffer(text, textEncoding));
+    } catch(e) {}
+  }
+  return (typeof ret === 'string' ? ret : text);
+}
+exports.decodeText = decodeText;
+
+
+var HEX = [
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
+  0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+], RE_PLUS = /\+/g;
+function Decoder() {
+  this.buffer = undefined;
+}
+Decoder.prototype.write = function(str) {
+  // Replace '+' with ' ' before decoding
+  str = str.replace(RE_PLUS, ' ');
+  var res = '';
+  var i = 0, p = 0, len = str.length;
+  for (; i < len; ++i) {
+    if (this.buffer !== undefined) {
+      if (!HEX[str.charCodeAt(i)]) {
+        res += '%' + this.buffer;
+        this.buffer = undefined;
+        --i; // retry character
+      } else {
+        this.buffer += str[i];
+        ++p;
+        if (this.buffer.length === 2) {
+          res += String.fromCharCode(parseInt(this.buffer, 16));
+          this.buffer = undefined;
+        }
+      }
+    } else if (str[i] === '%') {
+      if (i > p) {
+        res += str.substring(p, i);
+        p = i;
+      }
+      this.buffer = '';
+      ++p;
+    }
+  }
+  if (p < len && this.buffer === undefined)
+    res += str.substring(p);
+  return res;
+};
+Decoder.prototype.reset = function() {
+  this.buffer = undefined;
+};
+exports.Decoder = Decoder;
+
+
+var RE_SPLIT_POSIX =
+      /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/,
+    RE_SPLIT_DEVICE =
+      /^([a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?([\\\/])?([\s\S]*?)$/,
+    RE_SPLIT_WINDOWS =
+      /^([\s\S]*?)((?:\.{1,2}|[^\\\/]+?|)(\.[^.\/\\]*|))(?:[\\\/]*)$/;
+function splitPathPosix(filename) {
+  return RE_SPLIT_POSIX.exec(filename).slice(1);
+}
+function splitPathWindows(filename) {
+  // Separate device+slash from tail
+  var result = RE_SPLIT_DEVICE.exec(filename),
+      device = (result[1] || '') + (result[2] || ''),
+      tail = result[3] || '';
+  // Split the tail into dir, basename and extension
+  var result2 = RE_SPLIT_WINDOWS.exec(tail),
+      dir = result2[1],
+      basename = result2[2],
+      ext = result2[3];
+  return [device, dir, basename, ext];
+}
+function basename(path) {
+  var f = splitPathPosix(path)[2];
+  if (f === path)
+    f = splitPathWindows(path)[2];
+  return f;
+}
+exports.basename = basename;
\ No newline at end of file

+{
+  "_from": "busboy@^0.2.11",
+  "_id": "busboy@0.2.14",
+  "_inBundle": false,
+  "_integrity": "sha1-bCpiLvz0fFe7vh4qnDetNseSVFM=",
+  "_location": "/busboy",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "busboy@^0.2.11",
+    "name": "busboy",
+    "escapedName": "busboy",
+    "rawSpec": "^0.2.11",
+    "saveSpec": null,
+    "fetchSpec": "^0.2.11"
+  },
+  "_requiredBy": [
+    "/multer"
+  ],
+  "_resolved": "https://registry.npmjs.org/busboy/-/busboy-0.2.14.tgz",
+  "_shasum": "6c2a622efcf47c57bbbe1e2a9c37ad36c7925453",
+  "_spec": "busboy@^0.2.11",
+  "_where": "C:\\Users\\1000c\\이것저것\\옾소\\Voicoding\\node_modules\\multer",
+  "author": {
+    "name": "Brian White",
+    "email": "mscdex@mscdex.net"
+  },
+  "bugs": {
+    "url": "https://github.com/mscdex/busboy/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "dicer": "0.2.5",
+    "readable-stream": "1.1.x"
+  },
+  "deprecated": false,
+  "description": "A streaming parser for HTML form data for node.js",
+  "engines": {
+    "node": ">=0.8.0"
+  },
+  "homepage": "https://github.com/mscdex/busboy#readme",
+  "keywords": [
+    "uploads",
+    "forms",
+    "multipart",
+    "form-data"
+  ],
+  "licenses": [
+    {
+      "type": "MIT",
+      "url": "http://github.com/mscdex/busboy/raw/master/LICENSE"
+    }
+  ],
+  "main": "./lib/main",
+  "name": "busboy",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/mscdex/busboy.git"
+  },
+  "scripts": {
+    "test": "node test/test.js"
+  },
+  "version": "0.2.14"
+}

+var Busboy = require('..');
+
+var path = require('path'),
+    inspect = require('util').inspect,
+    assert = require('assert');
+
+var EMPTY_FN = function() {};
+
+var t = 0,
+    group = path.basename(__filename, '.js') + '/';
+
+var tests = [
+  { source: ['foo'],
+    expected: [['foo', '', false, false]],
+    what: 'Unassigned value'
+  },
+  { source: ['foo=bar'],
+    expected: [['foo', 'bar', false, false]],
+    what: 'Assigned value'
+  },
+  { source: ['foo&bar=baz'],
+    expected: [['foo', '', false, false],
+               ['bar', 'baz', false, false]],
+    what: 'Unassigned and assigned value'
+  },
+  { source: ['foo=bar&baz'],
+    expected: [['foo', 'bar', false, false],
+               ['baz', '', false, false]],
+    what: 'Assigned and unassigned value'
+  },
+  { source: ['foo=bar&baz=bla'],
+    expected: [['foo', 'bar', false, false],
+               ['baz', 'bla', false, false]],
+    what: 'Two assigned values'
+  },
+  { source: ['foo&bar'],
+    expected: [['foo', '', false, false],
+               ['bar', '', false, false]],
+    what: 'Two unassigned values'
+  },
+  { source: ['foo&bar&'],
+    expected: [['foo', '', false, false],
+               ['bar', '', false, false]],
+    what: 'Two unassigned values and ampersand'
+  },
+  { source: ['foo=bar+baz%2Bquux'],
+    expected: [['foo', 'bar baz+quux', false, false]],
+    what: 'Assigned value with (plus) space'
+  },
+  { source: ['foo=bar%20baz%21'],
+    expected: [['foo', 'bar baz!', false, false]],
+    what: 'Assigned value with encoded bytes'
+  },
+  { source: ['foo%20bar=baz%20bla%21'],
+    expected: [['foo bar', 'baz bla!', false, false]],
+    what: 'Assigned value with encoded bytes #2'
+  },
+  { source: ['foo=bar%20baz%21&num=1000'],
+    expected: [['foo', 'bar baz!', false, false],
+               ['num', '1000', false, false]],
+    what: 'Two assigned values, one with encoded bytes'
+  },
+  { source: ['foo=bar&baz=bla'],
+    expected: [],
+    what: 'Limits: zero fields',
+    limits: { fields: 0 }
+  },
+  { source: ['foo=bar&baz=bla'],
+    expected: [['foo', 'bar', false, false]],
+    what: 'Limits: one field',
+    limits: { fields: 1 }
+  },
+  { source: ['foo=bar&baz=bla'],
+    expected: [['foo', 'bar', false, false],
+               ['baz', 'bla', false, false]],
+    what: 'Limits: field part lengths match limits',
+    limits: { fieldNameSize: 3, fieldSize: 3 }
+  },
+  { source: ['foo=bar&baz=bla'],
+    expected: [['fo', 'bar', true, false],
+               ['ba', 'bla', true, false]],
+    what: 'Limits: truncated field name',
+    limits: { fieldNameSize: 2 }
+  },
+  { source: ['foo=bar&baz=bla'],
+    expected: [['foo', 'ba', false, true],
+               ['baz', 'bl', false, true]],
+    what: 'Limits: truncated field value',
+    limits: { fieldSize: 2 }
+  },
+  { source: ['foo=bar&baz=bla'],
+    expected: [['fo', 'ba', true, true],
+               ['ba', 'bl', true, true]],
+    what: 'Limits: truncated field name and value',
+    limits: { fieldNameSize: 2, fieldSize: 2 }
+  },
+  { source: ['foo=bar&baz=bla'],
+    expected: [['fo', '', true, true],
+               ['ba', '', true, true]],
+    what: 'Limits: truncated field name and zero value limit',
+    limits: { fieldNameSize: 2, fieldSize: 0 }
+  },
+  { source: ['foo=bar&baz=bla'],
+    expected: [['', '', true, true],
+               ['', '', true, true]],
+    what: 'Limits: truncated zero field name and zero value limit',
+    limits: { fieldNameSize: 0, fieldSize: 0 }
+  },
+  { source: ['&'],
+    expected: [],
+    what: 'Ampersand'
+  },
+  { source: ['&&&&&'],
+    expected: [],
+    what: 'Many ampersands'
+  },
+  { source: ['='],
+    expected: [['', '', false, false]],
+    what: 'Assigned value, empty name and value'
+  },
+  { source: [''],
+    expected: [],
+    what: 'Nothing'
+  },
+];
+
+function next() {
+  if (t === tests.length)
+    return;
+
+  var v = tests[t];
+
+  var busboy = new Busboy({
+        limits: v.limits,
+        headers: {
+          'content-type': 'application/x-www-form-urlencoded; charset=utf-8'
+        }
+      }),
+      finishes = 0,
+      results = [];
+
+  busboy.on('field', function(key, val, keyTrunc, valTrunc) {
+    results.push([key, val, keyTrunc, valTrunc]);
+  });
+  busboy.on('file', function() {
+    throw new Error(makeMsg(v.what, 'Unexpected file'));
+  });
+  busboy.on('finish', function() {
+    assert(finishes++ === 0, makeMsg(v.what, 'finish emitted multiple times'));
+    assert.deepEqual(results.length,
+                     v.expected.length,
+                     makeMsg(v.what, 'Parsed result count mismatch. Saw '
+                                     + results.length
+                                     + '. Expected: ' + v.expected.length));
+
+    var i = 0;
+    results.forEach(function(result) {
+      assert.deepEqual(result,
+                       v.expected[i],
+                       makeMsg(v.what,
+                               'Result mismatch:\nParsed: ' + inspect(result)
+                               + '\nExpected: ' + inspect(v.expected[i]))
+                      );
+      ++i;
+    });
+    ++t;
+    next();
+  });
+
+  v.source.forEach(function(s) {
+    busboy.write(new Buffer(s, 'utf8'), EMPTY_FN);
+  });
+  busboy.end();
+}
+next();
+
+function makeMsg(what, msg) {
+  return '[' + group + what + ']: ' + msg;
+}
+
+process.on('exit', function() {
+  assert(t === tests.length, makeMsg('_exit', 'Only finished ' + t + '/' + tests.length + ' tests'));
+});

+var Decoder = require('../lib/utils').Decoder;
+
+var path = require('path'),
+    assert = require('assert');
+
+var group = path.basename(__filename, '.js') + '/';
+
+[
+  { source: ['Hello world'],
+    expected: 'Hello world',
+    what: 'No encoded bytes'
+  },
+  { source: ['Hello%20world'],
+    expected: 'Hello world',
+    what: 'One full encoded byte'
+  },
+  { source: ['Hello%20world%21'],
+    expected: 'Hello world!',
+    what: 'Two full encoded bytes'
+  },
+  { source: ['Hello%', '20world'],
+    expected: 'Hello world',
+    what: 'One full encoded byte split #1'
+  },
+  { source: ['Hello%2', '0world'],
+    expected: 'Hello world',
+    what: 'One full encoded byte split #2'
+  },
+  { source: ['Hello%20', 'world'],
+    expected: 'Hello world',
+    what: 'One full encoded byte (concat)'
+  },
+  { source: ['Hello%2Qworld'],
+    expected: 'Hello%2Qworld',
+    what: 'Malformed encoded byte #1'
+  },
+  { source: ['Hello%world'],
+    expected: 'Hello%world',
+    what: 'Malformed encoded byte #2'
+  },
+  { source: ['Hello+world'],
+    expected: 'Hello world',
+    what: 'Plus to space'
+  },
+  { source: ['Hello+world%21'],
+    expected: 'Hello world!',
+    what: 'Plus and encoded byte'
+  },
+  { source: ['5%2B5%3D10'],
+    expected: '5+5=10',
+    what: 'Encoded plus'
+  },
+  { source: ['5+%2B+5+%3D+10'],
+    expected: '5 + 5 = 10',
+    what: 'Spaces and encoded plus'
+  },
+].forEach(function(v) {
+  var dec = new Decoder(), result = '';
+  v.source.forEach(function(s) {
+    result += dec.write(s);
+  });
+  var msg = '[' + group + v.what + ']: decoded string mismatch.\n'
+            + 'Saw: ' + result + '\n'
+            + 'Expected: ' + v.expected;
+  assert.deepEqual(result, v.expected, msg);
+});

+var parseParams = require('../lib/utils').parseParams;
+
+var path = require('path'),
+    assert = require('assert'),
+    inspect = require('util').inspect;
+
+var group = path.basename(__filename, '.js') + '/';
+
+[
+  { source: 'video/ogg',
+    expected: ['video/ogg'],
+    what: 'No parameters'
+  },
+  { source: 'video/ogg;',
+    expected: ['video/ogg'],
+    what: 'No parameters (with separator)'
+  },
+  { source: 'video/ogg; ',
+    expected: ['video/ogg'],
+    what: 'No parameters (with separator followed by whitespace)'
+  },
+  { source: ';video/ogg',
+    expected: ['', 'video/ogg'],
+    what: 'Empty parameter'
+  },
+  { source: 'video/*',
+    expected: ['video/*'],
+    what: 'Subtype with asterisk'
+  },
+  { source: 'text/plain; encoding=utf8',
+    expected: ['text/plain', ['encoding', 'utf8']],
+    what: 'Unquoted'
+  },
+  { source: 'text/plain; encoding=',
+    expected: ['text/plain', ['encoding', '']],
+    what: 'Unquoted empty string'
+  },
+  { source: 'text/plain; encoding="utf8"',
+    expected: ['text/plain', ['encoding', 'utf8']],
+    what: 'Quoted'
+  },
+  { source: 'text/plain; greeting="hello \\"world\\""',
+    expected: ['text/plain', ['greeting', 'hello "world"']],
+    what: 'Quotes within quoted'
+  },
+  { source: 'text/plain; encoding=""',
+    expected: ['text/plain', ['encoding', '']],
+    what: 'Quoted empty string'
+  },
+  { source: 'text/plain; encoding="utf8";\t   foo=bar;test',
+    expected: ['text/plain', ['encoding', 'utf8'], ['foo', 'bar'], 'test'],
+    what: 'Multiple params with various spacing'
+  },
+  { source: "text/plain; filename*=iso-8859-1'en'%A3%20rates",
+    expected: ['text/plain', ['filename', '£ rates']],
+    what: 'Extended parameter (RFC 5987) with language'
+  },
+  { source: "text/plain; filename*=utf-8''%c2%a3%20and%20%e2%82%ac%20rates",
+    expected: ['text/plain', ['filename', '£ and € rates']],
+    what: 'Extended parameter (RFC 5987) without language'
+  },
+  { source: "text/plain; filename*=utf-8''%E6%B5%8B%E8%AF%95%E6%96%87%E6%A1%A3",
+    expected: ['text/plain', ['filename', '测试文档']],
+    what: 'Extended parameter (RFC 5987) without language #2'
+  },
+  { source: "text/plain; filename*=iso-8859-1'en'%A3%20rates; altfilename*=utf-8''%c2%a3%20and%20%e2%82%ac%20rates",
+    expected: ['text/plain', ['filename', '£ rates'], ['altfilename', '£ and € rates']],
+    what: 'Multiple extended parameters (RFC 5987) with mixed charsets'
+  },
+  { source: "text/plain; filename*=iso-8859-1'en'%A3%20rates; altfilename=\"foobarbaz\"",
+    expected: ['text/plain', ['filename', '£ rates'], ['altfilename', 'foobarbaz']],
+    what: 'Mixed regular and extended parameters (RFC 5987)'
+  },
+  { source: "text/plain; filename=\"foobarbaz\"; altfilename*=iso-8859-1'en'%A3%20rates",
+    expected: ['text/plain', ['filename', 'foobarbaz'], ['altfilename', '£ rates']],
+    what: 'Mixed regular and extended parameters (RFC 5987) #2'
+  },
+  { source: 'text/plain; filename="C:\\folder\\test.png"',
+    expected: ['text/plain', ['filename', 'C:\\folder\\test.png']],
+    what: 'Unescaped backslashes should be considered backslashes'
+  },
+  { source: 'text/plain; filename="John \\"Magic\\" Smith.png"',
+    expected: ['text/plain', ['filename', 'John "Magic" Smith.png']],
+    what: 'Escaped double-quotes should be considered double-quotes'
+  },
+  { source: 'multipart/form-data; charset=utf-8; boundary=0xKhTmLbOuNdArY',
+    expected: ['multipart/form-data', ['charset', 'utf-8'], ['boundary', '0xKhTmLbOuNdArY']],
+    what: 'Multiple non-quoted parameters'
+  },
+].forEach(function(v) {
+  var result = parseParams(v.source),
+      msg = '[' + group + v.what + ']: parsed parameters mismatch.\n'
+            + 'Saw: ' + inspect(result) + '\n'
+            + 'Expected: ' + inspect(v.expected);
+  assert.deepEqual(result, v.expected, msg);
+});

+require('fs').readdirSync(__dirname).forEach(function(f) {
+  if (f.substr(0, 5) === 'test-')
+    require('./' + f);
+});
\ No newline at end of file

+The MIT License
+
+Copyright (c) 2013 Max Ogden
+
+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.
\ No newline at end of file

+var Writable = require('readable-stream').Writable
+var inherits = require('inherits')
+var bufferFrom = require('buffer-from')
+
+if (typeof Uint8Array === 'undefined') {
+  var U8 = require('typedarray').Uint8Array
+} else {
+  var U8 = Uint8Array
+}
+
+function ConcatStream(opts, cb) {
+  if (!(this instanceof ConcatStream)) return new ConcatStream(opts, cb)
+
+  if (typeof opts === 'function') {
+    cb = opts
+    opts = {}
+  }
+  if (!opts) opts = {}
+
+  var encoding = opts.encoding
+  var shouldInferEncoding = false
+
+  if (!encoding) {
+    shouldInferEncoding = true
+  } else {
+    encoding =  String(encoding).toLowerCase()
+    if (encoding === 'u8' || encoding === 'uint8') {
+      encoding = 'uint8array'
+    }
+  }
+
+  Writable.call(this, { objectMode: true })
+
+  this.encoding = encoding
+  this.shouldInferEncoding = shouldInferEncoding
+
+  if (cb) this.on('finish', function () { cb(this.getBody()) })
+  this.body = []
+}
+
+module.exports = ConcatStream
+inherits(ConcatStream, Writable)
+
+ConcatStream.prototype._write = function(chunk, enc, next) {
+  this.body.push(chunk)
+  next()
+}
+
+ConcatStream.prototype.inferEncoding = function (buff) {
+  var firstBuffer = buff === undefined ? this.body[0] : buff;
+  if (Buffer.isBuffer(firstBuffer)) return 'buffer'
+  if (typeof Uint8Array !== 'undefined' && firstBuffer instanceof Uint8Array) return 'uint8array'
+  if (Array.isArray(firstBuffer)) return 'array'
+  if (typeof firstBuffer === 'string') return 'string'
+  if (Object.prototype.toString.call(firstBuffer) === "[object Object]") return 'object'
+  return 'buffer'
+}
+
+ConcatStream.prototype.getBody = function () {
+  if (!this.encoding && this.body.length === 0) return []
+  if (this.shouldInferEncoding) this.encoding = this.inferEncoding()
+  if (this.encoding === 'array') return arrayConcat(this.body)
+  if (this.encoding === 'string') return stringConcat(this.body)
+  if (this.encoding === 'buffer') return bufferConcat(this.body)
+  if (this.encoding === 'uint8array') return u8Concat(this.body)
+  return this.body
+}
+
+var isArray = Array.isArray || function (arr) {
+  return Object.prototype.toString.call(arr) == '[object Array]'
+}
+
+function isArrayish (arr) {
+  return /Array\]$/.test(Object.prototype.toString.call(arr))
+}
+
+function isBufferish (p) {
+  return typeof p === 'string' || isArrayish(p) || (p && typeof p.subarray === 'function')
+}
+
+function stringConcat (parts) {
+  var strings = []
+  var needsToString = false
+  for (var i = 0; i < parts.length; i++) {
+    var p = parts[i]
+    if (typeof p === 'string') {
+      strings.push(p)
+    } else if (Buffer.isBuffer(p)) {
+      strings.push(p)
+    } else if (isBufferish(p)) {
+      strings.push(bufferFrom(p))
+    } else {
+      strings.push(bufferFrom(String(p)))
+    }
+  }
+  if (Buffer.isBuffer(parts[0])) {
+    strings = Buffer.concat(strings)
+    strings = strings.toString('utf8')
+  } else {
+    strings = strings.join('')
+  }
+  return strings
+}
+
+function bufferConcat (parts) {
+  var bufs = []
+  for (var i = 0; i < parts.length; i++) {
+    var p = parts[i]
+    if (Buffer.isBuffer(p)) {
+      bufs.push(p)
+    } else if (isBufferish(p)) {
+      bufs.push(bufferFrom(p))
+    } else {
+      bufs.push(bufferFrom(String(p)))
+    }
+  }
+  return Buffer.concat(bufs)
+}
+
+function arrayConcat (parts) {
+  var res = []
+  for (var i = 0; i < parts.length; i++) {
+    res.push.apply(res, parts[i])
+  }
+  return res
+}
+
+function u8Concat (parts) {
+  var len = 0
+  for (var i = 0; i < parts.length; i++) {
+    if (typeof parts[i] === 'string') {
+      parts[i] = bufferFrom(parts[i])
+    }
+    len += parts[i].length
+  }
+  var u8 = new U8(len)
+  for (var i = 0, offset = 0; i < parts.length; i++) {
+    var part = parts[i]
+    for (var j = 0; j < part.length; j++) {
+      u8[offset++] = part[j]
+    }
+  }
+  return u8
+}

+node_modules

+language: node_js
+node_js:
+  - "0.8"
+  - "0.10"

+
+test:
+	@node_modules/.bin/tape test.js
+
+.PHONY: test
+

+
+# isarray
+
+`Array#isArray` for older browsers.
+
+[![build status](https://secure.travis-ci.org/juliangruber/isarray.svg)](http://travis-ci.org/juliangruber/isarray)
+[![downloads](https://img.shields.io/npm/dm/isarray.svg)](https://www.npmjs.org/package/isarray)
+
+[![browser support](https://ci.testling.com/juliangruber/isarray.png)
+](https://ci.testling.com/juliangruber/isarray)
+
+## Usage
+
+```js
+var isArray = require('isarray');
+
+console.log(isArray([])); // => true
+console.log(isArray({})); // => false
+```
+
+## Installation
+
+With [npm](http://npmjs.org) do
+
+```bash
+$ npm install isarray
+```
+
+Then bundle for the browser with
+[browserify](https://github.com/substack/browserify).
+
+With [component](http://component.io) do
+
+```bash
+$ component install juliangruber/isarray
+```
+
+## License
+
+(MIT)
+
+Copyright (c) 2013 Julian Gruber <julian@juliangruber.com>
+
+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.

+{
+  "name" : "isarray",
+  "description" : "Array#isArray for older browsers",
+  "version" : "0.0.1",
+  "repository" : "juliangruber/isarray",
+  "homepage": "https://github.com/juliangruber/isarray",
+  "main" : "index.js",
+  "scripts" : [
+    "index.js"
+  ],
+  "dependencies" : {},
+  "keywords": ["browser","isarray","array"],
+  "author": {
+    "name": "Julian Gruber",
+    "email": "mail@juliangruber.com",
+    "url": "http://juliangruber.com"
+  },
+  "license": "MIT"
+}

+var toString = {}.toString;
+
+module.exports = Array.isArray || function (arr) {
+  return toString.call(arr) == '[object Array]';
+};

+{
+  "_from": "isarray@~1.0.0",
+  "_id": "isarray@1.0.0",
+  "_inBundle": false,
+  "_integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=",
+  "_location": "/concat-stream/isarray",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "isarray@~1.0.0",
+    "name": "isarray",
+    "escapedName": "isarray",
+    "rawSpec": "~1.0.0",
+    "saveSpec": null,
+    "fetchSpec": "~1.0.0"
+  },
+  "_requiredBy": [
+    "/concat-stream/readable-stream"
+  ],
+  "_resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz",
+  "_shasum": "bb935d48582cba168c06834957a54a3e07124f11",
+  "_spec": "isarray@~1.0.0",
+  "_where": "C:\\Users\\1000c\\이것저것\\옾소\\Voicoding\\node_modules\\concat-stream\\node_modules\\readable-stream",
+  "author": {
+    "name": "Julian Gruber",
+    "email": "mail@juliangruber.com",
+    "url": "http://juliangruber.com"
+  },
+  "bugs": {
+    "url": "https://github.com/juliangruber/isarray/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {},
+  "deprecated": false,
+  "description": "Array#isArray for older browsers",
+  "devDependencies": {
+    "tape": "~2.13.4"
+  },
+  "homepage": "https://github.com/juliangruber/isarray",
+  "keywords": [
+    "browser",
+    "isarray",
+    "array"
+  ],
+  "license": "MIT",
+  "main": "index.js",
+  "name": "isarray",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/juliangruber/isarray.git"
+  },
+  "scripts": {
+    "test": "tape test.js"
+  },
+  "testling": {
+    "files": "test.js",
+    "browsers": [
+      "ie/8..latest",
+      "firefox/17..latest",
+      "firefox/nightly",
+      "chrome/22..latest",
+      "chrome/canary",
+      "opera/12..latest",
+      "opera/next",
+      "safari/5.1..latest",
+      "ipad/6.0..latest",
+      "iphone/6.0..latest",
+      "android-browser/4.2..latest"
+    ]
+  },
+  "version": "1.0.0"
+}

+var isArray = require('./');
+var test = require('tape');
+
+test('is array', function(t){
+  t.ok(isArray([]));
+  t.notOk(isArray({}));
+  t.notOk(isArray(null));
+  t.notOk(isArray(false));
+
+  var obj = {};
+  obj[0] = true;
+  t.notOk(isArray(obj));
+
+  var arr = [];
+  arr.foo = 'bar';
+  t.ok(isArray(arr));
+
+  t.end();
+});
+

+sudo: false
+language: node_js
+before_install:
+  - (test $NPM_LEGACY && npm install -g npm@2 && npm install -g npm@3) || true
+notifications:
+  email: false
+matrix:
+  fast_finish: true
+  include:
+  - node_js: '0.8'
+    env: NPM_LEGACY=true
+  - node_js: '0.10'
+    env: NPM_LEGACY=true
+  - node_js: '0.11'
+    env: NPM_LEGACY=true
+  - node_js: '0.12'
+    env: NPM_LEGACY=true
+  - node_js: 1
+    env: NPM_LEGACY=true
+  - node_js: 2
+    env: NPM_LEGACY=true
+  - node_js: 3
+    env: NPM_LEGACY=true
+  - node_js: 4
+  - node_js: 5
+  - node_js: 6
+  - node_js: 7
+  - node_js: 8
+  - node_js: 9
+script: "npm run test"
+env:
+  global:
+  - secure: rE2Vvo7vnjabYNULNyLFxOyt98BoJexDqsiOnfiD6kLYYsiQGfr/sbZkPMOFm9qfQG7pjqx+zZWZjGSswhTt+626C0t/njXqug7Yps4c3dFblzGfreQHp7wNX5TFsvrxd6dAowVasMp61sJcRnB2w8cUzoe3RAYUDHyiHktwqMc=
+  - secure: g9YINaKAdMatsJ28G9jCGbSaguXCyxSTy+pBO6Ch0Cf57ZLOTka3HqDj8p3nV28LUIHZ3ut5WO43CeYKwt4AUtLpBS3a0dndHdY6D83uY6b2qh5hXlrcbeQTq2cvw2y95F7hm4D1kwrgZ7ViqaKggRcEupAL69YbJnxeUDKWEdI=

+Node.js is licensed for use as follows:
+
+"""
+Copyright Node.js contributors. All rights reserved.
+
+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.
+"""
+
+This license applies to parts of Node.js originating from the
+https://github.com/joyent/node repository:
+
+"""
+Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+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.
+"""

+# readable-stream
+
+***Node-core v8.11.1 streams for userland*** [![Build Status](https://travis-ci.org/nodejs/readable-stream.svg?branch=master)](https://travis-ci.org/nodejs/readable-stream)
+
+
+[![NPM](https://nodei.co/npm/readable-stream.png?downloads=true&downloadRank=true)](https://nodei.co/npm/readable-stream/)
+[![NPM](https://nodei.co/npm-dl/readable-stream.png?&months=6&height=3)](https://nodei.co/npm/readable-stream/)
+
+
+[![Sauce Test Status](https://saucelabs.com/browser-matrix/readable-stream.svg)](https://saucelabs.com/u/readable-stream)
+
+```bash
+npm install --save readable-stream
+```
+
+***Node-core streams for userland***
+
+This package is a mirror of the Streams2 and Streams3 implementations in
+Node-core.
+
+Full documentation may be found on the [Node.js website](https://nodejs.org/dist/v8.11.1/docs/api/stream.html).
+
+If you want to guarantee a stable streams base, regardless of what version of
+Node you, or the users of your libraries are using, use **readable-stream** *only* and avoid the *"stream"* module in Node-core, for background see [this blogpost](http://r.va.gg/2014/06/why-i-dont-use-nodes-core-stream-module.html).
+
+As of version 2.0.0 **readable-stream** uses semantic versioning.
+
+# Streams Working Group
+
+`readable-stream` is maintained by the Streams Working Group, which
+oversees the development and maintenance of the Streams API within
+Node.js. The responsibilities of the Streams Working Group include:
+
+* Addressing stream issues on the Node.js issue tracker.
+* Authoring and editing stream documentation within the Node.js project.
+* Reviewing changes to stream subclasses within the Node.js project.
+* Redirecting changes to streams from the Node.js project to this
+  project.
+* Assisting in the implementation of stream providers within Node.js.
+* Recommending versions of `readable-stream` to be included in Node.js.
+* Messaging about the future of streams to give the community advance
+  notice of changes.
+
+<a name="members"></a>
+## Team Members
+
+* **Chris Dickinson** ([@chrisdickinson](https://github.com/chrisdickinson)) &lt;christopher.s.dickinson@gmail.com&gt;
+  - Release GPG key: 9554F04D7259F04124DE6B476D5A82AC7E37093B
+* **Calvin Metcalf** ([@calvinmetcalf](https://github.com/calvinmetcalf)) &lt;calvin.metcalf@gmail.com&gt;
+  - Release GPG key: F3EF5F62A87FC27A22E643F714CE4FF5015AA242
+* **Rod Vagg** ([@rvagg](https://github.com/rvagg)) &lt;rod@vagg.org&gt;
+  - Release GPG key: DD8F2338BAE7501E3DD5AC78C273792F7D83545D
+* **Sam Newman** ([@sonewman](https://github.com/sonewman)) &lt;newmansam@outlook.com&gt;
+* **Mathias Buus** ([@mafintosh](https://github.com/mafintosh)) &lt;mathiasbuus@gmail.com&gt;
+* **Domenic Denicola** ([@domenic](https://github.com/domenic)) &lt;d@domenic.me&gt;
+* **Matteo Collina** ([@mcollina](https://github.com/mcollina)) &lt;matteo.collina@gmail.com&gt;
+  - Release GPG key: 3ABC01543F22DD2239285CDD818674489FBC127E
+* **Irina Shestak** ([@lrlna](https://github.com/lrlna)) &lt;shestak.irina@gmail.com&gt;

+# streams WG Meeting 2015-01-30
+
+## Links
+
+* **Google Hangouts Video**: http://www.youtube.com/watch?v=I9nDOSGfwZg
+* **GitHub Issue**: https://github.com/iojs/readable-stream/issues/106
+* **Original Minutes Google Doc**: https://docs.google.com/document/d/17aTgLnjMXIrfjgNaTUnHQO7m3xgzHR2VXBTmi03Qii4/
+
+## Agenda
+
+Extracted from https://github.com/iojs/readable-stream/labels/wg-agenda prior to meeting.
+
+* adopt a charter [#105](https://github.com/iojs/readable-stream/issues/105)
+* release and versioning strategy [#101](https://github.com/iojs/readable-stream/issues/101)
+* simpler stream creation [#102](https://github.com/iojs/readable-stream/issues/102)
+* proposal: deprecate implicit flowing of streams [#99](https://github.com/iojs/readable-stream/issues/99)
+
+## Minutes
+
+### adopt a charter
+
+* group: +1's all around
+
+### What versioning scheme should be adopted?
+* group: +1’s 3.0.0
+* domenic+group: pulling in patches from other sources where appropriate
+* mikeal: version independently, suggesting versions for io.js
+* mikeal+domenic: work with TC to notify in advance of changes
+simpler stream creation
+
+### streamline creation of streams
+* sam: streamline creation of streams
+* domenic: nice simple solution posted
+  but, we lose the opportunity to change the model
+  may not be backwards incompatible (double check keys)
+
+  **action item:** domenic will check
+
+### remove implicit flowing of streams on(‘data’)
+* add isFlowing / isPaused
+* mikeal: worrying that we’re documenting polyfill methods – confuses users
+* domenic: more reflective API is probably good, with warning labels for users
+* new section for mad scientists (reflective stream access)
+* calvin: name the “third state”
+* mikeal: maybe borrow the name from whatwg?
+* domenic: we’re missing the “third state”
+* consensus: kind of difficult to name the third state
+* mikeal: figure out differences in states / compat
+* mathias: always flow on data – eliminates third state
+  * explore what it breaks
+
+**action items:**
+* ask isaac for ability to list packages by what public io.js APIs they use (esp. Stream)
+* ask rod/build for infrastructure
+* **chris**: explore the “flow on data” approach
+* add isPaused/isFlowing
+* add new docs section
+* move isPaused to that section
+
+

+module.exports = require('./lib/_stream_duplex.js');

+module.exports = require('./readable').Duplex

+// Copyright Joyent, Inc. and other Node 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.
+
+// a duplex stream is just a stream that is both readable and writable.
+// Since JS doesn't have multiple prototypal inheritance, this class
+// prototypally inherits from Readable, and then parasitically from
+// Writable.
+
+'use strict';
+
+/*<replacement>*/
+
+var pna = require('process-nextick-args');
+/*</replacement>*/
+
+/*<replacement>*/
+var objectKeys = Object.keys || function (obj) {
+  var keys = [];
+  for (var key in obj) {
+    keys.push(key);
+  }return keys;
+};
+/*</replacement>*/
+
+module.exports = Duplex;
+
+/*<replacement>*/
+var util = Object.create(require('core-util-is'));
+util.inherits = require('inherits');
+/*</replacement>*/
+
+var Readable = require('./_stream_readable');
+var Writable = require('./_stream_writable');
+
+util.inherits(Duplex, Readable);
+
+{
+  // avoid scope creep, the keys array can then be collected
+  var keys = objectKeys(Writable.prototype);
+  for (var v = 0; v < keys.length; v++) {
+    var method = keys[v];
+    if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];
+  }
+}
+
+function Duplex(options) {
+  if (!(this instanceof Duplex)) return new Duplex(options);
+
+  Readable.call(this, options);
+  Writable.call(this, options);
+
+  if (options && options.readable === false) this.readable = false;
+
+  if (options && options.writable === false) this.writable = false;
+
+  this.allowHalfOpen = true;
+  if (options && options.allowHalfOpen === false) this.allowHalfOpen = false;
+
+  this.once('end', onend);
+}
+
+Object.defineProperty(Duplex.prototype, 'writableHighWaterMark', {
+  // making it explicit this property is not enumerable
+  // because otherwise some prototype manipulation in
+  // userland will fail
+  enumerable: false,
+  get: function () {
+    return this._writableState.highWaterMark;
+  }
+});
+
+// the no-half-open enforcer
+function onend() {
+  // if we allow half-open state, or if the writable side ended,
+  // then we're ok.
+  if (this.allowHalfOpen || this._writableState.ended) return;
+
+  // no more data can be written.
+  // But allow more writes to happen in this tick.
+  pna.nextTick(onEndNT, this);
+}
+
+function onEndNT(self) {
+  self.end();
+}
+
+Object.defineProperty(Duplex.prototype, 'destroyed', {
+  get: function () {
+    if (this._readableState === undefined || this._writableState === undefined) {
+      return false;
+    }
+    return this._readableState.destroyed && this._writableState.destroyed;
+  },
+  set: function (value) {
+    // we ignore the value if the stream
+    // has not been initialized yet
+    if (this._readableState === undefined || this._writableState === undefined) {
+      return;
+    }
+
+    // backward compatibility, the user is explicitly
+    // managing destroyed
+    this._readableState.destroyed = value;
+    this._writableState.destroyed = value;
+  }
+});
+
+Duplex.prototype._destroy = function (err, cb) {
+  this.push(null);
+  this.end();
+
+  pna.nextTick(cb, err);
+};
\ No newline at end of file

+// Copyright Joyent, Inc. and other Node 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.
+
+// a passthrough stream.
+// basically just the most minimal sort of Transform stream.
+// Every written chunk gets output as-is.
+
+'use strict';
+
+module.exports = PassThrough;
+
+var Transform = require('./_stream_transform');
+
+/*<replacement>*/
+var util = Object.create(require('core-util-is'));
+util.inherits = require('inherits');
+/*</replacement>*/
+
+util.inherits(PassThrough, Transform);
+
+function PassThrough(options) {
+  if (!(this instanceof PassThrough)) return new PassThrough(options);
+
+  Transform.call(this, options);
+}
+
+PassThrough.prototype._transform = function (chunk, encoding, cb) {
+  cb(null, chunk);
+};
\ No newline at end of file

+// Copyright Joyent, Inc. and other Node 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.
+
+// a transform stream is a readable/writable stream where you do
+// something with the data.  Sometimes it's called a "filter",
+// but that's not a great name for it, since that implies a thing where
+// some bits pass through, and others are simply ignored.  (That would
+// be a valid example of a transform, of course.)
+//
+// While the output is causally related to the input, it's not a
+// necessarily symmetric or synchronous transformation.  For example,
+// a zlib stream might take multiple plain-text writes(), and then
+// emit a single compressed chunk some time in the future.
+//
+// Here's how this works:
+//
+// The Transform stream has all the aspects of the readable and writable
+// stream classes.  When you write(chunk), that calls _write(chunk,cb)
+// internally, and returns false if there's a lot of pending writes
+// buffered up.  When you call read(), that calls _read(n) until
+// there's enough pending readable data buffered up.
+//
+// In a transform stream, the written data is placed in a buffer.  When
+// _read(n) is called, it transforms the queued up data, calling the
+// buffered _write cb's as it consumes chunks.  If consuming a single
+// written chunk would result in multiple output chunks, then the first
+// outputted bit calls the readcb, and subsequent chunks just go into
+// the read buffer, and will cause it to emit 'readable' if necessary.
+//
+// This way, back-pressure is actually determined by the reading side,
+// since _read has to be called to start processing a new chunk.  However,
+// a pathological inflate type of transform can cause excessive buffering
+// here.  For example, imagine a stream where every byte of input is
+// interpreted as an integer from 0-255, and then results in that many
+// bytes of output.  Writing the 4 bytes {ff,ff,ff,ff} would result in
+// 1kb of data being output.  In this case, you could write a very small
+// amount of input, and end up with a very large amount of output.  In
+// such a pathological inflating mechanism, there'd be no way to tell
+// the system to stop doing the transform.  A single 4MB write could
+// cause the system to run out of memory.
+//
+// However, even in such a pathological case, only a single written chunk
+// would be consumed, and then the rest would wait (un-transformed) until
+// the results of the previous transformed chunk were consumed.
+
+'use strict';
+
+module.exports = Transform;
+
+var Duplex = require('./_stream_duplex');
+
+/*<replacement>*/
+var util = Object.create(require('core-util-is'));
+util.inherits = require('inherits');
+/*</replacement>*/
+
+util.inherits(Transform, Duplex);
+
+function afterTransform(er, data) {
+  var ts = this._transformState;
+  ts.transforming = false;
+
+  var cb = ts.writecb;
+
+  if (!cb) {
+    return this.emit('error', new Error('write callback called multiple times'));
+  }
+
+  ts.writechunk = null;
+  ts.writecb = null;
+
+  if (data != null) // single equals check for both `null` and `undefined`
+    this.push(data);
+
+  cb(er);
+
+  var rs = this._readableState;
+  rs.reading = false;
+  if (rs.needReadable || rs.length < rs.highWaterMark) {
+    this._read(rs.highWaterMark);
+  }
+}
+
+function Transform(options) {
+  if (!(this instanceof Transform)) return new Transform(options);
+
+  Duplex.call(this, options);
+
+  this._transformState = {
+    afterTransform: afterTransform.bind(this),
+    needTransform: false,
+    transforming: false,
+    writecb: null,
+    writechunk: null,
+    writeencoding: null
+  };
+
+  // start out asking for a readable event once data is transformed.
+  this._readableState.needReadable = true;
+
+  // we have implemented the _read method, and done the other things
+  // that Readable wants before the first _read call, so unset the
+  // sync guard flag.
+  this._readableState.sync = false;
+
+  if (options) {
+    if (typeof options.transform === 'function') this._transform = options.transform;
+
+    if (typeof options.flush === 'function') this._flush = options.flush;
+  }
+
+  // When the writable side finishes, then flush out anything remaining.
+  this.on('prefinish', prefinish);
+}
+
+function prefinish() {
+  var _this = this;
+
+  if (typeof this._flush === 'function') {
+    this._flush(function (er, data) {
+      done(_this, er, data);
+    });
+  } else {
+    done(this, null, null);
+  }
+}
+
+Transform.prototype.push = function (chunk, encoding) {
+  this._transformState.needTransform = false;
+  return Duplex.prototype.push.call(this, chunk, encoding);
+};
+
+// This is the part where you do stuff!
+// override this function in implementation classes.
+// 'chunk' is an input chunk.
+//
+// Call `push(newChunk)` to pass along transformed output
+// to the readable side.  You may call 'push' zero or more times.
+//
+// Call `cb(err)` when you are done with this chunk.  If you pass
+// an error, then that'll put the hurt on the whole operation.  If you
+// never call cb(), then you'll never get another chunk.
+Transform.prototype._transform = function (chunk, encoding, cb) {
+  throw new Error('_transform() is not implemented');
+};
+
+Transform.prototype._write = function (chunk, encoding, cb) {
+  var ts = this._transformState;
+  ts.writecb = cb;
+  ts.writechunk = chunk;
+  ts.writeencoding = encoding;
+  if (!ts.transforming) {
+    var rs = this._readableState;
+    if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);
+  }
+};
+
+// Doesn't matter what the args are here.
+// _transform does all the work.
+// That we got here means that the readable side wants more data.
+Transform.prototype._read = function (n) {
+  var ts = this._transformState;
+
+  if (ts.writechunk !== null && ts.writecb && !ts.transforming) {
+    ts.transforming = true;
+    this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
+  } else {
+    // mark that we need a transform, so that any data that comes in
+    // will get processed, now that we've asked for it.
+    ts.needTransform = true;
+  }
+};
+
+Transform.prototype._destroy = function (err, cb) {
+  var _this2 = this;
+
+  Duplex.prototype._destroy.call(this, err, function (err2) {
+    cb(err2);
+    _this2.emit('close');
+  });
+};
+
+function done(stream, er, data) {
+  if (er) return stream.emit('error', er);
+
+  if (data != null) // single equals check for both `null` and `undefined`
+    stream.push(data);
+
+  // if there's nothing in the write buffer, then that means
+  // that nothing more will ever be provided
+  if (stream._writableState.length) throw new Error('Calling transform done when ws.length != 0');
+
+  if (stream._transformState.transforming) throw new Error('Calling transform done when still transforming');
+
+  return stream.push(null);
+}
\ No newline at end of file

+'use strict';
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var Buffer = require('safe-buffer').Buffer;
+var util = require('util');
+
+function copyBuffer(src, target, offset) {
+  src.copy(target, offset);
+}
+
+module.exports = function () {
+  function BufferList() {
+    _classCallCheck(this, BufferList);
+
+    this.head = null;
+    this.tail = null;
+    this.length = 0;
+  }
+
+  BufferList.prototype.push = function push(v) {
+    var entry = { data: v, next: null };
+    if (this.length > 0) this.tail.next = entry;else this.head = entry;
+    this.tail = entry;
+    ++this.length;
+  };
+
+  BufferList.prototype.unshift = function unshift(v) {
+    var entry = { data: v, next: this.head };
+    if (this.length === 0) this.tail = entry;
+    this.head = entry;
+    ++this.length;
+  };
+
+  BufferList.prototype.shift = function shift() {
+    if (this.length === 0) return;
+    var ret = this.head.data;
+    if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;
+    --this.length;
+    return ret;
+  };
+
+  BufferList.prototype.clear = function clear() {
+    this.head = this.tail = null;
+    this.length = 0;
+  };
+
+  BufferList.prototype.join = function join(s) {
+    if (this.length === 0) return '';
+    var p = this.head;
+    var ret = '' + p.data;
+    while (p = p.next) {
+      ret += s + p.data;
+    }return ret;
+  };
+
+  BufferList.prototype.concat = function concat(n) {
+    if (this.length === 0) return Buffer.alloc(0);
+    if (this.length === 1) return this.head.data;
+    var ret = Buffer.allocUnsafe(n >>> 0);
+    var p = this.head;
+    var i = 0;
+    while (p) {
+      copyBuffer(p.data, ret, i);
+      i += p.data.length;
+      p = p.next;
+    }
+    return ret;
+  };
+
+  return BufferList;
+}();
+
+if (util && util.inspect && util.inspect.custom) {
+  module.exports.prototype[util.inspect.custom] = function () {
+    var obj = util.inspect({ length: this.length });
+    return this.constructor.name + ' ' + obj;
+  };
+}
\ No newline at end of file

+'use strict';
+
+/*<replacement>*/
+
+var pna = require('process-nextick-args');
+/*</replacement>*/
+
+// undocumented cb() API, needed for core, not for public API
+function destroy(err, cb) {
+  var _this = this;
+
+  var readableDestroyed = this._readableState && this._readableState.destroyed;
+  var writableDestroyed = this._writableState && this._writableState.destroyed;
+
+  if (readableDestroyed || writableDestroyed) {
+    if (cb) {
+      cb(err);
+    } else if (err && (!this._writableState || !this._writableState.errorEmitted)) {
+      pna.nextTick(emitErrorNT, this, err);
+    }
+    return this;
+  }
+
+  // we set destroyed to true before firing error callbacks in order
+  // to make it re-entrance safe in case destroy() is called within callbacks
+
+  if (this._readableState) {
+    this._readableState.destroyed = true;
+  }
+
+  // if this is a duplex stream mark the writable part as destroyed as well
+  if (this._writableState) {
+    this._writableState.destroyed = true;
+  }
+
+  this._destroy(err || null, function (err) {
+    if (!cb && err) {
+      pna.nextTick(emitErrorNT, _this, err);
+      if (_this._writableState) {
+        _this._writableState.errorEmitted = true;
+      }
+    } else if (cb) {
+      cb(err);
+    }
+  });
+
+  return this;
+}
+
+function undestroy() {
+  if (this._readableState) {
+    this._readableState.destroyed = false;
+    this._readableState.reading = false;
+    this._readableState.ended = false;
+    this._readableState.endEmitted = false;
+  }
+
+  if (this._writableState) {
+    this._writableState.destroyed = false;
+    this._writableState.ended = false;
+    this._writableState.ending = false;
+    this._writableState.finished = false;
+    this._writableState.errorEmitted = false;
+  }
+}
+
+function emitErrorNT(self, err) {
+  self.emit('error', err);
+}
+
+module.exports = {
+  destroy: destroy,
+  undestroy: undestroy
+};
\ No newline at end of file

+{
+  "_from": "readable-stream@^2.2.2",
+  "_id": "readable-stream@2.3.7",
+  "_inBundle": false,
+  "_integrity": "sha512-Ebho8K4jIbHAxnuxi7o42OrZgF/ZTNcsZj6nRKyUmkhLFq8CHItp/fy6hQZuZmP/n3yZ9VBUbp4zz/mX8hmYPw==",
+  "_location": "/concat-stream/readable-stream",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "readable-stream@^2.2.2",
+    "name": "readable-stream",
+    "escapedName": "readable-stream",
+    "rawSpec": "^2.2.2",
+    "saveSpec": null,
+    "fetchSpec": "^2.2.2"
+  },
+  "_requiredBy": [
+    "/concat-stream"
+  ],
+  "_resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.7.tgz",
+  "_shasum": "1eca1cf711aef814c04f62252a36a62f6cb23b57",
+  "_spec": "readable-stream@^2.2.2",
+  "_where": "C:\\Users\\1000c\\이것저것\\옾소\\Voicoding\\node_modules\\concat-stream",
+  "browser": {
+    "util": false,
+    "./readable.js": "./readable-browser.js",
+    "./writable.js": "./writable-browser.js",
+    "./duplex.js": "./duplex-browser.js",
+    "./lib/internal/streams/stream.js": "./lib/internal/streams/stream-browser.js"
+  },
+  "bugs": {
+    "url": "https://github.com/nodejs/readable-stream/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "core-util-is": "~1.0.0",
+    "inherits": "~2.0.3",
+    "isarray": "~1.0.0",
+    "process-nextick-args": "~2.0.0",
+    "safe-buffer": "~5.1.1",
+    "string_decoder": "~1.1.1",
+    "util-deprecate": "~1.0.1"
+  },
+  "deprecated": false,
+  "description": "Streams3, a user-land copy of the stream library from Node.js",
+  "devDependencies": {
+    "assert": "^1.4.0",
+    "babel-polyfill": "^6.9.1",
+    "buffer": "^4.9.0",
+    "lolex": "^2.3.2",
+    "nyc": "^6.4.0",
+    "tap": "^0.7.0",
+    "tape": "^4.8.0"
+  },
+  "homepage": "https://github.com/nodejs/readable-stream#readme",
+  "keywords": [
+    "readable",
+    "stream",
+    "pipe"
+  ],
+  "license": "MIT",
+  "main": "readable.js",
+  "name": "readable-stream",
+  "nyc": {
+    "include": [
+      "lib/**.js"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/nodejs/readable-stream.git"
+  },
+  "scripts": {
+    "ci": "tap test/parallel/*.js test/ours/*.js --tap | tee test.tap && node test/verify-dependencies.js",
+    "cover": "nyc npm test",
+    "report": "nyc report --reporter=lcov",
+    "test": "tap test/parallel/*.js test/ours/*.js && node test/verify-dependencies.js"
+  },
+  "version": "2.3.7"
+}

+module.exports = require('./readable').PassThrough

+exports = module.exports = require('./lib/_stream_readable.js');
+exports.Stream = exports;
+exports.Readable = exports;
+exports.Writable = require('./lib/_stream_writable.js');
+exports.Duplex = require('./lib/_stream_duplex.js');
+exports.Transform = require('./lib/_stream_transform.js');
+exports.PassThrough = require('./lib/_stream_passthrough.js');

+var Stream = require('stream');
+if (process.env.READABLE_STREAM === 'disable' && Stream) {
+  module.exports = Stream;
+  exports = module.exports = Stream.Readable;
+  exports.Readable = Stream.Readable;
+  exports.Writable = Stream.Writable;
+  exports.Duplex = Stream.Duplex;
+  exports.Transform = Stream.Transform;
+  exports.PassThrough = Stream.PassThrough;
+  exports.Stream = Stream;
+} else {
+  exports = module.exports = require('./lib/_stream_readable.js');
+  exports.Stream = Stream || exports;
+  exports.Readable = exports;
+  exports.Writable = require('./lib/_stream_writable.js');
+  exports.Duplex = require('./lib/_stream_duplex.js');
+  exports.Transform = require('./lib/_stream_transform.js');
+  exports.PassThrough = require('./lib/_stream_passthrough.js');
+}

+module.exports = require('./readable').Transform

+module.exports = require('./lib/_stream_writable.js');

+var Stream = require("stream")
+var Writable = require("./lib/_stream_writable.js")
+
+if (process.env.READABLE_STREAM === 'disable') {
+  module.exports = Stream && Stream.Writable || Writable
+} else {
+  module.exports = Writable
+}

+sudo: false
+language: node_js
+before_install:
+  - npm install -g npm@2
+  - test $NPM_LEGACY && npm install -g npm@latest-3 || npm install npm -g
+notifications:
+  email: false
+matrix:
+  fast_finish: true
+  include:
+  - node_js: '0.8'
+    env:
+      - TASK=test
+      - NPM_LEGACY=true
+  - node_js: '0.10'
+    env:
+      - TASK=test
+      - NPM_LEGACY=true
+  - node_js: '0.11'
+    env:
+      - TASK=test
+      - NPM_LEGACY=true
+  - node_js: '0.12'
+    env:
+      - TASK=test
+      - NPM_LEGACY=true
+  - node_js: 1
+    env:
+      - TASK=test
+      - NPM_LEGACY=true
+  - node_js: 2
+    env:
+      - TASK=test
+      - NPM_LEGACY=true
+  - node_js: 3
+    env:
+      - TASK=test
+      - NPM_LEGACY=true
+  - node_js: 4
+    env: TASK=test
+  - node_js: 5
+    env: TASK=test
+  - node_js: 6
+    env: TASK=test
+  - node_js: 7
+    env: TASK=test
+  - node_js: 8
+    env: TASK=test
+  - node_js: 9
+    env: TASK=test

+Node.js is licensed for use as follows:
+
+"""
+Copyright Node.js contributors. All rights reserved.
+
+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.
+"""
+
+This license applies to parts of Node.js originating from the
+https://github.com/joyent/node repository:
+
+"""
+Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+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.
+"""
+

+# string_decoder
+
+***Node-core v8.9.4 string_decoder for userland***
+
+
+[![NPM](https://nodei.co/npm/string_decoder.png?downloads=true&downloadRank=true)](https://nodei.co/npm/string_decoder/)
+[![NPM](https://nodei.co/npm-dl/string_decoder.png?&months=6&height=3)](https://nodei.co/npm/string_decoder/)
+
+
+```bash
+npm install --save string_decoder
+```
+
+***Node-core string_decoder for userland***
+
+This package is a mirror of the string_decoder implementation in Node-core.
+
+Full documentation may be found on the [Node.js website](https://nodejs.org/dist/v8.9.4/docs/api/).
+
+As of version 1.0.0 **string_decoder** uses semantic versioning.
+
+## Previous versions
+
+Previous version numbers match the versions found in Node core, e.g. 0.10.24 matches Node 0.10.24, likewise 0.11.10 matches Node 0.11.10.
+
+## Update
+
+The *build/* directory contains a build script that will scrape the source from the [nodejs/node](https://github.com/nodejs/node) repo given a specific Node version.
+
+## Streams Working Group
+
+`string_decoder` is maintained by the Streams Working Group, which
+oversees the development and maintenance of the Streams API within
+Node.js. The responsibilities of the Streams Working Group include:
+
+* Addressing stream issues on the Node.js issue tracker.
+* Authoring and editing stream documentation within the Node.js project.
+* Reviewing changes to stream subclasses within the Node.js project.
+* Redirecting changes to streams from the Node.js project to this
+  project.
+* Assisting in the implementation of stream providers within Node.js.
+* Recommending versions of `readable-stream` to be included in Node.js.
+* Messaging about the future of streams to give the community advance
+  notice of changes.
+
+See [readable-stream](https://github.com/nodejs/readable-stream) for
+more details.

+{
+  "_from": "string_decoder@~1.1.1",
+  "_id": "string_decoder@1.1.1",
+  "_inBundle": false,
+  "_integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==",
+  "_location": "/concat-stream/string_decoder",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "string_decoder@~1.1.1",
+    "name": "string_decoder",
+    "escapedName": "string_decoder",
+    "rawSpec": "~1.1.1",
+    "saveSpec": null,
+    "fetchSpec": "~1.1.1"
+  },
+  "_requiredBy": [
+    "/concat-stream/readable-stream"
+  ],
+  "_resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz",
+  "_shasum": "9cf1611ba62685d7030ae9e4ba34149c3af03fc8",
+  "_spec": "string_decoder@~1.1.1",
+  "_where": "C:\\Users\\1000c\\이것저것\\옾소\\Voicoding\\node_modules\\concat-stream\\node_modules\\readable-stream",
+  "bugs": {
+    "url": "https://github.com/nodejs/string_decoder/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "safe-buffer": "~5.1.0"
+  },
+  "deprecated": false,
+  "description": "The string_decoder module from Node core",
+  "devDependencies": {
+    "babel-polyfill": "^6.23.0",
+    "core-util-is": "^1.0.2",
+    "inherits": "^2.0.3",
+    "tap": "~0.4.8"
+  },
+  "homepage": "https://github.com/nodejs/string_decoder",
+  "keywords": [
+    "string",
+    "decoder",
+    "browser",
+    "browserify"
+  ],
+  "license": "MIT",
+  "main": "lib/string_decoder.js",
+  "name": "string_decoder",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/nodejs/string_decoder.git"
+  },
+  "scripts": {
+    "ci": "tap test/parallel/*.js test/ours/*.js --tap | tee test.tap && node test/verify-dependencies.js",
+    "test": "tap test/parallel/*.js && node test/verify-dependencies"
+  },
+  "version": "1.1.1"
+}

+{
+  "_from": "concat-stream@^1.5.2",
+  "_id": "concat-stream@1.6.2",
+  "_inBundle": false,
+  "_integrity": "sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw==",
+  "_location": "/concat-stream",
+  "_phantomChildren": {
+    "core-util-is": "1.0.2",
+    "inherits": "2.0.4",
+    "process-nextick-args": "2.0.1",
+    "safe-buffer": "5.1.2",
+    "util-deprecate": "1.0.2"
+  },
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "concat-stream@^1.5.2",
+    "name": "concat-stream",
+    "escapedName": "concat-stream",
+    "rawSpec": "^1.5.2",
+    "saveSpec": null,
+    "fetchSpec": "^1.5.2"
+  },
+  "_requiredBy": [
+    "/multer"
+  ],
+  "_resolved": "https://registry.npmjs.org/concat-stream/-/concat-stream-1.6.2.tgz",
+  "_shasum": "904bdf194cd3122fc675c77fc4ac3d4ff0fd1a34",
+  "_spec": "concat-stream@^1.5.2",
+  "_where": "C:\\Users\\1000c\\이것저것\\옾소\\Voicoding\\node_modules\\multer",
+  "author": {
+    "name": "Max Ogden",
+    "email": "max@maxogden.com"
+  },
+  "bugs": {
+    "url": "http://github.com/maxogden/concat-stream/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "buffer-from": "^1.0.0",
+    "inherits": "^2.0.3",
+    "readable-stream": "^2.2.2",
+    "typedarray": "^0.0.6"
+  },
+  "deprecated": false,
+  "description": "writable stream that concatenates strings or binary data and calls a callback with the result",
+  "devDependencies": {
+    "tape": "^4.6.3"
+  },
+  "engines": [
+    "node >= 0.8"
+  ],
+  "files": [
+    "index.js"
+  ],
+  "homepage": "https://github.com/maxogden/concat-stream#readme",
+  "license": "MIT",
+  "main": "index.js",
+  "name": "concat-stream",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/maxogden/concat-stream.git"
+  },
+  "scripts": {
+    "test": "tape test/*.js test/server/*.js"
+  },
+  "tags": [
+    "stream",
+    "simple",
+    "util",
+    "utility"
+  ],
+  "testling": {
+    "files": "test/*.js",
+    "browsers": [
+      "ie/8..latest",
+      "firefox/17..latest",
+      "firefox/nightly",
+      "chrome/22..latest",
+      "chrome/canary",
+      "opera/12..latest",
+      "opera/next",
+      "safari/5.1..latest",
+      "ipad/6.0..latest",
+      "iphone/6.0..latest",
+      "android-browser/4.2..latest"
+    ]
+  },
+  "version": "1.6.2"
+}

+# concat-stream
+
+Writable stream that concatenates all the data from a stream and calls a callback with the result. Use this when you want to collect all the data from a stream into a single buffer.
+
+[![Build Status](https://travis-ci.org/maxogden/concat-stream.svg?branch=master)](https://travis-ci.org/maxogden/concat-stream)
+
+[![NPM](https://nodei.co/npm/concat-stream.png)](https://nodei.co/npm/concat-stream/)
+
+### description
+
+Streams emit many buffers. If you want to collect all of the buffers, and when the stream ends concatenate all of the buffers together and receive a single buffer then this is the module for you.
+
+Only use this if you know you can fit all of the output of your stream into a single Buffer (e.g. in RAM).
+
+There are also `objectMode` streams that emit things other than Buffers, and you can concatenate these too. See below for details.
+
+## Related
+
+`concat-stream` is part of the [mississippi stream utility collection](https://github.com/maxogden/mississippi) which includes more useful stream modules similar to this one.
+
+### examples
+
+#### Buffers
+
+```js
+var fs = require('fs')
+var concat = require('concat-stream')
+
+var readStream = fs.createReadStream('cat.png')
+var concatStream = concat(gotPicture)
+
+readStream.on('error', handleError)
+readStream.pipe(concatStream)
+
+function gotPicture(imageBuffer) {
+  // imageBuffer is all of `cat.png` as a node.js Buffer
+}
+
+function handleError(err) {
+  // handle your error appropriately here, e.g.:
+  console.error(err) // print the error to STDERR
+  process.exit(1) // exit program with non-zero exit code
+}
+
+```
+
+#### Arrays
+
+```js
+var write = concat(function(data) {})
+write.write([1,2,3])
+write.write([4,5,6])
+write.end()
+// data will be [1,2,3,4,5,6] in the above callback
+```
+
+#### Uint8Arrays
+
+```js
+var write = concat(function(data) {})
+var a = new Uint8Array(3)
+a[0] = 97; a[1] = 98; a[2] = 99
+write.write(a)
+write.write('!')
+write.end(Buffer.from('!!1'))
+```
+
+See `test/` for more examples
+
+# methods
+
+```js
+var concat = require('concat-stream')
+```
+
+## var writable = concat(opts={}, cb)
+
+Return a `writable` stream that will fire `cb(data)` with all of the data that
+was written to the stream. Data can be written to `writable` as strings,
+Buffers, arrays of byte integers, and Uint8Arrays. 
+
+By default `concat-stream` will give you back the same data type as the type of the first buffer written to the stream. Use `opts.encoding` to set what format `data` should be returned as, e.g. if you if you don't want to rely on the built-in type checking or for some other reason.
+
+* `string` - get a string
+* `buffer` - get back a Buffer
+* `array` - get an array of byte integers
+* `uint8array`, `u8`, `uint8` - get back a Uint8Array
+* `object`, get back an array of Objects
+
+If you don't specify an encoding, and the types can't be inferred (e.g. you write things that aren't in the list above), it will try to convert concat them into a `Buffer`.
+
+If nothing is written to `writable` then `data` will be an empty array `[]`.
+
+# error handling
+
+`concat-stream` does not handle errors for you, so you must handle errors on whatever streams you pipe into `concat-stream`. This is a general rule when programming with node.js streams: always handle errors on each and every stream. Since `concat-stream` is not itself a stream it does not emit errors.
+
+We recommend using [`end-of-stream`](https://npmjs.org/end-of-stream) or [`pump`](https://npmjs.org/pump) for writing error tolerant stream code.
+
+# license
+
+MIT LICENSE

+Copyright Node.js contributors. All rights reserved.
+
+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.

+# core-util-is
+
+The `util.is*` functions introduced in Node v0.12.

+// Copyright Joyent, Inc. and other Node 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.
+
+// NOTE: These type checking functions intentionally don't use `instanceof`
+// because it is fragile and can be easily faked with `Object.create()`.
+
+function isArray(arg) {
+  if (Array.isArray) {
+    return Array.isArray(arg);
+  }
+  return objectToString(arg) === '[object Array]';
+}
+exports.isArray = isArray;
+
+function isBoolean(arg) {
+  return typeof arg === 'boolean';
+}
+exports.isBoolean = isBoolean;
+
+function isNull(arg) {
+  return arg === null;
+}
+exports.isNull = isNull;
+
+function isNullOrUndefined(arg) {
+  return arg == null;
+}
+exports.isNullOrUndefined = isNullOrUndefined;
+
+function isNumber(arg) {
+  return typeof arg === 'number';
+}
+exports.isNumber = isNumber;
+
+function isString(arg) {
+  return typeof arg === 'string';
+}
+exports.isString = isString;
+
+function isSymbol(arg) {
+  return typeof arg === 'symbol';
+}
+exports.isSymbol = isSymbol;
+
+function isUndefined(arg) {
+  return arg === void 0;
+}
+exports.isUndefined = isUndefined;
+
+function isRegExp(re) {
+  return objectToString(re) === '[object RegExp]';
+}
+exports.isRegExp = isRegExp;
+
+function isObject(arg) {
+  return typeof arg === 'object' && arg !== null;
+}
+exports.isObject = isObject;
+
+function isDate(d) {
+  return objectToString(d) === '[object Date]';
+}
+exports.isDate = isDate;
+
+function isError(e) {
+  return (objectToString(e) === '[object Error]' || e instanceof Error);
+}
+exports.isError = isError;
+
+function isFunction(arg) {
+  return typeof arg === 'function';
+}
+exports.isFunction = isFunction;
+
+function isPrimitive(arg) {
+  return arg === null ||
+         typeof arg === 'boolean' ||
+         typeof arg === 'number' ||
+         typeof arg === 'string' ||
+         typeof arg === 'symbol' ||  // ES6 symbol
+         typeof arg === 'undefined';
+}
+exports.isPrimitive = isPrimitive;
+
+exports.isBuffer = Buffer.isBuffer;
+
+function objectToString(o) {
+  return Object.prototype.toString.call(o);
+}

+{
+  "_from": "core-util-is@~1.0.0",
+  "_id": "core-util-is@1.0.2",
+  "_inBundle": false,
+  "_integrity": "sha1-tf1UIgqivFq1eqtxQMlAdUUDwac=",
+  "_location": "/core-util-is",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "core-util-is@~1.0.0",
+    "name": "core-util-is",
+    "escapedName": "core-util-is",
+    "rawSpec": "~1.0.0",
+    "saveSpec": null,
+    "fetchSpec": "~1.0.0"
+  },
+  "_requiredBy": [
+    "/concat-stream/readable-stream",
+    "/readable-stream"
+  ],
+  "_resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.2.tgz",
+  "_shasum": "b5fd54220aa2bc5ab57aab7140c940754503c1a7",
+  "_spec": "core-util-is@~1.0.0",
+  "_where": "C:\\Users\\1000c\\이것저것\\옾소\\Voicoding\\node_modules\\readable-stream",
+  "author": {
+    "name": "Isaac Z. Schlueter",
+    "email": "i@izs.me",
+    "url": "http://blog.izs.me/"
+  },
+  "bugs": {
+    "url": "https://github.com/isaacs/core-util-is/issues"
+  },
+  "bundleDependencies": false,
+  "deprecated": false,
+  "description": "The `util.is*` functions introduced in Node v0.12.",
+  "devDependencies": {
+    "tap": "^2.3.0"
+  },
+  "homepage": "https://github.com/isaacs/core-util-is#readme",
+  "keywords": [
+    "util",
+    "isBuffer",
+    "isArray",
+    "isNumber",
+    "isString",
+    "isRegExp",
+    "isThis",
+    "isThat",
+    "polyfill"
+  ],
+  "license": "MIT",
+  "main": "lib/util.js",
+  "name": "core-util-is",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/isaacs/core-util-is.git"
+  },
+  "scripts": {
+    "test": "tap test.js"
+  },
+  "version": "1.0.2"
+}

+var assert = require('tap');
+
+var t = require('./lib/util');
+
+assert.equal(t.isArray([]), true);
+assert.equal(t.isArray({}), false);
+
+assert.equal(t.isBoolean(null), false);
+assert.equal(t.isBoolean(true), true);
+assert.equal(t.isBoolean(false), true);
+
+assert.equal(t.isNull(null), true);
+assert.equal(t.isNull(undefined), false);
+assert.equal(t.isNull(false), false);
+assert.equal(t.isNull(), false);
+
+assert.equal(t.isNullOrUndefined(null), true);
+assert.equal(t.isNullOrUndefined(undefined), true);
+assert.equal(t.isNullOrUndefined(false), false);
+assert.equal(t.isNullOrUndefined(), true);
+
+assert.equal(t.isNumber(null), false);
+assert.equal(t.isNumber('1'), false);
+assert.equal(t.isNumber(1), true);
+
+assert.equal(t.isString(null), false);
+assert.equal(t.isString('1'), true);
+assert.equal(t.isString(1), false);
+
+assert.equal(t.isSymbol(null), false);
+assert.equal(t.isSymbol('1'), false);
+assert.equal(t.isSymbol(1), false);
+assert.equal(t.isSymbol(Symbol()), true);
+
+assert.equal(t.isUndefined(null), false);
+assert.equal(t.isUndefined(undefined), true);
+assert.equal(t.isUndefined(false), false);
+assert.equal(t.isUndefined(), true);
+
+assert.equal(t.isRegExp(null), false);
+assert.equal(t.isRegExp('1'), false);
+assert.equal(t.isRegExp(new RegExp()), true);
+
+assert.equal(t.isObject({}), true);
+assert.equal(t.isObject([]), true);
+assert.equal(t.isObject(new RegExp()), true);
+assert.equal(t.isObject(new Date()), true);
+
+assert.equal(t.isDate(null), false);
+assert.equal(t.isDate('1'), false);
+assert.equal(t.isDate(new Date()), true);
+
+assert.equal(t.isError(null), false);
+assert.equal(t.isError({ err: true }), false);
+assert.equal(t.isError(new Error()), true);
+
+assert.equal(t.isFunction(null), false);
+assert.equal(t.isFunction({ }), false);
+assert.equal(t.isFunction(function() {}), true);
+
+assert.equal(t.isPrimitive(null), true);
+assert.equal(t.isPrimitive(''), true);
+assert.equal(t.isPrimitive(0), true);
+assert.equal(t.isPrimitive(new Date()), false);
+
+assert.equal(t.isBuffer(null), false);
+assert.equal(t.isBuffer({}), false);
+assert.equal(t.isBuffer(new Buffer(0)), true);

+sudo: false
+language: cpp
+notifications:
+  email: false
+env:
+  matrix:
+  - TRAVIS_NODE_VERSION="0.10"
+  - TRAVIS_NODE_VERSION="0.12"
+  - TRAVIS_NODE_VERSION="4"
+  - TRAVIS_NODE_VERSION="5"
+install:
+  - rm -rf ~/.nvm && git clone https://github.com/creationix/nvm.git ~/.nvm && source ~/.nvm/nvm.sh && nvm install $TRAVIS_NODE_VERSION
+  - node --version
+  - npm --version
+  - npm install
+script: npm test

+Copyright Brian White. All rights reserved.
+
+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.
\ No newline at end of file

+
+Description
+===========
+
+A very fast streaming multipart parser for node.js.
+
+Benchmarks can be found [here](https://github.com/mscdex/dicer/wiki/Benchmarks).
+
+
+Requirements
+============
+
+* [node.js](http://nodejs.org/) -- v0.8.0 or newer
+
+
+Install
+============
+
+    npm install dicer
+
+
+Examples
+========
+
+* Parse an HTTP form upload
+
+```javascript
+var inspect = require('util').inspect,
+    http = require('http');
+
+var Dicer = require('dicer');
+
+    // quick and dirty way to parse multipart boundary
+var RE_BOUNDARY = /^multipart\/.+?(?:; boundary=(?:(?:"(.+)")|(?:([^\s]+))))$/i,
+    HTML = new Buffer('<html><head></head><body>\
+                       <form method="POST" enctype="multipart/form-data">\
+                         <input type="text" name="textfield"><br />\
+                         <input type="file" name="filefield"><br />\
+                         <input type="submit">\
+                       </form>\
+                       </body></html>'),
+    PORT = 8080;
+
+http.createServer(function(req, res) {
+  var m;
+  if (req.method === 'POST'
+      && req.headers['content-type']
+      && (m = RE_BOUNDARY.exec(req.headers['content-type']))) {
+    var d = new Dicer({ boundary: m[1] || m[2] });
+
+    d.on('part', function(p) {
+      console.log('New part!');
+      p.on('header', function(header) {
+        for (var h in header) {
+          console.log('Part header: k: ' + inspect(h)
+                      + ', v: ' + inspect(header[h]));
+        }
+      });
+      p.on('data', function(data) {
+        console.log('Part data: ' + inspect(data.toString()));
+      });
+      p.on('end', function() {
+        console.log('End of part\n');
+      });
+    });
+    d.on('finish', function() {
+      console.log('End of parts');
+      res.writeHead(200);
+      res.end('Form submission successful!');
+    });
+    req.pipe(d);
+  } else if (req.method === 'GET' && req.url === '/') {
+    res.writeHead(200);
+    res.end(HTML);
+  } else {
+    res.writeHead(404);
+    res.end();
+  }
+}).listen(PORT, function() {
+  console.log('Listening for requests on port ' + PORT);
+});
+```
+
+
+API
+===
+
+_Dicer_ is a _WritableStream_
+
+Dicer (special) events
+----------------------
+
+* **finish**() - Emitted when all parts have been parsed and the Dicer instance has been ended.
+
+* **part**(< _PartStream_ >stream) - Emitted when a new part has been found.
+
+* **preamble**(< _PartStream_ >stream) - Emitted for preamble if you should happen to need it (can usually be ignored).
+
+* **trailer**(< _Buffer_ >data) - Emitted when trailing data was found after the terminating boundary (as with the preamble, this can usually be ignored too).
+
+
+Dicer methods
+-------------
+
+* **(constructor)**(< _object_ >config) - Creates and returns a new Dicer instance with the following valid `config` settings:
+
+    * **boundary** - _string_ - This is the boundary used to detect the beginning of a new part.
+
+    * **headerFirst** - _boolean_ - If true, preamble header parsing will be performed first.
+
+    * **maxHeaderPairs** - _integer_ - The maximum number of header key=>value pairs to parse **Default:** 2000 (same as node's http).
+
+* **setBoundary**(< _string_ >boundary) - _(void)_ - Sets the boundary to use for parsing and performs some initialization needed for parsing. You should only need to use this if you set `headerFirst` to true in the constructor and are parsing the boundary from the preamble header.
+
+
+
+_PartStream_ is a _ReadableStream_
+
+PartStream (special) events
+---------------------------
+
+* **header**(< _object_ >header) - An object containing the header for this particular part. Each property value is an _array_ of one or more string values.

+var assert = require('assert');
+var Dicer = require('..'),
+    boundary = '-----------------------------168072824752491622650073',
+    d = new Dicer({ boundary: boundary }),
+    mb = 100,
+    buffer = createMultipartBuffer(boundary, mb * 1024 * 1024),
+    callbacks =
+      { partBegin: -1,
+        partEnd: -1,
+        headerField: -1,
+        headerValue: -1,
+        partData: -1,
+        end: -1,
+      };
+
+
+d.on('part', function(p) {
+  callbacks.partBegin++;
+  p.on('header', function(header) {
+    /*for (var h in header)
+      console.log('Part header: k: ' + inspect(h) + ', v: ' + inspect(header[h]));*/
+  });
+  p.on('data', function(data) {
+    callbacks.partData++;
+    //console.log('Part data: ' + inspect(data.toString()));
+  });
+  p.on('end', function() {
+    //console.log('End of part\n');
+    callbacks.partEnd++;
+  });
+});
+d.on('end', function() {
+  //console.log('End of parts');
+  callbacks.end++;
+});
+
+var start = +new Date(),
+    nparsed = d.write(buffer),
+    duration = +new Date - start,
+    mbPerSec = (mb / (duration / 1000)).toFixed(2);
+
+console.log(mbPerSec+' mb/sec');
+
+//assert.equal(nparsed, buffer.length);
+
+function createMultipartBuffer(boundary, size) {
+  var head =
+        '--'+boundary+'\r\n'
+      + 'content-disposition: form-data; name="field1"\r\n'
+      + '\r\n'
+    , tail = '\r\n--'+boundary+'--\r\n'
+    , buffer = new Buffer(size);
+
+  buffer.write(head, 'ascii', 0);
+  buffer.write(tail, 'ascii', buffer.length - tail.length);
+  return buffer;
+}
+
+process.on('exit', function() {
+  /*for (var k in callbacks) {
+    assert.equal(0, callbacks[k], k+' count off by '+callbacks[k]);
+  }*/
+});

+var assert = require('assert');
+require('../node_modules/formidable/test/common');
+var multipartParser = require('../node_modules/formidable/lib/multipart_parser'),
+    MultipartParser = multipartParser.MultipartParser,
+    parser = new MultipartParser(),
+    boundary = '-----------------------------168072824752491622650073',
+    mb = 100,
+    buffer = createMultipartBuffer(boundary, mb * 1024 * 1024),
+    callbacks =
+      { partBegin: -1,
+        partEnd: -1,
+        headerField: -1,
+        headerValue: -1,
+        partData: -1,
+        end: -1,
+      };
+
+
+parser.initWithBoundary(boundary);
+parser.onHeaderField = function() {
+  callbacks.headerField++;
+};
+
+parser.onHeaderValue = function() {
+  callbacks.headerValue++;
+};
+
+parser.onPartBegin = function() {
+  callbacks.partBegin++;
+};
+
+parser.onPartData = function() {
+  callbacks.partData++;
+};
+
+parser.onPartEnd = function() {
+  callbacks.partEnd++;
+};
+
+parser.onEnd = function() {
+  callbacks.end++;
+};
+
+var start = +new Date(),
+    nparsed = parser.write(buffer),
+    duration = +new Date - start,
+    mbPerSec = (mb / (duration / 1000)).toFixed(2);
+
+console.log(mbPerSec+' mb/sec');
+
+//assert.equal(nparsed, buffer.length);
+
+function createMultipartBuffer(boundary, size) {
+  var head =
+        '--'+boundary+'\r\n'
+      + 'content-disposition: form-data; name="field1"\r\n'
+      + '\r\n'
+    , tail = '\r\n--'+boundary+'--\r\n'
+    , buffer = new Buffer(size);
+
+  buffer.write(head, 'ascii', 0);
+  buffer.write(tail, 'ascii', buffer.length - tail.length);
+  return buffer;
+}
+
+process.on('exit', function() {
+  /*for (var k in callbacks) {
+    assert.equal(0, callbacks[k], k+' count off by '+callbacks[k]);
+  }*/
+});

+var assert = require('assert');
+var multipartser = require('multipartser'),
+    boundary = '-----------------------------168072824752491622650073',
+    parser = multipartser(),
+    mb = 100,
+    buffer = createMultipartBuffer(boundary, mb * 1024 * 1024),
+    callbacks =
+      { partBegin: -1,
+        partEnd: -1,
+        headerField: -1,
+        headerValue: -1,
+        partData: -1,
+        end: -1,
+      };
+
+parser.boundary( boundary );
+
+parser.on( 'part', function ( part ) {
+});
+
+parser.on( 'end', function () {
+  //console.log( 'completed parsing' );
+});
+
+parser.on( 'error', function ( error ) {
+  console.error( error );
+});
+
+var start = +new Date(),
+    nparsed = parser.data(buffer),
+    nend = parser.end(),
+    duration = +new Date - start,
+    mbPerSec = (mb / (duration / 1000)).toFixed(2);
+
+console.log(mbPerSec+' mb/sec');
+
+//assert.equal(nparsed, buffer.length);
+
+function createMultipartBuffer(boundary, size) {
+  var head =
+        '--'+boundary+'\r\n'
+      + 'content-disposition: form-data; name="field1"\r\n'
+      + '\r\n'
+    , tail = '\r\n--'+boundary+'--\r\n'
+    , buffer = new Buffer(size);
+
+  buffer.write(head, 'ascii', 0);
+  buffer.write(tail, 'ascii', buffer.length - tail.length);
+  return buffer;
+}
+
+process.on('exit', function() {
+  /*for (var k in callbacks) {
+    assert.equal(0, callbacks[k], k+' count off by '+callbacks[k]);
+  }*/
+});

+var assert = require('assert'),
+    Form = require('multiparty').Form,
+    boundary = '-----------------------------168072824752491622650073',
+    mb = 100,
+    buffer = createMultipartBuffer(boundary, mb * 1024 * 1024),
+    callbacks =
+      { partBegin: -1,
+        partEnd: -1,
+        headerField: -1,
+        headerValue: -1,
+        partData: -1,
+        end: -1,
+      };
+
+var form = new Form({ boundary: boundary });
+
+hijack('onParseHeaderField', function() {
+  callbacks.headerField++;
+});
+
+hijack('onParseHeaderValue', function() {
+  callbacks.headerValue++;
+});
+
+hijack('onParsePartBegin', function() {
+  callbacks.partBegin++;
+});
+
+hijack('onParsePartData', function() {
+  callbacks.partData++;
+});
+
+hijack('onParsePartEnd', function() {
+  callbacks.partEnd++;
+});
+
+form.on('finish', function() {
+  callbacks.end++;
+});
+
+var start = new Date();
+form.write(buffer, function(err) {
+  var duration = new Date() - start;
+  assert.ifError(err);
+  var mbPerSec = (mb / (duration / 1000)).toFixed(2);
+  console.log(mbPerSec+' mb/sec');
+});
+
+//assert.equal(nparsed, buffer.length);
+
+function createMultipartBuffer(boundary, size) {
+  var head =
+        '--'+boundary+'\r\n'
+      + 'content-disposition: form-data; name="field1"\r\n'
+      + '\r\n'
+    , tail = '\r\n--'+boundary+'--\r\n'
+    , buffer = new Buffer(size);
+
+  buffer.write(head, 'ascii', 0);
+  buffer.write(tail, 'ascii', buffer.length - tail.length);
+  return buffer;
+}
+
+process.on('exit', function() {
+  /*for (var k in callbacks) {
+    assert.equal(0, callbacks[k], k+' count off by '+callbacks[k]);
+  }*/
+});
+
+function hijack(name, fn) {
+  var oldFn = form[name];
+  form[name] = function() {
+    fn();
+    return oldFn.apply(this, arguments);
+  };
+}

+// A special, edited version of the multipart parser from parted is needed here
+// because otherwise it attempts to do some things above and beyond just parsing
+// -- like saving to disk and whatnot
+
+var assert = require('assert');
+var Parser = require('./parted-multipart'),
+    boundary = '-----------------------------168072824752491622650073',
+    parser = new Parser('boundary=' + boundary),
+    mb = 100,
+    buffer = createMultipartBuffer(boundary, mb * 1024 * 1024),
+    callbacks =
+      { partBegin: -1,
+        partEnd: -1,
+        headerField: -1,
+        headerValue: -1,
+        partData: -1,
+        end: -1,
+      };
+
+
+parser.on('header', function() {
+  //callbacks.headerField++;
+});
+
+parser.on('data', function() {
+  //callbacks.partBegin++;
+});
+
+parser.on('part', function() {
+
+});
+
+parser.on('end', function() {
+  //callbacks.end++;
+});
+
+var start = +new Date(),
+    nparsed = parser.write(buffer),
+    duration = +new Date - start,
+    mbPerSec = (mb / (duration / 1000)).toFixed(2);
+
+console.log(mbPerSec+' mb/sec');
+
+//assert.equal(nparsed, buffer.length);
+
+function createMultipartBuffer(boundary, size) {
+  var head =
+        '--'+boundary+'\r\n'
+      + 'content-disposition: form-data; name="field1"\r\n'
+      + '\r\n'
+    , tail = '\r\n--'+boundary+'--\r\n'
+    , buffer = new Buffer(size);
+
+  buffer.write(head, 'ascii', 0);
+  buffer.write(tail, 'ascii', buffer.length - tail.length);
+  return buffer;
+}
+
+process.on('exit', function() {
+  /*for (var k in callbacks) {
+    assert.equal(0, callbacks[k], k+' count off by '+callbacks[k]);
+  }*/
+});

+/**
+ * Parted (https://github.com/chjj/parted)
+ * A streaming multipart state parser.
+ * Copyright (c) 2011, Christopher Jeffrey. (MIT Licensed)
+ */
+
+var fs = require('fs')
+  , path = require('path')
+  , EventEmitter = require('events').EventEmitter
+  , StringDecoder = require('string_decoder').StringDecoder
+  , set = require('qs').set
+  , each = Array.prototype.forEach;
+
+/**
+ * Character Constants
+ */
+
+var DASH = '-'.charCodeAt(0)
+  , CR = '\r'.charCodeAt(0)
+  , LF = '\n'.charCodeAt(0)
+  , COLON = ':'.charCodeAt(0)
+  , SPACE = ' '.charCodeAt(0);
+
+/**
+ * Parser
+ */
+
+var Parser = function(type, options) {
+  if (!(this instanceof Parser)) {
+    return new Parser(type, options);
+  }
+
+  EventEmitter.call(this);
+
+  this.writable = true;
+  this.readable = true;
+
+  this.options = options || {};
+
+  var key = grab(type, 'boundary');
+  if (!key) {
+    return this._error('No boundary key found.');
+  }
+
+  this.key = new Buffer('\r\n--' + key);
+
+  this._key = {};
+  each.call(this.key, function(ch) {
+    this._key[ch] = true;
+  }, this);
+
+  this.state = 'start';
+  this.pending = 0;
+  this.written = 0;
+  this.writtenDisk = 0;
+  this.buff = new Buffer(200);
+
+  this.preamble = true;
+  this.epilogue = false;
+
+  this._reset();
+};
+
+Parser.prototype.__proto__ = EventEmitter.prototype;
+
+/**
+ * Parsing
+ */
+
+Parser.prototype.write = function(data) {
+  if (!this.writable
+      || this.epilogue) return;
+
+  try {
+    this._parse(data);
+  } catch (e) {
+    this._error(e);
+  }
+
+  return true;
+};
+
+Parser.prototype.end = function(data) {
+  if (!this.writable) return;
+
+  if (data) this.write(data);
+
+  if (!this.epilogue) {
+    return this._error('Message underflow.');
+  }
+
+  return true;
+};
+
+Parser.prototype._parse = function(data) {
+  var i = 0
+    , len = data.length
+    , buff = this.buff
+    , key = this.key
+    , ch
+    , val
+    , j;
+
+  for (; i < len; i++) {
+    if (this.pos >= 200) {
+      return this._error('Potential buffer overflow.');
+    }
+
+    ch = data[i];
+
+    switch (this.state) {
+      case 'start':
+        switch (ch) {
+          case DASH:
+            this.pos = 3;
+            this.state = 'key';
+            break;
+          default:
+            break;
+        }
+        break;
+      case 'key':
+        if (this.pos === key.length) {
+          this.state = 'key_end';
+          i--;
+        } else if (ch !== key[this.pos]) {
+          if (this.preamble) {
+            this.state = 'start';
+            i--;
+          } else {
+            this.state = 'body';
+            val = this.pos - i;
+            if (val > 0) {
+              this._write(key.slice(0, val));
+            }
+            i--;
+          }
+        } else {
+          this.pos++;
+        }
+        break;
+      case 'key_end':
+        switch (ch) {
+          case CR:
+            this.state = 'key_line_end';
+            break;
+          case DASH:
+            this.state = 'key_dash_end';
+            break;
+          default:
+            return this._error('Expected CR or DASH.');
+        }
+        break;
+      case 'key_line_end':
+        switch (ch) {
+          case LF:
+            if (this.preamble) {
+              this.preamble = false;
+            } else {
+              this._finish();
+            }
+            this.state = 'header_name';
+            this.pos = 0;
+            break;
+          default:
+            return this._error('Expected CR.');
+        }
+        break;
+      case 'key_dash_end':
+        switch (ch) {
+          case DASH:
+            this.epilogue = true;
+            this._finish();
+            return;
+          default:
+            return this._error('Expected DASH.');
+        }
+        break;
+      case 'header_name':
+        switch (ch) {
+          case COLON:
+            this.header = buff.toString('ascii', 0, this.pos);
+            this.pos = 0;
+            this.state = 'header_val';
+            break;
+          default:
+            buff[this.pos++] = ch | 32;
+            break;
+        }
+        break;
+      case 'header_val':
+        switch (ch) {
+          case CR:
+            this.state = 'header_val_end';
+            break;
+          case SPACE:
+            if (this.pos === 0) {
+              break;
+            }
+            ; // FALL-THROUGH
+          default:
+            buff[this.pos++] = ch;
+            break;
+        }
+        break;
+      case 'header_val_end':
+        switch (ch) {
+          case LF:
+            val = buff.toString('ascii', 0, this.pos);
+            this._header(this.header, val);
+            this.pos = 0;
+            this.state = 'header_end';
+            break;
+          default:
+            return this._error('Expected LF.');
+        }
+        break;
+      case 'header_end':
+        switch (ch) {
+          case CR:
+            this.state = 'head_end';
+            break;
+          default:
+            this.state = 'header_name';
+            i--;
+            break;
+        }
+        break;
+      case 'head_end':
+        switch (ch) {
+          case LF:
+            this.state = 'body';
+            i++;
+            if (i >= len) return;
+            data = data.slice(i);
+            i = -1;
+            len = data.length;
+            break;
+          default:
+            return this._error('Expected LF.');
+        }
+        break;
+      case 'body':
+        switch (ch) {
+          case CR:
+            if (i > 0) {
+              this._write(data.slice(0, i));
+            }
+            this.pos = 1;
+            this.state = 'key';
+            data = data.slice(i);
+            i = 0;
+            len = data.length;
+            break;
+          default:
+            // boyer-moore-like algorithm
+            // at felixge's suggestion
+            while ((j = i + key.length - 1) < len) {
+              if (this._key[data[j]]) break;
+              i = j;
+            }
+            break;
+        }
+        break;
+    }
+  }
+
+  if (this.state === 'body') {
+    this._write(data);
+  }
+};
+
+Parser.prototype._header = function(name, val) {
+  /*if (name === 'content-disposition') {
+    this.field = grab(val, 'name');
+    this.file = grab(val, 'filename');
+
+    if (this.file) {
+      this.data = stream(this.file, this.options.path);
+    } else {
+      this.decode = new StringDecoder('utf8');
+      this.data = '';
+    }
+  }*/
+
+  return this.emit('header', name, val);
+};
+
+Parser.prototype._write = function(data) {
+  /*if (this.data == null) {
+    return this._error('No disposition.');
+  }
+
+  if (this.file) {
+    this.data.write(data);
+    this.writtenDisk += data.length;
+  } else {
+    this.data += this.decode.write(data);
+    this.written += data.length;
+  }*/
+
+  this.emit('data', data);
+};
+
+Parser.prototype._reset = function() {
+  this.pos = 0;
+  this.decode = null;
+  this.field = null;
+  this.data = null;
+  this.file = null;
+  this.header = null;
+};
+
+Parser.prototype._error = function(err) {
+  this.destroy();
+  this.emit('error', typeof err === 'string'
+    ? new Error(err)
+    : err);
+};
+
+Parser.prototype.destroy = function(err) {
+  this.writable = false;
+  this.readable = false;
+  this._reset();
+};
+
+Parser.prototype._finish = function() {
+  var self = this
+    , field = this.field
+    , data = this.data
+    , file = this.file
+    , part;
+
+  this.pending++;
+
+  this._reset();
+
+  if (data && data.path) {
+    part = data.path;
+    data.end(next);
+  } else {
+    part = data;
+    next();
+  }
+
+  function next() {
+    if (!self.readable) return;
+
+    self.pending--;
+
+    self.emit('part', field, part);
+
+    if (data && data.path) {
+      self.emit('file', field, part, file);
+    }
+
+    if (self.epilogue && !self.pending) {
+      self.emit('end');
+      self.destroy();
+    }
+  }
+};
+
+/**
+ * Uploads
+ */
+
+Parser.root = process.platform === 'win32'
+  ? 'C:/Temp'
+  : '/tmp';
+
+/**
+ * Middleware
+ */
+
+Parser.middleware = function(options) {
+  options = options || {};
+  return function(req, res, next) {
+    if (options.ensureBody) {
+      req.body = {};
+    }
+
+    if (req.method === 'GET'
+        || req.method === 'HEAD'
+        || req._multipart) return next();
+
+    req._multipart = true;
+
+    var type = req.headers['content-type'];
+
+    if (type) type = type.split(';')[0].trim().toLowerCase();
+
+    if (type === 'multipart/form-data') {
+      Parser.handle(req, res, next, options);
+    } else {
+      next();
+    }
+  };
+};
+
+/**
+ * Handler
+ */
+
+Parser.handle = function(req, res, next, options) {
+  var parser = new Parser(req.headers['content-type'], options)
+    , diskLimit = options.diskLimit
+    , limit = options.limit
+    , parts = {}
+    , files = {};
+
+  parser.on('error', function(err) {
+    req.destroy();
+    next(err);
+  });
+
+  parser.on('part', function(field, part) {
+    set(parts, field, part);
+  });
+
+  parser.on('file', function(field, path, name) {
+    set(files, field, {
+      path: path,
+      name: name,
+      toString: function() {
+        return path;
+      }
+    });
+  });
+
+  parser.on('data', function() {
+    if (this.writtenDisk > diskLimit || this.written > limit) {
+      this.emit('error', new Error('Overflow.'));
+      this.destroy();
+    }
+  });
+
+  parser.on('end', next);
+
+  req.body = parts;
+  req.files = files;
+  req.pipe(parser);
+};
+
+/**
+ * Helpers
+ */
+
+var isWindows = process.platform === 'win32';
+
+var stream = function(name, dir) {
+  var ext = path.extname(name) || ''
+    , name = path.basename(name, ext) || ''
+    , dir = dir || Parser.root
+    , tag;
+
+  tag = Math.random().toString(36).substring(2);
+
+  name = name.substring(0, 200) + '.' + tag;
+  name = path.join(dir, name) + ext.substring(0, 6);
+  name = name.replace(/\0/g, '');
+
+  if (isWindows) {
+    name = name.replace(/[:*<>|"?]/g, '');
+  }
+
+  return fs.createWriteStream(name);
+};
+
+var grab = function(str, name) {
+  if (!str) return;
+
+  var rx = new RegExp('\\b' + name + '\\s*=\\s*("[^"]+"|\'[^\']+\'|[^;,]+)', 'i')
+    , cap = rx.exec(str);
+
+  if (cap) {
+    return cap[1].trim().replace(/^['"]|['"]$/g, '');
+  }
+};
+
+/**
+ * Expose
+ */
+
+module.exports = Parser;
\ No newline at end of file