0.2.0 - Mid migration

web/node_modules/spdy-transport/.travis.yml

@@ -0,0 +1,14 @@
+sudo: false
+
+language: node_js
+
+node_js:
+  - "6"
+  - "8"
+  - "10"
+  - "stable"
+
+script:
+  - npm run lint
+  - npm test
+  - npm run coverage

web/node_modules/spdy-transport/README.md

@@ -0,0 +1,76 @@
+# spdy-transport
+
+[![Build Status](https://travis-ci.org/spdy-http2/spdy-transport.svg?branch=master)](http://travis-ci.org/spdy-http2/spdy-transport)
+[![NPM version](https://badge.fury.io/js/spdy-transport.svg)](http://badge.fury.io/js/spdy-transport)
+[![dependencies Status](https://david-dm.org/spdy-http2/spdy-transport/status.svg?style=flat-square)](https://david-dm.org/spdy-http2/spdy-transport)
+[![Standard - JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg?style=flat-square)](http://standardjs.com/)
+[![Waffle](https://img.shields.io/badge/track-waffle-blue.svg?style=flat-square)](https://waffle.io/spdy-http2/node-spdy)
+
+> SPDY/HTTP2 generic transport implementation.
+
+## Usage
+
+```javascript
+var transport = require('spdy-transport');
+
+// NOTE: socket is some stream or net.Socket instance, may be an argument
+// of `net.createServer`'s connection handler.
+
+var server = transport.connection.create(socket, {
+  protocol: 'http2',
+  isServer: true
+});
+
+server.on('stream', function(stream) {
+  console.log(stream.method, stream.path, stream.headers);
+  stream.respond(200, {
+    header: 'value'
+  });
+
+  stream.on('readable', function() {
+    var chunk = stream.read();
+    if (!chunk)
+      return;
+
+    console.log(chunk);
+  });
+
+  stream.on('end', function() {
+    console.log('end');
+  });
+
+  // And other node.js Stream APIs
+  // ...
+});
+```
+
+## LICENSE
+
+This software is licensed under the MIT License.
+
+Copyright Fedor Indutny, 2015.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to permit
+persons to whom the Software is furnished to do so, subject to the
+following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+[0]: http://json.org/
+[1]: http://github.com/indutny/bud-backend
+[2]: https://github.com/nodejs/io.js
+[3]: https://github.com/libuv/libuv
+[4]: http://openssl.org/

web/node_modules/spdy-transport/lib/spdy-transport.js

@@ -0,0 +1,25 @@
+'use strict'
+
+var transport = exports
+
+// Exports utils
+transport.utils = require('./spdy-transport/utils')
+
+// Export parser&framer
+transport.protocol = {}
+transport.protocol.base = require('./spdy-transport/protocol/base')
+transport.protocol.spdy = require('./spdy-transport/protocol/spdy')
+transport.protocol.http2 = require('./spdy-transport/protocol/http2')
+
+// Window
+transport.Window = require('./spdy-transport/window')
+
+// Priority Tree
+transport.Priority = require('./spdy-transport/priority')
+
+// Export Connection and Stream
+transport.Stream = require('./spdy-transport/stream').Stream
+transport.Connection = require('./spdy-transport/connection').Connection
+
+// Just for `transport.connection.create()`
+transport.connection = transport.Connection

web/node_modules/spdy-transport/lib/spdy-transport/connection.js

@@ -0,0 +1,845 @@
+'use strict'
+
+var util = require('util')
+var transport = require('../spdy-transport')
+
+var debug = {
+  server: require('debug')('spdy:connection:server'),
+  client: require('debug')('spdy:connection:client')
+}
+var EventEmitter = require('events').EventEmitter
+
+var Stream = transport.Stream
+
+function Connection (socket, options) {
+  EventEmitter.call(this)
+
+  var state = {}
+  this._spdyState = state
+
+  // NOTE: There's a big trick here. Connection is used as a `this` argument
+  // to the wrapped `connection` event listener.
+  // socket end doesn't necessarly mean connection drop
+  this.httpAllowHalfOpen = true
+
+  state.timeout = new transport.utils.Timeout(this)
+
+  // Protocol info
+  state.protocol = transport.protocol[options.protocol]
+  state.version = null
+  state.constants = state.protocol.constants
+  state.pair = null
+  state.isServer = options.isServer
+
+  // Root of priority tree (i.e. stream id = 0)
+  state.priorityRoot = new transport.Priority({
+    defaultWeight: state.constants.DEFAULT_WEIGHT,
+    maxCount: transport.protocol.base.constants.MAX_PRIORITY_STREAMS
+  })
+
+  // Defaults
+  state.maxStreams = options.maxStreams ||
+                     state.constants.MAX_CONCURRENT_STREAMS
+
+  state.autoSpdy31 = options.protocol.name !== 'h2' && options.autoSpdy31
+  state.acceptPush = options.acceptPush === undefined
+    ? !state.isServer
+    : options.acceptPush
+
+  if (options.maxChunk === false) { state.maxChunk = Infinity } else if (options.maxChunk === undefined) { state.maxChunk = transport.protocol.base.constants.DEFAULT_MAX_CHUNK } else {
+    state.maxChunk = options.maxChunk
+  }
+
+  // Connection-level flow control
+  var windowSize = options.windowSize || 1 << 20
+  state.window = new transport.Window({
+    id: 0,
+    isServer: state.isServer,
+    recv: {
+      size: state.constants.DEFAULT_WINDOW,
+      max: state.constants.MAX_INITIAL_WINDOW_SIZE
+    },
+    send: {
+      size: state.constants.DEFAULT_WINDOW,
+      max: state.constants.MAX_INITIAL_WINDOW_SIZE
+    }
+  })
+
+  // It starts with DEFAULT_WINDOW, update must be sent to change it on client
+  state.window.recv.setMax(windowSize)
+
+  // Boilerplate for Stream constructor
+  state.streamWindow = new transport.Window({
+    id: -1,
+    isServer: state.isServer,
+    recv: {
+      size: windowSize,
+      max: state.constants.MAX_INITIAL_WINDOW_SIZE
+    },
+    send: {
+      size: state.constants.DEFAULT_WINDOW,
+      max: state.constants.MAX_INITIAL_WINDOW_SIZE
+    }
+  })
+
+  // Various state info
+  state.pool = state.protocol.compressionPool.create(options.headerCompression)
+  state.counters = {
+    push: 0,
+    stream: 0
+  }
+
+  // Init streams list
+  state.stream = {
+    map: {},
+    count: 0,
+    nextId: state.isServer ? 2 : 1,
+    lastId: {
+      both: 0,
+      received: 0
+    }
+  }
+  state.ping = {
+    nextId: state.isServer ? 2 : 1,
+    map: {}
+  }
+  state.goaway = false
+
+  // Debug
+  state.debug = state.isServer ? debug.server : debug.client
+
+  // X-Forwarded feature
+  state.xForward = null
+
+  // Create parser and hole for framer
+  state.parser = state.protocol.parser.create({
+    // NOTE: needed to distinguish ping from ping ACK in SPDY
+    isServer: state.isServer,
+    window: state.window
+  })
+  state.framer = state.protocol.framer.create({
+    window: state.window,
+    timeout: state.timeout
+  })
+
+  // SPDY has PUSH enabled on servers
+  if (state.protocol.name === 'spdy') {
+    state.framer.enablePush(state.isServer)
+  }
+
+  if (!state.isServer) { state.parser.skipPreface() }
+
+  this.socket = socket
+
+  this._init()
+}
+util.inherits(Connection, EventEmitter)
+exports.Connection = Connection
+
+Connection.create = function create (socket, options) {
+  return new Connection(socket, options)
+}
+
+Connection.prototype._init = function init () {
+  var self = this
+  var state = this._spdyState
+  var pool = state.pool
+
+  // Initialize session window
+  state.window.recv.on('drain', function () {
+    self._onSessionWindowDrain()
+  })
+
+  // Initialize parser
+  state.parser.on('data', function (frame) {
+    self._handleFrame(frame)
+  })
+  state.parser.once('version', function (version) {
+    self._onVersion(version)
+  })
+
+  // Propagate parser errors
+  state.parser.on('error', function (err) {
+    self._onParserError(err)
+  })
+
+  // Propagate framer errors
+  state.framer.on('error', function (err) {
+    self.emit('error', err)
+  })
+
+  this.socket.pipe(state.parser)
+  state.framer.pipe(this.socket)
+
+  // Allow high-level api to catch socket errors
+  this.socket.on('error', function onSocketError (e) {
+    self.emit('error', e)
+  })
+
+  this.socket.once('close', function onclose (hadError) {
+    var err
+    if (hadError) {
+      err = new Error('socket hang up')
+      err.code = 'ECONNRESET'
+    }
+
+    self.destroyStreams(err)
+    self.emit('close')
+
+    if (state.pair) {
+      pool.put(state.pair)
+    }
+
+    state.framer.resume()
+  })
+
+  // Reset timeout on close
+  this.once('close', function () {
+    self.setTimeout(0)
+  })
+
+  function _onWindowOverflow () {
+    self._onWindowOverflow()
+  }
+
+  state.window.recv.on('overflow', _onWindowOverflow)
+  state.window.send.on('overflow', _onWindowOverflow)
+
+  // Do not allow half-open connections
+  this.socket.allowHalfOpen = false
+}
+
+Connection.prototype._onVersion = function _onVersion (version) {
+  var state = this._spdyState
+  var prev = state.version
+  var parser = state.parser
+  var framer = state.framer
+  var pool = state.pool
+
+  state.version = version
+  state.debug('id=0 version=%d', version)
+
+  // Ignore transition to 3.1
+  if (!prev) {
+    state.pair = pool.get(version)
+    parser.setCompression(state.pair)
+    framer.setCompression(state.pair)
+  }
+  framer.setVersion(version)
+
+  if (!state.isServer) {
+    framer.prefaceFrame()
+    if (state.xForward !== null) {
+      framer.xForwardedFor({ host: state.xForward })
+    }
+  }
+
+  // Send preface+settings frame (once)
+  framer.settingsFrame({
+    max_header_list_size: state.constants.DEFAULT_MAX_HEADER_LIST_SIZE,
+    max_concurrent_streams: state.maxStreams,
+    enable_push: state.acceptPush ? 1 : 0,
+    initial_window_size: state.window.recv.max
+  })
+
+  // Update session window
+  if (state.version >= 3.1 || (state.isServer && state.autoSpdy31)) { this._onSessionWindowDrain() }
+
+  this.emit('version', version)
+}
+
+Connection.prototype._onParserError = function _onParserError (err) {
+  var state = this._spdyState
+
+  // Prevent further errors
+  state.parser.kill()
+
+  // Send GOAWAY
+  if (err instanceof transport.protocol.base.utils.ProtocolError) {
+    this._goaway({
+      lastId: state.stream.lastId.both,
+      code: err.code,
+      extra: err.message,
+      send: true
+    })
+  }
+
+  this.emit('error', err)
+}
+
+Connection.prototype._handleFrame = function _handleFrame (frame) {
+  var state = this._spdyState
+
+  state.debug('id=0 frame', frame)
+  state.timeout.reset()
+
+  // For testing purposes
+  this.emit('frame', frame)
+
+  var stream
+
+  // Session window update
+  if (frame.type === 'WINDOW_UPDATE' && frame.id === 0) {
+    if (state.version < 3.1 && state.autoSpdy31) {
+      state.debug('id=0 switch version to 3.1')
+      state.version = 3.1
+      this.emit('version', 3.1)
+    }
+    state.window.send.update(frame.delta)
+    return
+  }
+
+  if (state.isServer && frame.type === 'PUSH_PROMISE') {
+    state.debug('id=0 server PUSH_PROMISE')
+    this._goaway({
+      lastId: state.stream.lastId.both,
+      code: 'PROTOCOL_ERROR',
+      send: true
+    })
+    return
+  }
+
+  if (!stream && frame.id !== undefined) {
+    // Load created one
+    stream = state.stream.map[frame.id]
+
+    // Fail if not found
+    if (!stream &&
+        frame.type !== 'HEADERS' &&
+        frame.type !== 'PRIORITY' &&
+        frame.type !== 'RST') {
+      // Other side should destroy the stream upon receiving GOAWAY
+      if (this._isGoaway(frame.id)) { return }
+
+      state.debug('id=0 stream=%d not found', frame.id)
+      state.framer.rstFrame({ id: frame.id, code: 'INVALID_STREAM' })
+      return
+    }
+  }
+
+  // Create new stream
+  if (!stream && frame.type === 'HEADERS') {
+    this._handleHeaders(frame)
+    return
+  }
+
+  if (stream) {
+    stream._handleFrame(frame)
+  } else if (frame.type === 'SETTINGS') {
+    this._handleSettings(frame.settings)
+  } else if (frame.type === 'ACK_SETTINGS') {
+    // TODO(indutny): handle it one day
+  } else if (frame.type === 'PING') {
+    this._handlePing(frame)
+  } else if (frame.type === 'GOAWAY') {
+    this._handleGoaway(frame)
+  } else if (frame.type === 'X_FORWARDED_FOR') {
+    // Set X-Forwarded-For only once
+    if (state.xForward === null) {
+      state.xForward = frame.host
+    }
+  } else if (frame.type === 'PRIORITY') {
+    // TODO(indutny): handle this
+  } else {
+    state.debug('id=0 unknown frame type: %s', frame.type)
+  }
+}
+
+Connection.prototype._onWindowOverflow = function _onWindowOverflow () {
+  var state = this._spdyState
+  state.debug('id=0 window overflow')
+  this._goaway({
+    lastId: state.stream.lastId.both,
+    code: 'FLOW_CONTROL_ERROR',
+    send: true
+  })
+}
+
+Connection.prototype._isGoaway = function _isGoaway (id) {
+  var state = this._spdyState
+  if (state.goaway !== false && state.goaway < id) { return true }
+  return false
+}
+
+Connection.prototype._getId = function _getId () {
+  var state = this._spdyState
+
+  var id = state.stream.nextId
+  state.stream.nextId += 2
+  return id
+}
+
+Connection.prototype._createStream = function _createStream (uri) {
+  var state = this._spdyState
+  var id = uri.id
+  if (id === undefined) { id = this._getId() }
+
+  var isGoaway = this._isGoaway(id)
+
+  if (uri.push && !state.acceptPush) {
+    state.debug('id=0 push disabled promisedId=%d', id)
+
+    // Fatal error
+    this._goaway({
+      lastId: state.stream.lastId.both,
+      code: 'PROTOCOL_ERROR',
+      send: true
+    })
+    isGoaway = true
+  }
+
+  var stream = new Stream(this, {
+    id: id,
+    request: uri.request !== false,
+    method: uri.method,
+    path: uri.path,
+    host: uri.host,
+    priority: uri.priority,
+    headers: uri.headers,
+    parent: uri.parent,
+    readable: !isGoaway && uri.readable,
+    writable: !isGoaway && uri.writable
+  })
+  var self = this
+
+  // Just an empty stream for API consistency
+  if (isGoaway) {
+    return stream
+  }
+
+  state.stream.lastId.both = Math.max(state.stream.lastId.both, id)
+
+  state.debug('id=0 add stream=%d', stream.id)
+  state.stream.map[stream.id] = stream
+  state.stream.count++
+  state.counters.stream++
+  if (stream.parent !== null) {
+    state.counters.push++
+  }
+
+  stream.once('close', function () {
+    self._removeStream(stream)
+  })
+
+  return stream
+}
+
+Connection.prototype._handleHeaders = function _handleHeaders (frame) {
+  var state = this._spdyState
+
+  // Must be HEADERS frame after stream close
+  if (frame.id <= state.stream.lastId.received) { return }
+
+  // Someone is using our ids!
+  if ((frame.id + state.stream.nextId) % 2 === 0) {
+    state.framer.rstFrame({ id: frame.id, code: 'PROTOCOL_ERROR' })
+    return
+  }
+
+  var stream = this._createStream({
+    id: frame.id,
+    request: false,
+    method: frame.headers[':method'],
+    path: frame.headers[':path'],
+    host: frame.headers[':authority'],
+    priority: frame.priority,
+    headers: frame.headers,
+    writable: frame.writable
+  })
+
+  // GOAWAY
+  if (this._isGoaway(stream.id)) {
+    return
+  }
+
+  state.stream.lastId.received = Math.max(
+    state.stream.lastId.received,
+    stream.id
+  )
+
+  // TODO(indutny) handle stream limit
+  if (!this.emit('stream', stream)) {
+    // No listeners was set - abort the stream
+    stream.abort()
+    return
+  }
+
+  // Create fake frame to simulate end of the data
+  if (frame.fin) {
+    stream._handleFrame({ type: 'FIN', fin: true })
+  }
+
+  return stream
+}
+
+Connection.prototype._onSessionWindowDrain = function _onSessionWindowDrain () {
+  var state = this._spdyState
+  if (state.version < 3.1 && !(state.isServer && state.autoSpdy31)) {
+    return
+  }
+
+  var delta = state.window.recv.getDelta()
+  if (delta === 0) {
+    return
+  }
+
+  state.debug('id=0 session window drain, update by %d', delta)
+
+  state.framer.windowUpdateFrame({
+    id: 0,
+    delta: delta
+  })
+  state.window.recv.update(delta)
+}
+
+Connection.prototype.start = function start (version) {
+  this._spdyState.parser.setVersion(version)
+}
+
+// Mostly for testing
+Connection.prototype.getVersion = function getVersion () {
+  return this._spdyState.version
+}
+
+Connection.prototype._handleSettings = function _handleSettings (settings) {
+  var state = this._spdyState
+
+  state.framer.ackSettingsFrame()
+
+  this._setDefaultWindow(settings)
+  if (settings.max_frame_size) { state.framer.setMaxFrameSize(settings.max_frame_size) }
+
+  // TODO(indutny): handle max_header_list_size
+  if (settings.header_table_size) {
+    try {
+      state.pair.compress.updateTableSize(settings.header_table_size)
+    } catch (e) {
+      this._goaway({
+        lastId: 0,
+        code: 'PROTOCOL_ERROR',
+        send: true
+      })
+      return
+    }
+  }
+
+  // HTTP2 clients needs to enable PUSH streams explicitly
+  if (state.protocol.name !== 'spdy') {
+    if (settings.enable_push === undefined) {
+      state.framer.enablePush(state.isServer)
+    } else {
+      state.framer.enablePush(settings.enable_push === 1)
+    }
+  }
+
+  // TODO(indutny): handle max_concurrent_streams
+}
+
+Connection.prototype._setDefaultWindow = function _setDefaultWindow (settings) {
+  if (settings.initial_window_size === undefined) {
+    return
+  }
+
+  var state = this._spdyState
+
+  // Update defaults
+  var window = state.streamWindow
+  window.send.setMax(settings.initial_window_size)
+
+  // Update existing streams
+  Object.keys(state.stream.map).forEach(function (id) {
+    var stream = state.stream.map[id]
+    var window = stream._spdyState.window
+
+    window.send.updateMax(settings.initial_window_size)
+  })
+}
+
+Connection.prototype._handlePing = function handlePing (frame) {
+  var self = this
+  var state = this._spdyState
+
+  // Handle incoming PING
+  if (!frame.ack) {
+    state.framer.pingFrame({
+      opaque: frame.opaque,
+      ack: true
+    })
+
+    self.emit('ping', frame.opaque)
+    return
+  }
+
+  // Handle reply PING
+  var hex = frame.opaque.toString('hex')
+  if (!state.ping.map[hex]) {
+    return
+  }
+  var ping = state.ping.map[hex]
+  delete state.ping.map[hex]
+
+  if (ping.cb) {
+    ping.cb(null)
+  }
+}
+
+Connection.prototype._handleGoaway = function handleGoaway (frame) {
+  this._goaway({
+    lastId: frame.lastId,
+    code: frame.code,
+    send: false
+  })
+}
+
+Connection.prototype.ping = function ping (callback) {
+  var state = this._spdyState
+
+  // HTTP2 is using 8-byte opaque
+  var opaque = Buffer.alloc(state.constants.PING_OPAQUE_SIZE)
+  opaque.fill(0)
+  opaque.writeUInt32BE(state.ping.nextId, opaque.length - 4)
+  state.ping.nextId += 2
+
+  state.ping.map[opaque.toString('hex')] = { cb: callback }
+  state.framer.pingFrame({
+    opaque: opaque,
+    ack: false
+  })
+}
+
+Connection.prototype.getCounter = function getCounter (name) {
+  return this._spdyState.counters[name]
+}
+
+Connection.prototype.reserveStream = function reserveStream (uri, callback) {
+  var stream = this._createStream(uri)
+
+  // GOAWAY
+  if (this._isGoaway(stream.id)) {
+    var err = new Error('Can\'t send request after GOAWAY')
+    process.nextTick(function () {
+      if (callback) { callback(err) } else {
+        stream.emit('error', err)
+      }
+    })
+    return stream
+  }
+
+  if (callback) {
+    process.nextTick(function () {
+      callback(null, stream)
+    })
+  }
+
+  return stream
+}
+
+Connection.prototype.request = function request (uri, callback) {
+  var stream = this.reserveStream(uri, function (err) {
+    if (err) {
+      if (callback) {
+        callback(err)
+      } else {
+        stream.emit('error', err)
+      }
+      return
+    }
+
+    if (stream._wasSent()) {
+      if (callback) {
+        callback(null, stream)
+      }
+      return
+    }
+
+    stream.send(function (err) {
+      if (err) {
+        if (callback) { return callback(err) } else { return stream.emit('error', err) }
+      }
+
+      if (callback) {
+        callback(null, stream)
+      }
+    })
+  })
+
+  return stream
+}
+
+Connection.prototype._removeStream = function _removeStream (stream) {
+  var state = this._spdyState
+
+  state.debug('id=0 remove stream=%d', stream.id)
+  delete state.stream.map[stream.id]
+  state.stream.count--
+
+  if (state.stream.count === 0) {
+    this.emit('_streamDrain')
+  }
+}
+
+Connection.prototype._goaway = function _goaway (params) {
+  var state = this._spdyState
+  var self = this
+
+  state.goaway = params.lastId
+  state.debug('id=0 goaway from=%d', state.goaway)
+
+  Object.keys(state.stream.map).forEach(function (id) {
+    var stream = state.stream.map[id]
+
+    // Abort every stream started after GOAWAY
+    if (stream.id <= params.lastId) {
+      return
+    }
+
+    stream.abort()
+    stream.emit('error', new Error('New stream after GOAWAY'))
+  })
+
+  function finish () {
+    // Destroy socket if there are no streams
+    if (state.stream.count === 0 || params.code !== 'OK') {
+      // No further frames should be processed
+      state.parser.kill()
+
+      process.nextTick(function () {
+        var err = new Error('Fatal error: ' + params.code)
+        self._onStreamDrain(err)
+      })
+      return
+    }
+
+    self.on('_streamDrain', self._onStreamDrain)
+  }
+
+  if (params.send) {
+    // Make sure that GOAWAY frame is sent before dumping framer
+    state.framer.goawayFrame({
+      lastId: params.lastId,
+      code: params.code,
+      extra: params.extra
+    }, finish)
+  } else {
+    finish()
+  }
+}
+
+Connection.prototype._onStreamDrain = function _onStreamDrain (error) {
+  var state = this._spdyState
+
+  state.debug('id=0 _onStreamDrain')
+
+  state.framer.dump()
+  state.framer.unpipe(this.socket)
+  state.framer.resume()
+
+  if (this.socket.destroySoon) {
+    this.socket.destroySoon()
+  }
+  this.emit('close', error)
+}
+
+Connection.prototype.end = function end (callback) {
+  var state = this._spdyState
+
+  if (callback) {
+    this.once('close', callback)
+  }
+  this._goaway({
+    lastId: state.stream.lastId.both,
+    code: 'OK',
+    send: true
+  })
+}
+
+Connection.prototype.destroyStreams = function destroyStreams (err) {
+  var state = this._spdyState
+  Object.keys(state.stream.map).forEach(function (id) {
+    var stream = state.stream.map[id]
+
+    stream.destroy()
+    if (err) {
+      stream.emit('error', err)
+    }
+  })
+}
+
+Connection.prototype.isServer = function isServer () {
+  return this._spdyState.isServer
+}
+
+Connection.prototype.getXForwardedFor = function getXForwardFor () {
+  return this._spdyState.xForward
+}
+
+Connection.prototype.sendXForwardedFor = function sendXForwardedFor (host) {
+  var state = this._spdyState
+  if (state.version !== null) {
+    state.framer.xForwardedFor({ host: host })
+  } else {
+    state.xForward = host
+  }
+}
+
+Connection.prototype.pushPromise = function pushPromise (parent, uri, callback) {
+  var state = this._spdyState
+
+  var stream = this._createStream({
+    request: false,
+    parent: parent,
+    method: uri.method,
+    path: uri.path,
+    host: uri.host,
+    priority: uri.priority,
+    headers: uri.headers,
+    readable: false
+  })
+
+  var err
+
+  // TODO(indutny): deduplicate this logic somehow
+  if (this._isGoaway(stream.id)) {
+    err = new Error('Can\'t send PUSH_PROMISE after GOAWAY')
+
+    process.nextTick(function () {
+      if (callback) {
+        callback(err)
+      } else {
+        stream.emit('error', err)
+      }
+    })
+    return stream
+  }
+
+  if (uri.push && !state.acceptPush) {
+    err = new Error(
+      'Can\'t send PUSH_PROMISE, other side won\'t accept it')
+    process.nextTick(function () {
+      if (callback) { callback(err) } else {
+        stream.emit('error', err)
+      }
+    })
+    return stream
+  }
+
+  stream._sendPush(uri.status, uri.response, function (err) {
+    if (!callback) {
+      if (err) {
+        stream.emit('error', err)
+      }
+      return
+    }
+
+    if (err) { return callback(err) }
+    callback(null, stream)
+  })
+
+  return stream
+}
+
+Connection.prototype.setTimeout = function setTimeout (delay, callback) {
+  var state = this._spdyState
+
+  state.timeout.set(delay, callback)
+}

web/node_modules/spdy-transport/lib/spdy-transport/priority.js

@@ -0,0 +1,188 @@
+'use strict'
+
+var transport = require('../spdy-transport')
+var utils = transport.utils
+
+var assert = require('assert')
+var debug = require('debug')('spdy:priority')
+
+function PriorityNode (tree, options) {
+  this.tree = tree
+
+  this.id = options.id
+  this.parent = options.parent
+  this.weight = options.weight
+
+  // To be calculated in `addChild`
+  this.priorityFrom = 0
+  this.priorityTo = 1
+  this.priority = 1
+
+  this.children = {
+    list: [],
+    weight: 0
+  }
+
+  if (this.parent !== null) {
+    this.parent.addChild(this)
+  }
+}
+
+function compareChildren (a, b) {
+  return a.weight === b.weight ? a.id - b.id : a.weight - b.weight
+}
+
+PriorityNode.prototype.toJSON = function toJSON () {
+  return {
+    parent: this.parent,
+    weight: this.weight,
+    exclusive: this.exclusive
+  }
+}
+
+PriorityNode.prototype.getPriority = function getPriority () {
+  return this.priority
+}
+
+PriorityNode.prototype.getPriorityRange = function getPriorityRange () {
+  return { from: this.priorityFrom, to: this.priorityTo }
+}
+
+PriorityNode.prototype.addChild = function addChild (child) {
+  child.parent = this
+  utils.binaryInsert(this.children.list, child, compareChildren)
+  this.children.weight += child.weight
+
+  this._updatePriority(this.priorityFrom, this.priorityTo)
+}
+
+PriorityNode.prototype.remove = function remove () {
+  assert(this.parent, 'Can\'t remove root node')
+
+  this.parent.removeChild(this)
+  this.tree._removeNode(this)
+
+  // Move all children to the parent
+  for (var i = 0; i < this.children.list.length; i++) {
+    this.parent.addChild(this.children.list[i])
+  }
+}
+
+PriorityNode.prototype.removeChild = function removeChild (child) {
+  this.children.weight -= child.weight
+  var index = utils.binarySearch(this.children.list, child, compareChildren)
+  if (index !== -1 && this.children.list.length >= index) {
+    this.children.list.splice(index, 1)
+  }
+}
+
+PriorityNode.prototype.removeChildren = function removeChildren () {
+  var children = this.children.list
+  this.children.list = []
+  this.children.weight = 0
+  return children
+}
+
+PriorityNode.prototype._updatePriority = function _updatePriority (from, to) {
+  this.priority = to - from
+  this.priorityFrom = from
+  this.priorityTo = to
+
+  var weight = 0
+  for (var i = 0; i < this.children.list.length; i++) {
+    var node = this.children.list[i]
+    var nextWeight = weight + node.weight
+
+    node._updatePriority(
+      from + this.priority * (weight / this.children.weight),
+      from + this.priority * (nextWeight / this.children.weight)
+    )
+    weight = nextWeight
+  }
+}
+
+function PriorityTree (options) {
+  this.map = {}
+  this.list = []
+  this.defaultWeight = options.defaultWeight || 16
+
+  this.count = 0
+  this.maxCount = options.maxCount
+
+  // Root
+  this.root = this.add({
+    id: 0,
+    parent: null,
+    weight: 1
+  })
+}
+module.exports = PriorityTree
+
+PriorityTree.create = function create (options) {
+  return new PriorityTree(options)
+}
+
+PriorityTree.prototype.add = function add (options) {
+  if (options.id === options.parent) {
+    return this.addDefault(options.id)
+  }
+
+  var parent = options.parent === null ? null : this.map[options.parent]
+  if (parent === undefined) {
+    return this.addDefault(options.id)
+  }
+
+  debug('add node=%d parent=%d weight=%d exclusive=%d',
+    options.id,
+    options.parent === null ? -1 : options.parent,
+    options.weight || this.defaultWeight,
+    options.exclusive ? 1 : 0)
+
+  var children
+  if (options.exclusive) {
+    children = parent.removeChildren()
+  }
+
+  var node = new PriorityNode(this, {
+    id: options.id,
+    parent: parent,
+    weight: options.weight || this.defaultWeight
+  })
+  this.map[options.id] = node
+
+  if (options.exclusive) {
+    for (var i = 0; i < children.length; i++) {
+      node.addChild(children[i])
+    }
+  }
+
+  this.count++
+  if (this.count > this.maxCount) {
+    debug('hit maximum remove id=%d', this.list[0].id)
+    this.list.shift().remove()
+  }
+
+  // Root node is not subject to removal
+  if (node.parent !== null) {
+    this.list.push(node)
+  }
+
+  return node
+}
+
+// Only for testing, should use `node`'s methods
+PriorityTree.prototype.get = function get (id) {
+  return this.map[id]
+}
+
+PriorityTree.prototype.addDefault = function addDefault (id) {
+  debug('creating default node')
+  return this.add({ id: id, parent: 0, weight: this.defaultWeight })
+}
+
+PriorityTree.prototype._removeNode = function _removeNode (node) {
+  delete this.map[node.id]
+  var index = utils.binarySearch(this.list, node, compareChildren)
+  this.list.splice(index, 1)
+  this.count--
+}

web/node_modules/spdy-transport/lib/spdy-transport/protocol/base/constants.js

@@ -0,0 +1,4 @@
+exports.DEFAULT_METHOD = 'GET'
+exports.DEFAULT_HOST = 'localhost'
+exports.MAX_PRIORITY_STREAMS = 100
+exports.DEFAULT_MAX_CHUNK = 8 * 1024

web/node_modules/spdy-transport/lib/spdy-transport/protocol/base/framer.js

@@ -0,0 +1,58 @@
+'use strict'
+
+var util = require('util')
+
+var transport = require('../../../spdy-transport')
+var base = require('./')
+var Scheduler = base.Scheduler
+
+function Framer (options) {
+  Scheduler.call(this)
+
+  this.version = null
+  this.compress = null
+  this.window = options.window
+  this.timeout = options.timeout
+
+  // Wait for `enablePush`
+  this.pushEnabled = null
+}
+util.inherits(Framer, Scheduler)
+module.exports = Framer
+
+Framer.prototype.setVersion = function setVersion (version) {
+  this.version = version
+  this.emit('version')
+}
+
+Framer.prototype.setCompression = function setCompresion (pair) {
+  this.compress = new transport.utils.LockStream(pair.compress)
+}
+
+Framer.prototype.enablePush = function enablePush (enable) {
+  this.pushEnabled = enable
+  this.emit('_pushEnabled')
+}
+
+Framer.prototype._checkPush = function _checkPush (callback) {
+  if (this.pushEnabled === null) {
+    this.once('_pushEnabled', function () {
+      this._checkPush(callback)
+    })
+    return
+  }
+
+  var err = null
+  if (!this.pushEnabled) {
+    err = new Error('PUSH_PROMISE disabled by other side')
+  }
+  process.nextTick(function () {
+    return callback(err)
+  })
+}
+
+Framer.prototype._resetTimeout = function _resetTimeout () {
+  if (this.timeout) {
+    this.timeout.reset()
+  }
+}

web/node_modules/spdy-transport/lib/spdy-transport/protocol/base/index.js

@@ -0,0 +1,7 @@
+'use strict'
+
+exports.utils = require('./utils')
+exports.constants = require('./constants')
+exports.Scheduler = require('./scheduler')
+exports.Parser = require('./parser')
+exports.Framer = require('./framer')

web/node_modules/spdy-transport/lib/spdy-transport/protocol/base/parser.js

@@ -0,0 +1,106 @@
+'use strict'
+
+var transport = require('../../../spdy-transport')
+
+var util = require('util')
+var utils = require('./').utils
+var OffsetBuffer = require('obuf')
+var Transform = require('readable-stream').Transform
+
+function Parser (options) {
+  Transform.call(this, {
+    readableObjectMode: true
+  })
+
+  this.buffer = new OffsetBuffer()
+  this.partial = false
+  this.waiting = 0
+
+  this.window = options.window
+
+  this.version = null
+  this.decompress = null
+  this.dead = false
+}
+module.exports = Parser
+util.inherits(Parser, Transform)
+
+Parser.prototype.error = utils.error
+
+Parser.prototype.kill = function kill () {
+  this.dead = true
+}
+
+Parser.prototype._transform = function transform (data, encoding, cb) {
+  if (!this.dead) { this.buffer.push(data) }
+
+  this._consume(cb)
+}
+
+Parser.prototype._consume = function _consume (cb) {
+  var self = this
+
+  function next (err, frame) {
+    if (err) {
+      return cb(err)
+    }
+
+    if (Array.isArray(frame)) {
+      for (var i = 0; i < frame.length; i++) {
+        self.push(frame[i])
+      }
+    } else if (frame) {
+      self.push(frame)
+    }
+
+    // Consume more packets
+    if (!sync) {
+      return self._consume(cb)
+    }
+
+    process.nextTick(function () {
+      self._consume(cb)
+    })
+  }
+
+  if (this.dead) {
+    return cb()
+  }
+
+  if (this.buffer.size < this.waiting) {
+    // No data at all
+    if (this.buffer.size === 0) {
+      return cb()
+    }
+
+    // Partial DATA frame or something that we can process partially
+    if (this.partial) {
+      var partial = this.buffer.clone(this.buffer.size)
+      this.buffer.skip(partial.size)
+      this.waiting -= partial.size
+
+      this.executePartial(partial, next)
+      return
+    }
+
+    // We shall not do anything until we get all expected data
+    return cb()
+  }
+
+  var sync = true
+
+  var content = this.buffer.clone(this.waiting)
+  this.buffer.skip(this.waiting)
+
+  this.execute(content, next)
+  sync = false
+}
+
+Parser.prototype.setVersion = function setVersion (version) {
+  this.version = version
+  this.emit('version', version)
+}
+
+Parser.prototype.setCompression = function setCompresion (pair) {
+  this.decompress = new transport.utils.LockStream(pair.decompress)
+}

web/node_modules/spdy-transport/lib/spdy-transport/protocol/base/scheduler.js

@@ -0,0 +1,216 @@
+'use strict'
+
+var transport = require('../../../spdy-transport')
+var utils = transport.utils
+
+var assert = require('assert')
+var util = require('util')
+var debug = require('debug')('spdy:scheduler')
+var Readable = require('readable-stream').Readable
+
+/*
+ * We create following structure in `pending`:
+ * [ [ id = 0 ], [ id = 1 ], [ id = 2 ], [ id = 0 ] ]
+ *     chunks      chunks      chunks      chunks
+ *     chunks                  chunks
+ *     chunks
+ *
+ * Then on the `.tick()` pass we pick one chunks from each item and remove the
+ * item if it is empty:
+ *
+ * [ [ id = 0 ], [ id = 2 ] ]
+ *     chunks      chunks
+ *     chunks
+ *
+ * Writing out: chunks for 0, chunks for 1, chunks for 2, chunks for 0
+ *
+ * This way data is interleaved between the different streams.
+ */
+
+function Scheduler (options) {
+  Readable.call(this)
+
+  // Pretty big window by default
+  this.window = 0.25
+
+  if (options && options.window) { this.window = options.window }
+
+  this.sync = []
+  this.list = []
+  this.count = 0
+  this.pendingTick = false
+}
+util.inherits(Scheduler, Readable)
+module.exports = Scheduler
+
+// Just for testing, really
+Scheduler.create = function create (options) {
+  return new Scheduler(options)
+}
+
+function insertCompare (a, b) {
+  return a.priority === b.priority
+    ? a.stream - b.stream
+    : b.priority - a.priority
+}
+
+Scheduler.prototype.schedule = function schedule (data) {
+  var priority = data.priority
+  var stream = data.stream
+  var chunks = data.chunks
+
+  // Synchronous frames should not be interleaved
+  if (priority === false) {
+    debug('queue sync', chunks)
+    this.sync.push(data)
+    this.count += chunks.length
+
+    this._read()
+    return
+  }
+
+  debug('queue async priority=%d stream=%d', priority, stream, chunks)
+  var item = new SchedulerItem(stream, priority)
+  var index = utils.binaryLookup(this.list, item, insertCompare)
+
+  // Push new item
+  if (index >= this.list.length || insertCompare(this.list[index], item) !== 0) {
+    this.list.splice(index, 0, item)
+  } else { // Coalesce
+    item = this.list[index]
+  }
+
+  item.push(data)
+
+  this.count += chunks.length
+
+  this._read()
+}
+
+Scheduler.prototype._read = function _read () {
+  if (this.count === 0) {
+    return
+  }
+
+  if (this.pendingTick) {
+    return
+  }
+  this.pendingTick = true
+
+  var self = this
+  process.nextTick(function () {
+    self.pendingTick = false
+    self.tick()
+  })
+}
+
+Scheduler.prototype.tick = function tick () {
+  // No luck for async frames
+  if (!this.tickSync()) { return false }
+
+  return this.tickAsync()
+}
+
+Scheduler.prototype.tickSync = function tickSync () {
+  // Empty sync queue first
+  var sync = this.sync
+  var res = true
+  this.sync = []
+  for (var i = 0; i < sync.length; i++) {
+    var item = sync[i]
+    debug('tick sync pending=%d', this.count, item.chunks)
+    for (var j = 0; j < item.chunks.length; j++) {
+      this.count--
+      // TODO: handle stream backoff properly
+      try {
+        res = this.push(item.chunks[j])
+      } catch (err) {
+        this.emit('error', err)
+        return false
+      }
+    }
+    debug('after tick sync pending=%d', this.count)
+
+    // TODO(indutny): figure out the way to invoke callback on actual write
+    if (item.callback) {
+      item.callback(null)
+    }
+  }
+  return res
+}
+
+Scheduler.prototype.tickAsync = function tickAsync () {
+  var res = true
+  var list = this.list
+  if (list.length === 0) {
+    return res
+  }
+
+  var startPriority = list[0].priority
+  for (var index = 0; list.length > 0; index++) {
+    // Loop index
+    index %= list.length
+    if (startPriority - list[index].priority > this.window) { index = 0 }
+    debug('tick async index=%d start=%d', index, startPriority)
+
+    var current = list[index]
+    var item = current.shift()
+
+    if (current.isEmpty()) {
+      list.splice(index, 1)
+      if (index === 0 && list.length > 0) {
+        startPriority = list[0].priority
+      }
+      index--
+    }
+
+    debug('tick async pending=%d', this.count, item.chunks)
+    for (var i = 0; i < item.chunks.length; i++) {
+      this.count--
+      // TODO: handle stream backoff properly
+      try {
+        res = this.push(item.chunks[i])
+      } catch (err) {
+        this.emit('error', err)
+        return false
+      }
+    }
+    debug('after tick pending=%d', this.count)
+
+    // TODO(indutny): figure out the way to invoke callback on actual write
+    if (item.callback) {
+      item.callback(null)
+    }
+    if (!res) { break }
+  }
+
+  return res
+}
+
+Scheduler.prototype.dump = function dump () {
+  this.tickSync()
+
+  // Write everything out
+  while (!this.tickAsync()) {
+    // Intentional no-op
+  }
+  assert.strictEqual(this.count, 0)
+}
+
+function SchedulerItem (stream, priority) {
+  this.stream = stream
+  this.priority = priority
+  this.queue = []
+}
+
+SchedulerItem.prototype.push = function push (chunks) {
+  this.queue.push(chunks)
+}
+
+SchedulerItem.prototype.shift = function shift () {
+  return this.queue.shift()
+}
+
+SchedulerItem.prototype.isEmpty = function isEmpty () {
+  return this.queue.length === 0
+}

web/node_modules/spdy-transport/lib/spdy-transport/protocol/base/utils.js

@@ -0,0 +1,94 @@
+'use strict'
+
+var utils = exports
+
+var util = require('util')
+
+function ProtocolError (code, message) {
+  this.code = code
+  this.message = message
+}
+util.inherits(ProtocolError, Error)
+utils.ProtocolError = ProtocolError
+
+utils.error = function error (code, message) {
+  return new ProtocolError(code, message)
+}
+
+utils.reverse = function reverse (object) {
+  var result = []
+
+  Object.keys(object).forEach(function (key) {
+    result[object[key] | 0] = key
+  })
+
+  return result
+}
+
+// weight [1, 36] <=> priority [0, 7]
+// This way weight=16 is preserved and has priority=3
+utils.weightToPriority = function weightToPriority (weight) {
+  return ((Math.min(35, (weight - 1)) / 35) * 7) | 0
+}
+
+utils.priorityToWeight = function priorityToWeight (priority) {
+  return (((priority / 7) * 35) | 0) + 1
+}
+
+// Copy-Paste from node
+exports.addHeaderLine = function addHeaderLine (field, value, dest) {
+  field = field.toLowerCase()
+  if (/^:/.test(field)) {
+    dest[field] = value
+    return
+  }
+
+  switch (field) {
+    // Array headers:
+    case 'set-cookie':
+      if (dest[field] !== undefined) {
+        dest[field].push(value)
+      } else {
+        dest[field] = [ value ]
+      }
+      break
+
+    /* eslint-disable max-len */
+    // list is taken from:
+    /* eslint-enable max-len */
+    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':
+      // drop duplicates
+      if (dest[field] === undefined) {
+        dest[field] = value
+      }
+      break
+
+    case 'cookie':
+      // make semicolon-separated list
+      if (dest[field] !== undefined) {
+        dest[field] += '; ' + value
+      } else {
+        dest[field] = value
+      }
+      break
+
+    default:
+      // make comma-separated list
+      if (dest[field] !== undefined) {
+        dest[field] += ', ' + value
+      } else {
+        dest[field] = value
+      }
+  }
+}

web/node_modules/spdy-transport/lib/spdy-transport/protocol/http2/constants.js

@@ -0,0 +1,93 @@
+'use strict'
+
+var transport = require('../../../spdy-transport')
+var base = transport.protocol.base
+
+exports.PREFACE_SIZE = 24
+exports.PREFACE = 'PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n'
+exports.PREFACE_BUFFER = Buffer.from(exports.PREFACE)
+
+exports.PING_OPAQUE_SIZE = 8
+
+exports.FRAME_HEADER_SIZE = 9
+exports.INITIAL_MAX_FRAME_SIZE = 16384
+exports.ABSOLUTE_MAX_FRAME_SIZE = 16777215
+exports.HEADER_TABLE_SIZE = 4096
+exports.DEFAULT_MAX_HEADER_LIST_SIZE = 80 * 1024 // as in http_parser
+exports.MAX_INITIAL_WINDOW_SIZE = 2147483647
+
+exports.DEFAULT_WEIGHT = 16
+
+exports.MAX_CONCURRENT_STREAMS = Infinity
+
+exports.frameType = {
+  DATA: 0,
+  HEADERS: 1,
+  PRIORITY: 2,
+  RST_STREAM: 3,
+  SETTINGS: 4,
+  PUSH_PROMISE: 5,
+  PING: 6,
+  GOAWAY: 7,
+  WINDOW_UPDATE: 8,
+  CONTINUATION: 9,
+
+  // Custom
+  X_FORWARDED_FOR: 0xde
+}
+
+exports.flags = {
+  ACK: 0x01, // SETTINGS-only
+  END_STREAM: 0x01,
+  END_HEADERS: 0x04,
+  PADDED: 0x08,
+  PRIORITY: 0x20
+}
+
+exports.settings = {
+  SETTINGS_HEADER_TABLE_SIZE: 0x01,
+  SETTINGS_ENABLE_PUSH: 0x02,
+  SETTINGS_MAX_CONCURRENT_STREAMS: 0x03,
+  SETTINGS_INITIAL_WINDOW_SIZE: 0x04,
+  SETTINGS_MAX_FRAME_SIZE: 0x05,
+  SETTINGS_MAX_HEADER_LIST_SIZE: 0x06
+}
+
+exports.settingsIndex = [
+  null,
+  'header_table_size',
+  'enable_push',
+  'max_concurrent_streams',
+  'initial_window_size',
+  'max_frame_size',
+  'max_header_list_size'
+]
+
+exports.error = {
+  OK: 0,
+  NO_ERROR: 0,
+
+  PROTOCOL_ERROR: 1,
+  INTERNAL_ERROR: 2,
+  FLOW_CONTROL_ERROR: 3,
+  SETTINGS_TIMEOUT: 4,
+
+  STREAM_CLOSED: 5,
+  INVALID_STREAM: 5,
+
+  FRAME_SIZE_ERROR: 6,
+  REFUSED_STREAM: 7,
+  CANCEL: 8,
+  COMPRESSION_ERROR: 9,
+  CONNECT_ERROR: 10,
+  ENHANCE_YOUR_CALM: 11,
+  INADEQUATE_SECURITY: 12,
+  HTTP_1_1_REQUIRED: 13
+}
+exports.errorByCode = base.utils.reverse(exports.error)
+
+exports.DEFAULT_WINDOW = 64 * 1024 - 1
+
+exports.goaway = exports.error
+exports.goawayByCode = Object.assign({}, exports.errorByCode)
+exports.goawayByCode[0] = 'OK'

web/node_modules/spdy-transport/lib/spdy-transport/protocol/http2/framer.js

@@ -0,0 +1,542 @@
+'use strict'
+
+var transport = require('../../../spdy-transport')
+var base = transport.protocol.base
+var constants = require('./').constants
+
+var assert = require('assert')
+var util = require('util')
+var WriteBuffer = require('wbuf')
+var OffsetBuffer = require('obuf')
+var debug = require('debug')('spdy:framer')
+var debugExtra = require('debug')('spdy:framer:extra')
+
+function Framer (options) {
+  base.Framer.call(this, options)
+
+  this.maxFrameSize = constants.INITIAL_MAX_FRAME_SIZE
+}
+util.inherits(Framer, base.Framer)
+module.exports = Framer
+
+Framer.create = function create (options) {
+  return new Framer(options)
+}
+
+Framer.prototype.setMaxFrameSize = function setMaxFrameSize (size) {
+  this.maxFrameSize = size
+}
+
+Framer.prototype._frame = function _frame (frame, body, callback) {
+  debug('id=%d type=%s', frame.id, frame.type)
+
+  var buffer = new WriteBuffer()
+
+  buffer.reserve(constants.FRAME_HEADER_SIZE)
+  var len = buffer.skip(3)
+  buffer.writeUInt8(constants.frameType[frame.type])
+  buffer.writeUInt8(frame.flags)
+  buffer.writeUInt32BE(frame.id & 0x7fffffff)
+
+  body(buffer)
+
+  var frameSize = buffer.size - constants.FRAME_HEADER_SIZE
+  len.writeUInt24BE(frameSize)
+
+  var chunks = buffer.render()
+  var toWrite = {
+    stream: frame.id,
+    priority: frame.priority === undefined ? false : frame.priority,
+    chunks: chunks,
+    callback: callback
+  }
+
+  if (this.window && frame.type === 'DATA') {
+    var self = this
+    this._resetTimeout()
+    this.window.send.update(-frameSize, function () {
+      self._resetTimeout()
+      self.schedule(toWrite)
+    })
+  } else {
+    this._resetTimeout()
+    this.schedule(toWrite)
+  }
+
+  return chunks
+}
+
+Framer.prototype._split = function _split (frame) {
+  var buf = new OffsetBuffer()
+  for (var i = 0; i < frame.chunks.length; i++) { buf.push(frame.chunks[i]) }
+
+  var frames = []
+  while (!buf.isEmpty()) {
+    // First frame may have reserved bytes in it
+    var size = this.maxFrameSize
+    if (frames.length === 0) {
+      size -= frame.reserve
+    }
+    size = Math.min(size, buf.size)
+
+    var frameBuf = buf.clone(size)
+    buf.skip(size)
+
+    frames.push({
+      size: frameBuf.size,
+      chunks: frameBuf.toChunks()
+    })
+  }
+
+  return frames
+}
+
+Framer.prototype._continuationFrame = function _continuationFrame (frame,
+  body,
+  callback) {
+  var frames = this._split(frame)
+
+  frames.forEach(function (subFrame, i) {
+    var isFirst = i === 0
+    var isLast = i === frames.length - 1
+
+    var flags = isLast ? constants.flags.END_HEADERS : 0
+
+    // PRIORITY and friends
+    if (isFirst) {
+      flags |= frame.flags
+    }
+
+    this._frame({
+      id: frame.id,
+      priority: false,
+      type: isFirst ? frame.type : 'CONTINUATION',
+      flags: flags
+    }, function (buf) {
+      // Fill those reserved bytes
+      if (isFirst && body) { body(buf) }
+
+      buf.reserve(subFrame.size)
+      for (var i = 0; i < subFrame.chunks.length; i++) { buf.copyFrom(subFrame.chunks[i]) }
+    }, isLast ? callback : null)
+  }, this)
+
+  if (frames.length === 0) {
+    this._frame({
+      id: frame.id,
+      priority: false,
+      type: frame.type,
+      flags: frame.flags | constants.flags.END_HEADERS
+    }, function (buf) {
+      if (body) { body(buf) }
+    }, callback)
+  }
+}
+
+Framer.prototype._compressHeaders = function _compressHeaders (headers,
+  pairs,
+  callback) {
+  Object.keys(headers || {}).forEach(function (name) {
+    var lowName = name.toLowerCase()
+
+    // Not allowed in HTTP2
+    switch (lowName) {
+      case 'host':
+      case 'connection':
+      case 'keep-alive':
+      case 'proxy-connection':
+      case 'transfer-encoding':
+      case 'upgrade':
+        return
+    }
+
+    // Should be in `pairs`
+    if (/^:/.test(lowName)) {
+      return
+    }
+
+    // Do not compress, or index Cookie field (for security reasons)
+    var neverIndex = lowName === 'cookie' || lowName === 'set-cookie'
+
+    var value = headers[name]
+    if (Array.isArray(value)) {
+      for (var i = 0; i < value.length; i++) {
+        pairs.push({
+          name: lowName,
+          value: value[i] + '',
+          neverIndex: neverIndex,
+          huffman: !neverIndex
+        })
+      }
+    } else {
+      pairs.push({
+        name: lowName,
+        value: value + '',
+        neverIndex: neverIndex,
+        huffman: !neverIndex
+      })
+    }
+  })
+
+  assert(this.compress !== null, 'Framer version not initialized')
+  debugExtra('compressing headers=%j', pairs)
+  this.compress.write([ pairs ], callback)
+}
+
+Framer.prototype._isDefaultPriority = function _isDefaultPriority (priority) {
+  if (!priority) { return true }
+
+  return !priority.parent &&
+         priority.weight === constants.DEFAULT &&
+         !priority.exclusive
+}
+
+Framer.prototype._defaultHeaders = function _defaultHeaders (frame, pairs) {
+  if (!frame.path) {
+    throw new Error('`path` is required frame argument')
+  }
+
+  pairs.push({
+    name: ':method',
+    value: frame.method || base.constants.DEFAULT_METHOD
+  })
+  pairs.push({ name: ':path', value: frame.path })
+  pairs.push({ name: ':scheme', value: frame.scheme || 'https' })
+  pairs.push({
+    name: ':authority',
+    value: frame.host ||
+           (frame.headers && frame.headers.host) ||
+           base.constants.DEFAULT_HOST
+  })
+}
+
+Framer.prototype._headersFrame = function _headersFrame (kind, frame, callback) {
+  var pairs = []
+
+  if (kind === 'request') {
+    this._defaultHeaders(frame, pairs)
+  } else if (kind === 'response') {
+    pairs.push({ name: ':status', value: (frame.status || 200) + '' })
+  }
+
+  var self = this
+  this._compressHeaders(frame.headers, pairs, function (err, chunks) {
+    if (err) {
+      if (callback) {
+        return callback(err)
+      } else {
+        return self.emit('error', err)
+      }
+    }
+
+    var reserve = 0
+
+    // If priority info is present, and the values are not default ones
+    // reserve space for the priority info and add PRIORITY flag
+    var priority = frame.priority
+    if (!self._isDefaultPriority(priority)) { reserve = 5 }
+
+    var flags = reserve === 0 ? 0 : constants.flags.PRIORITY
+
+    // Mostly for testing
+    if (frame.fin) {
+      flags |= constants.flags.END_STREAM
+    }
+
+    self._continuationFrame({
+      id: frame.id,
+      type: 'HEADERS',
+      flags: flags,
+      reserve: reserve,
+      chunks: chunks
+    }, function (buf) {
+      if (reserve === 0) {
+        return
+      }
+
+      buf.writeUInt32BE(((priority.exclusive ? 0x80000000 : 0) |
+                         priority.parent) >>> 0)
+      buf.writeUInt8((priority.weight | 0) - 1)
+    }, callback)
+  })
+}
+
+Framer.prototype.requestFrame = function requestFrame (frame, callback) {
+  return this._headersFrame('request', frame, callback)
+}
+
+Framer.prototype.responseFrame = function responseFrame (frame, callback) {
+  return this._headersFrame('response', frame, callback)
+}
+
+Framer.prototype.headersFrame = function headersFrame (frame, callback) {
+  return this._headersFrame('headers', frame, callback)
+}
+
+Framer.prototype.pushFrame = function pushFrame (frame, callback) {
+  var self = this
+
+  function compress (headers, pairs, callback) {
+    self._compressHeaders(headers, pairs, function (err, chunks) {
+      if (err) {
+        if (callback) {
+          return callback(err)
+        } else {
+          return self.emit('error', err)
+        }
+      }
+
+      callback(chunks)
+    })
+  }
+
+  function sendPromise (chunks) {
+    self._continuationFrame({
+      id: frame.id,
+      type: 'PUSH_PROMISE',
+      reserve: 4,
+      chunks: chunks
+    }, function (buf) {
+      buf.writeUInt32BE(frame.promisedId)
+    })
+  }
+
+  function sendResponse (chunks, callback) {
+    var priority = frame.priority
+    var isDefaultPriority = self._isDefaultPriority(priority)
+    var flags = isDefaultPriority ? 0 : constants.flags.PRIORITY
+
+    // Mostly for testing
+    if (frame.fin) {
+      flags |= constants.flags.END_STREAM
+    }
+
+    self._continuationFrame({
+      id: frame.promisedId,
+      type: 'HEADERS',
+      flags: flags,
+      reserve: isDefaultPriority ? 0 : 5,
+      chunks: chunks
+    }, function (buf) {
+      if (isDefaultPriority) {
+        return
+      }
+
+      buf.writeUInt32BE((priority.exclusive ? 0x80000000 : 0) |
+                        priority.parent)
+      buf.writeUInt8((priority.weight | 0) - 1)
+    }, callback)
+  }
+
+  this._checkPush(function (err) {
+    if (err) {
+      return callback(err)
+    }
+
+    var pairs = {
+      promise: [],
+      response: []
+    }
+
+    self._defaultHeaders(frame, pairs.promise)
+    pairs.response.push({ name: ':status', value: (frame.status || 200) + '' })
+
+    compress(frame.headers, pairs.promise, function (promiseChunks) {
+      sendPromise(promiseChunks)
+      if (frame.response === false) {
+        return callback(null)
+      }
+      compress(frame.response, pairs.response, function (responseChunks) {
+        sendResponse(responseChunks, callback)
+      })
+    })
+  })
+}
+
+Framer.prototype.priorityFrame = function priorityFrame (frame, callback) {
+  this._frame({
+    id: frame.id,
+    priority: false,
+    type: 'PRIORITY',
+    flags: 0
+  }, function (buf) {
+    var priority = frame.priority
+    buf.writeUInt32BE((priority.exclusive ? 0x80000000 : 0) |
+                      priority.parent)
+    buf.writeUInt8((priority.weight | 0) - 1)
+  }, callback)
+}
+
+Framer.prototype.dataFrame = function dataFrame (frame, callback) {
+  var frames = this._split({
+    reserve: 0,
+    chunks: [ frame.data ]
+  })
+
+  var fin = frame.fin ? constants.flags.END_STREAM : 0
+
+  var self = this
+  frames.forEach(function (subFrame, i) {
+    var isLast = i === frames.length - 1
+    var flags = 0
+    if (isLast) {
+      flags |= fin
+    }
+
+    self._frame({
+      id: frame.id,
+      priority: frame.priority,
+      type: 'DATA',
+      flags: flags
+    }, function (buf) {
+      buf.reserve(subFrame.size)
+      for (var i = 0; i < subFrame.chunks.length; i++) { buf.copyFrom(subFrame.chunks[i]) }
+    }, isLast ? callback : null)
+  })
+
+  // Empty DATA
+  if (frames.length === 0) {
+    this._frame({
+      id: frame.id,
+      priority: frame.priority,
+      type: 'DATA',
+      flags: fin
+    }, function (buf) {
+      // No-op
+    }, callback)
+  }
+}
+
+Framer.prototype.pingFrame = function pingFrame (frame, callback) {
+  this._frame({
+    id: 0,
+    type: 'PING',
+    flags: frame.ack ? constants.flags.ACK : 0
+  }, function (buf) {
+    buf.copyFrom(frame.opaque)
+  }, callback)
+}
+
+Framer.prototype.rstFrame = function rstFrame (frame, callback) {
+  this._frame({
+    id: frame.id,
+    type: 'RST_STREAM',
+    flags: 0
+  }, function (buf) {
+    buf.writeUInt32BE(constants.error[frame.code])
+  }, callback)
+}
+
+Framer.prototype.prefaceFrame = function prefaceFrame (callback) {
+  debug('preface')
+  this._resetTimeout()
+  this.schedule({
+    stream: 0,
+    priority: false,
+    chunks: [ constants.PREFACE_BUFFER ],
+    callback: callback
+  })
+}
+
+Framer.prototype.settingsFrame = function settingsFrame (options, callback) {
+  var key = JSON.stringify(options)
+
+  var settings = Framer.settingsCache[key]
+  if (settings) {
+    debug('cached settings')
+    this._resetTimeout()
+    this.schedule({
+      id: 0,
+      priority: false,
+      chunks: settings,
+      callback: callback
+    })
+    return
+  }
+
+  var params = []
+  for (var i = 0; i < constants.settingsIndex.length; i++) {
+    var name = constants.settingsIndex[i]
+    if (!name) {
+      continue
+    }
+
+    // value: Infinity
+    if (!isFinite(options[name])) {
+      continue
+    }
+
+    if (options[name] !== undefined) {
+      params.push({ key: i, value: options[name] })
+    }
+  }
+
+  var bodySize = params.length * 6
+
+  var chunks = this._frame({
+    id: 0,
+    type: 'SETTINGS',
+    flags: 0
+  }, function (buffer) {
+    buffer.reserve(bodySize)
+    for (var i = 0; i < params.length; i++) {
+      var param = params[i]
+
+      buffer.writeUInt16BE(param.key)
+      buffer.writeUInt32BE(param.value)
+    }
+  }, callback)
+
+  Framer.settingsCache[key] = chunks
+}
+Framer.settingsCache = {}
+
+Framer.prototype.ackSettingsFrame = function ackSettingsFrame (callback) {
+  /* var chunks = */ this._frame({
+    id: 0,
+    type: 'SETTINGS',
+    flags: constants.flags.ACK
+  }, function (buffer) {
+    // No-op
+  }, callback)
+}
+
+Framer.prototype.windowUpdateFrame = function windowUpdateFrame (frame,
+  callback) {
+  this._frame({
+    id: frame.id,
+    type: 'WINDOW_UPDATE',
+    flags: 0
+  }, function (buffer) {
+    buffer.reserve(4)
+    buffer.writeInt32BE(frame.delta)
+  }, callback)
+}
+
+Framer.prototype.goawayFrame = function goawayFrame (frame, callback) {
+  this._frame({
+    type: 'GOAWAY',
+    id: 0,
+    flags: 0
+  }, function (buf) {
+    buf.reserve(8)
+
+    // Last-good-stream-ID
+    buf.writeUInt32BE(frame.lastId & 0x7fffffff)
+    // Code
+    buf.writeUInt32BE(constants.goaway[frame.code])
+
+    // Extra debugging information
+    if (frame.extra) { buf.write(frame.extra) }
+  }, callback)
+}
+
+Framer.prototype.xForwardedFor = function xForwardedFor (frame, callback) {
+  this._frame({
+    type: 'X_FORWARDED_FOR',
+    id: 0,
+    flags: 0
+  }, function (buf) {
+    buf.write(frame.host)
+  }, callback)
+}

web/node_modules/spdy-transport/lib/spdy-transport/protocol/http2/hpack-pool.js

@@ -0,0 +1,34 @@
+'use strict'
+
+var constants = require('./').constants
+
+var hpack = require('hpack.js')
+
+function Pool () {
+}
+module.exports = Pool
+
+Pool.create = function create () {
+  return new Pool()
+}
+
+Pool.prototype.get = function get (version) {
+  var options = {
+    table: {
+      maxSize: constants.HEADER_TABLE_SIZE
+    }
+  }
+
+  var compress = hpack.compressor.create(options)
+  var decompress = hpack.decompressor.create(options)
+
+  return {
+    version: version,
+
+    compress: compress,
+    decompress: decompress
+  }
+}
+
+Pool.prototype.put = function put () {
+}

web/node_modules/spdy-transport/lib/spdy-transport/protocol/http2/index.js

@@ -0,0 +1,8 @@
+'use strict'
+
+exports.name = 'h2'
+
+exports.constants = require('./constants')
+exports.parser = require('./parser')
+exports.framer = require('./framer')
+exports.compressionPool = require('./hpack-pool')

web/node_modules/spdy-transport/lib/spdy-transport/protocol/http2/parser.js

@@ -0,0 +1,578 @@
+'use strict'
+
+var parser = exports
+
+var transport = require('../../../spdy-transport')
+var base = transport.protocol.base
+var utils = base.utils
+var constants = require('./').constants
+
+var assert = require('assert')
+var util = require('util')
+
+function Parser (options) {
+  base.Parser.call(this, options)
+
+  this.isServer = options.isServer
+
+  this.waiting = constants.PREFACE_SIZE
+  this.state = 'preface'
+  this.pendingHeader = null
+
+  // Header Block queue
+  this._lastHeaderBlock = null
+  this.maxFrameSize = constants.INITIAL_MAX_FRAME_SIZE
+  this.maxHeaderListSize = constants.DEFAULT_MAX_HEADER_LIST_SIZE
+}
+util.inherits(Parser, base.Parser)
+
+parser.create = function create (options) {
+  return new Parser(options)
+}
+
+Parser.prototype.setMaxFrameSize = function setMaxFrameSize (size) {
+  this.maxFrameSize = size
+}
+
+Parser.prototype.setMaxHeaderListSize = function setMaxHeaderListSize (size) {
+  this.maxHeaderListSize = size
+}
+
+// Only for testing
+Parser.prototype.skipPreface = function skipPreface () {
+  // Just some number bigger than 3.1, doesn't really matter for HTTP2
+  this.setVersion(4)
+
+  // Parse frame header!
+  this.state = 'frame-head'
+  this.waiting = constants.FRAME_HEADER_SIZE
+}
+
+Parser.prototype.execute = function execute (buffer, callback) {
+  if (this.state === 'preface') { return this.onPreface(buffer, callback) }
+
+  if (this.state === 'frame-head') {
+    return this.onFrameHead(buffer, callback)
+  }
+
+  assert(this.state === 'frame-body' && this.pendingHeader !== null)
+
+  var self = this
+  var header = this.pendingHeader
+  this.pendingHeader = null
+
+  this.onFrameBody(header, buffer, function (err, frame) {
+    if (err) {
+      return callback(err)
+    }
+
+    self.state = 'frame-head'
+    self.partial = false
+    self.waiting = constants.FRAME_HEADER_SIZE
+    callback(null, frame)
+  })
+}
+
+Parser.prototype.executePartial = function executePartial (buffer, callback) {
+  var header = this.pendingHeader
+
+  assert.strictEqual(header.flags & constants.flags.PADDED, 0)
+
+  if (this.window) { this.window.recv.update(-buffer.size) }
+
+  callback(null, {
+    type: 'DATA',
+    id: header.id,
+
+    // Partial DATA can't be FIN
+    fin: false,
+    data: buffer.take(buffer.size)
+  })
+}
+
+Parser.prototype.onPreface = function onPreface (buffer, callback) {
+  if (buffer.take(buffer.size).toString() !== constants.PREFACE) {
+    return callback(this.error(constants.error.PROTOCOL_ERROR,
+      'Invalid preface'))
+  }
+
+  this.skipPreface()
+  callback(null, null)
+}
+
+Parser.prototype.onFrameHead = function onFrameHead (buffer, callback) {
+  var header = {
+    length: buffer.readUInt24BE(),
+    control: true,
+    type: buffer.readUInt8(),
+    flags: buffer.readUInt8(),
+    id: buffer.readUInt32BE() & 0x7fffffff
+  }
+
+  if (header.length > this.maxFrameSize) {
+    return callback(this.error(constants.error.FRAME_SIZE_ERROR,
+      'Frame length OOB'))
+  }
+
+  header.control = header.type !== constants.frameType.DATA
+
+  this.state = 'frame-body'
+  this.pendingHeader = header
+  this.waiting = header.length
+  this.partial = !header.control
+
+  // TODO(indutny): eventually support partial padded DATA
+  if (this.partial) {
+    this.partial = (header.flags & constants.flags.PADDED) === 0
+  }
+
+  callback(null, null)
+}
+
+Parser.prototype.onFrameBody = function onFrameBody (header, buffer, callback) {
+  var frameType = constants.frameType
+
+  if (header.type === frameType.DATA) {
+    this.onDataFrame(header, buffer, callback)
+  } else if (header.type === frameType.HEADERS) {
+    this.onHeadersFrame(header, buffer, callback)
+  } else if (header.type === frameType.CONTINUATION) {
+    this.onContinuationFrame(header, buffer, callback)
+  } else if (header.type === frameType.WINDOW_UPDATE) {
+    this.onWindowUpdateFrame(header, buffer, callback)
+  } else if (header.type === frameType.RST_STREAM) {
+    this.onRSTFrame(header, buffer, callback)
+  } else if (header.type === frameType.SETTINGS) {
+    this.onSettingsFrame(header, buffer, callback)
+  } else if (header.type === frameType.PUSH_PROMISE) {
+    this.onPushPromiseFrame(header, buffer, callback)
+  } else if (header.type === frameType.PING) {
+    this.onPingFrame(header, buffer, callback)
+  } else if (header.type === frameType.GOAWAY) {
+    this.onGoawayFrame(header, buffer, callback)
+  } else if (header.type === frameType.PRIORITY) {
+    this.onPriorityFrame(header, buffer, callback)
+  } else if (header.type === frameType.X_FORWARDED_FOR) {
+    this.onXForwardedFrame(header, buffer, callback)
+  } else {
+    this.onUnknownFrame(header, buffer, callback)
+  }
+}
+
+Parser.prototype.onUnknownFrame = function onUnknownFrame (header, buffer, callback) {
+  if (this._lastHeaderBlock !== null) {
+    callback(this.error(constants.error.PROTOCOL_ERROR,
+      'Received unknown frame in the middle of a header block'))
+    return
+  }
+  callback(null, { type: 'unknown: ' + header.type })
+}
+
+Parser.prototype.unpadData = function unpadData (header, body, callback) {
+  var isPadded = (header.flags & constants.flags.PADDED) !== 0
+
+  if (!isPadded) { return callback(null, body) }
+
+  if (!body.has(1)) {
+    return callback(this.error(constants.error.FRAME_SIZE_ERROR,
+      'Not enough space for padding'))
+  }
+
+  var pad = body.readUInt8()
+  if (!body.has(pad)) {
+    return callback(this.error(constants.error.PROTOCOL_ERROR,
+      'Invalid padding size'))
+  }
+
+  var contents = body.clone(body.size - pad)
+  body.skip(body.size)
+  callback(null, contents)
+}
+
+Parser.prototype.onDataFrame = function onDataFrame (header, body, callback) {
+  var isEndStream = (header.flags & constants.flags.END_STREAM) !== 0
+
+  if (header.id === 0) {
+    return callback(this.error(constants.error.PROTOCOL_ERROR,
+      'Received DATA frame with stream=0'))
+  }
+
+  // Count received bytes
+  if (this.window) {
+    this.window.recv.update(-body.size)
+  }
+
+  this.unpadData(header, body, function (err, data) {
+    if (err) {
+      return callback(err)
+    }
+
+    callback(null, {
+      type: 'DATA',
+      id: header.id,
+      fin: isEndStream,
+      data: data.take(data.size)
+    })
+  })
+}
+
+Parser.prototype.initHeaderBlock = function initHeaderBlock (header,
+  frame,
+  block,
+  callback) {
+  if (this._lastHeaderBlock) {
+    return callback(this.error(constants.error.PROTOCOL_ERROR,
+      'Duplicate Stream ID'))
+  }
+
+  this._lastHeaderBlock = {
+    id: header.id,
+    frame: frame,
+    queue: [],
+    size: 0
+  }
+
+  this.queueHeaderBlock(header, block, callback)
+}
+
+Parser.prototype.queueHeaderBlock = function queueHeaderBlock (header,
+  block,
+  callback) {
+  var self = this
+  var item = this._lastHeaderBlock
+  if (!this._lastHeaderBlock || item.id !== header.id) {
+    return callback(this.error(constants.error.PROTOCOL_ERROR,
+      'No matching stream for continuation'))
+  }
+
+  var fin = (header.flags & constants.flags.END_HEADERS) !== 0
+
+  var chunks = block.toChunks()
+  for (var i = 0; i < chunks.length; i++) {
+    var chunk = chunks[i]
+    item.queue.push(chunk)
+    item.size += chunk.length
+  }
+
+  if (item.size >= self.maxHeaderListSize) {
+    return callback(this.error(constants.error.PROTOCOL_ERROR,
+      'Compressed header list is too large'))
+  }
+
+  if (!fin) { return callback(null, null) }
+  this._lastHeaderBlock = null
+
+  this.decompress.write(item.queue, function (err, chunks) {
+    if (err) {
+      return callback(self.error(constants.error.COMPRESSION_ERROR,
+        err.message))
+    }
+
+    var headers = {}
+    var size = 0
+    for (var i = 0; i < chunks.length; i++) {
+      var header = chunks[i]
+
+      size += header.name.length + header.value.length + 32
+      if (size >= self.maxHeaderListSize) {
+        return callback(self.error(constants.error.PROTOCOL_ERROR,
+          'Header list is too large'))
+      }
+
+      if (/[A-Z]/.test(header.name)) {
+        return callback(self.error(constants.error.PROTOCOL_ERROR,
+          'Header name must be lowercase'))
+      }
+
+      utils.addHeaderLine(header.name, header.value, headers)
+    }
+
+    item.frame.headers = headers
+    item.frame.path = headers[':path']
+
+    callback(null, item.frame)
+  })
+}
+
+Parser.prototype.onHeadersFrame = function onHeadersFrame (header,
+  body,
+  callback) {
+  var self = this
+
+  if (header.id === 0) {
+    return callback(this.error(constants.error.PROTOCOL_ERROR,
+      'Invalid stream id for HEADERS'))
+  }
+
+  this.unpadData(header, body, function (err, data) {
+    if (err) { return callback(err) }
+
+    var isPriority = (header.flags & constants.flags.PRIORITY) !== 0
+    if (!data.has(isPriority ? 5 : 0)) {
+      return callback(self.error(constants.error.FRAME_SIZE_ERROR,
+        'Not enough data for HEADERS'))
+    }
+
+    var exclusive = false
+    var dependency = 0
+    var weight = constants.DEFAULT_WEIGHT
+    if (isPriority) {
+      dependency = data.readUInt32BE()
+      exclusive = (dependency & 0x80000000) !== 0
+      dependency &= 0x7fffffff
+
+      // Weight's range is [1, 256]
+      weight = data.readUInt8() + 1
+    }
+
+    if (dependency === header.id) {
+      return callback(self.error(constants.error.PROTOCOL_ERROR,
+        'Stream can\'t dependend on itself'))
+    }
+
+    var streamInfo = {
+      type: 'HEADERS',
+      id: header.id,
+      priority: {
+        parent: dependency,
+        exclusive: exclusive,
+        weight: weight
+      },
+      fin: (header.flags & constants.flags.END_STREAM) !== 0,
+      writable: true,
+      headers: null,
+      path: null
+    }
+
+    self.initHeaderBlock(header, streamInfo, data, callback)
+  })
+}
+
+Parser.prototype.onContinuationFrame = function onContinuationFrame (header,
+  body,
+  callback) {
+  this.queueHeaderBlock(header, body, callback)
+}
+
+Parser.prototype.onRSTFrame = function onRSTFrame (header, body, callback) {
+  if (body.size !== 4) {
+    return callback(this.error(constants.error.FRAME_SIZE_ERROR,
+      'RST_STREAM length not 4'))
+  }
+
+  if (header.id === 0) {
+    return callback(this.error(constants.error.PROTOCOL_ERROR,
+      'Invalid stream id for RST_STREAM'))
+  }
+
+  callback(null, {
+    type: 'RST',
+    id: header.id,
+    code: constants.errorByCode[body.readUInt32BE()]
+  })
+}
+
+Parser.prototype._validateSettings = function _validateSettings (settings) {
+  if (settings['enable_push'] !== undefined &&
+      settings['enable_push'] !== 0 &&
+      settings['enable_push'] !== 1) {
+    return this.error(constants.error.PROTOCOL_ERROR,
+      'SETTINGS_ENABLE_PUSH must be 0 or 1')
+  }
+
+  if (settings['initial_window_size'] !== undefined &&
+      (settings['initial_window_size'] > constants.MAX_INITIAL_WINDOW_SIZE ||
+       settings['initial_window_size'] < 0)) {
+    return this.error(constants.error.FLOW_CONTROL_ERROR,
+      'SETTINGS_INITIAL_WINDOW_SIZE is OOB')
+  }
+
+  if (settings['max_frame_size'] !== undefined &&
+      (settings['max_frame_size'] > constants.ABSOLUTE_MAX_FRAME_SIZE ||
+       settings['max_frame_size'] < constants.INITIAL_MAX_FRAME_SIZE)) {
+    return this.error(constants.error.PROTOCOL_ERROR,
+      'SETTINGS_MAX_FRAME_SIZE is OOB')
+  }
+
+  return undefined
+}
+
+Parser.prototype.onSettingsFrame = function onSettingsFrame (header,
+  body,
+  callback) {
+  if (header.id !== 0) {
+    return callback(this.error(constants.error.PROTOCOL_ERROR,
+      'Invalid stream id for SETTINGS'))
+  }
+
+  var isAck = (header.flags & constants.flags.ACK) !== 0
+  if (isAck && body.size !== 0) {
+    return callback(this.error(constants.error.FRAME_SIZE_ERROR,
+      'SETTINGS with ACK and non-zero length'))
+  }
+
+  if (isAck) {
+    return callback(null, { type: 'ACK_SETTINGS' })
+  }
+
+  if (body.size % 6 !== 0) {
+    return callback(this.error(constants.error.FRAME_SIZE_ERROR,
+      'SETTINGS length not multiple of 6'))
+  }
+
+  var settings = {}
+  while (!body.isEmpty()) {
+    var id = body.readUInt16BE()
+    var value = body.readUInt32BE()
+    var name = constants.settingsIndex[id]
+
+    if (name) {
+      settings[name] = value
+    }
+  }
+
+  var err = this._validateSettings(settings)
+  if (err !== undefined) {
+    return callback(err)
+  }
+
+  callback(null, {
+    type: 'SETTINGS',
+    settings: settings
+  })
+}
+
+Parser.prototype.onPushPromiseFrame = function onPushPromiseFrame (header,
+  body,
+  callback) {
+  if (header.id === 0) {
+    return callback(this.error(constants.error.PROTOCOL_ERROR,
+      'Invalid stream id for PUSH_PROMISE'))
+  }
+
+  var self = this
+  this.unpadData(header, body, function (err, data) {
+    if (err) {
+      return callback(err)
+    }
+
+    if (!data.has(4)) {
+      return callback(self.error(constants.error.FRAME_SIZE_ERROR,
+        'PUSH_PROMISE length less than 4'))
+    }
+
+    var streamInfo = {
+      type: 'PUSH_PROMISE',
+      id: header.id,
+      fin: false,
+      promisedId: data.readUInt32BE() & 0x7fffffff,
+      headers: null,
+      path: null
+    }
+
+    self.initHeaderBlock(header, streamInfo, data, callback)
+  })
+}
+
+Parser.prototype.onPingFrame = function onPingFrame (header, body, callback) {
+  if (body.size !== 8) {
+    return callback(this.error(constants.error.FRAME_SIZE_ERROR,
+      'PING length != 8'))
+  }
+
+  if (header.id !== 0) {
+    return callback(this.error(constants.error.PROTOCOL_ERROR,
+      'Invalid stream id for PING'))
+  }
+
+  var ack = (header.flags & constants.flags.ACK) !== 0
+  callback(null, { type: 'PING', opaque: body.take(body.size), ack: ack })
+}
+
+Parser.prototype.onGoawayFrame = function onGoawayFrame (header,
+  body,
+  callback) {
+  if (!body.has(8)) {
+    return callback(this.error(constants.error.FRAME_SIZE_ERROR,
+      'GOAWAY length < 8'))
+  }
+
+  if (header.id !== 0) {
+    return callback(this.error(constants.error.PROTOCOL_ERROR,
+      'Invalid stream id for GOAWAY'))
+  }
+
+  var frame = {
+    type: 'GOAWAY',
+    lastId: body.readUInt32BE(),
+    code: constants.goawayByCode[body.readUInt32BE()]
+  }
+
+  if (body.size !== 0) { frame.debug = body.take(body.size) }
+
+  callback(null, frame)
+}
+
+Parser.prototype.onPriorityFrame = function onPriorityFrame (header,
+  body,
+  callback) {
+  if (body.size !== 5) {
+    return callback(this.error(constants.error.FRAME_SIZE_ERROR,
+      'PRIORITY length != 5'))
+  }
+
+  if (header.id === 0) {
+    return callback(this.error(constants.error.PROTOCOL_ERROR,
+      'Invalid stream id for PRIORITY'))
+  }
+
+  var dependency = body.readUInt32BE()
+
+  // Again the range is from 1 to 256
+  var weight = body.readUInt8() + 1
+
+  if (dependency === header.id) {
+    return callback(this.error(constants.error.PROTOCOL_ERROR,
+      'Stream can\'t dependend on itself'))
+  }
+
+  callback(null, {
+    type: 'PRIORITY',
+    id: header.id,
+    priority: {
+      exclusive: (dependency & 0x80000000) !== 0,
+      parent: dependency & 0x7fffffff,
+      weight: weight
+    }
+  })
+}
+
+Parser.prototype.onWindowUpdateFrame = function onWindowUpdateFrame (header,
+  body,
+  callback) {
+  if (body.size !== 4) {
+    return callback(this.error(constants.error.FRAME_SIZE_ERROR,
+      'WINDOW_UPDATE length != 4'))
+  }
+
+  var delta = body.readInt32BE()
+  if (delta === 0) {
+    return callback(this.error(constants.error.PROTOCOL_ERROR,
+      'WINDOW_UPDATE delta == 0'))
+  }
+
+  callback(null, {
+    type: 'WINDOW_UPDATE',
+    id: header.id,
+    delta: delta
+  })
+}
+
+Parser.prototype.onXForwardedFrame = function onXForwardedFrame (header,
+  body,
+  callback) {
+  callback(null, {
+    type: 'X_FORWARDED_FOR',
+    host: body.take(body.size).toString()
+  })
+}

web/node_modules/spdy-transport/lib/spdy-transport/protocol/spdy/constants.js

@@ -0,0 +1,146 @@
+'use strict'
+
+var transport = require('../../../spdy-transport')
+var base = transport.protocol.base
+
+exports.FRAME_HEADER_SIZE = 8
+
+exports.PING_OPAQUE_SIZE = 4
+
+exports.MAX_CONCURRENT_STREAMS = Infinity
+exports.DEFAULT_MAX_HEADER_LIST_SIZE = Infinity
+
+exports.DEFAULT_WEIGHT = 16
+
+exports.frameType = {
+  SYN_STREAM: 1,
+  SYN_REPLY: 2,
+  RST_STREAM: 3,
+  SETTINGS: 4,
+  PING: 6,
+  GOAWAY: 7,
+  HEADERS: 8,
+  WINDOW_UPDATE: 9,
+
+  // Custom
+  X_FORWARDED_FOR: 0xf000
+}
+
+exports.flags = {
+  FLAG_FIN: 0x01,
+  FLAG_COMPRESSED: 0x02,
+  FLAG_UNIDIRECTIONAL: 0x02
+}
+
+exports.error = {
+  PROTOCOL_ERROR: 1,
+  INVALID_STREAM: 2,
+  REFUSED_STREAM: 3,
+  UNSUPPORTED_VERSION: 4,
+  CANCEL: 5,
+  INTERNAL_ERROR: 6,
+  FLOW_CONTROL_ERROR: 7,
+  STREAM_IN_USE: 8,
+  // STREAM_ALREADY_CLOSED: 9
+  STREAM_CLOSED: 9,
+  INVALID_CREDENTIALS: 10,
+  FRAME_TOO_LARGE: 11
+}
+exports.errorByCode = base.utils.reverse(exports.error)
+
+exports.settings = {
+  FLAG_SETTINGS_PERSIST_VALUE: 1,
+  FLAG_SETTINGS_PERSISTED: 2,
+
+  SETTINGS_UPLOAD_BANDWIDTH: 1,
+  SETTINGS_DOWNLOAD_BANDWIDTH: 2,
+  SETTINGS_ROUND_TRIP_TIME: 3,
+  SETTINGS_MAX_CONCURRENT_STREAMS: 4,
+  SETTINGS_CURRENT_CWND: 5,
+  SETTINGS_DOWNLOAD_RETRANS_RATE: 6,
+  SETTINGS_INITIAL_WINDOW_SIZE: 7,
+  SETTINGS_CLIENT_CERTIFICATE_VECTOR_SIZE: 8
+}
+
+exports.settingsIndex = [
+  null,
+
+  'upload_bandwidth',
+  'download_bandwidth',
+  'round_trip_time',
+  'max_concurrent_streams',
+  'current_cwnd',
+  'download_retrans_rate',
+  'initial_window_size',
+  'client_certificate_vector_size'
+]
+
+exports.DEFAULT_WINDOW = 64 * 1024
+exports.MAX_INITIAL_WINDOW_SIZE = 2147483647
+
+exports.goaway = {
+  OK: 0,
+  PROTOCOL_ERROR: 1,
+  INTERNAL_ERROR: 2
+}
+exports.goawayByCode = base.utils.reverse(exports.goaway)
+
+exports.statusReason = {
+  100: 'Continue',
+  101: 'Switching Protocols',
+  102: 'Processing', // RFC 2518, obsoleted by RFC 4918
+  200: 'OK',
+  201: 'Created',
+  202: 'Accepted',
+  203: 'Non-Authoritative Information',
+  204: 'No Content',
+  205: 'Reset Content',
+  206: 'Partial Content',
+  207: 'Multi-Status', // RFC 4918
+  300: 'Multiple Choices',
+  301: 'Moved Permanently',
+  302: 'Moved Temporarily',
+  303: 'See Other',
+  304: 'Not Modified',
+  305: 'Use Proxy',
+  307: 'Temporary Redirect',
+  308: 'Permanent Redirect', // RFC 7238
+  400: 'Bad Request',
+  401: 'Unauthorized',
+  402: 'Payment Required',
+  403: 'Forbidden',
+  404: 'Not Found',
+  405: 'Method Not Allowed',
+  406: 'Not Acceptable',
+  407: 'Proxy Authentication Required',
+  408: 'Request Time-out',
+  409: 'Conflict',
+  410: 'Gone',
+  411: 'Length Required',
+  412: 'Precondition Failed',
+  413: 'Request Entity Too Large',
+  414: 'Request-URI Too Large',
+  415: 'Unsupported Media Type',
+  416: 'Requested Range Not Satisfiable',
+  417: 'Expectation Failed',
+  418: 'I\'m a teapot', // RFC 2324
+  422: 'Unprocessable Entity', // RFC 4918
+  423: 'Locked', // RFC 4918
+  424: 'Failed Dependency', // RFC 4918
+  425: 'Unordered Collection', // RFC 4918
+  426: 'Upgrade Required', // RFC 2817
+  428: 'Precondition Required', // RFC 6585
+  429: 'Too Many Requests', // RFC 6585
+  431: 'Request Header Fields Too Large', // RFC 6585
+  500: 'Internal Server Error',
+  501: 'Not Implemented',
+  502: 'Bad Gateway',
+  503: 'Service Unavailable',
+  504: 'Gateway Time-out',
+  505: 'HTTP Version Not Supported',
+  506: 'Variant Also Negotiates', // RFC 2295
+  507: 'Insufficient Storage', // RFC 4918
+  509: 'Bandwidth Limit Exceeded',
+  510: 'Not Extended', // RFC 2774
+  511: 'Network Authentication Required' // RFC 6585
+}

web/node_modules/spdy-transport/lib/spdy-transport/protocol/spdy/dictionary.js

@@ -0,0 +1,203 @@
+'use strict'
+
+var dictionary = {}
+module.exports = dictionary
+
+dictionary[2] = Buffer.from([
+  'optionsgetheadpostputdeletetraceacceptaccept-charsetaccept-encodingaccept-',
+  'languageauthorizationexpectfromhostif-modified-sinceif-matchif-none-matchi',
+  'f-rangeif-unmodifiedsincemax-forwardsproxy-authorizationrangerefererteuser',
+  '-agent10010120020120220320420520630030130230330430530630740040140240340440',
+  '5406407408409410411412413414415416417500501502503504505accept-rangesageeta',
+  'glocationproxy-authenticatepublicretry-afterservervarywarningwww-authentic',
+  'ateallowcontent-basecontent-encodingcache-controlconnectiondatetrailertran',
+  'sfer-encodingupgradeviawarningcontent-languagecontent-lengthcontent-locati',
+  'oncontent-md5content-rangecontent-typeetagexpireslast-modifiedset-cookieMo',
+  'ndayTuesdayWednesdayThursdayFridaySaturdaySundayJanFebMarAprMayJunJulAugSe',
+  'pOctNovDecchunkedtext/htmlimage/pngimage/jpgimage/gifapplication/xmlapplic',
+  'ation/xhtmltext/plainpublicmax-agecharset=iso-8859-1utf-8gzipdeflateHTTP/1',
+  '.1statusversionurl\x00'
+].join(''))
+
+dictionary[3] = Buffer.from([
+  0x00, 0x00, 0x00, 0x07, 0x6f, 0x70, 0x74, 0x69, // ....opti
+  0x6f, 0x6e, 0x73, 0x00, 0x00, 0x00, 0x04, 0x68, // ons....h
+  0x65, 0x61, 0x64, 0x00, 0x00, 0x00, 0x04, 0x70, // ead....p
+  0x6f, 0x73, 0x74, 0x00, 0x00, 0x00, 0x03, 0x70, // ost....p
+  0x75, 0x74, 0x00, 0x00, 0x00, 0x06, 0x64, 0x65, // ut....de
+  0x6c, 0x65, 0x74, 0x65, 0x00, 0x00, 0x00, 0x05, // lete....
+  0x74, 0x72, 0x61, 0x63, 0x65, 0x00, 0x00, 0x00, // trace...
+  0x06, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x00, // .accept.
+  0x00, 0x00, 0x0e, 0x61, 0x63, 0x63, 0x65, 0x70, // ...accep
+  0x74, 0x2d, 0x63, 0x68, 0x61, 0x72, 0x73, 0x65, // t-charse
+  0x74, 0x00, 0x00, 0x00, 0x0f, 0x61, 0x63, 0x63, // t....acc
+  0x65, 0x70, 0x74, 0x2d, 0x65, 0x6e, 0x63, 0x6f, // ept-enco
+  0x64, 0x69, 0x6e, 0x67, 0x00, 0x00, 0x00, 0x0f, // ding....
+  0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x2d, 0x6c, // accept-l
+  0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x00, // anguage.
+  0x00, 0x00, 0x0d, 0x61, 0x63, 0x63, 0x65, 0x70, // ...accep
+  0x74, 0x2d, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x73, // t-ranges
+  0x00, 0x00, 0x00, 0x03, 0x61, 0x67, 0x65, 0x00, // ....age.
+  0x00, 0x00, 0x05, 0x61, 0x6c, 0x6c, 0x6f, 0x77, // ...allow
+  0x00, 0x00, 0x00, 0x0d, 0x61, 0x75, 0x74, 0x68, // ....auth
+  0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, // orizatio
+  0x6e, 0x00, 0x00, 0x00, 0x0d, 0x63, 0x61, 0x63, // n....cac
+  0x68, 0x65, 0x2d, 0x63, 0x6f, 0x6e, 0x74, 0x72, // he-contr
+  0x6f, 0x6c, 0x00, 0x00, 0x00, 0x0a, 0x63, 0x6f, // ol....co
+  0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, // nnection
+  0x00, 0x00, 0x00, 0x0c, 0x63, 0x6f, 0x6e, 0x74, // ....cont
+  0x65, 0x6e, 0x74, 0x2d, 0x62, 0x61, 0x73, 0x65, // ent-base
+  0x00, 0x00, 0x00, 0x10, 0x63, 0x6f, 0x6e, 0x74, // ....cont
+  0x65, 0x6e, 0x74, 0x2d, 0x65, 0x6e, 0x63, 0x6f, // ent-enco
+  0x64, 0x69, 0x6e, 0x67, 0x00, 0x00, 0x00, 0x10, // ding....
+  0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x2d, // content-
+  0x6c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, // language
+  0x00, 0x00, 0x00, 0x0e, 0x63, 0x6f, 0x6e, 0x74, // ....cont
+  0x65, 0x6e, 0x74, 0x2d, 0x6c, 0x65, 0x6e, 0x67, // ent-leng
+  0x74, 0x68, 0x00, 0x00, 0x00, 0x10, 0x63, 0x6f, // th....co
+  0x6e, 0x74, 0x65, 0x6e, 0x74, 0x2d, 0x6c, 0x6f, // ntent-lo
+  0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x00, // cation..
+  0x00, 0x0b, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, // ..conten
+  0x74, 0x2d, 0x6d, 0x64, 0x35, 0x00, 0x00, 0x00, // t-md5...
+  0x0d, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, // .content
+  0x2d, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x00, 0x00, // -range..
+  0x00, 0x0c, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, // ..conten
+  0x74, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x00, 0x00, // t-type..
+  0x00, 0x04, 0x64, 0x61, 0x74, 0x65, 0x00, 0x00, // ..date..
+  0x00, 0x04, 0x65, 0x74, 0x61, 0x67, 0x00, 0x00, // ..etag..
+  0x00, 0x06, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, // ..expect
+  0x00, 0x00, 0x00, 0x07, 0x65, 0x78, 0x70, 0x69, // ....expi
+  0x72, 0x65, 0x73, 0x00, 0x00, 0x00, 0x04, 0x66, // res....f
+  0x72, 0x6f, 0x6d, 0x00, 0x00, 0x00, 0x04, 0x68, // rom....h
+  0x6f, 0x73, 0x74, 0x00, 0x00, 0x00, 0x08, 0x69, // ost....i
+  0x66, 0x2d, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x00, // f-match.
+  0x00, 0x00, 0x11, 0x69, 0x66, 0x2d, 0x6d, 0x6f, // ...if-mo
+  0x64, 0x69, 0x66, 0x69, 0x65, 0x64, 0x2d, 0x73, // dified-s
+  0x69, 0x6e, 0x63, 0x65, 0x00, 0x00, 0x00, 0x0d, // ince....
+  0x69, 0x66, 0x2d, 0x6e, 0x6f, 0x6e, 0x65, 0x2d, // if-none-
+  0x6d, 0x61, 0x74, 0x63, 0x68, 0x00, 0x00, 0x00, // match...
+  0x08, 0x69, 0x66, 0x2d, 0x72, 0x61, 0x6e, 0x67, // .if-rang
+  0x65, 0x00, 0x00, 0x00, 0x13, 0x69, 0x66, 0x2d, // e....if-
+  0x75, 0x6e, 0x6d, 0x6f, 0x64, 0x69, 0x66, 0x69, // unmodifi
+  0x65, 0x64, 0x2d, 0x73, 0x69, 0x6e, 0x63, 0x65, // ed-since
+  0x00, 0x00, 0x00, 0x0d, 0x6c, 0x61, 0x73, 0x74, // ....last
+  0x2d, 0x6d, 0x6f, 0x64, 0x69, 0x66, 0x69, 0x65, // -modifie
+  0x64, 0x00, 0x00, 0x00, 0x08, 0x6c, 0x6f, 0x63, // d....loc
+  0x61, 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x00, 0x00, // ation...
+  0x0c, 0x6d, 0x61, 0x78, 0x2d, 0x66, 0x6f, 0x72, // .max-for
+  0x77, 0x61, 0x72, 0x64, 0x73, 0x00, 0x00, 0x00, // wards...
+  0x06, 0x70, 0x72, 0x61, 0x67, 0x6d, 0x61, 0x00, // .pragma.
+  0x00, 0x00, 0x12, 0x70, 0x72, 0x6f, 0x78, 0x79, // ...proxy
+  0x2d, 0x61, 0x75, 0x74, 0x68, 0x65, 0x6e, 0x74, // -authent
+  0x69, 0x63, 0x61, 0x74, 0x65, 0x00, 0x00, 0x00, // icate...
+  0x13, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x2d, 0x61, // .proxy-a
+  0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, // uthoriza
+  0x74, 0x69, 0x6f, 0x6e, 0x00, 0x00, 0x00, 0x05, // tion....
+  0x72, 0x61, 0x6e, 0x67, 0x65, 0x00, 0x00, 0x00, // range...
+  0x07, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x72, // .referer
+  0x00, 0x00, 0x00, 0x0b, 0x72, 0x65, 0x74, 0x72, // ....retr
+  0x79, 0x2d, 0x61, 0x66, 0x74, 0x65, 0x72, 0x00, // y-after.
+  0x00, 0x00, 0x06, 0x73, 0x65, 0x72, 0x76, 0x65, // ...serve
+  0x72, 0x00, 0x00, 0x00, 0x02, 0x74, 0x65, 0x00, // r....te.
+  0x00, 0x00, 0x07, 0x74, 0x72, 0x61, 0x69, 0x6c, // ...trail
+  0x65, 0x72, 0x00, 0x00, 0x00, 0x11, 0x74, 0x72, // er....tr
+  0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2d, 0x65, // ansfer-e
+  0x6e, 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67, 0x00, // ncoding.
+  0x00, 0x00, 0x07, 0x75, 0x70, 0x67, 0x72, 0x61, // ...upgra
+  0x64, 0x65, 0x00, 0x00, 0x00, 0x0a, 0x75, 0x73, // de....us
+  0x65, 0x72, 0x2d, 0x61, 0x67, 0x65, 0x6e, 0x74, // er-agent
+  0x00, 0x00, 0x00, 0x04, 0x76, 0x61, 0x72, 0x79, // ....vary
+  0x00, 0x00, 0x00, 0x03, 0x76, 0x69, 0x61, 0x00, // ....via.
+  0x00, 0x00, 0x07, 0x77, 0x61, 0x72, 0x6e, 0x69, // ...warni
+  0x6e, 0x67, 0x00, 0x00, 0x00, 0x10, 0x77, 0x77, // ng....ww
+  0x77, 0x2d, 0x61, 0x75, 0x74, 0x68, 0x65, 0x6e, // w-authen
+  0x74, 0x69, 0x63, 0x61, 0x74, 0x65, 0x00, 0x00, // ticate..
+  0x00, 0x06, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, // ..method
+  0x00, 0x00, 0x00, 0x03, 0x67, 0x65, 0x74, 0x00, // ....get.
+  0x00, 0x00, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, // ...statu
+  0x73, 0x00, 0x00, 0x00, 0x06, 0x32, 0x30, 0x30, // s....200
+  0x20, 0x4f, 0x4b, 0x00, 0x00, 0x00, 0x07, 0x76, // .OK....v
+  0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x00, 0x00, // ersion..
+  0x00, 0x08, 0x48, 0x54, 0x54, 0x50, 0x2f, 0x31, // ..HTTP.1
+  0x2e, 0x31, 0x00, 0x00, 0x00, 0x03, 0x75, 0x72, // .1....ur
+  0x6c, 0x00, 0x00, 0x00, 0x06, 0x70, 0x75, 0x62, // l....pub
+  0x6c, 0x69, 0x63, 0x00, 0x00, 0x00, 0x0a, 0x73, // lic....s
+  0x65, 0x74, 0x2d, 0x63, 0x6f, 0x6f, 0x6b, 0x69, // et-cooki
+  0x65, 0x00, 0x00, 0x00, 0x0a, 0x6b, 0x65, 0x65, // e....kee
+  0x70, 0x2d, 0x61, 0x6c, 0x69, 0x76, 0x65, 0x00, // p-alive.
+  0x00, 0x00, 0x06, 0x6f, 0x72, 0x69, 0x67, 0x69, // ...origi
+  0x6e, 0x31, 0x30, 0x30, 0x31, 0x30, 0x31, 0x32, // n1001012
+  0x30, 0x31, 0x32, 0x30, 0x32, 0x32, 0x30, 0x35, // 01202205
+  0x32, 0x30, 0x36, 0x33, 0x30, 0x30, 0x33, 0x30, // 20630030
+  0x32, 0x33, 0x30, 0x33, 0x33, 0x30, 0x34, 0x33, // 23033043
+  0x30, 0x35, 0x33, 0x30, 0x36, 0x33, 0x30, 0x37, // 05306307
+  0x34, 0x30, 0x32, 0x34, 0x30, 0x35, 0x34, 0x30, // 40240540
+  0x36, 0x34, 0x30, 0x37, 0x34, 0x30, 0x38, 0x34, // 64074084
+  0x30, 0x39, 0x34, 0x31, 0x30, 0x34, 0x31, 0x31, // 09410411
+  0x34, 0x31, 0x32, 0x34, 0x31, 0x33, 0x34, 0x31, // 41241341
+  0x34, 0x34, 0x31, 0x35, 0x34, 0x31, 0x36, 0x34, // 44154164
+  0x31, 0x37, 0x35, 0x30, 0x32, 0x35, 0x30, 0x34, // 17502504
+  0x35, 0x30, 0x35, 0x32, 0x30, 0x33, 0x20, 0x4e, // 505203.N
+  0x6f, 0x6e, 0x2d, 0x41, 0x75, 0x74, 0x68, 0x6f, // on-Autho
+  0x72, 0x69, 0x74, 0x61, 0x74, 0x69, 0x76, 0x65, // ritative
+  0x20, 0x49, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, // .Informa
+  0x74, 0x69, 0x6f, 0x6e, 0x32, 0x30, 0x34, 0x20, // tion204.
+  0x4e, 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x65, // No.Conte
+  0x6e, 0x74, 0x33, 0x30, 0x31, 0x20, 0x4d, 0x6f, // nt301.Mo
+  0x76, 0x65, 0x64, 0x20, 0x50, 0x65, 0x72, 0x6d, // ved.Perm
+  0x61, 0x6e, 0x65, 0x6e, 0x74, 0x6c, 0x79, 0x34, // anently4
+  0x30, 0x30, 0x20, 0x42, 0x61, 0x64, 0x20, 0x52, // 00.Bad.R
+  0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x34, 0x30, // equest40
+  0x31, 0x20, 0x55, 0x6e, 0x61, 0x75, 0x74, 0x68, // 1.Unauth
+  0x6f, 0x72, 0x69, 0x7a, 0x65, 0x64, 0x34, 0x30, // orized40
+  0x33, 0x20, 0x46, 0x6f, 0x72, 0x62, 0x69, 0x64, // 3.Forbid
+  0x64, 0x65, 0x6e, 0x34, 0x30, 0x34, 0x20, 0x4e, // den404.N
+  0x6f, 0x74, 0x20, 0x46, 0x6f, 0x75, 0x6e, 0x64, // ot.Found
+  0x35, 0x30, 0x30, 0x20, 0x49, 0x6e, 0x74, 0x65, // 500.Inte
+  0x72, 0x6e, 0x61, 0x6c, 0x20, 0x53, 0x65, 0x72, // rnal.Ser
+  0x76, 0x65, 0x72, 0x20, 0x45, 0x72, 0x72, 0x6f, // ver.Erro
+  0x72, 0x35, 0x30, 0x31, 0x20, 0x4e, 0x6f, 0x74, // r501.Not
+  0x20, 0x49, 0x6d, 0x70, 0x6c, 0x65, 0x6d, 0x65, // .Impleme
+  0x6e, 0x74, 0x65, 0x64, 0x35, 0x30, 0x33, 0x20, // nted503.
+  0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x20, // Service.
+  0x55, 0x6e, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, // Unavaila
+  0x62, 0x6c, 0x65, 0x4a, 0x61, 0x6e, 0x20, 0x46, // bleJan.F
+  0x65, 0x62, 0x20, 0x4d, 0x61, 0x72, 0x20, 0x41, // eb.Mar.A
+  0x70, 0x72, 0x20, 0x4d, 0x61, 0x79, 0x20, 0x4a, // pr.May.J
+  0x75, 0x6e, 0x20, 0x4a, 0x75, 0x6c, 0x20, 0x41, // un.Jul.A
+  0x75, 0x67, 0x20, 0x53, 0x65, 0x70, 0x74, 0x20, // ug.Sept.
+  0x4f, 0x63, 0x74, 0x20, 0x4e, 0x6f, 0x76, 0x20, // Oct.Nov.
+  0x44, 0x65, 0x63, 0x20, 0x30, 0x30, 0x3a, 0x30, // Dec.00.0
+  0x30, 0x3a, 0x30, 0x30, 0x20, 0x4d, 0x6f, 0x6e, // 0.00.Mon
+  0x2c, 0x20, 0x54, 0x75, 0x65, 0x2c, 0x20, 0x57, // ..Tue..W
+  0x65, 0x64, 0x2c, 0x20, 0x54, 0x68, 0x75, 0x2c, // ed..Thu.
+  0x20, 0x46, 0x72, 0x69, 0x2c, 0x20, 0x53, 0x61, // .Fri..Sa
+  0x74, 0x2c, 0x20, 0x53, 0x75, 0x6e, 0x2c, 0x20, // t..Sun..
+  0x47, 0x4d, 0x54, 0x63, 0x68, 0x75, 0x6e, 0x6b, // GMTchunk
+  0x65, 0x64, 0x2c, 0x74, 0x65, 0x78, 0x74, 0x2f, // ed.text.
+  0x68, 0x74, 0x6d, 0x6c, 0x2c, 0x69, 0x6d, 0x61, // html.ima
+  0x67, 0x65, 0x2f, 0x70, 0x6e, 0x67, 0x2c, 0x69, // ge.png.i
+  0x6d, 0x61, 0x67, 0x65, 0x2f, 0x6a, 0x70, 0x67, // mage.jpg
+  0x2c, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x2f, 0x67, // .image.g
+  0x69, 0x66, 0x2c, 0x61, 0x70, 0x70, 0x6c, 0x69, // if.appli
+  0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x78, // cation.x
+  0x6d, 0x6c, 0x2c, 0x61, 0x70, 0x70, 0x6c, 0x69, // ml.appli
+  0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x78, // cation.x
+  0x68, 0x74, 0x6d, 0x6c, 0x2b, 0x78, 0x6d, 0x6c, // html.xml
+  0x2c, 0x74, 0x65, 0x78, 0x74, 0x2f, 0x70, 0x6c, // .text.pl
+  0x61, 0x69, 0x6e, 0x2c, 0x74, 0x65, 0x78, 0x74, // ain.text
+  0x2f, 0x6a, 0x61, 0x76, 0x61, 0x73, 0x63, 0x72, // .javascr
+  0x69, 0x70, 0x74, 0x2c, 0x70, 0x75, 0x62, 0x6c, // ipt.publ
+  0x69, 0x63, 0x70, 0x72, 0x69, 0x76, 0x61, 0x74, // icprivat
+  0x65, 0x6d, 0x61, 0x78, 0x2d, 0x61, 0x67, 0x65, // emax-age
+  0x3d, 0x67, 0x7a, 0x69, 0x70, 0x2c, 0x64, 0x65, // .gzip.de
+  0x66, 0x6c, 0x61, 0x74, 0x65, 0x2c, 0x73, 0x64, // flate.sd
+  0x63, 0x68, 0x63, 0x68, 0x61, 0x72, 0x73, 0x65, // chcharse
+  0x74, 0x3d, 0x75, 0x74, 0x66, 0x2d, 0x38, 0x63, // t.utf-8c
+  0x68, 0x61, 0x72, 0x73, 0x65, 0x74, 0x3d, 0x69, // harset.i
+  0x73, 0x6f, 0x2d, 0x38, 0x38, 0x35, 0x39, 0x2d, // so-8859-
+  0x31, 0x2c, 0x75, 0x74, 0x66, 0x2d, 0x2c, 0x2a, // 1.utf-..
+  0x2c, 0x65, 0x6e, 0x71, 0x3d, 0x30, 0x2e // .enq.0.
+])
+
+dictionary[3.1] = dictionary[3]

web/node_modules/spdy-transport/lib/spdy-transport/protocol/spdy/framer.js

@@ -0,0 +1,519 @@
+'use strict'
+
+var transport = require('../../../spdy-transport')
+var constants = require('./').constants
+var base = transport.protocol.base
+var utils = base.utils
+
+var assert = require('assert')
+var util = require('util')
+var Buffer = require('buffer').Buffer
+var WriteBuffer = require('wbuf')
+
+var debug = require('debug')('spdy:framer')
+
+function Framer (options) {
+  base.Framer.call(this, options)
+}
+util.inherits(Framer, base.Framer)
+module.exports = Framer
+
+Framer.create = function create (options) {
+  return new Framer(options)
+}
+
+Framer.prototype.setMaxFrameSize = function setMaxFrameSize (size) {
+  // http2-only
+}
+
+Framer.prototype.headersToDict = function headersToDict (headers,
+  preprocess,
+  callback) {
+  function stringify (value) {
+    if (value !== undefined) {
+      if (Array.isArray(value)) {
+        return value.join('\x00')
+      } else if (typeof value === 'string') {
+        return value
+      } else {
+        return value.toString()
+      }
+    } else {
+      return ''
+    }
+  }
+
+  // Lower case of all headers keys
+  var loweredHeaders = {}
+  Object.keys(headers || {}).map(function (key) {
+    loweredHeaders[key.toLowerCase()] = headers[key]
+  })
+
+  // Allow outer code to add custom headers or remove something
+  if (preprocess) { preprocess(loweredHeaders) }
+
+  // Transform object into kv pairs
+  var size = this.version === 2 ? 2 : 4
+  var len = size
+  var pairs = Object.keys(loweredHeaders).filter(function (key) {
+    var lkey = key.toLowerCase()
+
+    // Will be in `:host`
+    if (lkey === 'host' && this.version >= 3) {
+      return false
+    }
+
+    return lkey !== 'connection' && lkey !== 'keep-alive' &&
+           lkey !== 'proxy-connection' && lkey !== 'transfer-encoding'
+  }, this).map(function (key) {
+    var klen = Buffer.byteLength(key)
+    var value = stringify(loweredHeaders[key])
+    var vlen = Buffer.byteLength(value)
+
+    len += size * 2 + klen + vlen
+    return [klen, key, vlen, value]
+  })
+
+  var block = new WriteBuffer()
+  block.reserve(len)
+
+  if (this.version === 2) {
+    block.writeUInt16BE(pairs.length)
+  } else {
+    block.writeUInt32BE(pairs.length)
+  }
+
+  pairs.forEach(function (pair) {
+    // Write key length
+    if (this.version === 2) {
+      block.writeUInt16BE(pair[0])
+    } else {
+      block.writeUInt32BE(pair[0])
+    }
+
+    // Write key
+    block.write(pair[1])
+
+    // Write value length
+    if (this.version === 2) {
+      block.writeUInt16BE(pair[2])
+    } else {
+      block.writeUInt32BE(pair[2])
+    }
+    // Write value
+    block.write(pair[3])
+  }, this)
+
+  assert(this.compress !== null, 'Framer version not initialized')
+  this.compress.write(block.render(), callback)
+}
+
+Framer.prototype._frame = function _frame (frame, body, callback) {
+  if (!this.version) {
+    this.on('version', function () {
+      this._frame(frame, body, callback)
+    })
+    return
+  }
+
+  debug('id=%d type=%s', frame.id, frame.type)
+
+  var buffer = new WriteBuffer()
+
+  buffer.writeUInt16BE(0x8000 | this.version)
+  buffer.writeUInt16BE(constants.frameType[frame.type])
+  buffer.writeUInt8(frame.flags)
+  var len = buffer.skip(3)
+
+  body(buffer)
+
+  var frameSize = buffer.size - constants.FRAME_HEADER_SIZE
+  len.writeUInt24BE(frameSize)
+
+  var chunks = buffer.render()
+  var toWrite = {
+    stream: frame.id,
+    priority: false,
+    chunks: chunks,
+    callback: callback
+  }
+
+  this._resetTimeout()
+  this.schedule(toWrite)
+
+  return chunks
+}
+
+Framer.prototype._synFrame = function _synFrame (frame, callback) {
+  var self = this
+
+  if (!frame.path) {
+    throw new Error('`path` is required frame argument')
+  }
+
+  function preprocess (headers) {
+    var method = frame.method || base.constants.DEFAULT_METHOD
+    var version = frame.version || 'HTTP/1.1'
+    var scheme = frame.scheme || 'https'
+    var host = frame.host ||
+               (frame.headers && frame.headers.host) ||
+               base.constants.DEFAULT_HOST
+
+    if (self.version === 2) {
+      headers.method = method
+      headers.version = version
+      headers.url = frame.path
+      headers.scheme = scheme
+      headers.host = host
+      if (frame.status) {
+        headers.status = frame.status
+      }
+    } else {
+      headers[':method'] = method
+      headers[':version'] = version
+      headers[':path'] = frame.path
+      headers[':scheme'] = scheme
+      headers[':host'] = host
+      if (frame.status) { headers[':status'] = frame.status }
+    }
+  }
+
+  this.headersToDict(frame.headers, preprocess, function (err, chunks) {
+    if (err) {
+      if (callback) {
+        return callback(err)
+      } else {
+        return self.emit('error', err)
+      }
+    }
+
+    self._frame({
+      type: 'SYN_STREAM',
+      id: frame.id,
+      flags: frame.fin ? constants.flags.FLAG_FIN : 0
+    }, function (buf) {
+      buf.reserve(10)
+
+      buf.writeUInt32BE(frame.id & 0x7fffffff)
+      buf.writeUInt32BE(frame.associated & 0x7fffffff)
+
+      var weight = (frame.priority && frame.priority.weight) ||
+                   constants.DEFAULT_WEIGHT
+
+      // We only have 3 bits for priority in SPDY, try to fit it into this
+      var priority = utils.weightToPriority(weight)
+      buf.writeUInt8(priority << 5)
+
+      // CREDENTIALS slot
+      buf.writeUInt8(0)
+
+      for (var i = 0; i < chunks.length; i++) {
+        buf.copyFrom(chunks[i])
+      }
+    }, callback)
+  })
+}
+
+Framer.prototype.requestFrame = function requestFrame (frame, callback) {
+  this._synFrame({
+    id: frame.id,
+    fin: frame.fin,
+    associated: 0,
+    method: frame.method,
+    version: frame.version,
+    scheme: frame.scheme,
+    host: frame.host,
+    path: frame.path,
+    priority: frame.priority,
+    headers: frame.headers
+  }, callback)
+}
+
+Framer.prototype.responseFrame = function responseFrame (frame, callback) {
+  var self = this
+
+  var reason = frame.reason
+  if (!reason) {
+    reason = constants.statusReason[frame.status]
+  }
+
+  function preprocess (headers) {
+    if (self.version === 2) {
+      headers.status = frame.status + ' ' + reason
+      headers.version = 'HTTP/1.1'
+    } else {
+      headers[':status'] = frame.status + ' ' + reason
+      headers[':version'] = 'HTTP/1.1'
+    }
+  }
+
+  this.headersToDict(frame.headers, preprocess, function (err, chunks) {
+    if (err) {
+      if (callback) {
+        return callback(err)
+      } else {
+        return self.emit('error', err)
+      }
+    }
+
+    self._frame({
+      type: 'SYN_REPLY',
+      id: frame.id,
+      flags: 0
+    }, function (buf) {
+      buf.reserve(self.version === 2 ? 6 : 4)
+
+      buf.writeUInt32BE(frame.id & 0x7fffffff)
+
+      // Unused data
+      if (self.version === 2) {
+        buf.writeUInt16BE(0)
+      }
+
+      for (var i = 0; i < chunks.length; i++) {
+        buf.copyFrom(chunks[i])
+      }
+    }, callback)
+  })
+}
+
+Framer.prototype.pushFrame = function pushFrame (frame, callback) {
+  var self = this
+
+  this._checkPush(function (err) {
+    if (err) { return callback(err) }
+
+    self._synFrame({
+      id: frame.promisedId,
+      associated: frame.id,
+      method: frame.method,
+      status: frame.status || 200,
+      version: frame.version,
+      scheme: frame.scheme,
+      host: frame.host,
+      path: frame.path,
+      priority: frame.priority,
+
+      // Merge everything together, there is no difference in SPDY protocol
+      headers: Object.assign(Object.assign({}, frame.headers), frame.response)
+    }, callback)
+  })
+}
+
+Framer.prototype.headersFrame = function headersFrame (frame, callback) {
+  var self = this
+
+  this.headersToDict(frame.headers, null, function (err, chunks) {
+    if (err) {
+      if (callback) { return callback(err) } else {
+        return self.emit('error', err)
+      }
+    }
+
+    self._frame({
+      type: 'HEADERS',
+      id: frame.id,
+      priority: false,
+      flags: 0
+    }, function (buf) {
+      buf.reserve(4 + (self.version === 2 ? 2 : 0))
+      buf.writeUInt32BE(frame.id & 0x7fffffff)
+
+      // Unused data
+      if (self.version === 2) { buf.writeUInt16BE(0) }
+
+      for (var i = 0; i < chunks.length; i++) {
+        buf.copyFrom(chunks[i])
+      }
+    }, callback)
+  })
+}
+
+Framer.prototype.dataFrame = function dataFrame (frame, callback) {
+  if (!this.version) {
+    return this.on('version', function () {
+      this.dataFrame(frame, callback)
+    })
+  }
+
+  debug('id=%d type=DATA', frame.id)
+
+  var buffer = new WriteBuffer()
+  buffer.reserve(8 + frame.data.length)
+
+  buffer.writeUInt32BE(frame.id & 0x7fffffff)
+  buffer.writeUInt8(frame.fin ? 0x01 : 0x0)
+  buffer.writeUInt24BE(frame.data.length)
+  buffer.copyFrom(frame.data)
+
+  var chunks = buffer.render()
+  var toWrite = {
+    stream: frame.id,
+    priority: frame.priority,
+    chunks: chunks,
+    callback: callback
+  }
+
+  var self = this
+  this._resetTimeout()
+
+  var bypass = this.version < 3.1
+  this.window.send.update(-frame.data.length, bypass ? undefined : function () {
+    self._resetTimeout()
+    self.schedule(toWrite)
+  })
+
+  if (bypass) {
+    this._resetTimeout()
+    this.schedule(toWrite)
+  }
+}
+
+Framer.prototype.pingFrame = function pingFrame (frame, callback) {
+  this._frame({
+    type: 'PING',
+    id: 0,
+    flags: 0
+  }, function (buf, callback) {
+    buf.reserve(4)
+
+    var opaque = frame.opaque
+    buf.writeUInt32BE(opaque.readUInt32BE(opaque.length - 4, true))
+  }, callback)
+}
+
+Framer.prototype.rstFrame = function rstFrame (frame, callback) {
+  this._frame({
+    type: 'RST_STREAM',
+    id: frame.id,
+    flags: 0
+  }, function (buf) {
+    buf.reserve(8)
+
+    // Stream ID
+    buf.writeUInt32BE(frame.id & 0x7fffffff)
+    // Status Code
+    buf.writeUInt32BE(constants.error[frame.code])
+
+    // Extra debugging information
+    if (frame.extra) {
+      buf.write(frame.extra)
+    }
+  }, callback)
+}
+
+Framer.prototype.prefaceFrame = function prefaceFrame () {
+}
+
+Framer.prototype.settingsFrame = function settingsFrame (options, callback) {
+  var self = this
+
+  var key = this.version + '/' + JSON.stringify(options)
+
+  var settings = Framer.settingsCache[key]
+  if (settings) {
+    debug('cached settings')
+    this._resetTimeout()
+    this.schedule({
+      stream: 0,
+      priority: false,
+      chunks: settings,
+      callback: callback
+    })
+    return
+  }
+
+  var params = []
+  for (var i = 0; i < constants.settingsIndex.length; i++) {
+    var name = constants.settingsIndex[i]
+    if (!name) { continue }
+
+    // value: Infinity
+    if (!isFinite(options[name])) {
+      continue
+    }
+
+    if (options[name] !== undefined) {
+      params.push({ key: i, value: options[name] })
+    }
+  }
+
+  var frame = this._frame({
+    type: 'SETTINGS',
+    id: 0,
+    flags: 0
+  }, function (buf) {
+    buf.reserve(4 + 8 * params.length)
+
+    // Count of entries
+    buf.writeUInt32BE(params.length)
+
+    params.forEach(function (param) {
+      var flag = constants.settings.FLAG_SETTINGS_PERSIST_VALUE << 24
+
+      if (self.version === 2) {
+        buf.writeUInt32LE(flag | param.key)
+      } else { buf.writeUInt32BE(flag | param.key) }
+      buf.writeUInt32BE(param.value & 0x7fffffff)
+    })
+  }, callback)
+
+  Framer.settingsCache[key] = frame
+}
+Framer.settingsCache = {}
+
+Framer.prototype.ackSettingsFrame = function ackSettingsFrame (callback) {
+  if (callback) {
+    process.nextTick(callback)
+  }
+}
+
+Framer.prototype.windowUpdateFrame = function windowUpdateFrame (frame,
+  callback) {
+  this._frame({
+    type: 'WINDOW_UPDATE',
+    id: frame.id,
+    flags: 0
+  }, function (buf) {
+    buf.reserve(8)
+
+    // ID
+    buf.writeUInt32BE(frame.id & 0x7fffffff)
+
+    // Delta
+    buf.writeInt32BE(frame.delta)
+  }, callback)
+}
+
+Framer.prototype.goawayFrame = function goawayFrame (frame, callback) {
+  this._frame({
+    type: 'GOAWAY',
+    id: 0,
+    flags: 0
+  }, function (buf) {
+    buf.reserve(8)
+
+    // Last-good-stream-ID
+    buf.writeUInt32BE(frame.lastId & 0x7fffffff)
+    // Status
+    buf.writeUInt32BE(constants.goaway[frame.code])
+  }, callback)
+}
+
+Framer.prototype.priorityFrame = function priorityFrame (frame, callback) {
+  // No such thing in SPDY
+  if (callback) {
+    process.nextTick(callback)
+  }
+}
+
+Framer.prototype.xForwardedFor = function xForwardedFor (frame, callback) {
+  this._frame({
+    type: 'X_FORWARDED_FOR',
+    id: 0,
+    flags: 0
+  }, function (buf) {
+    buf.writeUInt32BE(Buffer.byteLength(frame.host))
+    buf.write(frame.host)
+  }, callback)
+}

web/node_modules/spdy-transport/lib/spdy-transport/protocol/spdy/index.js

@@ -0,0 +1,9 @@
+'use strict'
+
+exports.name = 'spdy'
+
+exports.dictionary = require('./dictionary')
+exports.constants = require('./constants')
+exports.parser = require('./parser')
+exports.framer = require('./framer')
+exports.compressionPool = require('./zlib-pool')

web/node_modules/spdy-transport/lib/spdy-transport/protocol/spdy/parser.js

@@ -0,0 +1,485 @@
+'use strict'
+
+var parser = exports
+
+var transport = require('../../../spdy-transport')
+var base = transport.protocol.base
+var utils = base.utils
+var constants = require('./constants')
+
+var assert = require('assert')
+var util = require('util')
+var OffsetBuffer = require('obuf')
+
+function Parser (options) {
+  base.Parser.call(this, options)
+
+  this.isServer = options.isServer
+  this.waiting = constants.FRAME_HEADER_SIZE
+  this.state = 'frame-head'
+  this.pendingHeader = null
+}
+util.inherits(Parser, base.Parser)
+
+parser.create = function create (options) {
+  return new Parser(options)
+}
+
+Parser.prototype.setMaxFrameSize = function setMaxFrameSize (size) {
+  // http2-only
+}
+
+Parser.prototype.setMaxHeaderListSize = function setMaxHeaderListSize (size) {
+  // http2-only
+}
+
+// Only for testing
+Parser.prototype.skipPreface = function skipPreface () {
+}
+
+Parser.prototype.execute = function execute (buffer, callback) {
+  if (this.state === 'frame-head') { return this.onFrameHead(buffer, callback) }
+
+  assert(this.state === 'frame-body' && this.pendingHeader !== null)
+
+  var self = this
+  var header = this.pendingHeader
+  this.pendingHeader = null
+
+  this.onFrameBody(header, buffer, function (err, frame) {
+    if (err) {
+      return callback(err)
+    }
+
+    self.state = 'frame-head'
+    self.waiting = constants.FRAME_HEADER_SIZE
+    self.partial = false
+    callback(null, frame)
+  })
+}
+
+Parser.prototype.executePartial = function executePartial (buffer, callback) {
+  var header = this.pendingHeader
+
+  if (this.window) {
+    this.window.recv.update(-buffer.size)
+  }
+
+  // DATA frame
+  callback(null, {
+    type: 'DATA',
+    id: header.id,
+
+    // Partial DATA can't be FIN
+    fin: false,
+    data: buffer.take(buffer.size)
+  })
+}
+
+Parser.prototype.onFrameHead = function onFrameHead (buffer, callback) {
+  var header = {
+    control: (buffer.peekUInt8() & 0x80) === 0x80,
+    version: null,
+    type: null,
+    id: null,
+    flags: null,
+    length: null
+  }
+
+  if (header.control) {
+    header.version = buffer.readUInt16BE() & 0x7fff
+    header.type = buffer.readUInt16BE()
+  } else {
+    header.id = buffer.readUInt32BE(0) & 0x7fffffff
+  }
+  header.flags = buffer.readUInt8()
+  header.length = buffer.readUInt24BE()
+
+  if (this.version === null && header.control) {
+    // TODO(indutny): do ProtocolError here and in the rest of errors
+    if (header.version !== 2 && header.version !== 3) {
+      return callback(new Error('Unsupported SPDY version: ' + header.version))
+    }
+    this.setVersion(header.version)
+  }
+
+  this.state = 'frame-body'
+  this.waiting = header.length
+  this.pendingHeader = header
+  this.partial = !header.control
+
+  callback(null, null)
+}
+
+Parser.prototype.onFrameBody = function onFrameBody (header, buffer, callback) {
+  // Data frame
+  if (!header.control) {
+    // Count received bytes
+    if (this.window) {
+      this.window.recv.update(-buffer.size)
+    }
+
+    // No support for compressed DATA
+    if ((header.flags & constants.flags.FLAG_COMPRESSED) !== 0) {
+      return callback(new Error('DATA compression not supported'))
+    }
+
+    if (header.id === 0) {
+      return callback(this.error(constants.error.PROTOCOL_ERROR,
+        'Invalid stream id for DATA'))
+    }
+
+    return callback(null, {
+      type: 'DATA',
+      id: header.id,
+      fin: (header.flags & constants.flags.FLAG_FIN) !== 0,
+      data: buffer.take(buffer.size)
+    })
+  }
+
+  if (header.type === 0x01 || header.type === 0x02) { // SYN_STREAM or SYN_REPLY
+    this.onSynHeadFrame(header.type, header.flags, buffer, callback)
+  } else if (header.type === 0x03) { // RST_STREAM
+    this.onRSTFrame(buffer, callback)
+  } else if (header.type === 0x04) { // SETTINGS
+    this.onSettingsFrame(buffer, callback)
+  } else if (header.type === 0x05) {
+    callback(null, { type: 'NOOP' })
+  } else if (header.type === 0x06) { // PING
+    this.onPingFrame(buffer, callback)
+  } else if (header.type === 0x07) { // GOAWAY
+    this.onGoawayFrame(buffer, callback)
+  } else if (header.type === 0x08) { // HEADERS
+    this.onHeaderFrames(buffer, callback)
+  } else if (header.type === 0x09) { // WINDOW_UPDATE
+    this.onWindowUpdateFrame(buffer, callback)
+  } else if (header.type === 0xf000) { // X-FORWARDED
+    this.onXForwardedFrame(buffer, callback)
+  } else {
+    callback(null, { type: 'unknown: ' + header.type })
+  }
+}
+
+Parser.prototype._filterHeader = function _filterHeader (headers, name) {
+  var res = {}
+  var keys = Object.keys(headers)
+
+  for (var i = 0; i < keys.length; i++) {
+    var key = keys[i]
+    if (key !== name) {
+      res[key] = headers[key]
+    }
+  }
+
+  return res
+}
+
+Parser.prototype.onSynHeadFrame = function onSynHeadFrame (type,
+  flags,
+  body,
+  callback) {
+  var self = this
+  var stream = type === 0x01
+  var offset = stream ? 10 : this.version === 2 ? 6 : 4
+
+  if (!body.has(offset)) {
+    return callback(new Error('SynHead OOB'))
+  }
+
+  var head = body.clone(offset)
+  body.skip(offset)
+  this.parseKVs(body, function (err, headers) {
+    if (err) {
+      return callback(err)
+    }
+
+    if (stream &&
+        (!headers[':method'] || !headers[':path'])) {
+      return callback(new Error('Missing `:method` and/or `:path` header'))
+    }
+
+    var id = head.readUInt32BE() & 0x7fffffff
+
+    if (id === 0) {
+      return callback(self.error(constants.error.PROTOCOL_ERROR,
+        'Invalid stream id for HEADERS'))
+    }
+
+    var associated = stream ? head.readUInt32BE() & 0x7fffffff : 0
+    var priority = stream
+      ? head.readUInt8() >> 5
+      : utils.weightToPriority(constants.DEFAULT_WEIGHT)
+    var fin = (flags & constants.flags.FLAG_FIN) !== 0
+    var unidir = (flags & constants.flags.FLAG_UNIDIRECTIONAL) !== 0
+    var path = headers[':path']
+
+    var isPush = stream && associated !== 0
+
+    var weight = utils.priorityToWeight(priority)
+    var priorityInfo = {
+      weight: weight,
+      exclusive: false,
+      parent: 0
+    }
+
+    if (!isPush) {
+      callback(null, {
+        type: 'HEADERS',
+        id: id,
+        priority: priorityInfo,
+        fin: fin,
+        writable: !unidir,
+        headers: headers,
+        path: path
+      })
+      return
+    }
+
+    if (stream && !headers[':status']) {
+      return callback(new Error('Missing `:status` header'))
+    }
+
+    var filteredHeaders = self._filterHeader(headers, ':status')
+
+    callback(null, [ {
+      type: 'PUSH_PROMISE',
+      id: associated,
+      fin: false,
+      promisedId: id,
+      headers: filteredHeaders,
+      path: path
+    }, {
+      type: 'HEADERS',
+      id: id,
+      fin: fin,
+      priority: priorityInfo,
+      writable: true,
+      path: undefined,
+      headers: {
+        ':status': headers[':status']
+      }
+    }])
+  })
+}
+
+Parser.prototype.onHeaderFrames = function onHeaderFrames (body, callback) {
+  var offset = this.version === 2 ? 6 : 4
+  if (!body.has(offset)) {
+    return callback(new Error('HEADERS OOB'))
+  }
+
+  var streamId = body.readUInt32BE() & 0x7fffffff
+  if (this.version === 2) { body.skip(2) }
+
+  this.parseKVs(body, function (err, headers) {
+    if (err) { return callback(err) }
+
+    callback(null, {
+      type: 'HEADERS',
+      priority: {
+        parent: 0,
+        exclusive: false,
+        weight: constants.DEFAULT_WEIGHT
+      },
+      id: streamId,
+      fin: false,
+      writable: true,
+      path: undefined,
+      headers: headers
+    })
+  })
+}
+
+Parser.prototype.parseKVs = function parseKVs (buffer, callback) {
+  var self = this
+
+  this.decompress.write(buffer.toChunks(), function (err, chunks) {
+    if (err) {
+      return callback(err)
+    }
+
+    var buffer = new OffsetBuffer()
+    for (var i = 0; i < chunks.length; i++) {
+      buffer.push(chunks[i])
+    }
+
+    var size = self.version === 2 ? 2 : 4
+    if (!buffer.has(size)) { return callback(new Error('KV OOB')) }
+
+    var count = self.version === 2
+      ? buffer.readUInt16BE()
+      : buffer.readUInt32BE()
+
+    var headers = {}
+
+    function readString () {
+      if (!buffer.has(size)) { return null }
+      var len = self.version === 2
+        ? buffer.readUInt16BE()
+        : buffer.readUInt32BE()
+
+      if (!buffer.has(len)) { return null }
+
+      var value = buffer.take(len)
+      return value.toString()
+    }
+
+    while (count > 0) {
+      var key = readString()
+      var value = readString()
+
+      if (key === null || value === null) {
+        return callback(new Error('Headers OOB'))
+      }
+
+      if (self.version < 3) {
+        var isInternal = /^(method|version|url|host|scheme|status)$/.test(key)
+        if (key === 'url') {
+          key = 'path'
+        }
+        if (isInternal) {
+          key = ':' + key
+        }
+      }
+
+      // Compatibility with HTTP2
+      if (key === ':status') {
+        value = value.split(/ /g, 2)[0]
+      }
+
+      count--
+      if (key === ':host') {
+        key = ':authority'
+      }
+
+      // Skip version, not present in HTTP2
+      if (key === ':version') {
+        continue
+      }
+
+      value = value.split(/\0/g)
+      for (var j = 0; j < value.length; j++) {
+        utils.addHeaderLine(key, value[j], headers)
+      }
+    }
+
+    callback(null, headers)
+  })
+}
+
+Parser.prototype.onRSTFrame = function onRSTFrame (body, callback) {
+  if (!body.has(8)) { return callback(new Error('RST OOB')) }
+
+  var frame = {
+    type: 'RST',
+    id: body.readUInt32BE() & 0x7fffffff,
+    code: constants.errorByCode[body.readUInt32BE()]
+  }
+
+  if (frame.id === 0) {
+    return callback(this.error(constants.error.PROTOCOL_ERROR,
+      'Invalid stream id for RST'))
+  }
+
+  if (body.size !== 0) {
+    frame.extra = body.take(body.size)
+  }
+  callback(null, frame)
+}
+
+Parser.prototype.onSettingsFrame = function onSettingsFrame (body, callback) {
+  if (!body.has(4)) {
+    return callback(new Error('SETTINGS OOB'))
+  }
+
+  var settings = {}
+  var number = body.readUInt32BE()
+  var idMap = {
+    1: 'upload_bandwidth',
+    2: 'download_bandwidth',
+    3: 'round_trip_time',
+    4: 'max_concurrent_streams',
+    5: 'current_cwnd',
+    6: 'download_retrans_rate',
+    7: 'initial_window_size',
+    8: 'client_certificate_vector_size'
+  }
+
+  if (!body.has(number * 8)) {
+    return callback(new Error('SETTINGS OOB#2'))
+  }
+
+  for (var i = 0; i < number; i++) {
+    var id = this.version === 2
+      ? body.readUInt32LE()
+      : body.readUInt32BE()
+
+    var flags = (id >> 24) & 0xff
+    id = id & 0xffffff
+
+    // Skip persisted settings
+    if (flags & 0x2) { continue }
+
+    var name = idMap[id]
+
+    settings[name] = body.readUInt32BE()
+  }
+
+  callback(null, {
+    type: 'SETTINGS',
+    settings: settings
+  })
+}
+
+Parser.prototype.onPingFrame = function onPingFrame (body, callback) {
+  if (!body.has(4)) {
+    return callback(new Error('PING OOB'))
+  }
+
+  var isServer = this.isServer
+  var opaque = body.clone(body.size).take(body.size)
+  var id = body.readUInt32BE()
+  var ack = isServer ? (id % 2 === 0) : (id % 2 === 1)
+
+  callback(null, { type: 'PING', opaque: opaque, ack: ack })
+}
+
+Parser.prototype.onGoawayFrame = function onGoawayFrame (body, callback) {
+  if (!body.has(8)) {
+    return callback(new Error('GOAWAY OOB'))
+  }
+
+  callback(null, {
+    type: 'GOAWAY',
+    lastId: body.readUInt32BE() & 0x7fffffff,
+    code: constants.goawayByCode[body.readUInt32BE()]
+  })
+}
+
+Parser.prototype.onWindowUpdateFrame = function onWindowUpdateFrame (body,
+  callback) {
+  if (!body.has(8)) {
+    return callback(new Error('WINDOW_UPDATE OOB'))
+  }
+
+  callback(null, {
+    type: 'WINDOW_UPDATE',
+    id: body.readUInt32BE() & 0x7fffffff,
+    delta: body.readInt32BE()
+  })
+}
+
+Parser.prototype.onXForwardedFrame = function onXForwardedFrame (body,
+  callback) {
+  if (!body.has(4)) {
+    return callback(new Error('X_FORWARDED OOB'))
+  }
+
+  var len = body.readUInt32BE()
+  if (!body.has(len)) { return callback(new Error('X_FORWARDED host length OOB')) }
+
+  callback(null, {
+    type: 'X_FORWARDED_FOR',
+    host: body.take(len).toString()
+  })
+}

web/node_modules/spdy-transport/lib/spdy-transport/protocol/spdy/zlib-pool.js

@@ -0,0 +1,65 @@
+'use strict'
+
+var zlibpool = exports
+var zlib = require('zlib')
+
+var transport = require('../../../spdy-transport')
+
+// TODO(indutny): think about it, why has it always been Z_SYNC_FLUSH here.
+// It should be possible to manually flush stuff after the write instead
+function createDeflate (version, compression) {
+  var deflate = zlib.createDeflate({
+    dictionary: transport.protocol.spdy.dictionary[version],
+    flush: zlib.Z_SYNC_FLUSH,
+    windowBits: 11,
+    level: compression ? zlib.Z_DEFAULT_COMPRESSION : zlib.Z_NO_COMPRESSION
+  })
+
+  // For node.js v0.8
+  deflate._flush = zlib.Z_SYNC_FLUSH
+
+  return deflate
+}
+
+function createInflate (version) {
+  var inflate = zlib.createInflate({
+    dictionary: transport.protocol.spdy.dictionary[version],
+    flush: zlib.Z_SYNC_FLUSH
+  })
+
+  // For node.js v0.8
+  inflate._flush = zlib.Z_SYNC_FLUSH
+
+  return inflate
+}
+
+function Pool (compression) {
+  this.compression = compression
+  this.pool = {
+    2: [],
+    3: [],
+    3.1: []
+  }
+}
+
+zlibpool.create = function create (compression) {
+  return new Pool(compression)
+}
+
+Pool.prototype.get = function get (version) {
+  if (this.pool[version].length > 0) {
+    return this.pool[version].pop()
+  } else {
+    var id = version
+
+    return {
+      version: version,
+      compress: createDeflate(id, this.compression),
+      decompress: createInflate(id)
+    }
+  }
+}
+
+Pool.prototype.put = function put (pair) {
+  this.pool[pair.version].push(pair)
+}

web/node_modules/spdy-transport/lib/spdy-transport/stream.js

@@ -0,0 +1,710 @@
+'use strict'
+
+var transport = require('../spdy-transport')
+
+var assert = require('assert')
+var util = require('util')
+
+var debug = {
+  client: require('debug')('spdy:stream:client'),
+  server: require('debug')('spdy:stream:server')
+}
+var Duplex = require('readable-stream').Duplex
+
+function Stream (connection, options) {
+  Duplex.call(this)
+
+  var connectionState = connection._spdyState
+
+  var state = {}
+  this._spdyState = state
+
+  this.id = options.id
+  this.method = options.method
+  this.path = options.path
+  this.host = options.host
+  this.headers = options.headers || {}
+  this.connection = connection
+  this.parent = options.parent || null
+
+  state.socket = null
+  state.protocol = connectionState.protocol
+  state.constants = state.protocol.constants
+
+  // See _initPriority()
+  state.priority = null
+
+  state.version = this.connection.getVersion()
+  state.isServer = this.connection.isServer()
+  state.debug = state.isServer ? debug.server : debug.client
+
+  state.framer = connectionState.framer
+  state.parser = connectionState.parser
+
+  state.request = options.request
+  state.needResponse = options.request
+  state.window = connectionState.streamWindow.clone(options.id)
+  state.sessionWindow = connectionState.window
+  state.maxChunk = connectionState.maxChunk
+
+  // Can't send incoming request
+  // (See `.send()` method)
+  state.sent = !state.request
+
+  state.readable = options.readable !== false
+  state.writable = options.writable !== false
+
+  state.aborted = false
+
+  state.corked = 0
+  state.corkQueue = []
+
+  state.timeout = new transport.utils.Timeout(this)
+
+  this.on('finish', this._onFinish)
+  this.on('end', this._onEnd)
+
+  var self = this
+  function _onWindowOverflow () {
+    self._onWindowOverflow()
+  }
+
+  state.window.recv.on('overflow', _onWindowOverflow)
+  state.window.send.on('overflow', _onWindowOverflow)
+
+  this._initPriority(options.priority)
+
+  if (!state.readable) { this.push(null) }
+  if (!state.writable) {
+    this._writableState.ended = true
+    this._writableState.finished = true
+  }
+}
+util.inherits(Stream, Duplex)
+exports.Stream = Stream
+
+Stream.prototype._init = function _init (socket) {
+  this.socket = socket
+}
+
+Stream.prototype._initPriority = function _initPriority (priority) {
+  var state = this._spdyState
+  var connectionState = this.connection._spdyState
+  var root = connectionState.priorityRoot
+
+  if (!priority) {
+    state.priority = root.addDefault(this.id)
+    return
+  }
+
+  state.priority = root.add({
+    id: this.id,
+    parent: priority.parent,
+    weight: priority.weight,
+    exclusive: priority.exclusive
+  })
+}
+
+Stream.prototype._handleFrame = function _handleFrame (frame) {
+  var state = this._spdyState
+
+  // Ignore any kind of data after abort
+  if (state.aborted) {
+    state.debug('id=%d ignoring frame=%s after abort', this.id, frame.type)
+    return
+  }
+
+  // Restart the timer on incoming frames
+  state.timeout.reset()
+
+  if (frame.type === 'DATA') {
+    this._handleData(frame)
+  } else if (frame.type === 'HEADERS') {
+    this._handleHeaders(frame)
+  } else if (frame.type === 'RST') {
+    this._handleRST(frame)
+  } else if (frame.type === 'WINDOW_UPDATE') { this._handleWindowUpdate(frame) } else if (frame.type === 'PRIORITY') {
+    this._handlePriority(frame)
+  } else if (frame.type === 'PUSH_PROMISE') { this._handlePushPromise(frame) }
+
+  if (frame.fin) {
+    state.debug('id=%d end', this.id)
+    this.push(null)
+  }
+}
+
+function checkAborted (stream, state, callback) {
+  if (state.aborted) {
+    state.debug('id=%d abort write', stream.id)
+    process.nextTick(function () {
+      callback(new Error('Stream write aborted'))
+    })
+    return true
+  }
+
+  return false
+}
+
+function _send (stream, state, data, callback) {
+  if (checkAborted(stream, state, callback)) {
+    return
+  }
+
+  state.debug('id=%d presend=%d', stream.id, data.length)
+
+  state.timeout.reset()
+
+  state.window.send.update(-data.length, function () {
+    if (checkAborted(stream, state, callback)) {
+      return
+    }
+
+    state.debug('id=%d send=%d', stream.id, data.length)
+
+    state.timeout.reset()
+
+    state.framer.dataFrame({
+      id: stream.id,
+      priority: state.priority.getPriority(),
+      fin: false,
+      data: data
+    }, function (err) {
+      state.debug('id=%d postsend=%d', stream.id, data.length)
+      callback(err)
+    })
+  })
+}
+
+Stream.prototype._write = function _write (data, enc, callback) {
+  var state = this._spdyState
+
+  // Send the request if it wasn't sent
+  if (!state.sent) { this.send() }
+
+  // Writes should come after pending control frames (response and headers)
+  if (state.corked !== 0) {
+    var self = this
+    state.corkQueue.push(function () {
+      self._write(data, enc, callback)
+    })
+    return
+  }
+
+  // Split DATA in chunks to prevent window from going negative
+  this._splitStart(data, _send, callback)
+}
+
+Stream.prototype._splitStart = function _splitStart (data, onChunk, callback) {
+  return this._split(data, 0, onChunk, callback)
+}
+
+Stream.prototype._split = function _split (data, offset, onChunk, callback) {
+  if (offset === data.length) {
+    return process.nextTick(callback)
+  }
+
+  var state = this._spdyState
+  var local = state.window.send
+  var session = state.sessionWindow.send
+
+  var availSession = Math.max(0, session.getCurrent())
+  if (availSession === 0) {
+    availSession = session.getMax()
+  }
+  var availLocal = Math.max(0, local.getCurrent())
+  if (availLocal === 0) {
+    availLocal = local.getMax()
+  }
+
+  var avail = Math.min(availSession, availLocal)
+  avail = Math.min(avail, state.maxChunk)
+
+  var self = this
+
+  if (avail === 0) {
+    state.window.send.update(0, function () {
+      self._split(data, offset, onChunk, callback)
+    })
+    return
+  }
+
+  // Split data in chunks in a following way:
+  var limit = avail
+  var size = Math.min(data.length - offset, limit)
+
+  var chunk = data.slice(offset, offset + size)
+
+  onChunk(this, state, chunk, function (err) {
+    if (err) { return callback(err) }
+
+    // Get the next chunk
+    self._split(data, offset + size, onChunk, callback)
+  })
+}
+
+Stream.prototype._read = function _read () {
+  var state = this._spdyState
+
+  if (!state.window.recv.isDraining()) {
+    return
+  }
+
+  var delta = state.window.recv.getDelta()
+
+  state.debug('id=%d window emptying, update by %d', this.id, delta)
+
+  state.window.recv.update(delta)
+  state.framer.windowUpdateFrame({
+    id: this.id,
+    delta: delta
+  })
+}
+
+Stream.prototype._handleData = function _handleData (frame) {
+  var state = this._spdyState
+
+  // DATA on ended or not readable stream!
+  if (!state.readable || this._readableState.ended) {
+    state.framer.rstFrame({ id: this.id, code: 'STREAM_CLOSED' })
+    return
+  }
+
+  state.debug('id=%d recv=%d', this.id, frame.data.length)
+  state.window.recv.update(-frame.data.length)
+
+  this.push(frame.data)
+}
+
+Stream.prototype._handleRST = function _handleRST (frame) {
+  if (frame.code !== 'CANCEL') {
+    this.emit('error', new Error('Got RST: ' + frame.code))
+  }
+  this.abort()
+}
+
+Stream.prototype._handleWindowUpdate = function _handleWindowUpdate (frame) {
+  var state = this._spdyState
+
+  state.window.send.update(frame.delta)
+}
+
+Stream.prototype._onWindowOverflow = function _onWindowOverflow () {
+  var state = this._spdyState
+
+  state.debug('id=%d window overflow', this.id)
+  state.framer.rstFrame({ id: this.id, code: 'FLOW_CONTROL_ERROR' })
+
+  this.aborted = true
+  this.emit('error', new Error('HTTP2 window overflow'))
+}
+
+Stream.prototype._handlePriority = function _handlePriority (frame) {
+  var state = this._spdyState
+
+  state.priority.remove()
+  state.priority = null
+  this._initPriority(frame.priority)
+
+  // Mostly for testing purposes
+  this.emit('priority', frame.priority)
+}
+
+Stream.prototype._handleHeaders = function _handleHeaders (frame) {
+  var state = this._spdyState
+
+  if (!state.readable || this._readableState.ended) {
+    state.framer.rstFrame({ id: this.id, code: 'STREAM_CLOSED' })
+    return
+  }
+
+  if (state.needResponse) {
+    return this._handleResponse(frame)
+  }
+
+  this.emit('headers', frame.headers)
+}
+
+Stream.prototype._handleResponse = function _handleResponse (frame) {
+  var state = this._spdyState
+
+  if (frame.headers[':status'] === undefined) {
+    state.framer.rstFrame({ id: this.id, code: 'PROTOCOL_ERROR' })
+    return
+  }
+
+  state.needResponse = false
+  this.emit('response', frame.headers[':status'] | 0, frame.headers)
+}
+
+Stream.prototype._onFinish = function _onFinish () {
+  var state = this._spdyState
+
+  // Send the request if it wasn't sent
+  if (!state.sent) {
+    // NOTE: will send HEADERS with FIN flag
+    this.send()
+  } else {
+    // Just an `.end()` without any writes will trigger immediate `finish` event
+    // without any calls to `_write()`.
+    if (state.corked !== 0) {
+      var self = this
+      state.corkQueue.push(function () {
+        self._onFinish()
+      })
+      return
+    }
+
+    state.framer.dataFrame({
+      id: this.id,
+      priority: state.priority.getPriority(),
+      fin: true,
+      data: Buffer.alloc(0)
+    })
+  }
+
+  this._maybeClose()
+}
+
+Stream.prototype._onEnd = function _onEnd () {
+  this._maybeClose()
+}
+
+Stream.prototype._checkEnded = function _checkEnded (callback) {
+  var state = this._spdyState
+
+  var ended = false
+  if (state.aborted) { ended = true }
+
+  if (!state.writable || this._writableState.finished) { ended = true }
+
+  if (!ended) {
+    return true
+  }
+
+  if (!callback) {
+    return false
+  }
+
+  var err = new Error('Ended stream can\'t send frames')
+  process.nextTick(function () {
+    callback(err)
+  })
+
+  return false
+}
+
+Stream.prototype._maybeClose = function _maybeClose () {
+  var state = this._spdyState
+
+  // .abort() emits `close`
+  if (state.aborted) {
+    return
+  }
+
+  if ((!state.readable || this._readableState.ended) &&
+      this._writableState.finished) {
+    // Clear timeout
+    state.timeout.set(0)
+
+    this.emit('close')
+  }
+}
+
+Stream.prototype._handlePushPromise = function _handlePushPromise (frame) {
+  var push = this.connection._createStream({
+    id: frame.promisedId,
+    parent: this,
+    push: true,
+    request: true,
+    method: frame.headers[':method'],
+    path: frame.headers[':path'],
+    host: frame.headers[':authority'],
+    priority: frame.priority,
+    headers: frame.headers,
+    writable: false
+  })
+
+  // GOAWAY
+  if (this.connection._isGoaway(push.id)) {
+    return
+  }
+
+  if (!this.emit('pushPromise', push)) {
+    push.abort()
+  }
+}
+
+Stream.prototype._hardCork = function _hardCork () {
+  var state = this._spdyState
+
+  this.cork()
+  state.corked++
+}
+
+Stream.prototype._hardUncork = function _hardUncork () {
+  var state = this._spdyState
+
+  this.uncork()
+  state.corked--
+  if (state.corked !== 0) {
+    return
+  }
+
+  // Invoke callbacks
+  var queue = state.corkQueue
+  state.corkQueue = []
+  for (var i = 0; i < queue.length; i++) {
+    queue[i]()
+  }
+}
+
+Stream.prototype._sendPush = function _sendPush (status, response, callback) {
+  var self = this
+  var state = this._spdyState
+
+  this._hardCork()
+  state.framer.pushFrame({
+    id: this.parent.id,
+    promisedId: this.id,
+    priority: state.priority.toJSON(),
+    path: this.path,
+    host: this.host,
+    method: this.method,
+    status: status,
+    headers: this.headers,
+    response: response
+  }, function (err) {
+    self._hardUncork()
+
+    callback(err)
+  })
+}
+
+Stream.prototype._wasSent = function _wasSent () {
+  var state = this._spdyState
+  return state.sent
+}
+
+// Public API
+
+Stream.prototype.send = function send (callback) {
+  var state = this._spdyState
+
+  if (state.sent) {
+    var err = new Error('Stream was already sent')
+    process.nextTick(function () {
+      if (callback) {
+        callback(err)
+      }
+    })
+    return
+  }
+
+  state.sent = true
+  state.timeout.reset()
+
+  // GET requests should always be auto-finished
+  if (this.method === 'GET') {
+    this._writableState.ended = true
+    this._writableState.finished = true
+  }
+
+  // TODO(indunty): ideally it should just take a stream object as an input
+  var self = this
+  this._hardCork()
+  state.framer.requestFrame({
+    id: this.id,
+    method: this.method,
+    path: this.path,
+    host: this.host,
+    priority: state.priority.toJSON(),
+    headers: this.headers,
+    fin: this._writableState.finished
+  }, function (err) {
+    self._hardUncork()
+
+    if (!callback) {
+      return
+    }
+
+    callback(err)
+  })
+}
+
+Stream.prototype.respond = function respond (status, headers, callback) {
+  var self = this
+  var state = this._spdyState
+  assert(!state.request, 'Can\'t respond on request')
+
+  state.timeout.reset()
+
+  if (!this._checkEnded(callback)) { return }
+
+  var frame = {
+    id: this.id,
+    status: status,
+    headers: headers
+  }
+  this._hardCork()
+  state.framer.responseFrame(frame, function (err) {
+    self._hardUncork()
+    if (callback) { callback(err) }
+  })
+}
+
+Stream.prototype.setWindow = function setWindow (size) {
+  var state = this._spdyState
+
+  state.timeout.reset()
+
+  if (!this._checkEnded()) {
+    return
+  }
+
+  state.debug('id=%d force window max=%d', this.id, size)
+  state.window.recv.setMax(size)
+
+  var delta = state.window.recv.getDelta()
+  if (delta === 0) { return }
+
+  state.framer.windowUpdateFrame({
+    id: this.id,
+    delta: delta
+  })
+  state.window.recv.update(delta)
+}
+
+Stream.prototype.sendHeaders = function sendHeaders (headers, callback) {
+  var self = this
+  var state = this._spdyState
+
+  state.timeout.reset()
+
+  if (!this._checkEnded(callback)) {
+    return
+  }
+
+  // Request wasn't yet send, coalesce headers
+  if (!state.sent) {
+    this.headers = Object.assign({}, this.headers)
+    Object.assign(this.headers, headers)
+    process.nextTick(function () {
+      if (callback) {
+        callback(null)
+      }
+    })
+    return
+  }
+
+  this._hardCork()
+  state.framer.headersFrame({
+    id: this.id,
+    headers: headers
+  }, function (err) {
+    self._hardUncork()
+    if (callback) { callback(err) }
+  })
+}
+
+Stream.prototype._destroy = function destroy () {
+  this.abort()
+}
+
+Stream.prototype.abort = function abort (code, callback) {
+  var state = this._spdyState
+
+  // .abort(callback)
+  if (typeof code === 'function') {
+    callback = code
+    code = null
+  }
+
+  if (this._readableState.ended && this._writableState.finished) {
+    state.debug('id=%d already closed', this.id)
+    if (callback) {
+      process.nextTick(callback)
+    }
+    return
+  }
+
+  if (state.aborted) {
+    state.debug('id=%d already aborted', this.id)
+    if (callback) { process.nextTick(callback) }
+    return
+  }
+
+  state.aborted = true
+  state.debug('id=%d abort', this.id)
+
+  this.setTimeout(0)
+
+  var abortCode = code || 'CANCEL'
+
+  state.framer.rstFrame({
+    id: this.id,
+    code: abortCode
+  })
+
+  var self = this
+  process.nextTick(function () {
+    if (callback) {
+      callback(null)
+    }
+    self.emit('close', new Error('Aborted, code: ' + abortCode))
+  })
+}
+
+Stream.prototype.setPriority = function setPriority (info) {
+  var state = this._spdyState
+
+  state.timeout.reset()
+
+  if (!this._checkEnded()) {
+    return
+  }
+
+  state.debug('id=%d priority change', this.id, info)
+
+  var frame = { id: this.id, priority: info }
+
+  // Change priority on this side
+  this._handlePriority(frame)
+
+  // And on the other too
+  state.framer.priorityFrame(frame)
+}
+
+Stream.prototype.pushPromise = function pushPromise (uri, callback) {
+  if (!this._checkEnded(callback)) {
+    return
+  }
+
+  var self = this
+  this._hardCork()
+  var push = this.connection.pushPromise(this, uri, function (err) {
+    self._hardUncork()
+    if (!err) {
+      push._hardUncork()
+    }
+
+    if (callback) {
+      return callback(err, push)
+    }
+
+    if (err) { push.emit('error', err) }
+  })
+  push._hardCork()
+
+  return push
+}
+
+Stream.prototype.setMaxChunk = function setMaxChunk (size) {
+  var state = this._spdyState
+  state.maxChunk = size
+}
+
+Stream.prototype.setTimeout = function setTimeout (delay, callback) {
+  var state = this._spdyState
+
+  state.timeout.set(delay, callback)
+}

web/node_modules/spdy-transport/lib/spdy-transport/utils.js

@@ -0,0 +1,196 @@
+'use strict'
+
+var util = require('util')
+var isNode = require('detect-node')
+
+// Node.js 0.8, 0.10 and 0.12 support
+Object.assign = (process.versions.modules >= 46 || !isNode)
+  ? Object.assign // eslint-disable-next-line
+  : util._extend
+
+function QueueItem () {
+  this.prev = null
+  this.next = null
+}
+exports.QueueItem = QueueItem
+
+function Queue () {
+  QueueItem.call(this)
+
+  this.prev = this
+  this.next = this
+}
+util.inherits(Queue, QueueItem)
+exports.Queue = Queue
+
+Queue.prototype.insertTail = function insertTail (item) {
+  item.prev = this.prev
+  item.next = this
+  item.prev.next = item
+  item.next.prev = item
+}
+
+Queue.prototype.remove = function remove (item) {
+  var next = item.next
+  var prev = item.prev
+
+  item.next = item
+  item.prev = item
+  next.prev = prev
+  prev.next = next
+}
+
+Queue.prototype.head = function head () {
+  return this.next
+}
+
+Queue.prototype.tail = function tail () {
+  return this.prev
+}
+
+Queue.prototype.isEmpty = function isEmpty () {
+  return this.next === this
+}
+
+Queue.prototype.isRoot = function isRoot (item) {
+  return this === item
+}
+
+function LockStream (stream) {
+  this.locked = false
+  this.queue = []
+  this.stream = stream
+}
+exports.LockStream = LockStream
+
+LockStream.prototype.write = function write (chunks, callback) {
+  var self = this
+
+  // Do not let it interleave
+  if (this.locked) {
+    this.queue.push(function () {
+      return self.write(chunks, callback)
+    })
+    return
+  }
+
+  this.locked = true
+
+  function done (err, chunks) {
+    self.stream.removeListener('error', done)
+
+    self.locked = false
+    if (self.queue.length > 0) { self.queue.shift()() }
+    callback(err, chunks)
+  }
+
+  this.stream.on('error', done)
+
+  // Accumulate all output data
+  var output = []
+  function onData (chunk) {
+    output.push(chunk)
+  }
+  this.stream.on('data', onData)
+
+  function next (err) {
+    self.stream.removeListener('data', onData)
+    if (err) {
+      return done(err)
+    }
+
+    done(null, output)
+  }
+
+  for (var i = 0; i < chunks.length - 1; i++) { this.stream.write(chunks[i]) }
+
+  if (chunks.length > 0) {
+    this.stream.write(chunks[i], next)
+  } else { process.nextTick(next) }
+
+  if (this.stream.execute) {
+    this.stream.execute(function (err) {
+      if (err) { return done(err) }
+    })
+  }
+}
+
+// Just finds the place in array to insert
+function binaryLookup (list, item, compare) {
+  var start = 0
+  var end = list.length
+
+  while (start < end) {
+    var pos = (start + end) >> 1
+    var cmp = compare(item, list[pos])
+
+    if (cmp === 0) {
+      start = pos
+      end = pos
+      break
+    } else if (cmp < 0) {
+      end = pos
+    } else {
+      start = pos + 1
+    }
+  }
+
+  return start
+}
+exports.binaryLookup = binaryLookup
+
+function binaryInsert (list, item, compare) {
+  var index = binaryLookup(list, item, compare)
+
+  list.splice(index, 0, item)
+}
+exports.binaryInsert = binaryInsert
+
+function binarySearch (list, item, compare) {
+  var index = binaryLookup(list, item, compare)
+
+  if (index >= list.length) {
+    return -1
+  }
+
+  if (compare(item, list[index]) === 0) {
+    return index
+  }
+
+  return -1
+}
+exports.binarySearch = binarySearch
+
+function Timeout (object) {
+  this.delay = 0
+  this.timer = null
+  this.object = object
+}
+exports.Timeout = Timeout
+
+Timeout.prototype.set = function set (delay, callback) {
+  this.delay = delay
+  this.reset()
+  if (!callback) { return }
+
+  if (this.delay === 0) {
+    this.object.removeListener('timeout', callback)
+  } else {
+    this.object.once('timeout', callback)
+  }
+}
+
+Timeout.prototype.reset = function reset () {
+  if (this.timer !== null) {
+    clearTimeout(this.timer)
+    this.timer = null
+  }
+
+  if (this.delay === 0) { return }
+
+  var self = this
+  this.timer = setTimeout(function () {
+    self.timer = null
+    self.object.emit('timeout')
+  }, this.delay)
+}

web/node_modules/spdy-transport/lib/spdy-transport/window.js

@@ -0,0 +1,174 @@
+'use strict'
+
+var util = require('util')
+var EventEmitter = require('events').EventEmitter
+var debug = {
+  server: require('debug')('spdy:window:server'),
+  client: require('debug')('spdy:window:client')
+}
+
+function Side (window, name, options) {
+  EventEmitter.call(this)
+
+  this.name = name
+  this.window = window
+  this.current = options.size
+  this.max = options.size
+  this.limit = options.max
+  this.lowWaterMark = options.lowWaterMark === undefined
+    ? this.max / 2
+    : options.lowWaterMark
+
+  this._refilling = false
+  this._refillQueue = []
+}
+util.inherits(Side, EventEmitter)
+
+Side.prototype.setMax = function setMax (max) {
+  this.window.debug('id=%d side=%s setMax=%d',
+    this.window.id,
+    this.name,
+    max)
+  this.max = max
+  this.lowWaterMark = this.max / 2
+}
+
+Side.prototype.updateMax = function updateMax (max) {
+  var delta = max - this.max
+  this.window.debug('id=%d side=%s updateMax=%d delta=%d',
+    this.window.id,
+    this.name,
+    max,
+    delta)
+
+  this.max = max
+  this.lowWaterMark = max / 2
+
+  this.update(delta)
+}
+
+Side.prototype.setLowWaterMark = function setLowWaterMark (lwm) {
+  this.lowWaterMark = lwm
+}
+
+Side.prototype.update = function update (size, callback) {
+  // Not enough space for the update, wait for refill
+  if (size <= 0 && callback && this.isEmpty()) {
+    this.window.debug('id=%d side=%s wait for refill=%d [%d/%d]',
+      this.window.id,
+      this.name,
+      -size,
+      this.current,
+      this.max)
+    this._refillQueue.push({
+      size: size,
+      callback: callback
+    })
+    return
+  }
+
+  this.current += size
+
+  if (this.current > this.limit) {
+    this.emit('overflow')
+    return
+  }
+
+  this.window.debug('id=%d side=%s update by=%d [%d/%d]',
+    this.window.id,
+    this.name,
+    size,
+    this.current,
+    this.max)
+
+  // Time to send WINDOW_UPDATE
+  if (size < 0 && this.isDraining()) {
+    this.window.debug('id=%d side=%s drained', this.window.id, this.name)
+    this.emit('drain')
+  }
+
+  // Time to write
+  if (size > 0 && this.current > 0 && this.current <= size) {
+    this.window.debug('id=%d side=%s full', this.window.id, this.name)
+    this.emit('full')
+  }
+
+  this._processRefillQueue()
+
+  if (callback) { process.nextTick(callback) }
+}
+
+Side.prototype.getCurrent = function getCurrent () {
+  return this.current
+}
+
+Side.prototype.getMax = function getMax () {
+  return this.max
+}
+
+Side.prototype.getDelta = function getDelta () {
+  return this.max - this.current
+}
+
+Side.prototype.isDraining = function isDraining () {
+  return this.current <= this.lowWaterMark
+}
+
+Side.prototype.isEmpty = function isEmpty () {
+  return this.current <= 0
+}
+
+// Private
+
+Side.prototype._processRefillQueue = function _processRefillQueue () {
+  // Prevent recursion
+  if (this._refilling) {
+    return
+  }
+  this._refilling = true
+
+  while (this._refillQueue.length > 0) {
+    var item = this._refillQueue[0]
+
+    if (this.isEmpty()) {
+      break
+    }
+
+    this.window.debug('id=%d side=%s refilled for size=%d',
+      this.window.id,
+      this.name,
+      -item.size)
+
+    this._refillQueue.shift()
+    this.update(item.size, item.callback)
+  }
+
+  this._refilling = false
+}
+
+function Window (options) {
+  this.id = options.id
+  this.isServer = options.isServer
+  this.debug = this.isServer ? debug.server : debug.client
+
+  this.recv = new Side(this, 'recv', options.recv)
+  this.send = new Side(this, 'send', options.send)
+}
+module.exports = Window
+
+Window.prototype.clone = function clone (id) {
+  return new Window({
+    id: id,
+    isServer: this.isServer,
+    recv: {
+      size: this.recv.max,
+      max: this.recv.limit,
+      lowWaterMark: this.recv.lowWaterMark
+    },
+    send: {
+      size: this.send.max,
+      max: this.send.limit,
+      lowWaterMark: this.send.lowWaterMark
+    }
+  })
+}

web/node_modules/spdy-transport/node_modules/readable-stream/CONTRIBUTING.md

@@ -0,0 +1,38 @@
+# Developer's Certificate of Origin 1.1
+
+By making a contribution to this project, I certify that:
+
+* (a) The contribution was created in whole or in part by me and I
+  have the right to submit it under the open source license
+  indicated in the file; or
+
+* (b) The contribution is based upon previous work that, to the best
+  of my knowledge, is covered under an appropriate open source
+  license and I have the right under that license to submit that
+  work with modifications, whether created in whole or in part
+  by me, under the same open source license (unless I am
+  permitted to submit under a different license), as indicated
+  in the file; or
+
+* (c) The contribution was provided directly to me by some other
+  person who certified (a), (b) or (c) and I have not modified
+  it.
+
+* (d) I understand and agree that this project and the contribution
+  are public and that a record of the contribution (including all
+  personal information I submit with it, including my sign-off) is
+  maintained indefinitely and may be redistributed consistent with
+  this project or the open source license(s) involved.
+
+## Moderation Policy
+
+The [Node.js Moderation Policy] applies to this WG.
+
+## Code of Conduct
+
+The [Node.js Code of Conduct][] applies to this WG.
+
+[Node.js Code of Conduct]:
+https://github.com/nodejs/node/blob/master/CODE_OF_CONDUCT.md
+[Node.js Moderation Policy]:
+https://github.com/nodejs/TSC/blob/master/Moderation-Policy.md

web/node_modules/spdy-transport/node_modules/readable-stream/GOVERNANCE.md

@@ -0,0 +1,136 @@
+### Streams Working Group
+
+The Node.js Streams is jointly governed by a Working Group
+(WG)
+that is responsible for high-level guidance of the project.
+
+The WG has final authority over this project including:
+
+* Technical direction
+* Project governance and process (including this policy)
+* Contribution policy
+* GitHub repository hosting
+* Conduct guidelines
+* Maintaining the list of additional Collaborators
+
+For the current list of WG members, see the project
+[README.md](./README.md#current-project-team-members).
+
+### Collaborators
+
+The readable-stream GitHub repository is
+maintained by the WG and additional Collaborators who are added by the
+WG on an ongoing basis.
+
+Individuals making significant and valuable contributions are made
+Collaborators and given commit-access to the project. These
+individuals are identified by the WG and their addition as
+Collaborators is discussed during the WG meeting.
+
+_Note:_ If you make a significant contribution and are not considered
+for commit-access log an issue or contact a WG member directly and it
+will be brought up in the next WG meeting.
+
+Modifications of the contents of the readable-stream repository are
+made on
+a collaborative basis. Anybody with a GitHub account may propose a
+modification via pull request and it will be considered by the project
+Collaborators. All pull requests must be reviewed and accepted by a
+Collaborator with sufficient expertise who is able to take full
+responsibility for the change. In the case of pull requests proposed
+by an existing Collaborator, an additional Collaborator is required
+for sign-off. Consensus should be sought if additional Collaborators
+participate and there is disagreement around a particular
+modification. See _Consensus Seeking Process_ below for further detail
+on the consensus model used for governance.
+
+Collaborators may opt to elevate significant or controversial
+modifications, or modifications that have not found consensus to the
+WG for discussion by assigning the ***WG-agenda*** tag to a pull
+request or issue. The WG should serve as the final arbiter where
+required.
+
+For the current list of Collaborators, see the project
+[README.md](./README.md#members).
+
+### WG Membership
+
+WG seats are not time-limited.  There is no fixed size of the WG.
+However, the expected target is between 6 and 12, to ensure adequate
+coverage of important areas of expertise, balanced with the ability to
+make decisions efficiently.
+
+There is no specific set of requirements or qualifications for WG
+membership beyond these rules.
+
+The WG may add additional members to the WG by unanimous consensus.
+
+A WG member may be removed from the WG by voluntary resignation, or by
+unanimous consensus of all other WG members.
+
+Changes to WG membership should be posted in the agenda, and may be
+suggested as any other agenda item (see "WG Meetings" below).
+
+If an addition or removal is proposed during a meeting, and the full
+WG is not in attendance to participate, then the addition or removal
+is added to the agenda for the subsequent meeting.  This is to ensure
+that all members are given the opportunity to participate in all
+membership decisions.  If a WG member is unable to attend a meeting
+where a planned membership decision is being made, then their consent
+is assumed.
+
+No more than 1/3 of the WG members may be affiliated with the same
+employer.  If removal or resignation of a WG member, or a change of
+employment by a WG member, creates a situation where more than 1/3 of
+the WG membership shares an employer, then the situation must be
+immediately remedied by the resignation or removal of one or more WG
+members affiliated with the over-represented employer(s).
+
+### WG Meetings
+
+The WG meets occasionally on a Google Hangout On Air. A designated moderator
+approved by the WG runs the meeting. Each meeting should be
+published to YouTube.
+
+Items are added to the WG agenda that are considered contentious or
+are modifications of governance, contribution policy, WG membership,
+or release process.
+
+The intention of the agenda is not to approve or review all patches;
+that should happen continuously on GitHub and be handled by the larger
+group of Collaborators.
+
+Any community member or contributor can ask that something be added to
+the next meeting's agenda by logging a GitHub Issue. Any Collaborator,
+WG member or the moderator can add the item to the agenda by adding
+the ***WG-agenda*** tag to the issue.
+
+Prior to each WG meeting the moderator will share the Agenda with
+members of the WG. WG members can add any items they like to the
+agenda at the beginning of each meeting. The moderator and the WG
+cannot veto or remove items.
+
+The WG may invite persons or representatives from certain projects to
+participate in a non-voting capacity.
+
+The moderator is responsible for summarizing the discussion of each
+agenda item and sends it as a pull request after the meeting.
+
+### Consensus Seeking Process
+
+The WG follows a
+[Consensus
+Seeking](http://en.wikipedia.org/wiki/Consensus-seeking_decision-making)
+decision-making model.
+
+When an agenda item has appeared to reach a consensus the moderator
+will ask "Does anyone object?" as a final call for dissent from the
+consensus.
+
+If an agenda item cannot reach a consensus a WG member can call for
+either a closing vote or a vote to table the issue to the next
+meeting. The call for a vote must be seconded by a majority of the WG
+or else the discussion will continue. Simple majority wins.
+
+Note that changes to WG membership require a majority consensus.  See
+"WG Membership" above.

web/node_modules/spdy-transport/node_modules/readable-stream/LICENSE

@@ -0,0 +1,47 @@
+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.
+"""

web/node_modules/spdy-transport/node_modules/readable-stream/README.md

@@ -0,0 +1,106 @@
+# readable-stream
+
+***Node.js core streams for userland*** [![Build Status](https://travis-ci.com/nodejs/readable-stream.svg?branch=master)](https://travis-ci.com/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/readabe-stream.svg)](https://saucelabs.com/u/readabe-stream)
+
+```bash
+npm install --save readable-stream
+```
+
+This package is a mirror of the streams implementations in Node.js.
+
+Full documentation may be found on the [Node.js website](https://nodejs.org/dist/v10.19.0/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.
+
+## Version 3.x.x
+
+v3.x.x of `readable-stream` is a cut from Node 10. This version supports Node 6, 8, and 10, as well as evergreen browsers, IE 11 and latest Safari. The breaking changes introduced by v3 are composed by the combined breaking changes in [Node v9](https://nodejs.org/en/blog/release/v9.0.0/) and [Node v10](https://nodejs.org/en/blog/release/v10.0.0/), as follows:
+
+1. Error codes: https://github.com/nodejs/node/pull/13310,
+   https://github.com/nodejs/node/pull/13291,
+   https://github.com/nodejs/node/pull/16589,
+   https://github.com/nodejs/node/pull/15042,
+   https://github.com/nodejs/node/pull/15665,
+   https://github.com/nodejs/readable-stream/pull/344
+2. 'readable' have precedence over flowing
+   https://github.com/nodejs/node/pull/18994
+3. make virtual methods errors consistent
+   https://github.com/nodejs/node/pull/18813
+4. updated streams error handling
+   https://github.com/nodejs/node/pull/18438
+5. writable.end should return this.
+   https://github.com/nodejs/node/pull/18780
+6. readable continues to read when push('')
+   https://github.com/nodejs/node/pull/18211
+7. add custom inspect to BufferList
+   https://github.com/nodejs/node/pull/17907
+8. always defer 'readable' with nextTick
+   https://github.com/nodejs/node/pull/17979
+
+## Version 2.x.x
+v2.x.x of `readable-stream` is a cut of the stream module from Node 8 (there have been no semver-major changes from Node 4 to 8). This version supports all Node.js versions from 0.8, as well as evergreen browsers and IE 10 & 11.
+
+### Big Thanks
+
+Cross-browser Testing Platform and Open Source <3 Provided by [Sauce Labs][sauce]
+
+# Usage
+
+You can swap your `require('stream')` with `require('readable-stream')`
+without any changes, if you are just using one of the main classes and
+functions.
+
+```js
+const {
+  Readable,
+  Writable,
+  Transform,
+  Duplex,
+  pipeline,
+  finished
+} = require('readable-stream')
+````
+
+Note that `require('stream')` will return `Stream`, while
+`require('readable-stream')` will return `Readable`. We discourage using
+whatever is exported directly, but rather use one of the properties as
+shown in the example above.
+
+# 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
+
+* **Calvin Metcalf** ([@calvinmetcalf](https://github.com/calvinmetcalf)) &lt;calvin.metcalf@gmail.com&gt;
+  - Release GPG key: F3EF5F62A87FC27A22E643F714CE4FF5015AA242
+* **Mathias Buus** ([@mafintosh](https://github.com/mafintosh)) &lt;mathiasbuus@gmail.com&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;
+* **Yoshua Wyuts** ([@yoshuawuyts](https://github.com/yoshuawuyts)) &lt;yoshuawuyts@gmail.com&gt;
+
+[sauce]: https://saucelabs.com

web/node_modules/spdy-transport/node_modules/readable-stream/errors-browser.js

@@ -0,0 +1,127 @@
+'use strict';
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }
+
+var codes = {};
+
+function createErrorType(code, message, Base) {
+  if (!Base) {
+    Base = Error;
+  }
+
+  function getMessage(arg1, arg2, arg3) {
+    if (typeof message === 'string') {
+      return message;
+    } else {
+      return message(arg1, arg2, arg3);
+    }
+  }
+
+  var NodeError =
+  /*#__PURE__*/
+  function (_Base) {
+    _inheritsLoose(NodeError, _Base);
+
+    function NodeError(arg1, arg2, arg3) {
+      return _Base.call(this, getMessage(arg1, arg2, arg3)) || this;
+    }
+
+    return NodeError;
+  }(Base);
+
+  NodeError.prototype.name = Base.name;
+  NodeError.prototype.code = code;
+  codes[code] = NodeError;
+} // https://github.com/nodejs/node/blob/v10.8.0/lib/internal/errors.js
+
+
+function oneOf(expected, thing) {
+  if (Array.isArray(expected)) {
+    var len = expected.length;
+    expected = expected.map(function (i) {
+      return String(i);
+    });
+
+    if (len > 2) {
+      return "one of ".concat(thing, " ").concat(expected.slice(0, len - 1).join(', '), ", or ") + expected[len - 1];
+    } else if (len === 2) {
+      return "one of ".concat(thing, " ").concat(expected[0], " or ").concat(expected[1]);
+    } else {
+      return "of ".concat(thing, " ").concat(expected[0]);
+    }
+  } else {
+    return "of ".concat(thing, " ").concat(String(expected));
+  }
+} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith
+
+
+function startsWith(str, search, pos) {
+  return str.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search;
+} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith
+
+
+function endsWith(str, search, this_len) {
+  if (this_len === undefined || this_len > str.length) {
+    this_len = str.length;
+  }
+
+  return str.substring(this_len - search.length, this_len) === search;
+} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes
+
+
+function includes(str, search, start) {
+  if (typeof start !== 'number') {
+    start = 0;
+  }
+
+  if (start + search.length > str.length) {
+    return false;
+  } else {
+    return str.indexOf(search, start) !== -1;
+  }
+}
+
+createErrorType('ERR_INVALID_OPT_VALUE', function (name, value) {
+  return 'The value "' + value + '" is invalid for option "' + name + '"';
+}, TypeError);
+createErrorType('ERR_INVALID_ARG_TYPE', function (name, expected, actual) {
+  // determiner: 'must be' or 'must not be'
+  var determiner;
+
+  if (typeof expected === 'string' && startsWith(expected, 'not ')) {
+    determiner = 'must not be';
+    expected = expected.replace(/^not /, '');
+  } else {
+    determiner = 'must be';
+  }
+
+  var msg;
+
+  if (endsWith(name, ' argument')) {
+    // For cases like 'first argument'
+    msg = "The ".concat(name, " ").concat(determiner, " ").concat(oneOf(expected, 'type'));
+  } else {
+    var type = includes(name, '.') ? 'property' : 'argument';
+    msg = "The \"".concat(name, "\" ").concat(type, " ").concat(determiner, " ").concat(oneOf(expected, 'type'));
+  }
+
+  msg += ". Received type ".concat(typeof actual);
+  return msg;
+}, TypeError);
+createErrorType('ERR_STREAM_PUSH_AFTER_EOF', 'stream.push() after EOF');
+createErrorType('ERR_METHOD_NOT_IMPLEMENTED', function (name) {
+  return 'The ' + name + ' method is not implemented';
+});
+createErrorType('ERR_STREAM_PREMATURE_CLOSE', 'Premature close');
+createErrorType('ERR_STREAM_DESTROYED', function (name) {
+  return 'Cannot call ' + name + ' after a stream was destroyed';
+});
+createErrorType('ERR_MULTIPLE_CALLBACK', 'Callback called multiple times');
+createErrorType('ERR_STREAM_CANNOT_PIPE', 'Cannot pipe, not readable');
+createErrorType('ERR_STREAM_WRITE_AFTER_END', 'write after end');
+createErrorType('ERR_STREAM_NULL_VALUES', 'May not write null values to stream', TypeError);
+createErrorType('ERR_UNKNOWN_ENCODING', function (arg) {
+  return 'Unknown encoding: ' + arg;
+}, TypeError);
+createErrorType('ERR_STREAM_UNSHIFT_AFTER_END_EVENT', 'stream.unshift() after end event');
+module.exports.codes = codes;

web/node_modules/spdy-transport/node_modules/readable-stream/errors.js

@@ -0,0 +1,116 @@
+'use strict';
+
+const codes = {};
+
+function createErrorType(code, message, Base) {
+  if (!Base) {
+    Base = Error
+  }
+
+  function getMessage (arg1, arg2, arg3) {
+    if (typeof message === 'string') {
+      return message
+    } else {
+      return message(arg1, arg2, arg3)
+    }
+  }
+
+  class NodeError extends Base {
+    constructor (arg1, arg2, arg3) {
+      super(getMessage(arg1, arg2, arg3));
+    }
+  }
+
+  NodeError.prototype.name = Base.name;
+  NodeError.prototype.code = code;
+
+  codes[code] = NodeError;
+}
+
+// https://github.com/nodejs/node/blob/v10.8.0/lib/internal/errors.js
+function oneOf(expected, thing) {
+  if (Array.isArray(expected)) {
+    const len = expected.length;
+    expected = expected.map((i) => String(i));
+    if (len > 2) {
+      return `one of ${thing} ${expected.slice(0, len - 1).join(', ')}, or ` +
+             expected[len - 1];
+    } else if (len === 2) {
+      return `one of ${thing} ${expected[0]} or ${expected[1]}`;
+    } else {
+      return `of ${thing} ${expected[0]}`;
+    }
+  } else {
+    return `of ${thing} ${String(expected)}`;
+  }
+}
+
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith
+function startsWith(str, search, pos) {
+	return str.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search;
+}
+
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith
+function endsWith(str, search, this_len) {
+	if (this_len === undefined || this_len > str.length) {
+		this_len = str.length;
+	}
+	return str.substring(this_len - search.length, this_len) === search;
+}
+
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes
+function includes(str, search, start) {
+  if (typeof start !== 'number') {
+    start = 0;
+  }
+
+  if (start + search.length > str.length) {
+    return false;
+  } else {
+    return str.indexOf(search, start) !== -1;
+  }
+}
+
+createErrorType('ERR_INVALID_OPT_VALUE', function (name, value) {
+  return 'The value "' + value + '" is invalid for option "' + name + '"'
+}, TypeError);
+createErrorType('ERR_INVALID_ARG_TYPE', function (name, expected, actual) {
+  // determiner: 'must be' or 'must not be'
+  let determiner;
+  if (typeof expected === 'string' && startsWith(expected, 'not ')) {
+    determiner = 'must not be';
+    expected = expected.replace(/^not /, '');
+  } else {
+    determiner = 'must be';
+  }
+
+  let msg;
+  if (endsWith(name, ' argument')) {
+    // For cases like 'first argument'
+    msg = `The ${name} ${determiner} ${oneOf(expected, 'type')}`;
+  } else {
+    const type = includes(name, '.') ? 'property' : 'argument';
+    msg = `The "${name}" ${type} ${determiner} ${oneOf(expected, 'type')}`;
+  }
+
+  msg += `. Received type ${typeof actual}`;
+  return msg;
+}, TypeError);
+createErrorType('ERR_STREAM_PUSH_AFTER_EOF', 'stream.push() after EOF');
+createErrorType('ERR_METHOD_NOT_IMPLEMENTED', function (name) {
+  return 'The ' + name + ' method is not implemented'
+});
+createErrorType('ERR_STREAM_PREMATURE_CLOSE', 'Premature close');
+createErrorType('ERR_STREAM_DESTROYED', function (name) {
+  return 'Cannot call ' + name + ' after a stream was destroyed';
+});
+createErrorType('ERR_MULTIPLE_CALLBACK', 'Callback called multiple times');
+createErrorType('ERR_STREAM_CANNOT_PIPE', 'Cannot pipe, not readable');
+createErrorType('ERR_STREAM_WRITE_AFTER_END', 'write after end');
+createErrorType('ERR_STREAM_NULL_VALUES', 'May not write null values to stream', TypeError);
+createErrorType('ERR_UNKNOWN_ENCODING', function (arg) {
+  return 'Unknown encoding: ' + arg
+}, TypeError);
+createErrorType('ERR_STREAM_UNSHIFT_AFTER_END_EVENT', 'stream.unshift() after end event');
+
+module.exports.codes = codes;

web/node_modules/spdy-transport/node_modules/readable-stream/experimentalWarning.js

@@ -0,0 +1,17 @@
+'use strict'
+
+var experimentalWarnings = new Set();
+
+function emitExperimentalWarning(feature) {
+  if (experimentalWarnings.has(feature)) return;
+  var msg = feature + ' is an experimental feature. This feature could ' +
+       'change at any time';
+  experimentalWarnings.add(feature);
+  process.emitWarning(msg, 'ExperimentalWarning');
+}
+
+function noop() {}
+
+module.exports.emitExperimentalWarning = process.emitWarning
+  ? emitExperimentalWarning
+  : noop;

web/node_modules/spdy-transport/node_modules/readable-stream/lib/_stream_duplex.js

@@ -0,0 +1,139 @@
+// 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 objectKeys = Object.keys || function (obj) {
+  var keys = [];
+
+  for (var key in obj) {
+    keys.push(key);
+  }
+
+  return keys;
+};
+/*</replacement>*/
+
+
+module.exports = Duplex;
+
+var Readable = require('./_stream_readable');
+
+var Writable = require('./_stream_writable');
+
+require('inherits')(Duplex, Readable);
+
+{
+  // Allow the keys array to be GC'ed.
+  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);
+  this.allowHalfOpen = true;
+
+  if (options) {
+    if (options.readable === false) this.readable = false;
+    if (options.writable === false) this.writable = false;
+
+    if (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 get() {
+    return this._writableState.highWaterMark;
+  }
+});
+Object.defineProperty(Duplex.prototype, 'writableBuffer', {
+  // making it explicit this property is not enumerable
+  // because otherwise some prototype manipulation in
+  // userland will fail
+  enumerable: false,
+  get: function get() {
+    return this._writableState && this._writableState.getBuffer();
+  }
+});
+Object.defineProperty(Duplex.prototype, 'writableLength', {
+  // making it explicit this property is not enumerable
+  // because otherwise some prototype manipulation in
+  // userland will fail
+  enumerable: false,
+  get: function get() {
+    return this._writableState.length;
+  }
+}); // the no-half-open enforcer
+
+function onend() {
+  // If the writable side ended, then we're ok.
+  if (this._writableState.ended) return; // no more data can be written.
+  // But allow more writes to happen in this tick.
+
+  process.nextTick(onEndNT, this);
+}
+
+function onEndNT(self) {
+  self.end();
+}
+
+Object.defineProperty(Duplex.prototype, 'destroyed', {
+  // making it explicit this property is not enumerable
+  // because otherwise some prototype manipulation in
+  // userland will fail
+  enumerable: false,
+  get: function get() {
+    if (this._readableState === undefined || this._writableState === undefined) {
+      return false;
+    }
+
+    return this._readableState.destroyed && this._writableState.destroyed;
+  },
+  set: function set(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;
+  }
+});

web/node_modules/spdy-transport/node_modules/readable-stream/lib/_stream_passthrough.js

@@ -0,0 +1,39 @@
+// 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');
+
+require('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);
+};

web/node_modules/spdy-transport/node_modules/readable-stream/lib/_stream_transform.js

@@ -0,0 +1,201 @@
+// 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 _require$codes = require('../errors').codes,
+    ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,
+    ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,
+    ERR_TRANSFORM_ALREADY_TRANSFORMING = _require$codes.ERR_TRANSFORM_ALREADY_TRANSFORMING,
+    ERR_TRANSFORM_WITH_LENGTH_0 = _require$codes.ERR_TRANSFORM_WITH_LENGTH_0;
+
+var Duplex = require('./_stream_duplex');
+
+require('inherits')(Transform, Duplex);
+
+function afterTransform(er, data) {
+  var ts = this._transformState;
+  ts.transforming = false;
+  var cb = ts.writecb;
+
+  if (cb === null) {
+    return this.emit('error', new ERR_MULTIPLE_CALLBACK());
+  }
+
+  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._readableState.destroyed) {
+    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) {
+  cb(new ERR_METHOD_NOT_IMPLEMENTED('_transform()'));
+};
+
+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.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) {
+  Duplex.prototype._destroy.call(this, err, function (err2) {
+    cb(err2);
+  });
+};
+
+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); // TODO(BridgeAR): Write a test for these two error cases
+  // if there's nothing in the write buffer, then that means
+  // that nothing more will ever be provided
+
+  if (stream._writableState.length) throw new ERR_TRANSFORM_WITH_LENGTH_0();
+  if (stream._transformState.transforming) throw new ERR_TRANSFORM_ALREADY_TRANSFORMING();
+  return stream.push(null);
+}

web/node_modules/spdy-transport/node_modules/readable-stream/lib/_stream_writable.js

@@ -0,0 +1,697 @@
+// 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 bit simpler than readable streams.
+// Implement an async ._write(chunk, encoding, cb), and it'll handle all
+// the drain event emission and buffering.
+'use strict';
+
+module.exports = Writable;
+/* <replacement> */
+
+function WriteReq(chunk, encoding, cb) {
+  this.chunk = chunk;
+  this.encoding = encoding;
+  this.callback = cb;
+  this.next = null;
+} // It seems a linked list but it is not
+// there will be only 2 of these for each stream
+
+
+function CorkedRequest(state) {
+  var _this = this;
+
+  this.next = null;
+  this.entry = null;
+
+  this.finish = function () {
+    onCorkedFinish(_this, state);
+  };
+}
+/* </replacement> */
+
+/*<replacement>*/
+
+
+var Duplex;
+/*</replacement>*/
+
+Writable.WritableState = WritableState;
+/*<replacement>*/
+
+var internalUtil = {
+  deprecate: require('util-deprecate')
+};
+/*</replacement>*/
+
+/*<replacement>*/
+
+var Stream = require('./internal/streams/stream');
+/*</replacement>*/
+
+
+var Buffer = require('buffer').Buffer;
+
+var OurUint8Array = global.Uint8Array || function () {};
+
+function _uint8ArrayToBuffer(chunk) {
+  return Buffer.from(chunk);
+}
+
+function _isUint8Array(obj) {
+  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
+}
+
+var destroyImpl = require('./internal/streams/destroy');
+
+var _require = require('./internal/streams/state'),
+    getHighWaterMark = _require.getHighWaterMark;
+
+var _require$codes = require('../errors').codes,
+    ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,
+    ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,
+    ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,
+    ERR_STREAM_CANNOT_PIPE = _require$codes.ERR_STREAM_CANNOT_PIPE,
+    ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED,
+    ERR_STREAM_NULL_VALUES = _require$codes.ERR_STREAM_NULL_VALUES,
+    ERR_STREAM_WRITE_AFTER_END = _require$codes.ERR_STREAM_WRITE_AFTER_END,
+    ERR_UNKNOWN_ENCODING = _require$codes.ERR_UNKNOWN_ENCODING;
+
+var errorOrDestroy = destroyImpl.errorOrDestroy;
+
+require('inherits')(Writable, Stream);
+
+function nop() {}
+
+function WritableState(options, stream, isDuplex) {
+  Duplex = Duplex || require('./_stream_duplex');
+  options = options || {}; // Duplex streams are both readable and writable, but share
+  // the same options object.
+  // However, some cases require setting options to different
+  // values for the readable and the writable sides of the duplex stream,
+  // e.g. options.readableObjectMode vs. options.writableObjectMode, etc.
+
+  if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; // object stream flag to indicate whether or not this stream
+  // contains buffers or objects.
+
+  this.objectMode = !!options.objectMode;
+  if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode; // the point at which write() starts returning false
+  // Note: 0 is a valid value, means that we always return false if
+  // the entire buffer is not flushed immediately on write()
+
+  this.highWaterMark = getHighWaterMark(this, options, 'writableHighWaterMark', isDuplex); // if _final has been called
+
+  this.finalCalled = false; // drain event flag.
+
+  this.needDrain = false; // at the start of calling end()
+
+  this.ending = false; // when end() has been called, and returned
+
+  this.ended = false; // when 'finish' is emitted
+
+  this.finished = false; // has it been destroyed
+
+  this.destroyed = false; // should we decode strings into buffers before passing to _write?
+  // this is here so that some node-core streams can optimize string
+  // handling at a lower level.
+
+  var noDecode = options.decodeStrings === false;
+  this.decodeStrings = !noDecode; // Crypto is kind of old and crusty.  Historically, its default string
+  // encoding is 'binary' so we have to make this configurable.
+  // Everything else in the universe uses 'utf8', though.
+
+  this.defaultEncoding = options.defaultEncoding || 'utf8'; // not an actual buffer we keep track of, but a measurement
+  // of how much we're waiting to get pushed to some underlying
+  // socket or file.
+
+  this.length = 0; // a flag to see when we're in the middle of a write.
+
+  this.writing = false; // when true all writes will be buffered until .uncork() call
+
+  this.corked = 0; // a flag to be able to tell if the onwrite cb is called immediately,
+  // or on a later tick.  We set this to true at first, because any
+  // actions that shouldn't happen until "later" should generally also
+  // not happen before the first write call.
+
+  this.sync = true; // a flag to know if we're processing previously buffered items, which
+  // may call the _write() callback in the same tick, so that we don't
+  // end up in an overlapped onwrite situation.
+
+  this.bufferProcessing = false; // the callback that's passed to _write(chunk,cb)
+
+  this.onwrite = function (er) {
+    onwrite(stream, er);
+  }; // the callback that the user supplies to write(chunk,encoding,cb)
+
+
+  this.writecb = null; // the amount that is being written when _write is called.
+
+  this.writelen = 0;
+  this.bufferedRequest = null;
+  this.lastBufferedRequest = null; // number of pending user-supplied write callbacks
+  // this must be 0 before 'finish' can be emitted
+
+  this.pendingcb = 0; // emit prefinish if the only thing we're waiting for is _write cbs
+  // This is relevant for synchronous Transform streams
+
+  this.prefinished = false; // True if the error was already emitted and should not be thrown again
+
+  this.errorEmitted = false; // Should close be emitted on destroy. Defaults to true.
+
+  this.emitClose = options.emitClose !== false; // Should .destroy() be called after 'finish' (and potentially 'end')
+
+  this.autoDestroy = !!options.autoDestroy; // count buffered requests
+
+  this.bufferedRequestCount = 0; // allocate the first CorkedRequest, there is always
+  // one allocated and free to use, and we maintain at most two
+
+  this.corkedRequestsFree = new CorkedRequest(this);
+}
+
+WritableState.prototype.getBuffer = function getBuffer() {
+  var current = this.bufferedRequest;
+  var out = [];
+
+  while (current) {
+    out.push(current);
+    current = current.next;
+  }
+
+  return out;
+};
+
+(function () {
+  try {
+    Object.defineProperty(WritableState.prototype, 'buffer', {
+      get: internalUtil.deprecate(function writableStateBufferGetter() {
+        return this.getBuffer();
+      }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')
+    });
+  } catch (_) {}
+})(); // Test _writableState for inheritance to account for Duplex streams,
+// whose prototype chain only points to Readable.
+
+
+var realHasInstance;
+
+if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {
+  realHasInstance = Function.prototype[Symbol.hasInstance];
+  Object.defineProperty(Writable, Symbol.hasInstance, {
+    value: function value(object) {
+      if (realHasInstance.call(this, object)) return true;
+      if (this !== Writable) return false;
+      return object && object._writableState instanceof WritableState;
+    }
+  });
+} else {
+  realHasInstance = function realHasInstance(object) {
+    return object instanceof this;
+  };
+}
+
+function Writable(options) {
+  Duplex = Duplex || require('./_stream_duplex'); // Writable ctor is applied to Duplexes, too.
+  // `realHasInstance` is necessary because using plain `instanceof`
+  // would return false, as no `_writableState` property is attached.
+  // Trying to use the custom `instanceof` for Writable here will also break the
+  // Node.js LazyTransform implementation, which has a non-trivial getter for
+  // `_writableState` that would lead to infinite recursion.
+  // Checking for a Stream.Duplex instance is faster here instead of inside
+  // the WritableState constructor, at least with V8 6.5
+
+  var isDuplex = this instanceof Duplex;
+  if (!isDuplex && !realHasInstance.call(Writable, this)) return new Writable(options);
+  this._writableState = new WritableState(options, this, isDuplex); // legacy.
+
+  this.writable = true;
+
+  if (options) {
+    if (typeof options.write === 'function') this._write = options.write;
+    if (typeof options.writev === 'function') this._writev = options.writev;
+    if (typeof options.destroy === 'function') this._destroy = options.destroy;
+    if (typeof options.final === 'function') this._final = options.final;
+  }
+
+  Stream.call(this);
+} // Otherwise people can pipe Writable streams, which is just wrong.
+
+
+Writable.prototype.pipe = function () {
+  errorOrDestroy(this, new ERR_STREAM_CANNOT_PIPE());
+};
+
+function writeAfterEnd(stream, cb) {
+  var er = new ERR_STREAM_WRITE_AFTER_END(); // TODO: defer error events consistently everywhere, not just the cb
+
+  errorOrDestroy(stream, er);
+  process.nextTick(cb, er);
+} // Checks that a user-supplied chunk is valid, especially for the particular
+// mode the stream is in. Currently this means that `null` is never accepted
+// and undefined/non-string values are only allowed in object mode.
+
+
+function validChunk(stream, state, chunk, cb) {
+  var er;
+
+  if (chunk === null) {
+    er = new ERR_STREAM_NULL_VALUES();
+  } else if (typeof chunk !== 'string' && !state.objectMode) {
+    er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer'], chunk);
+  }
+
+  if (er) {
+    errorOrDestroy(stream, er);
+    process.nextTick(cb, er);
+    return false;
+  }
+
+  return true;
+}
+
+Writable.prototype.write = function (chunk, encoding, cb) {
+  var state = this._writableState;
+  var ret = false;
+
+  var isBuf = !state.objectMode && _isUint8Array(chunk);
+
+  if (isBuf && !Buffer.isBuffer(chunk)) {
+    chunk = _uint8ArrayToBuffer(chunk);
+  }
+
+  if (typeof encoding === 'function') {
+    cb = encoding;
+    encoding = null;
+  }
+
+  if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;
+  if (typeof cb !== 'function') cb = nop;
+  if (state.ending) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {
+    state.pendingcb++;
+    ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);
+  }
+  return ret;
+};
+
+Writable.prototype.cork = function () {
+  this._writableState.corked++;
+};
+
+Writable.prototype.uncork = function () {
+  var state = this._writableState;
+
+  if (state.corked) {
+    state.corked--;
+    if (!state.writing && !state.corked && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);
+  }
+};
+
+Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
+  // node::ParseEncoding() requires lower case.
+  if (typeof encoding === 'string') encoding = encoding.toLowerCase();
+  if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new ERR_UNKNOWN_ENCODING(encoding);
+  this._writableState.defaultEncoding = encoding;
+  return this;
+};
+
+Object.defineProperty(Writable.prototype, 'writableBuffer', {
+  // making it explicit this property is not enumerable
+  // because otherwise some prototype manipulation in
+  // userland will fail
+  enumerable: false,
+  get: function get() {
+    return this._writableState && this._writableState.getBuffer();
+  }
+});
+
+function decodeChunk(state, chunk, encoding) {
+  if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {
+    chunk = Buffer.from(chunk, encoding);
+  }
+
+  return chunk;
+}
+
+Object.defineProperty(Writable.prototype, 'writableHighWaterMark', {
+  // making it explicit this property is not enumerable
+  // because otherwise some prototype manipulation in
+  // userland will fail
+  enumerable: false,
+  get: function get() {
+    return this._writableState.highWaterMark;
+  }
+}); // if we're already writing something, then just put this
+// in the queue, and wait our turn.  Otherwise, call _write
+// If we return false, then we need a drain event, so set that flag.
+
+function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {
+  if (!isBuf) {
+    var newChunk = decodeChunk(state, chunk, encoding);
+
+    if (chunk !== newChunk) {
+      isBuf = true;
+      encoding = 'buffer';
+      chunk = newChunk;
+    }
+  }
+
+  var len = state.objectMode ? 1 : chunk.length;
+  state.length += len;
+  var ret = state.length < state.highWaterMark; // we must ensure that previous needDrain will not be reset to false.
+
+  if (!ret) state.needDrain = true;
+
+  if (state.writing || state.corked) {
+    var last = state.lastBufferedRequest;
+    state.lastBufferedRequest = {
+      chunk: chunk,
+      encoding: encoding,
+      isBuf: isBuf,
+      callback: cb,
+      next: null
+    };
+
+    if (last) {
+      last.next = state.lastBufferedRequest;
+    } else {
+      state.bufferedRequest = state.lastBufferedRequest;
+    }
+
+    state.bufferedRequestCount += 1;
+  } else {
+    doWrite(stream, state, false, len, chunk, encoding, cb);
+  }
+
+  return ret;
+}
+
+function doWrite(stream, state, writev, len, chunk, encoding, cb) {
+  state.writelen = len;
+  state.writecb = cb;
+  state.writing = true;
+  state.sync = true;
+  if (state.destroyed) state.onwrite(new ERR_STREAM_DESTROYED('write'));else if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);
+  state.sync = false;
+}
+
+function onwriteError(stream, state, sync, er, cb) {
+  --state.pendingcb;
+
+  if (sync) {
+    // defer the callback if we are being called synchronously
+    // to avoid piling up things on the stack
+    process.nextTick(cb, er); // this can emit finish, and it will always happen
+    // after error
+
+    process.nextTick(finishMaybe, stream, state);
+    stream._writableState.errorEmitted = true;
+    errorOrDestroy(stream, er);
+  } else {
+    // the caller expect this to happen before if
+    // it is async
+    cb(er);
+    stream._writableState.errorEmitted = true;
+    errorOrDestroy(stream, er); // this can emit finish, but finish must
+    // always follow error
+
+    finishMaybe(stream, state);
+  }
+}
+
+function onwriteStateUpdate(state) {
+  state.writing = false;
+  state.writecb = null;
+  state.length -= state.writelen;
+  state.writelen = 0;
+}
+
+function onwrite(stream, er) {
+  var state = stream._writableState;
+  var sync = state.sync;
+  var cb = state.writecb;
+  if (typeof cb !== 'function') throw new ERR_MULTIPLE_CALLBACK();
+  onwriteStateUpdate(state);
+  if (er) onwriteError(stream, state, sync, er, cb);else {
+    // Check if we're actually ready to finish, but don't emit yet
+    var finished = needFinish(state) || stream.destroyed;
+
+    if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {
+      clearBuffer(stream, state);
+    }
+
+    if (sync) {
+      process.nextTick(afterWrite, stream, state, finished, cb);
+    } else {
+      afterWrite(stream, state, finished, cb);
+    }
+  }
+}
+
+function afterWrite(stream, state, finished, cb) {
+  if (!finished) onwriteDrain(stream, state);
+  state.pendingcb--;
+  cb();
+  finishMaybe(stream, state);
+} // Must force callback to be called on nextTick, so that we don't
+// emit 'drain' before the write() consumer gets the 'false' return
+// value, and has a chance to attach a 'drain' listener.
+
+
+function onwriteDrain(stream, state) {
+  if (state.length === 0 && state.needDrain) {
+    state.needDrain = false;
+    stream.emit('drain');
+  }
+} // if there's something in the buffer waiting, then process it
+
+
+function clearBuffer(stream, state) {
+  state.bufferProcessing = true;
+  var entry = state.bufferedRequest;
+
+  if (stream._writev && entry && entry.next) {
+    // Fast case, write everything using _writev()
+    var l = state.bufferedRequestCount;
+    var buffer = new Array(l);
+    var holder = state.corkedRequestsFree;
+    holder.entry = entry;
+    var count = 0;
+    var allBuffers = true;
+
+    while (entry) {
+      buffer[count] = entry;
+      if (!entry.isBuf) allBuffers = false;
+      entry = entry.next;
+      count += 1;
+    }
+
+    buffer.allBuffers = allBuffers;
+    doWrite(stream, state, true, state.length, buffer, '', holder.finish); // doWrite is almost always async, defer these to save a bit of time
+    // as the hot path ends with doWrite
+
+    state.pendingcb++;
+    state.lastBufferedRequest = null;
+
+    if (holder.next) {
+      state.corkedRequestsFree = holder.next;
+      holder.next = null;
+    } else {
+      state.corkedRequestsFree = new CorkedRequest(state);
+    }
+
+    state.bufferedRequestCount = 0;
+  } else {
+    // Slow case, write chunks one-by-one
+    while (entry) {
+      var chunk = entry.chunk;
+      var encoding = entry.encoding;
+      var cb = entry.callback;
+      var len = state.objectMode ? 1 : chunk.length;
+      doWrite(stream, state, false, len, chunk, encoding, cb);
+      entry = entry.next;
+      state.bufferedRequestCount--; // if we didn't call the onwrite immediately, then
+      // it means that we need to wait until it does.
+      // also, that means that the chunk and cb are currently
+      // being processed, so move the buffer counter past them.
+
+      if (state.writing) {
+        break;
+      }
+    }
+
+    if (entry === null) state.lastBufferedRequest = null;
+  }
+
+  state.bufferedRequest = entry;
+  state.bufferProcessing = false;
+}
+
+Writable.prototype._write = function (chunk, encoding, cb) {
+  cb(new ERR_METHOD_NOT_IMPLEMENTED('_write()'));
+};
+
+Writable.prototype._writev = null;
+
+Writable.prototype.end = function (chunk, encoding, cb) {
+  var state = this._writableState;
+
+  if (typeof chunk === 'function') {
+    cb = chunk;
+    chunk = null;
+    encoding = null;
+  } else if (typeof encoding === 'function') {
+    cb = encoding;
+    encoding = null;
+  }
+
+  if (chunk !== null && chunk !== undefined) this.write(chunk, encoding); // .end() fully uncorks
+
+  if (state.corked) {
+    state.corked = 1;
+    this.uncork();
+  } // ignore unnecessary end() calls.
+
+
+  if (!state.ending) endWritable(this, state, cb);
+  return this;
+};
+
+Object.defineProperty(Writable.prototype, 'writableLength', {
+  // making it explicit this property is not enumerable
+  // because otherwise some prototype manipulation in
+  // userland will fail
+  enumerable: false,
+  get: function get() {
+    return this._writableState.length;
+  }
+});
+
+function needFinish(state) {
+  return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;
+}
+
+function callFinal(stream, state) {
+  stream._final(function (err) {
+    state.pendingcb--;
+
+    if (err) {
+      errorOrDestroy(stream, err);
+    }
+
+    state.prefinished = true;
+    stream.emit('prefinish');
+    finishMaybe(stream, state);
+  });
+}
+
+function prefinish(stream, state) {
+  if (!state.prefinished && !state.finalCalled) {
+    if (typeof stream._final === 'function' && !state.destroyed) {
+      state.pendingcb++;
+      state.finalCalled = true;
+      process.nextTick(callFinal, stream, state);
+    } else {
+      state.prefinished = true;
+      stream.emit('prefinish');
+    }
+  }
+}
+
+function finishMaybe(stream, state) {
+  var need = needFinish(state);
+
+  if (need) {
+    prefinish(stream, state);
+
+    if (state.pendingcb === 0) {
+      state.finished = true;
+      stream.emit('finish');
+
+      if (state.autoDestroy) {
+        // In case of duplex streams we need a way to detect
+        // if the readable side is ready for autoDestroy as well
+        var rState = stream._readableState;
+
+        if (!rState || rState.autoDestroy && rState.endEmitted) {
+          stream.destroy();
+        }
+      }
+    }
+  }
+
+  return need;
+}
+
+function endWritable(stream, state, cb) {
+  state.ending = true;
+  finishMaybe(stream, state);
+
+  if (cb) {
+    if (state.finished) process.nextTick(cb);else stream.once('finish', cb);
+  }
+
+  state.ended = true;
+  stream.writable = false;
+}
+
+function onCorkedFinish(corkReq, state, err) {
+  var entry = corkReq.entry;
+  corkReq.entry = null;
+
+  while (entry) {
+    var cb = entry.callback;
+    state.pendingcb--;
+    cb(err);
+    entry = entry.next;
+  } // reuse the free corkReq.
+
+
+  state.corkedRequestsFree.next = corkReq;
+}
+
+Object.defineProperty(Writable.prototype, 'destroyed', {
+  // making it explicit this property is not enumerable
+  // because otherwise some prototype manipulation in
+  // userland will fail
+  enumerable: false,
+  get: function get() {
+    if (this._writableState === undefined) {
+      return false;
+    }
+
+    return this._writableState.destroyed;
+  },
+  set: function set(value) {
+    // we ignore the value if the stream
+    // has not been initialized yet
+    if (!this._writableState) {
+      return;
+    } // backward compatibility, the user is explicitly
+    // managing destroyed
+
+
+    this._writableState.destroyed = value;
+  }
+});
+Writable.prototype.destroy = destroyImpl.destroy;
+Writable.prototype._undestroy = destroyImpl.undestroy;
+
+Writable.prototype._destroy = function (err, cb) {
+  cb(err);
+};

web/node_modules/spdy-transport/node_modules/readable-stream/lib/internal/streams/async_iterator.js

@@ -0,0 +1,207 @@
+'use strict';
+
+var _Object$setPrototypeO;
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var finished = require('./end-of-stream');
+
+var kLastResolve = Symbol('lastResolve');
+var kLastReject = Symbol('lastReject');
+var kError = Symbol('error');
+var kEnded = Symbol('ended');
+var kLastPromise = Symbol('lastPromise');
+var kHandlePromise = Symbol('handlePromise');
+var kStream = Symbol('stream');
+
+function createIterResult(value, done) {
+  return {
+    value: value,
+    done: done
+  };
+}
+
+function readAndResolve(iter) {
+  var resolve = iter[kLastResolve];
+
+  if (resolve !== null) {
+    var data = iter[kStream].read(); // we defer if data is null
+    // we can be expecting either 'end' or
+    // 'error'
+
+    if (data !== null) {
+      iter[kLastPromise] = null;
+      iter[kLastResolve] = null;
+      iter[kLastReject] = null;
+      resolve(createIterResult(data, false));
+    }
+  }
+}
+
+function onReadable(iter) {
+  // we wait for the next tick, because it might
+  // emit an error with process.nextTick
+  process.nextTick(readAndResolve, iter);
+}
+
+function wrapForNext(lastPromise, iter) {
+  return function (resolve, reject) {
+    lastPromise.then(function () {
+      if (iter[kEnded]) {
+        resolve(createIterResult(undefined, true));
+        return;
+      }
+
+      iter[kHandlePromise](resolve, reject);
+    }, reject);
+  };
+}
+
+var AsyncIteratorPrototype = Object.getPrototypeOf(function () {});
+var ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPrototypeO = {
+  get stream() {
+    return this[kStream];
+  },
+
+  next: function next() {
+    var _this = this;
+
+    // if we have detected an error in the meanwhile
+    // reject straight away
+    var error = this[kError];
+
+    if (error !== null) {
+      return Promise.reject(error);
+    }
+
+    if (this[kEnded]) {
+      return Promise.resolve(createIterResult(undefined, true));
+    }
+
+    if (this[kStream].destroyed) {
+      // We need to defer via nextTick because if .destroy(err) is
+      // called, the error will be emitted via nextTick, and
+      // we cannot guarantee that there is no error lingering around
+      // waiting to be emitted.
+      return new Promise(function (resolve, reject) {
+        process.nextTick(function () {
+          if (_this[kError]) {
+            reject(_this[kError]);
+          } else {
+            resolve(createIterResult(undefined, true));
+          }
+        });
+      });
+    } // if we have multiple next() calls
+    // we will wait for the previous Promise to finish
+    // this logic is optimized to support for await loops,
+    // where next() is only called once at a time
+
+
+    var lastPromise = this[kLastPromise];
+    var promise;
+
+    if (lastPromise) {
+      promise = new Promise(wrapForNext(lastPromise, this));
+    } else {
+      // fast path needed to support multiple this.push()
+      // without triggering the next() queue
+      var data = this[kStream].read();
+
+      if (data !== null) {
+        return Promise.resolve(createIterResult(data, false));
+      }
+
+      promise = new Promise(this[kHandlePromise]);
+    }
+
+    this[kLastPromise] = promise;
+    return promise;
+  }
+}, _defineProperty(_Object$setPrototypeO, Symbol.asyncIterator, function () {
+  return this;
+}), _defineProperty(_Object$setPrototypeO, "return", function _return() {
+  var _this2 = this;
+
+  // destroy(err, cb) is a private API
+  // we can guarantee we have that here, because we control the
+  // Readable class this is attached to
+  return new Promise(function (resolve, reject) {
+    _this2[kStream].destroy(null, function (err) {
+      if (err) {
+        reject(err);
+        return;
+      }
+
+      resolve(createIterResult(undefined, true));
+    });
+  });
+}), _Object$setPrototypeO), AsyncIteratorPrototype);
+
+var createReadableStreamAsyncIterator = function createReadableStreamAsyncIterator(stream) {
+  var _Object$create;
+
+  var iterator = Object.create(ReadableStreamAsyncIteratorPrototype, (_Object$create = {}, _defineProperty(_Object$create, kStream, {
+    value: stream,
+    writable: true
+  }), _defineProperty(_Object$create, kLastResolve, {
+    value: null,
+    writable: true
+  }), _defineProperty(_Object$create, kLastReject, {
+    value: null,
+    writable: true
+  }), _defineProperty(_Object$create, kError, {
+    value: null,
+    writable: true
+  }), _defineProperty(_Object$create, kEnded, {
+    value: stream._readableState.endEmitted,
+    writable: true
+  }), _defineProperty(_Object$create, kHandlePromise, {
+    value: function value(resolve, reject) {
+      var data = iterator[kStream].read();
+
+      if (data) {
+        iterator[kLastPromise] = null;
+        iterator[kLastResolve] = null;
+        iterator[kLastReject] = null;
+        resolve(createIterResult(data, false));
+      } else {
+        iterator[kLastResolve] = resolve;
+        iterator[kLastReject] = reject;
+      }
+    },
+    writable: true
+  }), _Object$create));
+  iterator[kLastPromise] = null;
+  finished(stream, function (err) {
+    if (err && err.code !== 'ERR_STREAM_PREMATURE_CLOSE') {
+      var reject = iterator[kLastReject]; // reject if we are waiting for data in the Promise
+      // returned by next() and store the error
+
+      if (reject !== null) {
+        iterator[kLastPromise] = null;
+        iterator[kLastResolve] = null;
+        iterator[kLastReject] = null;
+        reject(err);
+      }
+
+      iterator[kError] = err;
+      return;
+    }
+
+    var resolve = iterator[kLastResolve];
+
+    if (resolve !== null) {
+      iterator[kLastPromise] = null;
+      iterator[kLastResolve] = null;
+      iterator[kLastReject] = null;
+      resolve(createIterResult(undefined, true));
+    }
+
+    iterator[kEnded] = true;
+  });
+  stream.on('readable', onReadable.bind(null, iterator));
+  return iterator;
+};
+
+module.exports = createReadableStreamAsyncIterator;

web/node_modules/spdy-transport/node_modules/readable-stream/lib/internal/streams/buffer_list.js

@@ -0,0 +1,210 @@
+'use strict';
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+var _require = require('buffer'),
+    Buffer = _require.Buffer;
+
+var _require2 = require('util'),
+    inspect = _require2.inspect;
+
+var custom = inspect && inspect.custom || 'inspect';
+
+function copyBuffer(src, target, offset) {
+  Buffer.prototype.copy.call(src, target, offset);
+}
+
+module.exports =
+/*#__PURE__*/
+function () {
+  function BufferList() {
+    _classCallCheck(this, BufferList);
+
+    this.head = null;
+    this.tail = null;
+    this.length = 0;
+  }
+
+  _createClass(BufferList, [{
+    key: "push",
+    value: 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;
+    }
+  }, {
+    key: "unshift",
+    value: function unshift(v) {
+      var entry = {
+        data: v,
+        next: this.head
+      };
+      if (this.length === 0) this.tail = entry;
+      this.head = entry;
+      ++this.length;
+    }
+  }, {
+    key: "shift",
+    value: 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;
+    }
+  }, {
+    key: "clear",
+    value: function clear() {
+      this.head = this.tail = null;
+      this.length = 0;
+    }
+  }, {
+    key: "join",
+    value: 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;
+    }
+  }, {
+    key: "concat",
+    value: function concat(n) {
+      if (this.length === 0) return Buffer.alloc(0);
+      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;
+    } // Consumes a specified amount of bytes or characters from the buffered data.
+
+  }, {
+    key: "consume",
+    value: function consume(n, hasStrings) {
+      var ret;
+
+      if (n < this.head.data.length) {
+        // `slice` is the same for buffers and strings.
+        ret = this.head.data.slice(0, n);
+        this.head.data = this.head.data.slice(n);
+      } else if (n === this.head.data.length) {
+        // First chunk is a perfect match.
+        ret = this.shift();
+      } else {
+        // Result spans more than one buffer.
+        ret = hasStrings ? this._getString(n) : this._getBuffer(n);
+      }
+
+      return ret;
+    }
+  }, {
+    key: "first",
+    value: function first() {
+      return this.head.data;
+    } // Consumes a specified amount of characters from the buffered data.
+
+  }, {
+    key: "_getString",
+    value: function _getString(n) {
+      var p = this.head;
+      var c = 1;
+      var ret = p.data;
+      n -= ret.length;
+
+      while (p = p.next) {
+        var str = p.data;
+        var nb = n > str.length ? str.length : n;
+        if (nb === str.length) ret += str;else ret += str.slice(0, n);
+        n -= nb;
+
+        if (n === 0) {
+          if (nb === str.length) {
+            ++c;
+            if (p.next) this.head = p.next;else this.head = this.tail = null;
+          } else {
+            this.head = p;
+            p.data = str.slice(nb);
+          }
+
+          break;
+        }
+
+        ++c;
+      }
+
+      this.length -= c;
+      return ret;
+    } // Consumes a specified amount of bytes from the buffered data.
+
+  }, {
+    key: "_getBuffer",
+    value: function _getBuffer(n) {
+      var ret = Buffer.allocUnsafe(n);
+      var p = this.head;
+      var c = 1;
+      p.data.copy(ret);
+      n -= p.data.length;
+
+      while (p = p.next) {
+        var buf = p.data;
+        var nb = n > buf.length ? buf.length : n;
+        buf.copy(ret, ret.length - n, 0, nb);
+        n -= nb;
+
+        if (n === 0) {
+          if (nb === buf.length) {
+            ++c;
+            if (p.next) this.head = p.next;else this.head = this.tail = null;
+          } else {
+            this.head = p;
+            p.data = buf.slice(nb);
+          }
+
+          break;
+        }
+
+        ++c;
+      }
+
+      this.length -= c;
+      return ret;
+    } // Make sure the linked list only shows the minimal necessary information.
+
+  }, {
+    key: custom,
+    value: function value(_, options) {
+      return inspect(this, _objectSpread({}, options, {
+        // Only inspect one level.
+        depth: 0,
+        // It should not recurse.
+        customInspect: false
+      }));
+    }
+  }]);
+
+  return BufferList;
+}();

web/node_modules/spdy-transport/node_modules/readable-stream/lib/internal/streams/destroy.js

@@ -0,0 +1,105 @@
+'use strict'; // 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) {
+      if (!this._writableState) {
+        process.nextTick(emitErrorNT, this, err);
+      } else if (!this._writableState.errorEmitted) {
+        this._writableState.errorEmitted = true;
+        process.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) {
+      if (!_this._writableState) {
+        process.nextTick(emitErrorAndCloseNT, _this, err);
+      } else if (!_this._writableState.errorEmitted) {
+        _this._writableState.errorEmitted = true;
+        process.nextTick(emitErrorAndCloseNT, _this, err);
+      } else {
+        process.nextTick(emitCloseNT, _this);
+      }
+    } else if (cb) {
+      process.nextTick(emitCloseNT, _this);
+      cb(err);
+    } else {
+      process.nextTick(emitCloseNT, _this);
+    }
+  });
+
+  return this;
+}
+
+function emitErrorAndCloseNT(self, err) {
+  emitErrorNT(self, err);
+  emitCloseNT(self);
+}
+
+function emitCloseNT(self) {
+  if (self._writableState && !self._writableState.emitClose) return;
+  if (self._readableState && !self._readableState.emitClose) return;
+  self.emit('close');
+}
+
+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.finalCalled = false;
+    this._writableState.prefinished = false;
+    this._writableState.finished = false;
+    this._writableState.errorEmitted = false;
+  }
+}
+
+function emitErrorNT(self, err) {
+  self.emit('error', err);
+}
+
+function errorOrDestroy(stream, err) {
+  // We have tests that rely on errors being emitted
+  // in the same tick, so changing this is semver major.
+  // For now when you opt-in to autoDestroy we allow
+  // the error to be emitted nextTick. In a future
+  // semver major update we should change the default to this.
+  var rState = stream._readableState;
+  var wState = stream._writableState;
+  if (rState && rState.autoDestroy || wState && wState.autoDestroy) stream.destroy(err);else stream.emit('error', err);
+}
+
+module.exports = {
+  destroy: destroy,
+  undestroy: undestroy,
+  errorOrDestroy: errorOrDestroy
+};

web/node_modules/spdy-transport/node_modules/readable-stream/lib/internal/streams/end-of-stream.js

@@ -0,0 +1,104 @@
+// Ported from https://github.com/mafintosh/end-of-stream with
+// permission from the author, Mathias Buus (@mafintosh).
+'use strict';
+
+var ERR_STREAM_PREMATURE_CLOSE = require('../../../errors').codes.ERR_STREAM_PREMATURE_CLOSE;
+
+function once(callback) {
+  var called = false;
+  return function () {
+    if (called) return;
+    called = true;
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    callback.apply(this, args);
+  };
+}
+
+function noop() {}
+
+function isRequest(stream) {
+  return stream.setHeader && typeof stream.abort === 'function';
+}
+
+function eos(stream, opts, callback) {
+  if (typeof opts === 'function') return eos(stream, null, opts);
+  if (!opts) opts = {};
+  callback = once(callback || noop);
+  var readable = opts.readable || opts.readable !== false && stream.readable;
+  var writable = opts.writable || opts.writable !== false && stream.writable;
+
+  var onlegacyfinish = function onlegacyfinish() {
+    if (!stream.writable) onfinish();
+  };
+
+  var writableEnded = stream._writableState && stream._writableState.finished;
+
+  var onfinish = function onfinish() {
+    writable = false;
+    writableEnded = true;
+    if (!readable) callback.call(stream);
+  };
+
+  var readableEnded = stream._readableState && stream._readableState.endEmitted;
+
+  var onend = function onend() {
+    readable = false;
+    readableEnded = true;
+    if (!writable) callback.call(stream);
+  };
+
+  var onerror = function onerror(err) {
+    callback.call(stream, err);
+  };
+
+  var onclose = function onclose() {
+    var err;
+
+    if (readable && !readableEnded) {
+      if (!stream._readableState || !stream._readableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();
+      return callback.call(stream, err);
+    }
+
+    if (writable && !writableEnded) {
+      if (!stream._writableState || !stream._writableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();
+      return callback.call(stream, err);
+    }
+  };
+
+  var onrequest = function onrequest() {
+    stream.req.on('finish', onfinish);
+  };
+
+  if (isRequest(stream)) {
+    stream.on('complete', onfinish);
+    stream.on('abort', onclose);
+    if (stream.req) onrequest();else stream.on('request', onrequest);
+  } else if (writable && !stream._writableState) {
+    // legacy streams
+    stream.on('end', onlegacyfinish);
+    stream.on('close', onlegacyfinish);
+  }
+
+  stream.on('end', onend);
+  stream.on('finish', onfinish);
+  if (opts.error !== false) stream.on('error', onerror);
+  stream.on('close', onclose);
+  return function () {
+    stream.removeListener('complete', onfinish);
+    stream.removeListener('abort', onclose);
+    stream.removeListener('request', onrequest);
+    if (stream.req) stream.req.removeListener('finish', onfinish);
+    stream.removeListener('end', onlegacyfinish);
+    stream.removeListener('close', onlegacyfinish);
+    stream.removeListener('finish', onfinish);
+    stream.removeListener('end', onend);
+    stream.removeListener('error', onerror);
+    stream.removeListener('close', onclose);
+  };
+}
+
+module.exports = eos;

web/node_modules/spdy-transport/node_modules/readable-stream/lib/internal/streams/from-browser.js

@@ -0,0 +1,3 @@
+module.exports = function () {
+  throw new Error('Readable.from is not available in the browser')
+};

web/node_modules/spdy-transport/node_modules/readable-stream/lib/internal/streams/from.js

@@ -0,0 +1,64 @@
+'use strict';
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var ERR_INVALID_ARG_TYPE = require('../../../errors').codes.ERR_INVALID_ARG_TYPE;
+
+function from(Readable, iterable, opts) {
+  var iterator;
+
+  if (iterable && typeof iterable.next === 'function') {
+    iterator = iterable;
+  } else if (iterable && iterable[Symbol.asyncIterator]) iterator = iterable[Symbol.asyncIterator]();else if (iterable && iterable[Symbol.iterator]) iterator = iterable[Symbol.iterator]();else throw new ERR_INVALID_ARG_TYPE('iterable', ['Iterable'], iterable);
+
+  var readable = new Readable(_objectSpread({
+    objectMode: true
+  }, opts)); // Reading boolean to protect against _read
+  // being called before last iteration completion.
+
+  var reading = false;
+
+  readable._read = function () {
+    if (!reading) {
+      reading = true;
+      next();
+    }
+  };
+
+  function next() {
+    return _next2.apply(this, arguments);
+  }
+
+  function _next2() {
+    _next2 = _asyncToGenerator(function* () {
+      try {
+        var _ref = yield iterator.next(),
+            value = _ref.value,
+            done = _ref.done;
+
+        if (done) {
+          readable.push(null);
+        } else if (readable.push((yield value))) {
+          next();
+        } else {
+          reading = false;
+        }
+      } catch (err) {
+        readable.destroy(err);
+      }
+    });
+    return _next2.apply(this, arguments);
+  }
+
+  return readable;
+}
+
+module.exports = from;

web/node_modules/spdy-transport/node_modules/readable-stream/lib/internal/streams/pipeline.js

@@ -0,0 +1,97 @@
+// Ported from https://github.com/mafintosh/pump with
+// permission from the author, Mathias Buus (@mafintosh).
+'use strict';
+
+var eos;
+
+function once(callback) {
+  var called = false;
+  return function () {
+    if (called) return;
+    called = true;
+    callback.apply(void 0, arguments);
+  };
+}
+
+var _require$codes = require('../../../errors').codes,
+    ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS,
+    ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED;
+
+function noop(err) {
+  // Rethrow the error if it exists to avoid swallowing it
+  if (err) throw err;
+}
+
+function isRequest(stream) {
+  return stream.setHeader && typeof stream.abort === 'function';
+}
+
+function destroyer(stream, reading, writing, callback) {
+  callback = once(callback);
+  var closed = false;
+  stream.on('close', function () {
+    closed = true;
+  });
+  if (eos === undefined) eos = require('./end-of-stream');
+  eos(stream, {
+    readable: reading,
+    writable: writing
+  }, function (err) {
+    if (err) return callback(err);
+    closed = true;
+    callback();
+  });
+  var destroyed = false;
+  return function (err) {
+    if (closed) return;
+    if (destroyed) return;
+    destroyed = true; // request.destroy just do .end - .abort is what we want
+
+    if (isRequest(stream)) return stream.abort();
+    if (typeof stream.destroy === 'function') return stream.destroy();
+    callback(err || new ERR_STREAM_DESTROYED('pipe'));
+  };
+}
+
+function call(fn) {
+  fn();
+}
+
+function pipe(from, to) {
+  return from.pipe(to);
+}
+
+function popCallback(streams) {
+  if (!streams.length) return noop;
+  if (typeof streams[streams.length - 1] !== 'function') return noop;
+  return streams.pop();
+}
+
+function pipeline() {
+  for (var _len = arguments.length, streams = new Array(_len), _key = 0; _key < _len; _key++) {
+    streams[_key] = arguments[_key];
+  }
+
+  var callback = popCallback(streams);
+  if (Array.isArray(streams[0])) streams = streams[0];
+
+  if (streams.length < 2) {
+    throw new ERR_MISSING_ARGS('streams');
+  }
+
+  var error;
+  var destroys = streams.map(function (stream, i) {
+    var reading = i < streams.length - 1;
+    var writing = i > 0;
+    return destroyer(stream, reading, writing, function (err) {
+      if (!error) error = err;
+      if (err) destroys.forEach(call);
+      if (reading) return;
+      destroys.forEach(call);
+      callback(error);
+    });
+  });
+  return streams.reduce(pipe);
+}
+
+module.exports = pipeline;

web/node_modules/spdy-transport/node_modules/readable-stream/lib/internal/streams/state.js

@@ -0,0 +1,27 @@
+'use strict';
+
+var ERR_INVALID_OPT_VALUE = require('../../../errors').codes.ERR_INVALID_OPT_VALUE;
+
+function highWaterMarkFrom(options, isDuplex, duplexKey) {
+  return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;
+}
+
+function getHighWaterMark(state, options, duplexKey, isDuplex) {
+  var hwm = highWaterMarkFrom(options, isDuplex, duplexKey);
+
+  if (hwm != null) {
+    if (!(isFinite(hwm) && Math.floor(hwm) === hwm) || hwm < 0) {
+      var name = isDuplex ? duplexKey : 'highWaterMark';
+      throw new ERR_INVALID_OPT_VALUE(name, hwm);
+    }
+
+    return Math.floor(hwm);
+  } // Default value
+
+
+  return state.objectMode ? 16 : 16 * 1024;
+}
+
+module.exports = {
+  getHighWaterMark: getHighWaterMark
+};

web/node_modules/spdy-transport/node_modules/readable-stream/lib/internal/streams/stream-browser.js

@@ -0,0 +1 @@
+module.exports = require('events').EventEmitter;

web/node_modules/spdy-transport/node_modules/readable-stream/lib/internal/streams/stream.js

@@ -0,0 +1 @@
+module.exports = require('stream');

web/node_modules/spdy-transport/node_modules/readable-stream/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "readable-stream",
+  "version": "3.6.0",
+  "description": "Streams3, a user-land copy of the stream library from Node.js",
+  "main": "readable.js",
+  "engines": {
+    "node": ">= 6"
+  },
+  "dependencies": {
+    "inherits": "^2.0.3",
+    "string_decoder": "^1.1.1",
+    "util-deprecate": "^1.0.1"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.2.0",
+    "@babel/core": "^7.2.0",
+    "@babel/polyfill": "^7.0.0",
+    "@babel/preset-env": "^7.2.0",
+    "airtap": "0.0.9",
+    "assert": "^1.4.0",
+    "bl": "^2.0.0",
+    "deep-strict-equal": "^0.2.0",
+    "events.once": "^2.0.2",
+    "glob": "^7.1.2",
+    "gunzip-maybe": "^1.4.1",
+    "hyperquest": "^2.1.3",
+    "lolex": "^2.6.0",
+    "nyc": "^11.0.0",
+    "pump": "^3.0.0",
+    "rimraf": "^2.6.2",
+    "tap": "^12.0.0",
+    "tape": "^4.9.0",
+    "tar-fs": "^1.16.2",
+    "util-promisify": "^2.1.0"
+  },
+  "scripts": {
+    "test": "tap -J --no-esm test/parallel/*.js test/ours/*.js",
+    "ci": "TAP=1 tap --no-esm test/parallel/*.js test/ours/*.js | tee test.tap",
+    "test-browsers": "airtap --sauce-connect --loopback airtap.local -- test/browser.js",
+    "test-browser-local": "airtap --open --local -- test/browser.js",
+    "cover": "nyc npm test",
+    "report": "nyc report --reporter=lcov",
+    "update-browser-errors": "babel -o errors-browser.js errors.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/nodejs/readable-stream"
+  },
+  "keywords": [
+    "readable",
+    "stream",
+    "pipe"
+  ],
+  "browser": {
+    "util": false,
+    "worker_threads": false,
+    "./errors": "./errors-browser.js",
+    "./readable.js": "./readable-browser.js",
+    "./lib/internal/streams/from.js": "./lib/internal/streams/from-browser.js",
+    "./lib/internal/streams/stream.js": "./lib/internal/streams/stream-browser.js"
+  },
+  "nyc": {
+    "include": [
+      "lib/**.js"
+    ]
+  },
+  "license": "MIT"
+}

web/node_modules/spdy-transport/node_modules/readable-stream/readable-browser.js

@@ -0,0 +1,9 @@
+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');
+exports.finished = require('./lib/internal/streams/end-of-stream.js');
+exports.pipeline = require('./lib/internal/streams/pipeline.js');

web/node_modules/spdy-transport/node_modules/readable-stream/readable.js

@@ -0,0 +1,16 @@
+var Stream = require('stream');
+if (process.env.READABLE_STREAM === 'disable' && Stream) {
+  module.exports = Stream.Readable;
+  Object.assign(module.exports, Stream);
+  module.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');
+  exports.finished = require('./lib/internal/streams/end-of-stream.js');
+  exports.pipeline = require('./lib/internal/streams/pipeline.js');
+}

web/node_modules/spdy-transport/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "spdy-transport",
+  "version": "3.0.0",
+  "main": "lib/spdy-transport",
+  "description": "SPDY v2, v3, v3.1 and HTTP2 transport",
+  "license": "MIT",
+  "keywords": [
+    "spdy",
+    "http2",
+    "transport"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/spdy-http2/spdy-transport.git"
+  },
+  "homepage": "https://github.com/spdy-http2/spdy-transport",
+  "author": "Fedor Indutny <fedor@indutny.com>",
+  "dependencies": {
+    "debug": "^4.1.0",
+    "detect-node": "^2.0.4",
+    "hpack.js": "^2.1.6",
+    "obuf": "^1.1.2",
+    "readable-stream": "^3.0.6",
+    "wbuf": "^1.7.3"
+  },
+  "devDependencies": {
+    "async": "^2.6.1",
+    "istanbul": "^0.4.5",
+    "mocha": "^5.2.0",
+    "pre-commit": "^1.2.2",
+    "standard": "^12.0.1",
+    "stream-pair": "^1.0.3"
+  },
+  "scripts": {
+    "lint": "standard",
+    "test": "mocha --reporter=spec test/**/*-test.js test/**/**/*-test.js",
+    "coverage": "istanbul cover node_modules/.bin/_mocha -- --reporter=spec test/**/*-test.js test/**/**/*-test.js"
+  },
+  "pre-commit": [
+    "lint",
+    "test"
+  ]
+}