typespeed 2.0.21 → 2.0.23

package/test/node_modules/amqplib/lib/error.js

@@ -1,24 +0,0 @@
-var inherits = require('util').inherits;
-
-function trimStack(stack, num) {
-  return stack && stack.split('\n').slice(num).join('\n');
-}
-
-function IllegalOperationError(msg, stack) {
-  var tmp = new Error();
-  this.message = msg;
-  this.stack = this.toString() + '\n' + trimStack(tmp.stack, 2);
-  this.stackAtStateChange = stack;
-}
-inherits(IllegalOperationError, Error);
-
-IllegalOperationError.prototype.name = 'IllegalOperationError';
-
-function stackCapture(reason) {
-  var e = new Error();
-  return 'Stack capture: ' + reason + '\n' +
-    trimStack(e.stack, 2);
-}
-
-module.exports.IllegalOperationError = IllegalOperationError;
-module.exports.stackCapture = stackCapture;

package/test/node_modules/amqplib/lib/format.js

@@ -1,40 +0,0 @@
-//
-//
-//
-
-// Stringifying various things
-
-'use strict';
-
-var defs = require('./defs');
-var format = require('util').format;
-var inherits = require('util').inherits;
-var HEARTBEAT = require('./frame').HEARTBEAT;
-
-module.exports.closeMessage = function(close) {
-  var code = close.fields.replyCode;
-  return format('%d (%s) with message "%s"',
-                code, defs.constant_strs[code],
-                close.fields.replyText);
-}
-
-module.exports.methodName = function(id) {
-  return defs.info(id).name;
-};
-
-module.exports.inspect = function(frame, showFields) {
-  if (frame === HEARTBEAT) {
-    return '<Heartbeat>';
-  }
-  else if (!frame.id) {
-    return format('<Content channel:%d size:%d>',
-                  frame.channel, frame.size);
-  }
-  else {
-    var info = defs.info(frame.id);
-    return format('<%s channel:%d%s>', info.name, frame.channel,
-                  (showFields)
-                  ? ' ' + JSON.stringify(frame.fields, undefined, 2)
-                  : '');
-  }
-}

package/test/node_modules/amqplib/lib/frame.js

@@ -1,113 +0,0 @@
-// The river sweeps through
-// Silt and twigs, gravel and leaves
-// Driving the wheel on
-
-'use strict';
-
-var defs = require('./defs');
-var constants = defs.constants;
-var decode = defs.decode;
-
-var Bits = require('@acuminous/bitsyntax');
-
-module.exports.PROTOCOL_HEADER = "AMQP" + String.fromCharCode(0, 0, 9, 1);
-
-/*
-  Frame format:
-
-  0      1         3             7                size+7 size+8
-  +------+---------+-------------+ +------------+ +-----------+
-  | type | channel | size        | | payload    | | frame-end |
-  +------+---------+-------------+ +------------+ +-----------+
-  octet   short     long            size octets    octet
-
-  In general I want to know those first three things straight away, so I
-  can discard frames early.
-
-*/
-
-// framing constants
-var FRAME_METHOD = constants.FRAME_METHOD,
-FRAME_HEARTBEAT = constants.FRAME_HEARTBEAT,
-FRAME_HEADER = constants.FRAME_HEADER,
-FRAME_BODY = constants.FRAME_BODY,
-FRAME_END = constants.FRAME_END;
-
-var bodyCons =
-  Bits.builder(FRAME_BODY,
-               'channel:16, size:32, payload:size/binary',
-               FRAME_END);
-
-// %%% TESTME possibly better to cons the first bit and write the
-// second directly, in the absence of IO lists
-module.exports.makeBodyFrame = function(channel, payload) {
-  return bodyCons({channel: channel, size: payload.length, payload: payload});
-};
-
-var frameHeaderPattern = Bits.matcher('type:8', 'channel:16',
-                                      'size:32', 'rest/binary');
-
-function parseFrame(bin, max) {
-  var fh = frameHeaderPattern(bin);
-  if (fh) {
-    var size = fh.size, rest = fh.rest;
-    if (size > max) {
-      throw new Error('Frame size exceeds frame max');
-    }
-    else if (rest.length > size) {
-      if (rest[size] !== FRAME_END)
-        throw new Error('Invalid frame');
-
-      return {
-        type: fh.type,
-        channel: fh.channel,
-        size: size,
-        payload: rest.slice(0, size),
-        rest: rest.slice(size + 1)
-      };
-    }
-  }
-  return false;
-}
-
-module.exports.parseFrame = parseFrame;
-
-var headerPattern = Bits.matcher('class:16',
-                                 '_weight:16',
-                                 'size:64',
-                                 'flagsAndfields/binary');
-
-var methodPattern = Bits.matcher('id:32, args/binary');
-
-var HEARTBEAT = {channel: 0};
-
-module.exports.decodeFrame = function(frame) {
-  var payload = frame.payload;
-  switch (frame.type) {
-  case FRAME_METHOD:
-    var idAndArgs = methodPattern(payload);
-    var id = idAndArgs.id;
-    var fields = decode(id, idAndArgs.args);
-    return {id: id, channel: frame.channel, fields: fields};
-  case FRAME_HEADER:
-    var parts = headerPattern(payload);
-    var id = parts['class'];
-    var fields = decode(id, parts.flagsAndfields);
-    return {id: id, channel: frame.channel,
-            size: parts.size, fields: fields};
-  case FRAME_BODY:
-    return {channel: frame.channel, content: frame.payload};
-  case FRAME_HEARTBEAT:
-    return HEARTBEAT;
-  default:
-    throw new Error('Unknown frame type ' + frame.type);
-  }
-}
-
-// encoded heartbeat
-module.exports.HEARTBEAT_BUF = Buffer.from([constants.FRAME_HEARTBEAT,
-                                           0, 0, 0, 0, // size = 0
-                                           0, 0, // channel = 0
-                                           constants.FRAME_END]);
-
-module.exports.HEARTBEAT = HEARTBEAT;

