@warlock.js/notifications 4.16.0 → 5.0.1

package/esm/node_modules/amqplib/lib/error.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.mjs","names":[],"sources":["../../../../../../../../../node_modules/amqplib/lib/error.js"],"sourcesContent":["var inherits = require('util').inherits;\n\nfunction trimStack(stack, num) {\n  return stack && stack.split('\\n').slice(num).join('\\n');\n}\n\nfunction IllegalOperationError(msg, stack) {\n  var tmp = new Error();\n  this.message = msg;\n  this.stack = this.toString() + '\\n' + trimStack(tmp.stack, 2);\n  this.stackAtStateChange = stack;\n}\ninherits(IllegalOperationError, Error);\n\nIllegalOperationError.prototype.name = 'IllegalOperationError';\n\nfunction stackCapture(reason) {\n  var e = new Error();\n  return 'Stack capture: ' + reason + '\\n' +\n    trimStack(e.stack, 2);\n}\n\nmodule.exports.IllegalOperationError = IllegalOperationError;\nmodule.exports.stackCapture = stackCapture;\n"],"x_google_ignoreList":[0],"mappings":";;;;CAAA,IAAI,qBAAmB,MAAM,CAAC,CAAC;CAE/B,SAAS,UAAU,OAAO,KAAK;EAC7B,OAAO,SAAS,MAAM,MAAM,IAAI,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,IAAI;CACxD;CAEA,SAAS,sBAAsB,KAAK,OAAO;EACzC,IAAI,sBAAM,IAAI,MAAM;EACpB,KAAK,UAAU;EACf,KAAK,QAAQ,KAAK,SAAS,IAAI,OAAO,UAAU,IAAI,OAAO,CAAC;EAC5D,KAAK,qBAAqB;CAC5B;CACA,SAAS,uBAAuB,KAAK;CAErC,sBAAsB,UAAU,OAAO;CAEvC,SAAS,aAAa,QAAQ;EAC5B,IAAI,oBAAI,IAAI,MAAM;EAClB,OAAO,oBAAoB,SAAS,OAClC,UAAU,EAAE,OAAO,CAAC;CACxB;CAEA,OAAO,QAAQ,wBAAwB;CACvC,OAAO,QAAQ,eAAe"}

package/esm/node_modules/amqplib/lib/format.mjs

@@ -0,0 +1,28 @@
+import { __commonJSMin, __require } from "../../../_virtual/_rolldown/runtime.mjs";
+import { require_defs } from "./defs.mjs";
+import { require_frame } from "./frame.mjs";
+
+//#region ../node_modules/amqplib/lib/format.js
+var require_format = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var defs = require_defs();
+	var format = __require("util").format;
+	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 return format("<%s channel:%d%s>", defs.info(frame.id).name, frame.channel, showFields ? " " + JSON.stringify(frame.fields, void 0, 2) : "");
+	};
+}));
+
+//#endregion
+export default require_format();
+
+export { require_format };
+//# sourceMappingURL=format.mjs.map

package/esm/node_modules/amqplib/lib/format.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.mjs","names":[],"sources":["../../../../../../../../../node_modules/amqplib/lib/format.js"],"sourcesContent":["//\n//\n//\n\n// Stringifying various things\n\n'use strict';\n\nvar defs = require('./defs');\nvar format = require('util').format;\nvar HEARTBEAT = require('./frame').HEARTBEAT;\n\nmodule.exports.closeMessage = function(close) {\n  var code = close.fields.replyCode;\n  return format('%d (%s) with message \"%s\"',\n                code, defs.constant_strs[code],\n                close.fields.replyText);\n}\n\nmodule.exports.methodName = function(id) {\n  return defs.info(id).name;\n};\n\nmodule.exports.inspect = function(frame, showFields) {\n  if (frame === HEARTBEAT) {\n    return '<Heartbeat>';\n  }\n  else if (!frame.id) {\n    return format('<Content channel:%d size:%d>',\n                  frame.channel, frame.size);\n  }\n  else {\n    var info = defs.info(frame.id);\n    return format('<%s channel:%d%s>', info.name, frame.channel,\n                  (showFields)\n                  ? ' ' + JSON.stringify(frame.fields, undefined, 2)\n                  : '');\n  }\n}\n"],"x_google_ignoreList":[0],"mappings":";;;;;;CAQA,IAAI;CACJ,IAAI,mBAAiB,MAAM,CAAC,CAAC;CAC7B,IAAI,4BAA+B;CAEnC,OAAO,QAAQ,eAAe,SAAS,OAAO;EAC5C,IAAI,OAAO,MAAM,OAAO;EACxB,OAAO,OAAO,+BACA,MAAM,KAAK,cAAc,OACzB,MAAM,OAAO,SAAS;CACtC;CAEA,OAAO,QAAQ,aAAa,SAAS,IAAI;EACvC,OAAO,KAAK,KAAK,EAAE,CAAC,CAAC;CACvB;CAEA,OAAO,QAAQ,UAAU,SAAS,OAAO,YAAY;EACnD,IAAI,UAAU,WACZ,OAAO;OAEJ,IAAI,CAAC,MAAM,IACd,OAAO,OAAO,gCACA,MAAM,SAAS,MAAM,IAAI;OAIvC,OAAO,OAAO,qBADH,KAAK,KAAK,MAAM,EACW,CAAC,CAAC,MAAM,MAAM,SACrC,aACC,MAAM,KAAK,UAAU,MAAM,QAAQ,QAAW,CAAC,IAC/C,EAAE;CAEtB"}

