Demo for query storing
Change-Id: I947bcac841992c3f6cfd01ab337c265b0d01cb70
diff --git a/node_modules/raw-body/.npmignore b/node_modules/raw-body/.npmignore
new file mode 100644
index 0000000..cd39b77
--- /dev/null
+++ b/node_modules/raw-body/.npmignore
@@ -0,0 +1,3 @@
+coverage/
+test/
+.travis.yml
diff --git a/node_modules/raw-body/HISTORY.md b/node_modules/raw-body/HISTORY.md
new file mode 100644
index 0000000..0731180
--- /dev/null
+++ b/node_modules/raw-body/HISTORY.md
@@ -0,0 +1,85 @@
+1.1.7 / 2014-06-12
+==================
+
+ * use `string_decoder` module from npm
+
+1.1.6 / 2014-05-27
+==================
+
+ * check encoding for old streams1
+ * support node.js < 0.10.6
+
+1.1.5 / 2014-05-14
+==================
+
+ * bump bytes
+
+1.1.4 / 2014-04-19
+==================
+
+ * allow true as an option
+ * bump bytes
+
+1.1.3 / 2014-03-02
+==================
+
+ * fix case when length=null
+
+1.1.2 / 2013-12-01
+==================
+
+ * be less strict on state.encoding check
+
+1.1.1 / 2013-11-27
+==================
+
+ * add engines
+
+1.1.0 / 2013-11-27
+==================
+
+ * add err.statusCode and err.type
+ * allow for encoding option to be true
+ * pause the stream instead of dumping on error
+ * throw if the stream's encoding is set
+
+1.0.1 / 2013-11-19
+==================
+
+ * dont support streams1, throw if dev set encoding
+
+1.0.0 / 2013-11-17
+==================
+
+ * rename `expected` option to `length`
+
+0.2.0 / 2013-11-15
+==================
+
+ * republish
+
+0.1.1 / 2013-11-15
+==================
+
+ * use bytes
+
+0.1.0 / 2013-11-11
+==================
+
+ * generator support
+
+0.0.3 / 2013-10-10
+==================
+
+ * update repo
+
+0.0.2 / 2013-09-14
+==================
+
+ * dump stream on bad headers
+ * listen to events after defining received and buffers
+
+0.0.1 / 2013-09-14
+==================
+
+ * Initial release
diff --git a/node_modules/raw-body/README.md b/node_modules/raw-body/README.md
new file mode 100644
index 0000000..844459d
--- /dev/null
+++ b/node_modules/raw-body/README.md
@@ -0,0 +1,100 @@
+# raw-body
+
+[](http://badge.fury.io/js/raw-body)
+[](https://travis-ci.org/stream-utils/raw-body)
+[](https://coveralls.io/r/stream-utils/raw-body)
+
+Gets the entire buffer of a stream either as a `Buffer` or a string.
+Validates the stream's length against an expected length and maximum limit.
+Ideal for parsing request bodies.
+
+## API
+
+```js
+var getRawBody = require('raw-body')
+
+app.use(function (req, res, next) {
+ getRawBody(req, {
+ length: req.headers['content-length'],
+ limit: '1mb',
+ encoding: 'utf8'
+ }, function (err, string) {
+ if (err)
+ return next(err)
+
+ req.text = string
+ next()
+ })
+})
+```
+
+or in a Koa generator:
+
+```js
+app.use(function* (next) {
+ var string = yield getRawBody(this.req, {
+ length: this.length,
+ limit: '1mb',
+ encoding: 'utf8'
+ })
+})
+```
+
+### getRawBody(stream, [options], [callback])
+
+Returns a thunk for yielding with generators.
+
+Options:
+
+- `length` - The length length of the stream.
+ If the contents of the stream do not add up to this length,
+ an `400` error code is returned.
+- `limit` - The byte limit of the body.
+ If the body ends up being larger than this limit,
+ a `413` error code is returned.
+- `encoding` - The requested encoding.
+ By default, a `Buffer` instance will be returned.
+ Most likely, you want `utf8`.
+ You can use any type of encoding supported by [StringDecoder](http://nodejs.org/api/string_decoder.html).
+ You can also pass `true` which sets it to the default `utf8`
+
+`callback(err, res)`:
+
+- `err` - the following attributes will be defined if applicable:
+
+ - `limit` - the limit in bytes
+ - `length` and `expected` - the expected length of the stream
+ - `received` - the received bytes
+ - `status` and `statusCode` - the corresponding status code for the error
+ - `type` - either `entity.too.large`, `request.size.invalid`, or `stream.encoding.set`
+
+- `res` - the result, either as a `String` if an encoding was set or a `Buffer` otherwise.
+
+If an error occurs, the stream will be paused,
+and you are responsible for correctly disposing the stream.
+For HTTP requests, no handling is required if you send a response.
+For streams that use file descriptors, you should `stream.destroy()` or `stream.close()` to prevent leaks.
+
+## License
+
+The MIT License (MIT)
+
+Copyright (c) 2013 Jonathan Ong me@jongleberry.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.
diff --git a/node_modules/raw-body/index.js b/node_modules/raw-body/index.js
new file mode 100644
index 0000000..e3c00aa
--- /dev/null
+++ b/node_modules/raw-body/index.js
@@ -0,0 +1,151 @@
+var bytes = require('bytes')
+
+// NOTE: the trailing slash is not a typo
+var StringDecoder = require('string_decoder/').StringDecoder
+
+module.exports = function (stream, options, done) {
+ if (typeof options === 'function') {
+ done = options
+ options = {}
+ } else if (!options) {
+ options = {}
+ } else if (options === true) {
+ options = {
+ encoding: 'utf8'
+ }
+ }
+
+ // convert the limit to an integer
+ var limit = null
+ if (typeof options.limit === 'number')
+ limit = options.limit
+ if (typeof options.limit === 'string')
+ limit = bytes(options.limit)
+
+ // convert the expected length to an integer
+ var length = null
+ if (options.length != null && !isNaN(options.length))
+ length = parseInt(options.length, 10)
+
+ // check the length and limit options.
+ // note: we intentionally leave the stream paused,
+ // so users should handle the stream themselves.
+ if (limit !== null && length !== null && length > limit) {
+ if (typeof stream.pause === 'function')
+ stream.pause()
+
+ process.nextTick(function () {
+ var err = makeError('request entity too large', 'entity.too.large')
+ err.status = err.statusCode = 413
+ err.length = err.expected = length
+ err.limit = limit
+ done(err)
+ })
+ return defer
+ }
+
+ // streams1: assert request encoding is buffer.
+ // streams2+: assert the stream encoding is buffer.
+ // stream._decoder: streams1
+ // state.encoding: streams2
+ // state.decoder: streams2, specifically < 0.10.6
+ var state = stream._readableState
+ if (stream._decoder || (state && (state.encoding || state.decoder))) {
+ if (typeof stream.pause === 'function')
+ stream.pause()
+
+ process.nextTick(function () {
+ var err = makeError('stream encoding should not be set',
+ 'stream.encoding.set')
+ // developer error
+ err.status = err.statusCode = 500
+ done(err)
+ })
+ return defer
+ }
+
+ var received = 0
+ // note: we delegate any invalid encodings to the constructor
+ var decoder = options.encoding
+ ? new StringDecoder(options.encoding === true ? 'utf8' : options.encoding)
+ : null
+ var buffer = decoder
+ ? ''
+ : []
+
+ stream.on('data', onData)
+ stream.once('end', onEnd)
+ stream.once('error', onEnd)
+ stream.once('close', cleanup)
+
+ return defer
+
+ // yieldable support
+ function defer(fn) {
+ done = fn
+ }
+
+ function onData(chunk) {
+ received += chunk.length
+ decoder
+ ? buffer += decoder.write(chunk)
+ : buffer.push(chunk)
+
+ if (limit !== null && received > limit) {
+ if (typeof stream.pause === 'function')
+ stream.pause()
+ var err = makeError('request entity too large', 'entity.too.large')
+ err.status = err.statusCode = 413
+ err.received = received
+ err.limit = limit
+ done(err)
+ cleanup()
+ }
+ }
+
+ function onEnd(err) {
+ if (err) {
+ if (typeof stream.pause === 'function')
+ stream.pause()
+ done(err)
+ } else if (length !== null && received !== length) {
+ err = makeError('request size did not match content length',
+ 'request.size.invalid')
+ err.status = err.statusCode = 400
+ err.received = received
+ err.length = err.expected = length
+ done(err)
+ } else {
+ done(null, decoder
+ ? buffer + decoder.end()
+ : Buffer.concat(buffer)
+ )
+ }
+
+ cleanup()
+ }
+
+ function cleanup() {
+ received = buffer = null
+
+ stream.removeListener('data', onData)
+ stream.removeListener('end', onEnd)
+ stream.removeListener('error', onEnd)
+ stream.removeListener('close', cleanup)
+ }
+}
+
+// to create serializable errors you must re-set message so
+// that it is enumerable and you must re configure the type
+// property so that is writable and enumerable
+function makeError(message, type) {
+ var error = new Error()
+ error.message = message
+ Object.defineProperty(error, 'type', {
+ value: type,
+ enumerable: true,
+ writable: true,
+ configurable: true
+ })
+ return error
+}
diff --git a/node_modules/raw-body/node_modules/string_decoder/.npmignore b/node_modules/raw-body/node_modules/string_decoder/.npmignore
new file mode 100644
index 0000000..206320c
--- /dev/null
+++ b/node_modules/raw-body/node_modules/string_decoder/.npmignore
@@ -0,0 +1,2 @@
+build
+test
diff --git a/node_modules/raw-body/node_modules/string_decoder/LICENSE b/node_modules/raw-body/node_modules/string_decoder/LICENSE
new file mode 100644
index 0000000..6de584a
--- /dev/null
+++ b/node_modules/raw-body/node_modules/string_decoder/LICENSE
@@ -0,0 +1,20 @@
+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.
diff --git a/node_modules/raw-body/node_modules/string_decoder/README.md b/node_modules/raw-body/node_modules/string_decoder/README.md
new file mode 100644
index 0000000..4d2aa00
--- /dev/null
+++ b/node_modules/raw-body/node_modules/string_decoder/README.md
@@ -0,0 +1,7 @@
+**string_decoder.js** (`require('string_decoder')`) from Node.js core
+
+Copyright Joyent, Inc. and other Node contributors. See LICENCE file for details.
+
+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. **Prefer the stable version over the unstable.**
+
+The *build/* directory contains a build script that will scrape the source from the [joyent/node](https://github.com/joyent/node) repo given a specific Node version.
\ No newline at end of file
diff --git a/node_modules/raw-body/node_modules/string_decoder/index.js b/node_modules/raw-body/node_modules/string_decoder/index.js
new file mode 100644
index 0000000..b00e54f
--- /dev/null
+++ b/node_modules/raw-body/node_modules/string_decoder/index.js
@@ -0,0 +1,221 @@
+// 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.
+
+var Buffer = require('buffer').Buffer;
+
+var isBufferEncoding = Buffer.isEncoding
+ || function(encoding) {
+ switch (encoding && encoding.toLowerCase()) {
+ case 'hex': case 'utf8': case 'utf-8': case 'ascii': case 'binary': case 'base64': case 'ucs2': case 'ucs-2': case 'utf16le': case 'utf-16le': case 'raw': return true;
+ default: return false;
+ }
+ }
+
+
+function assertEncoding(encoding) {
+ if (encoding && !isBufferEncoding(encoding)) {
+ throw new Error('Unknown encoding: ' + encoding);
+ }
+}
+
+// StringDecoder provides an interface for efficiently splitting a series of
+// buffers into a series of JS strings without breaking apart multi-byte
+// characters. CESU-8 is handled as part of the UTF-8 encoding.
+//
+// @TODO Handling all encodings inside a single object makes it very difficult
+// to reason about this code, so it should be split up in the future.
+// @TODO There should be a utf8-strict encoding that rejects invalid UTF-8 code
+// points as used by CESU-8.
+var StringDecoder = exports.StringDecoder = function(encoding) {
+ this.encoding = (encoding || 'utf8').toLowerCase().replace(/[-_]/, '');
+ assertEncoding(encoding);
+ switch (this.encoding) {
+ case 'utf8':
+ // CESU-8 represents each of Surrogate Pair by 3-bytes
+ this.surrogateSize = 3;
+ break;
+ case 'ucs2':
+ case 'utf16le':
+ // UTF-16 represents each of Surrogate Pair by 2-bytes
+ this.surrogateSize = 2;
+ this.detectIncompleteChar = utf16DetectIncompleteChar;
+ break;
+ case 'base64':
+ // Base-64 stores 3 bytes in 4 chars, and pads the remainder.
+ this.surrogateSize = 3;
+ this.detectIncompleteChar = base64DetectIncompleteChar;
+ break;
+ default:
+ this.write = passThroughWrite;
+ return;
+ }
+
+ // Enough space to store all bytes of a single character. UTF-8 needs 4
+ // bytes, but CESU-8 may require up to 6 (3 bytes per surrogate).
+ this.charBuffer = new Buffer(6);
+ // Number of bytes received for the current incomplete multi-byte character.
+ this.charReceived = 0;
+ // Number of bytes expected for the current incomplete multi-byte character.
+ this.charLength = 0;
+};
+
+
+// write decodes the given buffer and returns it as JS string that is
+// guaranteed to not contain any partial multi-byte characters. Any partial
+// character found at the end of the buffer is buffered up, and will be
+// returned when calling write again with the remaining bytes.
+//
+// Note: Converting a Buffer containing an orphan surrogate to a String
+// currently works, but converting a String to a Buffer (via `new Buffer`, or
+// Buffer#write) will replace incomplete surrogates with the unicode
+// replacement character. See https://codereview.chromium.org/121173009/ .
+StringDecoder.prototype.write = function(buffer) {
+ var charStr = '';
+ // if our last write ended with an incomplete multibyte character
+ while (this.charLength) {
+ // determine how many remaining bytes this buffer has to offer for this char
+ var available = (buffer.length >= this.charLength - this.charReceived) ?
+ this.charLength - this.charReceived :
+ buffer.length;
+
+ // add the new bytes to the char buffer
+ buffer.copy(this.charBuffer, this.charReceived, 0, available);
+ this.charReceived += available;
+
+ if (this.charReceived < this.charLength) {
+ // still not enough chars in this buffer? wait for more ...
+ return '';
+ }
+
+ // remove bytes belonging to the current character from the buffer
+ buffer = buffer.slice(available, buffer.length);
+
+ // get the character that was split
+ charStr = this.charBuffer.slice(0, this.charLength).toString(this.encoding);
+
+ // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character
+ var charCode = charStr.charCodeAt(charStr.length - 1);
+ if (charCode >= 0xD800 && charCode <= 0xDBFF) {
+ this.charLength += this.surrogateSize;
+ charStr = '';
+ continue;
+ }
+ this.charReceived = this.charLength = 0;
+
+ // if there are no more bytes in this buffer, just emit our char
+ if (buffer.length === 0) {
+ return charStr;
+ }
+ break;
+ }
+
+ // determine and set charLength / charReceived
+ this.detectIncompleteChar(buffer);
+
+ var end = buffer.length;
+ if (this.charLength) {
+ // buffer the incomplete character bytes we got
+ buffer.copy(this.charBuffer, 0, buffer.length - this.charReceived, end);
+ end -= this.charReceived;
+ }
+
+ charStr += buffer.toString(this.encoding, 0, end);
+
+ var end = charStr.length - 1;
+ var charCode = charStr.charCodeAt(end);
+ // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character
+ if (charCode >= 0xD800 && charCode <= 0xDBFF) {
+ var size = this.surrogateSize;
+ this.charLength += size;
+ this.charReceived += size;
+ this.charBuffer.copy(this.charBuffer, size, 0, size);
+ buffer.copy(this.charBuffer, 0, 0, size);
+ return charStr.substring(0, end);
+ }
+
+ // or just emit the charStr
+ return charStr;
+};
+
+// detectIncompleteChar determines if there is an incomplete UTF-8 character at
+// the end of the given buffer. If so, it sets this.charLength to the byte
+// length that character, and sets this.charReceived to the number of bytes
+// that are available for this character.
+StringDecoder.prototype.detectIncompleteChar = function(buffer) {
+ // determine how many bytes we have to check at the end of this buffer
+ var i = (buffer.length >= 3) ? 3 : buffer.length;
+
+ // Figure out if one of the last i bytes of our buffer announces an
+ // incomplete char.
+ for (; i > 0; i--) {
+ var c = buffer[buffer.length - i];
+
+ // See http://en.wikipedia.org/wiki/UTF-8#Description
+
+ // 110XXXXX
+ if (i == 1 && c >> 5 == 0x06) {
+ this.charLength = 2;
+ break;
+ }
+
+ // 1110XXXX
+ if (i <= 2 && c >> 4 == 0x0E) {
+ this.charLength = 3;
+ break;
+ }
+
+ // 11110XXX
+ if (i <= 3 && c >> 3 == 0x1E) {
+ this.charLength = 4;
+ break;
+ }
+ }
+ this.charReceived = i;
+};
+
+StringDecoder.prototype.end = function(buffer) {
+ var res = '';
+ if (buffer && buffer.length)
+ res = this.write(buffer);
+
+ if (this.charReceived) {
+ var cr = this.charReceived;
+ var buf = this.charBuffer;
+ var enc = this.encoding;
+ res += buf.slice(0, cr).toString(enc);
+ }
+
+ return res;
+};
+
+function passThroughWrite(buffer) {
+ return buffer.toString(this.encoding);
+}
+
+function utf16DetectIncompleteChar(buffer) {
+ this.charReceived = buffer.length % 2;
+ this.charLength = this.charReceived ? 2 : 0;
+}
+
+function base64DetectIncompleteChar(buffer) {
+ this.charReceived = buffer.length % 3;
+ this.charLength = this.charReceived ? 3 : 0;
+}
diff --git a/node_modules/raw-body/node_modules/string_decoder/package.json b/node_modules/raw-body/node_modules/string_decoder/package.json
new file mode 100644
index 0000000..68e87c5
--- /dev/null
+++ b/node_modules/raw-body/node_modules/string_decoder/package.json
@@ -0,0 +1,53 @@
+{
+ "_from": "string_decoder@0.10",
+ "_id": "string_decoder@0.10.31",
+ "_inBundle": false,
+ "_integrity": "sha1-YuIDvEF2bGwoyfyEMB2rHFMQ+pQ=",
+ "_location": "/raw-body/string_decoder",
+ "_phantomChildren": {},
+ "_requested": {
+ "type": "range",
+ "registry": true,
+ "raw": "string_decoder@0.10",
+ "name": "string_decoder",
+ "escapedName": "string_decoder",
+ "rawSpec": "0.10",
+ "saveSpec": null,
+ "fetchSpec": "0.10"
+ },
+ "_requiredBy": [
+ "/raw-body"
+ ],
+ "_resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz",
+ "_shasum": "62e203bc41766c6c28c9fc84301dab1c5310fa94",
+ "_spec": "string_decoder@0.10",
+ "_where": "C:\\Users\\marcr\\Desktop\\KorAp\\Git\\Kalamar\\node_modules\\raw-body",
+ "bugs": {
+ "url": "https://github.com/rvagg/string_decoder/issues"
+ },
+ "bundleDependencies": false,
+ "dependencies": {},
+ "deprecated": false,
+ "description": "The string_decoder module from Node core",
+ "devDependencies": {
+ "tap": "~0.4.8"
+ },
+ "homepage": "https://github.com/rvagg/string_decoder",
+ "keywords": [
+ "string",
+ "decoder",
+ "browser",
+ "browserify"
+ ],
+ "license": "MIT",
+ "main": "index.js",
+ "name": "string_decoder",
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/rvagg/string_decoder.git"
+ },
+ "scripts": {
+ "test": "tap test/simple/*.js"
+ },
+ "version": "0.10.31"
+}
diff --git a/node_modules/raw-body/package.json b/node_modules/raw-body/package.json
new file mode 100644
index 0000000..dd66f8b
--- /dev/null
+++ b/node_modules/raw-body/package.json
@@ -0,0 +1,63 @@
+{
+ "_from": "raw-body@~1.1.0",
+ "_id": "raw-body@1.1.7",
+ "_inBundle": false,
+ "_integrity": "sha1-HQJ8K/oRasxmI7yo8AAWVyqH1CU=",
+ "_location": "/raw-body",
+ "_phantomChildren": {},
+ "_requested": {
+ "type": "range",
+ "registry": true,
+ "raw": "raw-body@~1.1.0",
+ "name": "raw-body",
+ "escapedName": "raw-body",
+ "rawSpec": "~1.1.0",
+ "saveSpec": null,
+ "fetchSpec": "~1.1.0"
+ },
+ "_requiredBy": [
+ "/body"
+ ],
+ "_resolved": "https://registry.npmjs.org/raw-body/-/raw-body-1.1.7.tgz",
+ "_shasum": "1d027c2bfa116acc6623bca8f00016572a87d425",
+ "_spec": "raw-body@~1.1.0",
+ "_where": "C:\\Users\\marcr\\Desktop\\KorAp\\Git\\Kalamar\\node_modules\\body",
+ "author": {
+ "name": "Jonathan Ong",
+ "email": "me@jongleberry.com",
+ "url": "http://jongleberry.com"
+ },
+ "bugs": {
+ "url": "https://github.com/stream-utils/raw-body/issues"
+ },
+ "bundleDependencies": false,
+ "dependencies": {
+ "bytes": "1",
+ "string_decoder": "0.10"
+ },
+ "deprecated": false,
+ "description": "Get and validate the raw body of a readable stream.",
+ "devDependencies": {
+ "istanbul": "0.2.10",
+ "mocha": "~1.20.1",
+ "readable-stream": "~1.0.17",
+ "request": ">= 2.36.0 < 3",
+ "through2": "~0.4.1"
+ },
+ "engines": {
+ "node": ">= 0.8.0"
+ },
+ "homepage": "https://github.com/stream-utils/raw-body#readme",
+ "license": "MIT",
+ "name": "raw-body",
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/stream-utils/raw-body.git"
+ },
+ "scripts": {
+ "test": "mocha --reporter spec --bail test/",
+ "test-cov": "istanbul cover node_modules/mocha/bin/_mocha -- --reporter dot test/",
+ "test-travis": "istanbul cover node_modules/mocha/bin/_mocha --report lcovonly -- --reporter spec test/"
+ },
+ "version": "1.1.7"
+}