package/test/node_modules/amqplib/lib/heartbeat.js

@@ -1,89 +0,0 @@
-//
-//
-//
-
-// Heartbeats. In AMQP both clients and servers may expect a heartbeat
-// frame if there is no activity on the connection for a negotiated
-// period of time. If there's no activity for two such intervals, the
-// server or client is allowed to close the connection on the
-// presumption that the other party is dead.
-//
-// The client has two jobs here: the first is to send a heartbeat
-// frame if it's not sent any frames for a while, so that the server
-// doesn't think it's dead; the second is to check periodically that
-// it's seen activity from the server, and to advise if there doesn't
-// appear to have been any for over two intervals.
-//
-// Node.JS timers are a bit unreliable, in that they endeavour only to
-// fire at some indeterminate point *after* the given time (rather
-// gives the lie to 'realtime', dunnit). Because the scheduler is just
-// an event loop, it's quite easy to delay timers indefinitely by
-// reacting to some I/O with a lot of computation.
-//
-// To mitigate this I need a bit of creative interpretation:
-//
-//  - I'll schedule a server activity check for every `interval`, and
-//    check just how much time has passed. It will overshoot by at
-//    least a small margin; modulo missing timer deadlines, it'll
-//    notice between two and three intervals after activity actually
-//    stops (otherwise, at some point after two intervals).
-//
-//  - Every `interval / 2` I'll check that we've sent something since
-//    the last check, and if not, send a heartbeat frame. If we're
-//    really too busy to even run the check for two whole heartbeat
-//    intervals, there must be a lot of I (but not O, at least not on
-//    the connection), or computation, in which case perhaps it's best
-//    the server cuts us off anyway. Why `interval / 2`? Because the
-//    edge case is that the client sent a frame just after a
-//    heartbeat, which would mean I only send one after almost two
-//    intervals. (NB a heartbeat counts as a send, so it'll be checked
-//    at least twice before sending another)
-//
-// This design is based largely on RabbitMQ's heartbeating:
-// https://github.com/rabbitmq/rabbitmq-common/blob/master/src/rabbit_heartbeat.erl
-
-// %% Yes, I could apply the same 'actually passage of time' thing to
-// %% send as well as to recv.
-
-'use strict';
-
-var inherits = require('util').inherits;
-var EventEmitter = require('events').EventEmitter;
-
-// Exported so that we can mess with it in tests
-module.exports.UNITS_TO_MS = 1000;
-
-function Heart(interval, checkSend, checkRecv) {
-  EventEmitter.call(this);
-  this.interval = interval;
-
-  var intervalMs = interval * module.exports.UNITS_TO_MS;
-  // Function#bind is my new best friend
-  var beat = this.emit.bind(this, 'beat');
-  var timeout = this.emit.bind(this, 'timeout');
-
-  this.sendTimer = setInterval(
-    this.runHeartbeat.bind(this, checkSend, beat), intervalMs / 2);
-
-  // A timeout occurs if I see nothing for *two consecutive* intervals
-  var recvMissed = 0;
-  function missedTwo() {
-    if (!checkRecv()) return (++recvMissed < 2);
-    else { recvMissed = 0; return true; }
-  }
-  this.recvTimer = setInterval(
-    this.runHeartbeat.bind(this, missedTwo, timeout), intervalMs);
-}
-inherits(Heart, EventEmitter);
-
-module.exports.Heart = Heart;
-
-Heart.prototype.clear = function() {
-  clearInterval(this.sendTimer);
-  clearInterval(this.recvTimer);
-};
-
-Heart.prototype.runHeartbeat = function(check, fail) {
-  // Have we seen activity?
-  if (!check()) fail();
-};