package/esm/node_modules/amqplib/lib/frame.mjs

@@ -0,0 +1,130 @@
+import { __commonJSMin } from "../../../_virtual/_rolldown/runtime.mjs";
+import { require_buffer_more_ints } from "../../buffer-more-ints/buffer-more-ints.mjs";
+import { require_defs } from "./defs.mjs";
+
+//#region ../node_modules/amqplib/lib/frame.js
+var require_frame = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const ints = require_buffer_more_ints();
+	var defs = require_defs();
+	var constants = defs.constants;
+	var decode = defs.decode;
+	module.exports.PROTOCOL_HEADER = "AMQP" + String.fromCharCode(0, 0, 9, 1);
+	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;
+	const FRAME_HEADER_BYTES = 7;
+	const FRAME_END_BYTES = 1;
+	/**
+	* @typedef {{
+	*   type: number,
+	*   channel: number,
+	*   size: number,
+	*   payload: Buffer,
+	*   rest: Buffer
+	* }} FrameStructure
+	*/
+	/**
+	* This is a polyfill which will read a big int 64 bit as a number.
+	* @arg { Buffer } buffer
+	* @arg { number } offset
+	* @returns { number }
+	*/
+	function readInt64BE(buffer, offset) {
+		/**
+		* We try to use native implementation if available here because
+		* buffer-more-ints does not
+		*/
+		if (typeof Buffer.prototype.readBigInt64BE === "function") return Number(buffer.readBigInt64BE(offset));
+		return ints.readInt64BE(buffer, offset);
+	}
+	/**
+	* Make a frame header
+	* @arg { number } channel
+	* @arg { Buffer } payload
+	*/
+	module.exports.makeBodyFrame = function(channel, payload) {
+		const frameSize = FRAME_HEADER_BYTES + payload.length + FRAME_END_BYTES;
+		const frame = Buffer.alloc(frameSize);
+		let offset = 0;
+		offset = frame.writeUInt8(FRAME_BODY, offset);
+		offset = frame.writeUInt16BE(channel, offset);
+		offset = frame.writeInt32BE(payload.length, offset);
+		payload.copy(frame, offset);
+		offset += payload.length;
+		frame.writeUInt8(FRAME_END, offset);
+		return frame;
+	};
+	/**
+	* Parse an AMQP frame
+	* @arg { Buffer } bin
+	* @arg { number } max
+	* @returns { FrameStructure | boolean }
+	*/
+	function parseFrame(bin) {
+		if (bin.length < FRAME_HEADER_BYTES) return false;
+		const type = bin.readUInt8(0);
+		const channel = bin.readUInt16BE(1);
+		const size = bin.readUInt32BE(3);
+		const totalSize = FRAME_HEADER_BYTES + size + FRAME_END_BYTES;
+		if (bin.length < totalSize) return false;
+		if (bin.readUInt8(FRAME_HEADER_BYTES + size) !== FRAME_END) throw new Error("Invalid frame");
+		return {
+			type,
+			channel,
+			size,
+			payload: bin.subarray(FRAME_HEADER_BYTES, FRAME_HEADER_BYTES + size),
+			rest: bin.subarray(totalSize)
+		};
+	}
+	module.exports.parseFrame = parseFrame;
+	var HEARTBEAT = { channel: 0 };
+	/**
+	* Decode AMQP frame into JS object
+	* @param { FrameStructure } frame
+	* @returns
+	*/
+	module.exports.decodeFrame = (frame) => {
+		const payload = frame.payload;
+		const channel = frame.channel;
+		switch (frame.type) {
+			case FRAME_METHOD: {
+				const id = payload.readUInt32BE(0);
+				return {
+					id,
+					channel,
+					fields: decode(id, payload.subarray(4))
+				};
+			}
+			case FRAME_HEADER: {
+				const id = payload.readUInt16BE(0);
+				return {
+					id,
+					channel,
+					size: readInt64BE(payload, 4),
+					fields: decode(id, payload.subarray(12))
+				};
+			}
+			case FRAME_BODY: return {
+				channel,
+				content: payload
+			};
+			case FRAME_HEARTBEAT: return HEARTBEAT;
+			default: throw new Error("Unknown frame type " + frame.type);
+		}
+	};
+	module.exports.HEARTBEAT_BUF = Buffer.from([
+		constants.FRAME_HEARTBEAT,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		constants.FRAME_END
+	]);
+	module.exports.HEARTBEAT = HEARTBEAT;
+}));
+
+//#endregion
+export default require_frame();
+
+export { require_frame };
+//# sourceMappingURL=frame.mjs.map

