@jocmp/mercury-parser 2.2.3-dev → 2.2.5

package/node_modules/http-headers/README.md

@@ -0,0 +1,205 @@
+# http-headers
+
+[![Build status](https://travis-ci.org/watson/http-headers.svg?branch=master)](https://travis-ci.org/watson/http-headers)
+[![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat)](https://github.com/feross/standard)
+
+Parse the start-line and headers from an HTTP request or reponse.
+
+Converts:
+
+```http
+HTTP/1.1 200 OK
+Date: Tue, 10 Jun 2014 07:19:27 GMT
+Connection: keep-alive
+Transfer-Encoding: chunked
+
+Hello World
+```
+
+To this:
+
+```js
+{
+  version: { major: 1, minor: 1 },
+  statusCode: 200,
+  statusMessage: 'OK',
+  headers: {
+    date: 'Tue, 10 Jun 2014 07:19:27 GMT',
+    connection: 'keep-alive',
+    'transfer-encoding': 'chunked'
+  }
+}
+```
+
+**Features:**
+
+- Auto-detects and ignores body if present
+- Fully [RFC 2068](http://www.rfc-base.org/txt/rfc-2068.txt) compliant
+  (please [open an issue](https://github.com/watson/http-headers/issues)
+  if you find a discrepancy)
+- Support multi-line headers (lines will be joined with a space)
+- Support repeating headers
+
+## Installation
+
+```
+npm install http-headers --save
+```
+
+## Usage
+
+```js
+var net = require('net')
+var httpHeaders = require('http-headers')
+
+// create TCP server
+net.createServer(function (c) {
+  var buffers = []
+  c.on('data', buffers.push.bind(buffers))
+  c.on('end', function () {
+    var data = Buffer.concat(buffers)
+
+    // parse incoming data as an HTTP request and extra HTTP headers
+    console.log(httpHeaders(data))
+  })
+}).listen(8080)
+```
+
+### `http.ServerReponse` support
+
+If given an instance of `http.ServerResponse`, the reponse headers is
+automatically extracted, parsed and returned:
+
+```js
+var http = require('http')
+var httpHeaders = require('http-headers')
+
+http.createServer(function (req, res) {
+  res.end('Hello World')
+  console.log(httpHeaders(res))
+}).listen(8080)
+```
+
+#### Why?
+
+If you've ever needed to log or in another way access the headers sent
+to the client on a `http.ServerResponse` in Node.js, you know it's not
+as easy as with the `http.IncomingMessage` headers (which you just
+access via `request.headers['content-type']`).
+
+Response headers are not directly available on the `response` object.
+Instead all headers are preprocessed as a string on the private
+`response._header` property and needs to be processed in order to be
+available as an object.
+
+This module makes the task super simple.
+
+## API
+
+The http-headers module exposes a single parser function:
+
+```js
+httpHeaders(data[, onlyHeaders])
+```
+
+Arguments:
+
+- `data` - A string, buffer or instance of `http.ServerReponse`
+- `onlyHeaders` - An optional boolean. If `true`, only the headers
+  object will be returned. Defaults to `false`
+
+### Request example
+
+If given a request as input:
+
+```http
+GET /foo HTTP/1.1
+Date: Tue, 10 Jun 2014 07:19:27 GMT
+Connection: keep-alive
+Transfer-Encoding: chunked
+
+Hello World
+```
+
+Returns:
+
+```js
+{
+  method: 'GET',
+  url: '/foo',
+  version: { major: 1, minor: 1 },
+  headers: {
+    date: 'Tue, 10 Jun 2014 07:19:27 GMT',
+    connection: 'keep-alive',
+    'transfer-encoding': 'chunked'
+  }
+}
+```
+
+### Response example
+
+If given a request as input:
+
+```http
+HTTP/1.1 200 OK
+Date: Tue, 10 Jun 2014 07:19:27 GMT
+Connection: keep-alive
+Transfer-Encoding: chunked
+
+Hello World
+```
+
+Returns:
+
+```js
+{
+  version: { major: 1, minor: 1 },
+  statusCode: 200,
+  statusMessage: 'OK',
+  headers: {
+    date: 'Tue, 10 Jun 2014 07:19:27 GMT',
+    connection: 'keep-alive',
+    'transfer-encoding': 'chunked'
+  }
+}
+```
+
+### `onlyHeaders` example
+
+If the optional second argument is set to `true`, only headers are
+returned no matter the type of input:
+
+```js
+{
+  date: 'Tue, 10 Jun 2014 07:19:27 GMT',
+  connection: 'keep-alive',
+  'transfer-encoding': 'chunked'
+}
+```
+
+### No Start-Line
+
+If the `data` given does not contain an HTTP Start-Line, only the
+headers are returned, even if the `onlyHeaders` argument is `false`:
+
+```http
+Date: Tue, 10 Jun 2014 07:19:27 GMT
+Connection: keep-alive
+Transfer-Encoding: chunked
+
+Hello World
+```
+
+Returns:
+
+```js
+{
+  date: 'Tue, 10 Jun 2014 07:19:27 GMT',
+  connection: 'keep-alive',
+  'transfer-encoding': 'chunked'
+}
+```
+
+## License
+
+MIT

package/node_modules/http-headers/index.js

@@ -0,0 +1,137 @@
+'use strict'
+
+var nextLine = require('next-line')
+
+// RFC-2068 Start-Line definitions:
+//   Request-Line: Method SP Request-URI SP HTTP-Version CRLF
+//   Status-Line:  HTTP-Version SP Status-Code SP Reason-Phrase CRLF
+var startLine = /^[A-Z_]+(\/\d\.\d)? /
+var requestLine = /^([A-Z_]+) (.+) [A-Z]+\/(\d)\.(\d)$/
+var statusLine = /^[A-Z]+\/(\d)\.(\d) (\d{3}) (.*)$/
+
+module.exports = function (data, onlyHeaders) {
+  return parse(normalize(data), onlyHeaders)
+}
+
+function parse (str, onlyHeaders) {
+  var line = firstLine(str)
+  var match
+
+  if (onlyHeaders && startLine.test(line)) {
+    return parseHeaders(str)
+  } else if ((match = line.match(requestLine)) !== null) {
+    return {
+      method: match[1],
+      url: match[2],
+      version: { major: parseInt(match[3], 10), minor: parseInt(match[4], 10) },
+      headers: parseHeaders(str)
+    }
+  } else if ((match = line.match(statusLine)) !== null) {
+    return {
+      version: { major: parseInt(match[1], 10), minor: parseInt(match[2], 10) },
+      statusCode: parseInt(match[3], 10),
+      statusMessage: match[4],
+      headers: parseHeaders(str)
+    }
+  } else {
+    return parseHeaders(str)
+  }
+}
+
+function parseHeaders (str) {
+  var headers = {}
+  var next = nextLine(str)
+  var line = next()
+  var index, name, value
+
+  if (startLine.test(line)) line = next()
+
+  while (line) {
+    // subsequent lines in multi-line headers start with whitespace
+    if (line[0] === ' ' || line[0] === '\t') {
+      value += ' ' + line.trim()
+      line = next()
+      continue
+    }
+
+    if (name) addHeaderLine(name, value, headers)
+
+    index = line.indexOf(':')
+    name = line.substr(0, index)
+    value = line.substr(index + 1).trim()
+
+    line = next()
+  }
+
+  if (name) addHeaderLine(name, value, headers)
+
+  return headers
+}
+
+function normalize (str) {
+  if (str && str._header) str = str._header // extra headers from http.ServerResponse object
+  if (!str || typeof str.toString !== 'function') return ''
+  return str.toString().trim()
+}
+
+function firstLine (str) {
+  var nl = str.indexOf('\r\n')
+  if (nl === -1) return str
+  else return str.slice(0, nl)
+}
+
+// The following function is lifted from:
+// https://github.com/nodejs/node/blob/f1294f5bfd7f02bce8029818be9c92de59749137/lib/_http_incoming.js#L116-L170
+//
+// Add the given (field, value) pair to the message
+//
+// Per RFC2616, section 4.2 it is acceptable to join multiple instances of the
+// same header with a ', ' if the header in question supports specification of
+// multiple values this way. If not, we declare the first instance the winner
+// and drop the second. Extended header fields (those beginning with 'x-') are
+// always joined.
+function addHeaderLine (field, value, dest) {
+  field = field.toLowerCase()
+  switch (field) {
+    // Array headers:
+    case 'set-cookie':
+      if (dest[field] !== undefined) {
+        dest[field].push(value)
+      } else {
+        dest[field] = [value]
+      }
+      break
+
+    // list is taken from:
+    // https://mxr.mozilla.org/mozilla/source/netwerk/protocol/http/src/nsHttpHeaderArray.cpp
+    case 'content-type':
+    case 'content-length':
+    case 'user-agent':
+    case 'referer':
+    case 'host':
+    case 'authorization':
+    case 'proxy-authorization':
+    case 'if-modified-since':
+    case 'if-unmodified-since':
+    case 'from':
+    case 'location':
+    case 'max-forwards':
+    case 'retry-after':
+    case 'etag':
+    case 'last-modified':
+    case 'server':
+    case 'age':
+    case 'expires':
+      // drop duplicates
+      if (dest[field] === undefined) dest[field] = value
+      break
+
+    default:
+      // make comma-separated list
+      if (typeof dest[field] === 'string') {
+        dest[field] += ', ' + value
+      } else {
+        dest[field] = value
+      }
+  }
+}

package/node_modules/http-headers/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "http-headers",
+  "version": "3.0.2",
+  "description": "Parse http headers",
+  "main": "index.js",
+  "scripts": {
+    "test": "standard && tape test.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/watson/http-headers.git"
+  },
+  "dependencies": {
+    "next-line": "^1.1.0"
+  },
+  "devDependencies": {
+    "safe-buffer": "^5.1.1",
+    "standard": "^10.0.2",
+    "tape": "^4.7.0"
+  },
+  "keywords": [
+    "http",
+    "https",
+    "header",
+    "headers",
+    "parse",
+    "parsing",
+    "ServerResponse",
+    "response"
+  ],
+  "author": "Thomas Watson Steen <w@tson.dk> (https://twitter.com/wa7son)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/watson/http-headers/issues"
+  },
+  "homepage": "https://github.com/watson/http-headers",
+  "coordinates": [
+    55.6757062,
+    12.5774478
+  ]
+}

package/node_modules/http-headers/test.js

@@ -0,0 +1,163 @@
+'use strict'
+
+var test = require('tape')
+var http = require('http')
+var Buffer = require('safe-buffer').Buffer
+var httpHeaders = require('./')
+
+var requestLine = 'GET /foo HTTP/1.1\r\n'
+var statusLine = 'HTTP/1.1 200 OK\r\n'
+var msgHeaders = 'Date: Tue, 10 Jun 2014 07:29:20 GMT\r\n' +
+  'Connection: keep-alive\r\n' +
+  'Transfer-Encoding: chunked\r\n' +
+  'Age: foo\r\n' +
+  'Age: bar\r\n' +
+  'Set-Cookie: cookie\r\n' +
+  'X-List: A\r\n' +
+  'X-Multi-Line-Header: Foo\r\n' +
+  ' Bar\r\n' +
+  'X-List: B\r\n' +
+  '\r\n'
+var requestMsg = requestLine + msgHeaders + 'Hello: World'
+var responseMsg = statusLine + msgHeaders + 'Hello: World'
+
+var headerResult = {
+  date: 'Tue, 10 Jun 2014 07:29:20 GMT',
+  connection: 'keep-alive',
+  'transfer-encoding': 'chunked',
+  age: 'foo',
+  'set-cookie': ['cookie'],
+  'x-list': 'A, B',
+  'x-multi-line-header': 'Foo Bar'
+}
+var responseResult = {
+  version: { major: 1, minor: 1 },
+  statusCode: 200,
+  statusMessage: 'OK',
+  headers: headerResult
+}
+var requestResult = {
+  method: 'GET',
+  url: '/foo',
+  version: { major: 1, minor: 1 },
+  headers: headerResult
+}
+
+test('no argument', function (t) {
+  t.deepEqual(httpHeaders(), {})
+  t.deepEqual(httpHeaders(undefined, true), {})
+  t.end()
+})
+
+test('empty string', function (t) {
+  t.deepEqual(httpHeaders(''), {})
+  t.deepEqual(httpHeaders('', true), {})
+  t.end()
+})
+
+test('empty object', function (t) {
+  t.deepEqual(httpHeaders({}), {})
+  t.deepEqual(httpHeaders({}, true), {})
+  t.end()
+})
+
+test('empty buffer', function (t) {
+  t.deepEqual(httpHeaders(new Buffer('')), {})
+  t.deepEqual(httpHeaders(new Buffer(''), true), {})
+  t.end()
+})
+
+test('start-line + header', function (t) {
+  t.deepEqual(httpHeaders(requestLine + msgHeaders), requestResult)
+  t.deepEqual(httpHeaders(statusLine + msgHeaders), responseResult)
+  t.deepEqual(httpHeaders(new Buffer(requestLine + msgHeaders)), requestResult)
+  t.deepEqual(httpHeaders(new Buffer(statusLine + msgHeaders)), responseResult)
+  t.deepEqual(httpHeaders(requestLine + msgHeaders, true), headerResult)
+  t.deepEqual(httpHeaders(statusLine + msgHeaders, true), headerResult)
+  t.deepEqual(httpHeaders(new Buffer(requestLine + msgHeaders), true), headerResult)
+  t.deepEqual(httpHeaders(new Buffer(statusLine + msgHeaders), true), headerResult)
+  t.end()
+})
+
+test('request-line only', function (t) {
+  var requestResult = {
+    method: 'GET',
+    url: '/foo',
+    version: { major: 1, minor: 1 },
+    headers: {}
+  }
+
+  t.deepEqual(httpHeaders(requestLine + '\r\n'), requestResult)
+  t.deepEqual(httpHeaders(new Buffer(requestLine + '\r\n')), requestResult)
+  t.deepEqual(httpHeaders(requestLine + '\r\n', true), {})
+  t.deepEqual(httpHeaders(new Buffer(requestLine + '\r\n'), true), {})
+  t.end()
+})
+
+test('status-line only', function (t) {
+  var responseResult = {
+    version: { major: 1, minor: 1 },
+    statusCode: 200,
+    statusMessage: 'OK',
+    headers: {}
+  }
+
+  t.deepEqual(httpHeaders(statusLine + '\r\n'), responseResult)
+  t.deepEqual(httpHeaders(new Buffer(statusLine + '\r\n')), responseResult)
+  t.deepEqual(httpHeaders(statusLine + '\r\n', true), {})
+  t.deepEqual(httpHeaders(new Buffer(statusLine + '\r\n'), true), {})
+  t.end()
+})
+
+test('headers only', function (t) {
+  t.deepEqual(httpHeaders(msgHeaders), headerResult)
+  t.deepEqual(httpHeaders(new Buffer(msgHeaders)), headerResult)
+  t.deepEqual(httpHeaders(msgHeaders, true), headerResult)
+  t.deepEqual(httpHeaders(new Buffer(msgHeaders), true), headerResult)
+  t.end()
+})
+
+test('full http response', function (t) {
+  t.deepEqual(httpHeaders(requestMsg), requestResult)
+  t.deepEqual(httpHeaders(responseMsg), responseResult)
+  t.deepEqual(httpHeaders(new Buffer(requestMsg)), requestResult)
+  t.deepEqual(httpHeaders(new Buffer(responseMsg)), responseResult)
+  t.deepEqual(httpHeaders(requestMsg, true), headerResult)
+  t.deepEqual(httpHeaders(responseMsg, true), headerResult)
+  t.deepEqual(httpHeaders(new Buffer(requestMsg), true), headerResult)
+  t.deepEqual(httpHeaders(new Buffer(responseMsg), true), headerResult)
+  t.end()
+})
+
+test('http.ServerResponse', function (t) {
+  t.test('real http.ServerResponse object', function (t) {
+    var res = new http.ServerResponse({})
+    t.deepEqual(httpHeaders(res), {})
+    t.deepEqual(httpHeaders(res, true), {})
+    t.end()
+  })
+
+  t.test('no _header property', function (t) {
+    t.deepEqual(httpHeaders({ _header: undefined }), {})
+    t.deepEqual(httpHeaders({ _header: undefined }, true), {})
+    t.end()
+  })
+
+  t.test('empty string as _header', function (t) {
+    t.deepEqual(httpHeaders({ _header: '' }), {})
+    t.deepEqual(httpHeaders({ _header: '' }, true), {})
+    t.end()
+  })
+
+  t.test('normal _header property', function (t) {
+    t.deepEqual(httpHeaders({ _header: statusLine + msgHeaders }), responseResult)
+    t.deepEqual(httpHeaders({ _header: statusLine + msgHeaders }, true), headerResult)
+    t.end()
+  })
+})
+
+test('set-cookie', function (t) {
+  t.deepEqual(httpHeaders('Set-Cookie: foo'), { 'set-cookie': ['foo'] })
+  t.deepEqual(httpHeaders('Set-Cookie: foo\r\nSet-Cookie: bar'), { 'set-cookie': ['foo', 'bar'] })
+  t.end()
+})