package/test/node_modules/amqplib/lib/mux.js

@@ -1,129 +0,0 @@
-//
-//
-//
-
-'use strict';
-
-// A Mux is an object into which other readable streams may be piped;
-// it then writes 'packets' from the upstreams to the given
-// downstream.
-
-var assert = require('assert');
-
-var schedule = (typeof setImmediate === 'function') ?
-  setImmediate : process.nextTick;
-
-function Mux(downstream) {
-  this.newStreams = [];
-  this.oldStreams = [];
-  this.blocked = false;
-  this.scheduledRead = false;
-
-  this.out = downstream;
-  var self = this;
-  downstream.on('drain', function() {
-    self.blocked = false;
-    self._readIncoming();
-  });
-}
-
-// There are 2 states we can be in:
-
-// - waiting for outbound capacity, which will be signalled by a
-// - 'drain' event on the downstream; or,
-
-// - no packets to send, waiting for an inbound buffer to have
-//   packets, which will be signalled by a 'readable' event
-
-// If we write all packets available whenever there is outbound
-// capacity, we will either run out of outbound capacity (`#write`
-// returns false), or run out of packets (all calls to an
-// `inbound.read()` have returned null).
-
-Mux.prototype._readIncoming = function() {
-
-  // We may be sent here speculatively, if an incoming stream has
-  // become readable
-  if (this.blocked) return;
-
-  var accepting = true;
-  var out = this.out;
-
-  // Try to read a chunk from each stream in turn, until all streams
-  // are empty, or we exhaust our ability to accept chunks.
-  function roundrobin(streams) {
-    var s;
-    while (accepting && (s = streams.shift())) {
-      var chunk = s.read();
-      if (chunk !== null) {
-        accepting = out.write(chunk);
-        streams.push(s);
-      }
-    }
-  }
-
-  roundrobin(this.newStreams);
-
-  // Either we exhausted the new queues, or we ran out of capacity. If
-  // we ran out of capacity, all the remaining new streams (i.e.,
-  // those with packets left) become old streams. This effectively
-  // prioritises streams that keep their buffers close to empty over
-  // those that are constantly near full.
-
-  if (accepting) { // all new queues are exhausted, write as many as
-                   // we can from the old streams
-    assert.equal(0, this.newStreams.length);
-    roundrobin(this.oldStreams);
-  }
-  else { // ran out of room
-    assert(this.newStreams.length > 0, "Expect some new streams to remain");
-    Array.prototype.push.apply(this.oldStreams, this.newStreams);
-    this.newStreams = [];
-  }
-  // We may have exhausted all the old queues, or run out of room;
-  // either way, all we need to do is record whether we have capacity
-  // or not, so any speculative reads will know
-  this.blocked = !accepting;
-};
-
-Mux.prototype._scheduleRead = function() {
-  var self = this;
-
-  if (!self.scheduledRead) {
-    schedule(function() {
-      self.scheduledRead = false;
-      self._readIncoming();
-    });
-    self.scheduledRead = true;
-  }
-};
-
-Mux.prototype.pipeFrom = function(readable) {
-  var self = this;
-
-  function enqueue() {
-    self.newStreams.push(readable);
-    self._scheduleRead();
-  }
-
-  function cleanup() {
-    readable.removeListener('readable', enqueue);
-    readable.removeListener('error', cleanup);
-    readable.removeListener('end', cleanup);
-    readable.removeListener('unpipeFrom', cleanupIfMe);
-  }
-  function cleanupIfMe(dest) {
-    if (dest === self) cleanup();
-  }
-
-  readable.on('unpipeFrom', cleanupIfMe);
-  readable.on('end', cleanup);
-  readable.on('error', cleanup);
-  readable.on('readable', enqueue);
-};
-
-Mux.prototype.unpipeFrom = function(readable) {
-  readable.emit('unpipeFrom', this);
-};
-
-module.exports.Mux = Mux;