package/esm/node_modules/amqplib/lib/frame.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"frame.mjs","names":[],"sources":["../../../../../../../../../node_modules/amqplib/lib/frame.js"],"sourcesContent":["// The river sweeps through\n// Silt and twigs, gravel and leaves\n// Driving the wheel on\n\n'use strict';\n\nconst ints = require('buffer-more-ints')\nvar defs = require('./defs');\nvar constants = defs.constants;\nvar decode = defs.decode;\n\nmodule.exports.PROTOCOL_HEADER = \"AMQP\" + String.fromCharCode(0, 0, 9, 1);\n\n/*\n  Frame format:\n\n  0      1         3             7                size+7 size+8\n  +------+---------+-------------+ +------------+ +-----------+\n  | type | channel | size        | | payload    | | frame-end |\n  +------+---------+-------------+ +------------+ +-----------+\n  octet   short     long            size octets    octet\n\n  In general I want to know those first three things straight away, so I\n  can discard frames early.\n\n*/\n\n// framing constants\nvar FRAME_METHOD = constants.FRAME_METHOD,\nFRAME_HEARTBEAT = constants.FRAME_HEARTBEAT,\nFRAME_HEADER = constants.FRAME_HEADER,\nFRAME_BODY = constants.FRAME_BODY,\nFRAME_END = constants.FRAME_END;\n\n// expected byte sizes for frame parts\nconst TYPE_BYTES = 1\nconst CHANNEL_BYTES = 2\nconst SIZE_BYTES = 4\nconst FRAME_HEADER_BYTES = TYPE_BYTES + CHANNEL_BYTES + SIZE_BYTES\nconst FRAME_END_BYTES = 1\n\n/**\n * @typedef {{\n *   type: number,\n *   channel: number,\n *   size: number,\n *   payload: Buffer,\n *   rest: Buffer\n * }} FrameStructure\n */\n\n/**\n * This is a polyfill which will read a big int 64 bit as a number.\n * @arg { Buffer } buffer\n * @arg { number } offset\n * @returns { number }\n */\nfunction readInt64BE(buffer, offset) {\n  /**\n   * We try to use native implementation if available here because\n   * buffer-more-ints does not\n   */\n  if (typeof Buffer.prototype.readBigInt64BE === 'function') {\n    return Number(buffer.readBigInt64BE(offset))\n  }\n\n  return ints.readInt64BE(buffer, offset)\n}\n\n// %%% TESTME possibly better to cons the first bit and write the\n// second directly, in the absence of IO lists\n/**\n * Make a frame header\n * @arg { number } channel\n * @arg { Buffer } payload\n */\nmodule.exports.makeBodyFrame = function (channel, payload) {\n  const frameSize = FRAME_HEADER_BYTES + payload.length + FRAME_END_BYTES\n\n  const frame = Buffer.alloc(frameSize)\n\n  let offset = 0\n\n  offset = frame.writeUInt8(FRAME_BODY, offset)\n  offset = frame.writeUInt16BE(channel, offset)\n  offset = frame.writeInt32BE(payload.length, offset)\n\n  payload.copy(frame, offset)\n  offset += payload.length\n\n  frame.writeUInt8(FRAME_END, offset)\n\n  return frame\n};\n\n/**\n * Parse an AMQP frame\n * @arg { Buffer } bin\n * @arg { number } max\n * @returns { FrameStructure | boolean }\n */\nfunction parseFrame(bin) {\n  if (bin.length < FRAME_HEADER_BYTES) {\n    return false\n  }\n\n  const type = bin.readUInt8(0)\n  const channel = bin.readUInt16BE(1)\n  const size = bin.readUInt32BE(3)\n\n  const totalSize = FRAME_HEADER_BYTES + size + FRAME_END_BYTES\n\n  if (bin.length < totalSize) {\n    return false\n  }\n\n  const frameEnd = bin.readUInt8(FRAME_HEADER_BYTES + size)\n\n  if (frameEnd !== FRAME_END) {\n    throw new Error('Invalid frame')\n  }\n\n  return {\n    type,\n    channel,\n    size,\n    payload: bin.subarray(FRAME_HEADER_BYTES, FRAME_HEADER_BYTES + size),\n    rest: bin.subarray(totalSize)\n  }\n}\n\nmodule.exports.parseFrame = parseFrame;\n\nvar HEARTBEAT = {channel: 0};\n\n/**\n * Decode AMQP frame into JS object\n * @param { FrameStructure } frame\n * @returns\n */\nmodule.exports.decodeFrame = (frame) => {\n  const payload = frame.payload\n  const channel = frame.channel\n\n  switch (frame.type) {\n    case FRAME_METHOD: {\n      const id = payload.readUInt32BE(0)\n      const args = payload.subarray(4)\n      const fields = decode(id, args)\n      return { id, channel, fields }\n    }\n    case FRAME_HEADER: {\n      const id = payload.readUInt16BE(0)\n      // const weight = payload.readUInt16BE(2)\n      const size = readInt64BE(payload, 4)\n      const flagsAndfields = payload.subarray(12)\n      const fields = decode(id, flagsAndfields)\n      return { id, channel, size, fields }\n    }\n    case FRAME_BODY:\n      return { channel, content: payload }\n    case FRAME_HEARTBEAT:\n      return HEARTBEAT\n    default:\n      throw new Error('Unknown frame type ' + frame.type)\n  }\n}\n\n// encoded heartbeat\nmodule.exports.HEARTBEAT_BUF = Buffer.from([constants.FRAME_HEARTBEAT,\n                                           0, 0, 0, 0, // size = 0\n                                           0, 0, // channel = 0\n                                           constants.FRAME_END]);\n\nmodule.exports.HEARTBEAT = HEARTBEAT;"],"x_google_ignoreList":[0],"mappings":";;;;;;CAMA,MAAM;CACN,IAAI;CACJ,IAAI,YAAY,KAAK;CACrB,IAAI,SAAS,KAAK;CAElB,OAAO,QAAQ,kBAAkB,SAAS,OAAO,aAAa,GAAG,GAAG,GAAG,CAAC;CAiBxE,IAAI,eAAe,UAAU,cAC7B,kBAAkB,UAAU,iBAC5B,eAAe,UAAU,cACzB,aAAa,UAAU,YACvB,YAAY,UAAU;CAMtB,MAAM,qBAAqB;CAC3B,MAAM,kBAAkB;;;;;;;;;;;;;;;;CAkBxB,SAAS,YAAY,QAAQ,QAAQ;;;;;EAKnC,IAAI,OAAO,OAAO,UAAU,mBAAmB,YAC7C,OAAO,OAAO,OAAO,eAAe,MAAM,CAAC;EAG7C,OAAO,KAAK,YAAY,QAAQ,MAAM;CACxC;;;;;;CASA,OAAO,QAAQ,gBAAgB,SAAU,SAAS,SAAS;EACzD,MAAM,YAAY,qBAAqB,QAAQ,SAAS;EAExD,MAAM,QAAQ,OAAO,MAAM,SAAS;EAEpC,IAAI,SAAS;EAEb,SAAS,MAAM,WAAW,YAAY,MAAM;EAC5C,SAAS,MAAM,cAAc,SAAS,MAAM;EAC5C,SAAS,MAAM,aAAa,QAAQ,QAAQ,MAAM;EAElD,QAAQ,KAAK,OAAO,MAAM;EAC1B,UAAU,QAAQ;EAElB,MAAM,WAAW,WAAW,MAAM;EAElC,OAAO;CACT;;;;;;;CAQA,SAAS,WAAW,KAAK;EACvB,IAAI,IAAI,SAAS,oBACf,OAAO;EAGT,MAAM,OAAO,IAAI,UAAU,CAAC;EAC5B,MAAM,UAAU,IAAI,aAAa,CAAC;EAClC,MAAM,OAAO,IAAI,aAAa,CAAC;EAE/B,MAAM,YAAY,qBAAqB,OAAO;EAE9C,IAAI,IAAI,SAAS,WACf,OAAO;EAKT,IAFiB,IAAI,UAAU,qBAAqB,IAEzC,MAAM,WACf,MAAM,IAAI,MAAM,eAAe;EAGjC,OAAO;GACL;GACA;GACA;GACA,SAAS,IAAI,SAAS,oBAAoB,qBAAqB,IAAI;GACnE,MAAM,IAAI,SAAS,SAAS;EAC9B;CACF;CAEA,OAAO,QAAQ,aAAa;CAE5B,IAAI,YAAY,EAAC,SAAS,EAAC;;;;;;CAO3B,OAAO,QAAQ,eAAe,UAAU;EACtC,MAAM,UAAU,MAAM;EACtB,MAAM,UAAU,MAAM;EAEtB,QAAQ,MAAM,MAAd;GACE,KAAK,cAAc;IACjB,MAAM,KAAK,QAAQ,aAAa,CAAC;IAGjC,OAAO;KAAE;KAAI;KAAS,QADP,OAAO,IADT,QAAQ,SAAS,CACD,CACF;IAAE;GAC/B;GACA,KAAK,cAAc;IACjB,MAAM,KAAK,QAAQ,aAAa,CAAC;IAKjC,OAAO;KAAE;KAAI;KAAS,MAHT,YAAY,SAAS,CAGT;KAAG,QADb,OAAO,IADC,QAAQ,SAAS,EACD,CACN;IAAE;GACrC;GACA,KAAK,YACH,OAAO;IAAE;IAAS,SAAS;GAAQ;GACrC,KAAK,iBACH,OAAO;GACT,SACE,MAAM,IAAI,MAAM,wBAAwB,MAAM,IAAI;EACtD;CACF;CAGA,OAAO,QAAQ,gBAAgB,OAAO,KAAK;EAAC,UAAU;EACX;EAAG;EAAG;EAAG;EACT;EAAG;EACH,UAAU;CAAS,CAAC;CAE/D,OAAO,QAAQ,YAAY"}

package/esm/node_modules/amqplib/lib/heartbeat.mjs

@@ -0,0 +1,40 @@
+import { __commonJSMin, __require } from "../../../_virtual/_rolldown/runtime.mjs";
+
+//#region ../node_modules/amqplib/lib/heartbeat.js
+var require_heartbeat = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var EventEmitter = __require("events");
+	module.exports.UNITS_TO_MS = 1e3;
+	var Heart = class extends EventEmitter {
+		constructor(interval, checkSend, checkRecv) {
+			super();
+			this.interval = interval;
+			var intervalMs = interval * module.exports.UNITS_TO_MS;
+			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);
+			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);
+		}
+		clear() {
+			clearInterval(this.sendTimer);
+			clearInterval(this.recvTimer);
+		}
+		runHeartbeat(check, fail) {
+			if (!check()) fail();
+		}
+	};
+	module.exports.Heart = Heart;
+}));
+
+//#endregion
+export default require_heartbeat();
+
+export { require_heartbeat };
+//# sourceMappingURL=heartbeat.mjs.map

package/esm/node_modules/amqplib/lib/heartbeat.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"heartbeat.mjs","names":[],"sources":["../../../../../../../../../node_modules/amqplib/lib/heartbeat.js"],"sourcesContent":["//\n//\n//\n\n// Heartbeats. In AMQP both clients and servers may expect a heartbeat\n// frame if there is no activity on the connection for a negotiated\n// period of time. If there's no activity for two such intervals, the\n// server or client is allowed to close the connection on the\n// presumption that the other party is dead.\n//\n// The client has two jobs here: the first is to send a heartbeat\n// frame if it's not sent any frames for a while, so that the server\n// doesn't think it's dead; the second is to check periodically that\n// it's seen activity from the server, and to advise if there doesn't\n// appear to have been any for over two intervals.\n//\n// Node.JS timers are a bit unreliable, in that they endeavour only to\n// fire at some indeterminate point *after* the given time (rather\n// gives the lie to 'realtime', dunnit). Because the scheduler is just\n// an event loop, it's quite easy to delay timers indefinitely by\n// reacting to some I/O with a lot of computation.\n//\n// To mitigate this I need a bit of creative interpretation:\n//\n//  - I'll schedule a server activity check for every `interval`, and\n//    check just how much time has passed. It will overshoot by at\n//    least a small margin; modulo missing timer deadlines, it'll\n//    notice between two and three intervals after activity actually\n//    stops (otherwise, at some point after two intervals).\n//\n//  - Every `interval / 2` I'll check that we've sent something since\n//    the last check, and if not, send a heartbeat frame. If we're\n//    really too busy to even run the check for two whole heartbeat\n//    intervals, there must be a lot of I (but not O, at least not on\n//    the connection), or computation, in which case perhaps it's best\n//    the server cuts us off anyway. Why `interval / 2`? Because the\n//    edge case is that the client sent a frame just after a\n//    heartbeat, which would mean I only send one after almost two\n//    intervals. (NB a heartbeat counts as a send, so it'll be checked\n//    at least twice before sending another)\n//\n// This design is based largely on RabbitMQ's heartbeating:\n// https://github.com/rabbitmq/rabbitmq-common/blob/master/src/rabbit_heartbeat.erl\n\n// %% Yes, I could apply the same 'actually passage of time' thing to\n// %% send as well as to recv.\n\n'use strict';\n\nvar EventEmitter = require('events');\n\n// Exported so that we can mess with it in tests\nmodule.exports.UNITS_TO_MS = 1000;\n\nclass Heart extends EventEmitter {\n  constructor (interval, checkSend, checkRecv) {\n    super();\n\n    this.interval = interval;\n\n    var intervalMs = interval * module.exports.UNITS_TO_MS;\n    // Function#bind is my new best friend\n    var beat = this.emit.bind(this, 'beat');\n    var timeout = this.emit.bind(this, 'timeout');\n\n    this.sendTimer = setInterval(\n      this.runHeartbeat.bind(this, checkSend, beat), intervalMs / 2);\n\n    // A timeout occurs if I see nothing for *two consecutive* intervals\n    var recvMissed = 0;\n    function missedTwo () {\n      if (!checkRecv())\n        return (++recvMissed < 2);\n      else { recvMissed = 0; return true; }\n    }\n    this.recvTimer = setInterval(\n      this.runHeartbeat.bind(this, missedTwo, timeout), intervalMs);\n  }\n\n  clear () {\n    clearInterval(this.sendTimer);\n    clearInterval(this.recvTimer);\n  }\n\n  runHeartbeat (check, fail) {\n    // Have we seen activity?\n    if (!check())\n      fail();\n  }\n}\n\nmodule.exports.Heart = Heart;\n"],"x_google_ignoreList":[0],"mappings":";;;;CAiDA,IAAI,yBAAuB,QAAQ;CAGnC,OAAO,QAAQ,cAAc;CAE7B,IAAM,QAAN,cAAoB,aAAa;EAC/B,YAAa,UAAU,WAAW,WAAW;GAC3C,MAAM;GAEN,KAAK,WAAW;GAEhB,IAAI,aAAa,WAAW,OAAO,QAAQ;GAE3C,IAAI,OAAO,KAAK,KAAK,KAAK,MAAM,MAAM;GACtC,IAAI,UAAU,KAAK,KAAK,KAAK,MAAM,SAAS;GAE5C,KAAK,YAAY,YACf,KAAK,aAAa,KAAK,MAAM,WAAW,IAAI,GAAG,aAAa,CAAC;GAG/D,IAAI,aAAa;GACjB,SAAS,YAAa;IACpB,IAAI,CAAC,UAAU,GACb,OAAQ,EAAE,aAAa;SACpB;KAAE,aAAa;KAAG,OAAO;IAAM;GACtC;GACA,KAAK,YAAY,YACf,KAAK,aAAa,KAAK,MAAM,WAAW,OAAO,GAAG,UAAU;EAChE;EAEA,QAAS;GACP,cAAc,KAAK,SAAS;GAC5B,cAAc,KAAK,SAAS;EAC9B;EAEA,aAAc,OAAO,MAAM;GAEzB,IAAI,CAAC,MAAM,GACT,KAAK;EACT;CACF;CAEA,OAAO,QAAQ,QAAQ"}