package/test/node_modules/amqplib/package.json

@@ -1,37 +0,0 @@
-{
-  "name": "amqplib",
-  "homepage": "http://amqp-node.github.io/amqplib/",
-  "main": "./channel_api.js",
-  "version": "0.10.3",
-  "description": "An AMQP 0-9-1 (e.g., RabbitMQ) library and client.",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/amqp-node/amqplib.git"
-  },
-  "engines": {
-    "node": ">=10"
-  },
-  "dependencies": {
-    "@acuminous/bitsyntax": "^0.1.2",
-    "buffer-more-ints": "~1.0.0",
-    "readable-stream": "1.x >=1.1.9",
-    "url-parse": "~1.5.10"
-  },
-  "devDependencies": {
-    "claire": "0.4.1",
-    "mocha": "^9.2.2",
-    "nyc": "^15.1.0",
-    "uglify-js": "2.8.x"
-  },
-  "scripts": {
-    "test": "make test",
-    "prepare": "make"
-  },
-  "keywords": [
-    "AMQP",
-    "AMQP 0-9-1",
-    "RabbitMQ"
-  ],
-  "author": "Michael Bridgen <mikeb@squaremobius.net>",
-  "license": "MIT"
-}

package/test/node_modules/amqplib/test/bitset.js

@@ -1,69 +0,0 @@
-'use strict';
-
-const claire = require('claire');
-const {BitSet} = require('../lib/bitset');
-
-const {
-  forAll,
-  data: arb,
-  label,
-  choice,
-  transform
-} = claire;
-
-const PosInt = transform(Math.floor, arb.Positive);
-
-const EmptyBitSet = label('bitset', transform(
-  size => {
-    return new BitSet(size);
-  },
-  choice(arb.Nothing, PosInt)));
-
-suite('BitSet', () => {
-
-test('get bit', forAll(EmptyBitSet, PosInt)
-     .satisfy((b, bit) => {
-       b.set(bit);
-       return b.get(bit);
-     }).asTest());
-
-test('clear bit', forAll(EmptyBitSet, PosInt)
-     .satisfy((b, bit) => {
-       b.set(bit);
-       b.clear(bit);
-       return !b.get(bit);
-     }).asTest());
-
-test('next set of empty', forAll(EmptyBitSet)
-     .satisfy(b => {
-       return b.nextSetBit(0) === -1;
-     }).asTest());
-
-test('next set of one bit', forAll(EmptyBitSet, PosInt)
-     .satisfy((b, bit) => {
-       b.set(bit);
-       return b.nextSetBit(0) === bit;
-     }).asTest());
-
-test('next set same bit', forAll(EmptyBitSet, PosInt)
-     .satisfy((b, bit) => {
-       b.set(bit);
-       return b.nextSetBit(bit) === bit;
-     }).asTest());
-
-test('next set following bit', forAll(EmptyBitSet, PosInt)
-     .satisfy((b, bit) => {
-       b.set(bit);
-       return b.nextSetBit(bit+1) === -1;
-     }).asTest());
-
-test('next clear of empty', forAll(EmptyBitSet, PosInt)
-     .satisfy((b, bit) => { return b.nextClearBit(bit) === bit; })
-     .asTest());
-
-test('next clear of one set', forAll(EmptyBitSet, PosInt)
-     .satisfy((b, bit) => {
-       b.set(bit);
-       return b.nextClearBit(bit) === bit + 1;
-     }).asTest());
-});