package/esm/node_modules/amqplib/lib/mux.mjs

@@ -0,0 +1,86 @@
+import { __commonJSMin, __require } from "../../../_virtual/_rolldown/runtime.mjs";
+
+//#region ../node_modules/amqplib/lib/mux.js
+var require_mux = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var assert = __require("assert");
+	var schedule = typeof setImmediate === "function" ? setImmediate : process.nextTick;
+	var Mux = class {
+		constructor(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();
+			});
+		}
+		_readIncoming() {
+			if (this.blocked) return;
+			var accepting = true;
+			var out = this.out;
+			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);
+			if (accepting) {
+				assert.equal(0, this.newStreams.length);
+				roundrobin(this.oldStreams);
+			} else {
+				assert(this.newStreams.length > 0, "Expect some new streams to remain");
+				Array.prototype.push.apply(this.oldStreams, this.newStreams);
+				this.newStreams = [];
+			}
+			this.blocked = !accepting;
+		}
+		_scheduleRead() {
+			var self = this;
+			if (!self.scheduledRead) {
+				schedule(function() {
+					self.scheduledRead = false;
+					self._readIncoming();
+				});
+				self.scheduledRead = true;
+			}
+		}
+		pipeFrom(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);
+		}
+		unpipeFrom(readable) {
+			readable.emit("unpipeFrom", this);
+		}
+	};
+	module.exports.Mux = Mux;
+}));
+
+//#endregion
+export default require_mux();
+
+export { require_mux };
+//# sourceMappingURL=mux.mjs.map

package/esm/node_modules/amqplib/lib/mux.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mux.mjs","names":[],"sources":["../../../../../../../../../node_modules/amqplib/lib/mux.js"],"sourcesContent":["//\n//\n//\n\n'use strict';\n\n// A Mux is an object into which other readable streams may be piped;\n// it then writes 'packets' from the upstreams to the given\n// downstream.\n\nvar assert = require('assert');\n\nvar schedule = (typeof setImmediate === 'function') ?\n  setImmediate : process.nextTick;\n\nclass Mux {\n  constructor (downstream) {\n    this.newStreams = [];\n    this.oldStreams = [];\n    this.blocked = false;\n    this.scheduledRead = false;\n\n    this.out = downstream;\n    var self = this;\n    downstream.on('drain', function () {\n      self.blocked = false;\n      self._readIncoming();\n    });\n  }\n\n  // There are 2 states we can be in:\n  // - waiting for outbound capacity, which will be signalled by a\n  // - 'drain' event on the downstream; or,\n  // - no packets to send, waiting for an inbound buffer to have\n  //   packets, which will be signalled by a 'readable' event\n  // If we write all packets available whenever there is outbound\n  // capacity, we will either run out of outbound capacity (`#write`\n  // returns false), or run out of packets (all calls to an\n  // `inbound.read()` have returned null).\n  _readIncoming () {\n\n    // We may be sent here speculatively, if an incoming stream has\n    // become readable\n    if (this.blocked) return;\n\n    var accepting = true;\n    var out = this.out;\n\n    // Try to read a chunk from each stream in turn, until all streams\n    // are empty, or we exhaust our ability to accept chunks.\n    function roundrobin (streams) {\n      var s;\n      while (accepting && (s = streams.shift())) {\n        var chunk = s.read();\n        if (chunk !== null) {\n          accepting = out.write(chunk);\n          streams.push(s);\n        }\n      }\n    }\n\n    roundrobin(this.newStreams);\n\n    // Either we exhausted the new queues, or we ran out of capacity. If\n    // we ran out of capacity, all the remaining new streams (i.e.,\n    // those with packets left) become old streams. This effectively\n    // prioritises streams that keep their buffers close to empty over\n    // those that are constantly near full.\n    if (accepting) { // all new queues are exhausted, write as many as\n      // we can from the old streams\n      assert.equal(0, this.newStreams.length);\n      roundrobin(this.oldStreams);\n    }\n    else { // ran out of room\n      assert(this.newStreams.length > 0, \"Expect some new streams to remain\");\n      Array.prototype.push.apply(this.oldStreams, this.newStreams);\n      this.newStreams = [];\n    }\n    // We may have exhausted all the old queues, or run out of room;\n    // either way, all we need to do is record whether we have capacity\n    // or not, so any speculative reads will know\n    this.blocked = !accepting;\n  }\n\n  _scheduleRead () {\n    var self = this;\n\n    if (!self.scheduledRead) {\n      schedule(function () {\n        self.scheduledRead = false;\n        self._readIncoming();\n      });\n      self.scheduledRead = true;\n    }\n  }\n\n  pipeFrom (readable) {\n    var self = this;\n\n    function enqueue () {\n      self.newStreams.push(readable);\n      self._scheduleRead();\n    }\n\n    function cleanup () {\n      readable.removeListener('readable', enqueue);\n      readable.removeListener('error', cleanup);\n      readable.removeListener('end', cleanup);\n      readable.removeListener('unpipeFrom', cleanupIfMe);\n    }\n    function cleanupIfMe (dest) {\n      if (dest === self) cleanup();\n    }\n\n    readable.on('unpipeFrom', cleanupIfMe);\n    readable.on('end', cleanup);\n    readable.on('error', cleanup);\n    readable.on('readable', enqueue);\n  }\n\n  unpipeFrom (readable) {\n    readable.emit('unpipeFrom', this);\n  }\n}\n\nmodule.exports.Mux = Mux;\n"],"x_google_ignoreList":[0],"mappings":";;;;CAUA,IAAI,mBAAiB,QAAQ;CAE7B,IAAI,WAAY,OAAO,iBAAiB,aACtC,eAAe,QAAQ;CAEzB,IAAM,MAAN,MAAU;EACR,YAAa,YAAY;GACvB,KAAK,aAAa,CAAC;GACnB,KAAK,aAAa,CAAC;GACnB,KAAK,UAAU;GACf,KAAK,gBAAgB;GAErB,KAAK,MAAM;GACX,IAAI,OAAO;GACX,WAAW,GAAG,SAAS,WAAY;IACjC,KAAK,UAAU;IACf,KAAK,cAAc;GACrB,CAAC;EACH;EAWA,gBAAiB;GAIf,IAAI,KAAK,SAAS;GAElB,IAAI,YAAY;GAChB,IAAI,MAAM,KAAK;GAIf,SAAS,WAAY,SAAS;IAC5B,IAAI;IACJ,OAAO,cAAc,IAAI,QAAQ,MAAM,IAAI;KACzC,IAAI,QAAQ,EAAE,KAAK;KACnB,IAAI,UAAU,MAAM;MAClB,YAAY,IAAI,MAAM,KAAK;MAC3B,QAAQ,KAAK,CAAC;KAChB;IACF;GACF;GAEA,WAAW,KAAK,UAAU;GAO1B,IAAI,WAAW;IAEb,OAAO,MAAM,GAAG,KAAK,WAAW,MAAM;IACtC,WAAW,KAAK,UAAU;GAC5B,OACK;IACH,OAAO,KAAK,WAAW,SAAS,GAAG,mCAAmC;IACtE,MAAM,UAAU,KAAK,MAAM,KAAK,YAAY,KAAK,UAAU;IAC3D,KAAK,aAAa,CAAC;GACrB;GAIA,KAAK,UAAU,CAAC;EAClB;EAEA,gBAAiB;GACf,IAAI,OAAO;GAEX,IAAI,CAAC,KAAK,eAAe;IACvB,SAAS,WAAY;KACnB,KAAK,gBAAgB;KACrB,KAAK,cAAc;IACrB,CAAC;IACD,KAAK,gBAAgB;GACvB;EACF;EAEA,SAAU,UAAU;GAClB,IAAI,OAAO;GAEX,SAAS,UAAW;IAClB,KAAK,WAAW,KAAK,QAAQ;IAC7B,KAAK,cAAc;GACrB;GAEA,SAAS,UAAW;IAClB,SAAS,eAAe,YAAY,OAAO;IAC3C,SAAS,eAAe,SAAS,OAAO;IACxC,SAAS,eAAe,OAAO,OAAO;IACtC,SAAS,eAAe,cAAc,WAAW;GACnD;GACA,SAAS,YAAa,MAAM;IAC1B,IAAI,SAAS,MAAM,QAAQ;GAC7B;GAEA,SAAS,GAAG,cAAc,WAAW;GACrC,SAAS,GAAG,OAAO,OAAO;GAC1B,SAAS,GAAG,SAAS,OAAO;GAC5B,SAAS,GAAG,YAAY,OAAO;EACjC;EAEA,WAAY,UAAU;GACpB,SAAS,KAAK,cAAc,IAAI;EAClC;CACF;CAEA,OAAO,QAAQ,MAAM"}

package/esm/node_modules/amqplib/package.mjs

@@ -0,0 +1,41 @@
+import { __commonJSMin } from "../../_virtual/_rolldown/runtime.mjs";
+
+//#region ../node_modules/amqplib/package.json
+var require_package = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = {
+		"name": "amqplib",
+		"homepage": "http://amqp-node.github.io/amqplib/",
+		"main": "./channel_api.js",
+		"version": "0.10.9",
+		"description": "An AMQP 0-9-1 (e.g., RabbitMQ) library and client.",
+		"repository": {
+			"type": "git",
+			"url": "git+https://github.com/amqp-node/amqplib.git"
+		},
+		"engines": { "node": ">=10" },
+		"dependencies": {
+			"buffer-more-ints": "~1.0.0",
+			"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" },
+		"keywords": [
+			"AMQP",
+			"AMQP 0-9-1",
+			"RabbitMQ"
+		],
+		"author": "Michael Bridgen <mikeb@squaremobius.net>",
+		"license": "MIT"
+	};
+}));
+
+//#endregion
+export default require_package();
+
+export { require_package };
+//# sourceMappingURL=package.mjs.map

package/esm/node_modules/amqplib/package.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"package.mjs","names":[],"sources":["../../../../../../../../node_modules/amqplib/package.json"],"sourcesContent":[""],"x_google_ignoreList":[0],"mappings":""}