@warlock.js/notifications 4.16.0 → 5.0.1

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

@@ -0,0 +1,206 @@
+import { __commonJSMin, __require } from "../../../_virtual/_rolldown/runtime.mjs";
+import { require_defs } from "./defs.mjs";
+import { require_format } from "./format.mjs";
+import { require_channel } from "./channel.mjs";
+import { require_api_args } from "./api_args.mjs";
+
+//#region ../node_modules/amqplib/lib/channel_model.js
+var require_channel_model = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const EventEmitter = __require("events");
+	const promisify = __require("util").promisify;
+	const defs = require_defs();
+	const { BaseChannel } = require_channel();
+	const { acceptMessage } = require_channel();
+	const Args = require_api_args();
+	const { inspect } = require_format();
+	var ChannelModel = class extends EventEmitter {
+		constructor(connection) {
+			super();
+			this.connection = connection;
+			[
+				"error",
+				"close",
+				"blocked",
+				"unblocked"
+			].forEach((ev) => {
+				connection.on(ev, this.emit.bind(this, ev));
+			});
+		}
+		close() {
+			return promisify(this.connection.close.bind(this.connection))();
+		}
+		updateSecret(newSecret, reason) {
+			return promisify(this.connection._updateSecret.bind(this.connection))(newSecret, reason);
+		}
+		async createChannel(options) {
+			const channel = new Channel(this.connection);
+			channel.setOptions(options);
+			await channel.open();
+			return channel;
+		}
+		async createConfirmChannel(options) {
+			const channel = new ConfirmChannel(this.connection);
+			channel.setOptions(options);
+			await channel.open();
+			await channel.rpc(defs.ConfirmSelect, { nowait: false }, defs.ConfirmSelectOk);
+			return channel;
+		}
+	};
+	var Channel = class extends BaseChannel {
+		constructor(connection) {
+			super(connection);
+			this.on("delivery", this.handleDelivery.bind(this));
+			this.on("cancel", this.handleCancel.bind(this));
+		}
+		async rpc(method, fields, expect) {
+			return (await promisify((cb) => {
+				return this._rpc(method, fields, expect, cb);
+			})()).fields;
+		}
+		async open() {
+			return (await this.allocate.bind(this)()).rpc(defs.ChannelOpen, { outOfBand: "" }, defs.ChannelOpenOk);
+		}
+		close() {
+			return promisify((cb) => {
+				return this.closeBecause("Goodbye", defs.constants.REPLY_SUCCESS, cb);
+			})();
+		}
+		assertQueue(queue, options) {
+			return this.rpc(defs.QueueDeclare, Args.assertQueue(queue, options), defs.QueueDeclareOk);
+		}
+		checkQueue(queue) {
+			return this.rpc(defs.QueueDeclare, Args.checkQueue(queue), defs.QueueDeclareOk);
+		}
+		deleteQueue(queue, options) {
+			return this.rpc(defs.QueueDelete, Args.deleteQueue(queue, options), defs.QueueDeleteOk);
+		}
+		purgeQueue(queue) {
+			return this.rpc(defs.QueuePurge, Args.purgeQueue(queue), defs.QueuePurgeOk);
+		}
+		bindQueue(queue, source, pattern, argt) {
+			return this.rpc(defs.QueueBind, Args.bindQueue(queue, source, pattern, argt), defs.QueueBindOk);
+		}
+		unbindQueue(queue, source, pattern, argt) {
+			return this.rpc(defs.QueueUnbind, Args.unbindQueue(queue, source, pattern, argt), defs.QueueUnbindOk);
+		}
+		assertExchange(exchange, type, options) {
+			return this.rpc(defs.ExchangeDeclare, Args.assertExchange(exchange, type, options), defs.ExchangeDeclareOk).then((_ok) => {
+				return { exchange };
+			});
+		}
+		checkExchange(exchange) {
+			return this.rpc(defs.ExchangeDeclare, Args.checkExchange(exchange), defs.ExchangeDeclareOk);
+		}
+		deleteExchange(name, options) {
+			return this.rpc(defs.ExchangeDelete, Args.deleteExchange(name, options), defs.ExchangeDeleteOk);
+		}
+		bindExchange(dest, source, pattern, argt) {
+			return this.rpc(defs.ExchangeBind, Args.bindExchange(dest, source, pattern, argt), defs.ExchangeBindOk);
+		}
+		unbindExchange(dest, source, pattern, argt) {
+			return this.rpc(defs.ExchangeUnbind, Args.unbindExchange(dest, source, pattern, argt), defs.ExchangeUnbindOk);
+		}
+		publish(exchange, routingKey, content, options) {
+			const fieldsAndProps = Args.publish(exchange, routingKey, options);
+			return this.sendMessage(fieldsAndProps, fieldsAndProps, content);
+		}
+		sendToQueue(queue, content, options) {
+			return this.publish("", queue, content, options);
+		}
+		consume(queue, callback, options) {
+			const fields = Args.consume(queue, options);
+			return new Promise((resolve, reject) => {
+				this._rpc(defs.BasicConsume, fields, defs.BasicConsumeOk, (err, ok) => {
+					if (err) return reject(err);
+					this.registerConsumer(ok.fields.consumerTag, callback);
+					resolve(ok.fields);
+				});
+			});
+		}
+		async cancel(consumerTag) {
+			await promisify((cb) => {
+				this._rpc(defs.BasicCancel, Args.cancel(consumerTag), defs.BasicCancelOk, cb);
+			})().then((ok) => {
+				this.unregisterConsumer(consumerTag);
+				return ok.fields;
+			});
+		}
+		get(queue, options) {
+			const fields = Args.get(queue, options);
+			return new Promise((resolve, reject) => {
+				this.sendOrEnqueue(defs.BasicGet, fields, (err, f) => {
+					if (err) return reject(err);
+					if (f.id === defs.BasicGetEmpty) return resolve(false);
+					else if (f.id === defs.BasicGetOk) {
+						const fields = f.fields;
+						this.handleMessage = acceptMessage((m) => {
+							m.fields = fields;
+							resolve(m);
+						});
+					} else reject(/* @__PURE__ */ new Error(`Unexpected response to BasicGet: ${inspect(f)}`));
+				});
+			});
+		}
+		ack(message, allUpTo) {
+			this.sendImmediately(defs.BasicAck, Args.ack(message.fields.deliveryTag, allUpTo));
+		}
+		ackAll() {
+			this.sendImmediately(defs.BasicAck, Args.ack(0, true));
+		}
+		nack(message, allUpTo, requeue) {
+			this.sendImmediately(defs.BasicNack, Args.nack(message.fields.deliveryTag, allUpTo, requeue));
+		}
+		nackAll(requeue) {
+			this.sendImmediately(defs.BasicNack, Args.nack(0, true, requeue));
+		}
+		reject(message, requeue) {
+			this.sendImmediately(defs.BasicReject, Args.reject(message.fields.deliveryTag, requeue));
+		}
+		recover() {
+			return this.rpc(defs.BasicRecover, Args.recover(), defs.BasicRecoverOk);
+		}
+		qos(count, global) {
+			return this.rpc(defs.BasicQos, Args.prefetch(count, global), defs.BasicQosOk);
+		}
+	};
+	Channel.prototype.prefetch = Channel.prototype.qos;
+	var ConfirmChannel = class extends Channel {
+		publish(exchange, routingKey, content, options, cb) {
+			this.pushConfirmCallback(cb);
+			return super.publish(exchange, routingKey, content, options);
+		}
+		sendToQueue(queue, content, options, cb) {
+			return this.publish("", queue, content, options, cb);
+		}
+		waitForConfirms() {
+			const awaiting = [];
+			const unconfirmed = this.unconfirmed;
+			unconfirmed.forEach((val, index) => {
+				if (val !== null) {
+					const confirmed = new Promise((resolve, reject) => {
+						unconfirmed[index] = (err) => {
+							if (val) val(err);
+							if (err === null) resolve();
+							else reject(err);
+						};
+					});
+					awaiting.push(confirmed);
+				}
+			});
+			if (!this.pending) {
+				var cb;
+				while (cb = this.unconfirmed.shift()) if (cb) cb(/* @__PURE__ */ new Error("channel closed"));
+			}
+			return Promise.all(awaiting);
+		}
+	};
+	module.exports.ConfirmChannel = ConfirmChannel;
+	module.exports.Channel = Channel;
+	module.exports.ChannelModel = ChannelModel;
+}));
+
+//#endregion
+export default require_channel_model();
+
+export { require_channel_model };
+//# sourceMappingURL=channel_model.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"channel_model.mjs","names":[],"sources":["../../../../../../../../../node_modules/amqplib/lib/channel_model.js"],"sourcesContent":["//\n//\n//\n\n'use strict';\n\nconst EventEmitter = require('events');\nconst promisify = require('util').promisify;\nconst defs = require('./defs');\nconst {BaseChannel} = require('./channel');\nconst {acceptMessage} = require('./channel');\nconst Args = require('./api_args');\nconst {inspect} = require('./format');\n\nclass ChannelModel extends EventEmitter {\n  constructor(connection) {\n    super();\n    this.connection = connection;\n\n    ['error', 'close', 'blocked', 'unblocked'].forEach(ev => {\n      connection.on(ev, this.emit.bind(this, ev));\n    });\n  }\n\n  close() {\n    return promisify(this.connection.close.bind(this.connection))();\n  }\n\n  updateSecret(newSecret, reason) {\n    return promisify(this.connection._updateSecret.bind(this.connection))(newSecret, reason);\n  }\n\n  async createChannel(options) {\n    const channel = new Channel(this.connection);\n    channel.setOptions(options);\n    await channel.open();\n    return channel;\n  }\n\n  async createConfirmChannel(options) {\n    const channel = new ConfirmChannel(this.connection);\n    channel.setOptions(options);\n    await channel.open();\n    await channel.rpc(defs.ConfirmSelect, {nowait: false}, defs.ConfirmSelectOk);\n    return channel;\n  }\n}\n\n// Channels\n\nclass Channel extends BaseChannel {\n  constructor(connection) {\n    super(connection);\n    this.on('delivery', this.handleDelivery.bind(this));\n    this.on('cancel', this.handleCancel.bind(this));\n  }\n\n  // An RPC that returns a 'proper' promise, which resolves to just the\n  // response's fields; this is intended to be suitable for implementing\n  // API procedures.\n  async rpc(method, fields, expect) {\n    const f = await promisify(cb => {\n      return this._rpc(method, fields, expect, cb);\n    })();\n\n    return f.fields;\n  }\n\n  // Do the remarkably simple channel open handshake\n  async open() {\n    const ch = await this.allocate.bind(this)();\n    return ch.rpc(defs.ChannelOpen, {outOfBand: \"\"},\n                  defs.ChannelOpenOk);\n  }\n\n  close() {\n    return promisify(cb => {\n      return this.closeBecause(\"Goodbye\", defs.constants.REPLY_SUCCESS,\n                      cb);\n    })();\n  }\n\n  // === Public API, declaring queues and stuff ===\n\n  assertQueue(queue, options) {\n    return this.rpc(defs.QueueDeclare,\n                    Args.assertQueue(queue, options),\n                    defs.QueueDeclareOk);\n  }\n\n  checkQueue(queue) {\n    return this.rpc(defs.QueueDeclare,\n                    Args.checkQueue(queue),\n                    defs.QueueDeclareOk);\n  }\n\n  deleteQueue(queue, options) {\n    return this.rpc(defs.QueueDelete,\n                    Args.deleteQueue(queue, options),\n                    defs.QueueDeleteOk);\n  }\n\n  purgeQueue(queue) {\n    return this.rpc(defs.QueuePurge,\n                    Args.purgeQueue(queue),\n                    defs.QueuePurgeOk);\n  }\n\n  bindQueue(queue, source, pattern, argt) {\n    return this.rpc(defs.QueueBind,\n                    Args.bindQueue(queue, source, pattern, argt),\n                    defs.QueueBindOk);\n  }\n\n  unbindQueue(queue, source, pattern, argt) {\n    return this.rpc(defs.QueueUnbind,\n                    Args.unbindQueue(queue, source, pattern, argt),\n                    defs.QueueUnbindOk);\n  }\n\n  assertExchange(exchange, type, options) {\n    // The server reply is an empty set of fields, but it's convenient\n    // to have the exchange name handed to the continuation.\n    return this.rpc(defs.ExchangeDeclare,\n                    Args.assertExchange(exchange, type, options),\n                    defs.ExchangeDeclareOk)\n      .then(_ok => { return { exchange }; });\n  }\n\n  checkExchange(exchange) {\n    return this.rpc(defs.ExchangeDeclare,\n                    Args.checkExchange(exchange),\n                    defs.ExchangeDeclareOk);\n  }\n\n  deleteExchange(name, options) {\n    return this.rpc(defs.ExchangeDelete,\n                    Args.deleteExchange(name, options),\n                    defs.ExchangeDeleteOk);\n  }\n\n  bindExchange(dest, source, pattern, argt) {\n    return this.rpc(defs.ExchangeBind,\n                    Args.bindExchange(dest, source, pattern, argt),\n                    defs.ExchangeBindOk);\n  }\n\n  unbindExchange(dest, source, pattern, argt) {\n    return this.rpc(defs.ExchangeUnbind,\n                    Args.unbindExchange(dest, source, pattern, argt),\n                    defs.ExchangeUnbindOk);\n  }\n\n  // Working with messages\n\n  publish(exchange, routingKey, content, options) {\n    const fieldsAndProps = Args.publish(exchange, routingKey, options);\n    return this.sendMessage(fieldsAndProps, fieldsAndProps, content);\n  }\n\n  sendToQueue(queue, content, options) {\n    return this.publish('', queue, content, options);\n  }\n\n  consume(queue, callback, options) {\n    // NB we want the callback to be run synchronously, so that we've\n    // registered the consumerTag before any messages can arrive.\n    const fields = Args.consume(queue, options);\n    return new Promise((resolve, reject) => {\n      this._rpc(defs.BasicConsume, fields, defs.BasicConsumeOk, (err, ok) => {\n        if (err) return reject(err);\n        this.registerConsumer(ok.fields.consumerTag, callback);\n        resolve(ok.fields);\n      });\n    });\n  }\n\n  async cancel(consumerTag) {\n    const ok = await promisify(cb => {\n      this._rpc(defs.BasicCancel, Args.cancel(consumerTag),\n            defs.BasicCancelOk,\n            cb);\n    })()\n    .then(ok => {\n      this.unregisterConsumer(consumerTag);\n      return ok.fields;\n    });\n  }\n\n  get(queue, options) {\n    const fields = Args.get(queue, options);\n    return new Promise((resolve, reject) => {\n      this.sendOrEnqueue(defs.BasicGet, fields, (err, f) => {\n        if (err) return reject(err);\n        if (f.id === defs.BasicGetEmpty) {\n          return resolve(false);\n        }\n        else if (f.id === defs.BasicGetOk) {\n          const fields = f.fields;\n          this.handleMessage = acceptMessage(m => {\n            m.fields = fields;\n            resolve(m);\n          });\n        }\n        else {\n          reject(new Error(`Unexpected response to BasicGet: ${inspect(f)}`));\n        }\n      });\n    });\n  }\n\n  ack(message, allUpTo) {\n    this.sendImmediately(\n      defs.BasicAck,\n      Args.ack(message.fields.deliveryTag, allUpTo));\n  }\n\n  ackAll() {\n    this.sendImmediately(defs.BasicAck, Args.ack(0, true));\n  }\n\n  nack(message, allUpTo, requeue) {\n    this.sendImmediately(\n      defs.BasicNack,\n      Args.nack(message.fields.deliveryTag, allUpTo, requeue));\n  }\n\n  nackAll(requeue) {\n    this.sendImmediately(defs.BasicNack,\n                         Args.nack(0, true, requeue));\n  }\n\n  // `Basic.Nack` is not available in older RabbitMQ versions (or in the\n  // AMQP specification), so you have to use the one-at-a-time\n  // `Basic.Reject`. This is otherwise synonymous with\n  // `#nack(message, false, requeue)`.\n  reject(message, requeue) {\n    this.sendImmediately(\n      defs.BasicReject,\n      Args.reject(message.fields.deliveryTag, requeue));\n  }\n\n  recover() {\n    return this.rpc(defs.BasicRecover,\n                    Args.recover(),\n                    defs.BasicRecoverOk);\n  }\n\n  qos(count, global) {\n    return this.rpc(defs.BasicQos,\n                    Args.prefetch(count, global),\n                    defs.BasicQosOk);\n  }\n}\n\n// There are more options in AMQP than exposed here; RabbitMQ only\n// implements prefetch based on message count, and only for individual\n// channels or consumers. RabbitMQ v3.3.0 and after treat prefetch\n// (without `global` set) as per-consumer (for consumers following),\n// and prefetch with `global` set as per-channel.\nChannel.prototype.prefetch = Channel.prototype.qos\n\n// Confirm channel. This is a channel with confirms 'switched on',\n// meaning sent messages will provoke a responding 'ack' or 'nack'\n// from the server. The upshot of this is that `publish` and\n// `sendToQueue` both take a callback, which will be called either\n// with `null` as its argument to signify 'ack', or an exception as\n// its argument to signify 'nack'.\n\nclass ConfirmChannel extends Channel {\n  publish(exchange, routingKey, content, options, cb) {\n    this.pushConfirmCallback(cb);\n    return super.publish(exchange, routingKey, content, options);\n  }\n\n  sendToQueue(queue, content, options, cb) {\n    return this.publish('', queue, content, options, cb);\n  }\n\n  waitForConfirms() {\n    const awaiting = [];\n    const unconfirmed = this.unconfirmed;\n    unconfirmed.forEach((val, index) => {\n      if (val !== null) {\n        const confirmed = new Promise((resolve, reject) => {\n          unconfirmed[index] = err => {\n            if (val) val(err);\n            if (err === null) resolve();\n            else reject(err);\n          };\n        });\n        awaiting.push(confirmed);\n      }\n    });\n    // Channel closed\n    if (!this.pending) {\n      var cb;\n      while (cb = this.unconfirmed.shift()) {\n        if (cb) cb(new Error('channel closed'));\n      }\n    }\n    return Promise.all(awaiting);\n  }\n}\n\nmodule.exports.ConfirmChannel = ConfirmChannel;\nmodule.exports.Channel = Channel;\nmodule.exports.ChannelModel = ChannelModel;\n"],"x_google_ignoreList":[0],"mappings":";;;;;;;;CAMA,MAAM,yBAAuB,QAAQ;CACrC,MAAM,sBAAoB,MAAM,CAAC,CAAC;CAClC,MAAM;CACN,MAAM,EAAC;CACP,MAAM,EAAC;CACP,MAAM;CACN,MAAM,EAAC;CAEP,IAAM,eAAN,cAA2B,aAAa;EACtC,YAAY,YAAY;GACtB,MAAM;GACN,KAAK,aAAa;GAElB;IAAC;IAAS;IAAS;IAAW;GAAW,CAAC,CAAC,SAAQ,OAAM;IACvD,WAAW,GAAG,IAAI,KAAK,KAAK,KAAK,MAAM,EAAE,CAAC;GAC5C,CAAC;EACH;EAEA,QAAQ;GACN,OAAO,UAAU,KAAK,WAAW,MAAM,KAAK,KAAK,UAAU,CAAC,CAAC,CAAC;EAChE;EAEA,aAAa,WAAW,QAAQ;GAC9B,OAAO,UAAU,KAAK,WAAW,cAAc,KAAK,KAAK,UAAU,CAAC,CAAC,CAAC,WAAW,MAAM;EACzF;EAEA,MAAM,cAAc,SAAS;GAC3B,MAAM,UAAU,IAAI,QAAQ,KAAK,UAAU;GAC3C,QAAQ,WAAW,OAAO;GAC1B,MAAM,QAAQ,KAAK;GACnB,OAAO;EACT;EAEA,MAAM,qBAAqB,SAAS;GAClC,MAAM,UAAU,IAAI,eAAe,KAAK,UAAU;GAClD,QAAQ,WAAW,OAAO;GAC1B,MAAM,QAAQ,KAAK;GACnB,MAAM,QAAQ,IAAI,KAAK,eAAe,EAAC,QAAQ,MAAK,GAAG,KAAK,eAAe;GAC3E,OAAO;EACT;CACF;CAIA,IAAM,UAAN,cAAsB,YAAY;EAChC,YAAY,YAAY;GACtB,MAAM,UAAU;GAChB,KAAK,GAAG,YAAY,KAAK,eAAe,KAAK,IAAI,CAAC;GAClD,KAAK,GAAG,UAAU,KAAK,aAAa,KAAK,IAAI,CAAC;EAChD;EAKA,MAAM,IAAI,QAAQ,QAAQ,QAAQ;GAKhC,QAAO,MAJS,WAAU,OAAM;IAC9B,OAAO,KAAK,KAAK,QAAQ,QAAQ,QAAQ,EAAE;GAC7C,CAAC,CAAC,CAAC,EAEK,CAAC;EACX;EAGA,MAAM,OAAO;GAEX,QAAO,MADU,KAAK,SAAS,KAAK,IAAI,CAAC,CAAC,EACjC,CAAC,IAAI,KAAK,aAAa,EAAC,WAAW,GAAE,GAChC,KAAK,aAAa;EAClC;EAEA,QAAQ;GACN,OAAO,WAAU,OAAM;IACrB,OAAO,KAAK,aAAa,WAAW,KAAK,UAAU,eACnC,EAAE;GACpB,CAAC,CAAC,CAAC;EACL;EAIA,YAAY,OAAO,SAAS;GAC1B,OAAO,KAAK,IAAI,KAAK,cACL,KAAK,YAAY,OAAO,OAAO,GAC/B,KAAK,cAAc;EACrC;EAEA,WAAW,OAAO;GAChB,OAAO,KAAK,IAAI,KAAK,cACL,KAAK,WAAW,KAAK,GACrB,KAAK,cAAc;EACrC;EAEA,YAAY,OAAO,SAAS;GAC1B,OAAO,KAAK,IAAI,KAAK,aACL,KAAK,YAAY,OAAO,OAAO,GAC/B,KAAK,aAAa;EACpC;EAEA,WAAW,OAAO;GAChB,OAAO,KAAK,IAAI,KAAK,YACL,KAAK,WAAW,KAAK,GACrB,KAAK,YAAY;EACnC;EAEA,UAAU,OAAO,QAAQ,SAAS,MAAM;GACtC,OAAO,KAAK,IAAI,KAAK,WACL,KAAK,UAAU,OAAO,QAAQ,SAAS,IAAI,GAC3C,KAAK,WAAW;EAClC;EAEA,YAAY,OAAO,QAAQ,SAAS,MAAM;GACxC,OAAO,KAAK,IAAI,KAAK,aACL,KAAK,YAAY,OAAO,QAAQ,SAAS,IAAI,GAC7C,KAAK,aAAa;EACpC;EAEA,eAAe,UAAU,MAAM,SAAS;GAGtC,OAAO,KAAK,IAAI,KAAK,iBACL,KAAK,eAAe,UAAU,MAAM,OAAO,GAC3C,KAAK,iBAAiB,CAAC,CACpC,MAAK,QAAO;IAAE,OAAO,EAAE,SAAS;GAAG,CAAC;EACzC;EAEA,cAAc,UAAU;GACtB,OAAO,KAAK,IAAI,KAAK,iBACL,KAAK,cAAc,QAAQ,GAC3B,KAAK,iBAAiB;EACxC;EAEA,eAAe,MAAM,SAAS;GAC5B,OAAO,KAAK,IAAI,KAAK,gBACL,KAAK,eAAe,MAAM,OAAO,GACjC,KAAK,gBAAgB;EACvC;EAEA,aAAa,MAAM,QAAQ,SAAS,MAAM;GACxC,OAAO,KAAK,IAAI,KAAK,cACL,KAAK,aAAa,MAAM,QAAQ,SAAS,IAAI,GAC7C,KAAK,cAAc;EACrC;EAEA,eAAe,MAAM,QAAQ,SAAS,MAAM;GAC1C,OAAO,KAAK,IAAI,KAAK,gBACL,KAAK,eAAe,MAAM,QAAQ,SAAS,IAAI,GAC/C,KAAK,gBAAgB;EACvC;EAIA,QAAQ,UAAU,YAAY,SAAS,SAAS;GAC9C,MAAM,iBAAiB,KAAK,QAAQ,UAAU,YAAY,OAAO;GACjE,OAAO,KAAK,YAAY,gBAAgB,gBAAgB,OAAO;EACjE;EAEA,YAAY,OAAO,SAAS,SAAS;GACnC,OAAO,KAAK,QAAQ,IAAI,OAAO,SAAS,OAAO;EACjD;EAEA,QAAQ,OAAO,UAAU,SAAS;GAGhC,MAAM,SAAS,KAAK,QAAQ,OAAO,OAAO;GAC1C,OAAO,IAAI,SAAS,SAAS,WAAW;IACtC,KAAK,KAAK,KAAK,cAAc,QAAQ,KAAK,iBAAiB,KAAK,OAAO;KACrE,IAAI,KAAK,OAAO,OAAO,GAAG;KAC1B,KAAK,iBAAiB,GAAG,OAAO,aAAa,QAAQ;KACrD,QAAQ,GAAG,MAAM;IACnB,CAAC;GACH,CAAC;EACH;EAEA,MAAM,OAAO,aAAa;GACb,MAAM,WAAU,OAAM;IAC/B,KAAK,KAAK,KAAK,aAAa,KAAK,OAAO,WAAW,GAC7C,KAAK,eACL,EAAE;GACV,CAAC,CAAC,CAAC,CAAC,CACH,MAAK,OAAM;IACV,KAAK,mBAAmB,WAAW;IACnC,OAAO,GAAG;GACZ,CAAC;EACH;EAEA,IAAI,OAAO,SAAS;GAClB,MAAM,SAAS,KAAK,IAAI,OAAO,OAAO;GACtC,OAAO,IAAI,SAAS,SAAS,WAAW;IACtC,KAAK,cAAc,KAAK,UAAU,SAAS,KAAK,MAAM;KACpD,IAAI,KAAK,OAAO,OAAO,GAAG;KAC1B,IAAI,EAAE,OAAO,KAAK,eAChB,OAAO,QAAQ,KAAK;UAEjB,IAAI,EAAE,OAAO,KAAK,YAAY;MACjC,MAAM,SAAS,EAAE;MACjB,KAAK,gBAAgB,eAAc,MAAK;OACtC,EAAE,SAAS;OACX,QAAQ,CAAC;MACX,CAAC;KACH,OAEE,uBAAO,IAAI,MAAM,oCAAoC,QAAQ,CAAC,GAAG,CAAC;IAEtE,CAAC;GACH,CAAC;EACH;EAEA,IAAI,SAAS,SAAS;GACpB,KAAK,gBACH,KAAK,UACL,KAAK,IAAI,QAAQ,OAAO,aAAa,OAAO,CAAC;EACjD;EAEA,SAAS;GACP,KAAK,gBAAgB,KAAK,UAAU,KAAK,IAAI,GAAG,IAAI,CAAC;EACvD;EAEA,KAAK,SAAS,SAAS,SAAS;GAC9B,KAAK,gBACH,KAAK,WACL,KAAK,KAAK,QAAQ,OAAO,aAAa,SAAS,OAAO,CAAC;EAC3D;EAEA,QAAQ,SAAS;GACf,KAAK,gBAAgB,KAAK,WACL,KAAK,KAAK,GAAG,MAAM,OAAO,CAAC;EAClD;EAMA,OAAO,SAAS,SAAS;GACvB,KAAK,gBACH,KAAK,aACL,KAAK,OAAO,QAAQ,OAAO,aAAa,OAAO,CAAC;EACpD;EAEA,UAAU;GACR,OAAO,KAAK,IAAI,KAAK,cACL,KAAK,QAAQ,GACb,KAAK,cAAc;EACrC;EAEA,IAAI,OAAO,QAAQ;GACjB,OAAO,KAAK,IAAI,KAAK,UACL,KAAK,SAAS,OAAO,MAAM,GAC3B,KAAK,UAAU;EACjC;CACF;CAOA,QAAQ,UAAU,WAAW,QAAQ,UAAU;CAS/C,IAAM,iBAAN,cAA6B,QAAQ;EACnC,QAAQ,UAAU,YAAY,SAAS,SAAS,IAAI;GAClD,KAAK,oBAAoB,EAAE;GAC3B,OAAO,MAAM,QAAQ,UAAU,YAAY,SAAS,OAAO;EAC7D;EAEA,YAAY,OAAO,SAAS,SAAS,IAAI;GACvC,OAAO,KAAK,QAAQ,IAAI,OAAO,SAAS,SAAS,EAAE;EACrD;EAEA,kBAAkB;GAChB,MAAM,WAAW,CAAC;GAClB,MAAM,cAAc,KAAK;GACzB,YAAY,SAAS,KAAK,UAAU;IAClC,IAAI,QAAQ,MAAM;KAChB,MAAM,YAAY,IAAI,SAAS,SAAS,WAAW;MACjD,YAAY,UAAS,QAAO;OAC1B,IAAI,KAAK,IAAI,GAAG;OAChB,IAAI,QAAQ,MAAM,QAAQ;YACrB,OAAO,GAAG;MACjB;KACF,CAAC;KACD,SAAS,KAAK,SAAS;IACzB;GACF,CAAC;GAED,IAAI,CAAC,KAAK,SAAS;IACjB,IAAI;IACJ,OAAO,KAAK,KAAK,YAAY,MAAM,GACjC,IAAI,IAAI,mBAAG,IAAI,MAAM,gBAAgB,CAAC;GAE1C;GACA,OAAO,QAAQ,IAAI,QAAQ;EAC7B;CACF;CAEA,OAAO,QAAQ,iBAAiB;CAChC,OAAO,QAAQ,UAAU;CACzB,OAAO,QAAQ,eAAe"}

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

@@ -0,0 +1,273 @@
+import { __commonJSMin } from "../../../_virtual/_rolldown/runtime.mjs";
+import { require_buffer_more_ints } from "../../buffer-more-ints/buffer-more-ints.mjs";
+
+//#region ../node_modules/amqplib/lib/codec.js
+var require_codec = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var ints = require_buffer_more_ints();
+	function isFloatingPoint(n) {
+		return n >= 0x8000000000000000 || Math.abs(n) < 0x4000000000000 && Math.floor(n) !== n;
+	}
+	function encodeTable(buffer, val, offset) {
+		var start = offset;
+		offset += 4;
+		for (var key in val) if (val[key] !== void 0) {
+			var len = Buffer.byteLength(key);
+			buffer.writeUInt8(len, offset);
+			offset++;
+			buffer.write(key, offset, "utf8");
+			offset += len;
+			offset += encodeFieldValue(buffer, val[key], offset);
+		}
+		var size = offset - start;
+		buffer.writeUInt32BE(size - 4, start);
+		return size;
+	}
+	function encodeArray(buffer, val, offset) {
+		var start = offset;
+		offset += 4;
+		for (var i = 0, num = val.length; i < num; i++) offset += encodeFieldValue(buffer, val[i], offset);
+		var size = offset - start;
+		buffer.writeUInt32BE(size - 4, start);
+		return size;
+	}
+	function encodeFieldValue(buffer, value, offset) {
+		var start = offset;
+		var type = typeof value, val = value;
+		if (value && type === "object" && value.hasOwnProperty("!")) {
+			val = value.value;
+			type = value["!"];
+		}
+		if (type == "number") if (isFloatingPoint(val)) type = "double";
+		else if (val < 128 && val >= -128) type = "byte";
+		else if (val >= -32768 && val < 32768) type = "short";
+		else if (val >= -2147483648 && val < 2147483648) type = "int";
+		else type = "long";
+		function tag(t) {
+			buffer.write(t, offset);
+			offset++;
+		}
+		switch (type) {
+			case "string":
+				var len = Buffer.byteLength(val, "utf8");
+				tag("S");
+				buffer.writeUInt32BE(len, offset);
+				offset += 4;
+				buffer.write(val, offset, "utf8");
+				offset += len;
+				break;
+			case "object":
+				if (val === null) tag("V");
+				else if (Array.isArray(val)) {
+					tag("A");
+					offset += encodeArray(buffer, val, offset);
+				} else if (Buffer.isBuffer(val)) {
+					tag("x");
+					buffer.writeUInt32BE(val.length, offset);
+					offset += 4;
+					val.copy(buffer, offset);
+					offset += val.length;
+				} else {
+					tag("F");
+					offset += encodeTable(buffer, val, offset);
+				}
+				break;
+			case "boolean":
+				tag("t");
+				buffer.writeUInt8(val ? 1 : 0, offset);
+				offset++;
+				break;
+			case "double":
+			case "float64":
+				tag("d");
+				buffer.writeDoubleBE(val, offset);
+				offset += 8;
+				break;
+			case "byte":
+			case "int8":
+				tag("b");
+				buffer.writeInt8(val, offset);
+				offset++;
+				break;
+			case "unsignedbyte":
+			case "uint8":
+				tag("B");
+				buffer.writeUInt8(val, offset);
+				offset++;
+				break;
+			case "short":
+			case "int16":
+				tag("s");
+				buffer.writeInt16BE(val, offset);
+				offset += 2;
+				break;
+			case "unsignedshort":
+			case "uint16":
+				tag("u");
+				buffer.writeUInt16BE(val, offset);
+				offset += 2;
+				break;
+			case "int":
+			case "int32":
+				tag("I");
+				buffer.writeInt32BE(val, offset);
+				offset += 4;
+				break;
+			case "unsignedint":
+			case "uint32":
+				tag("i");
+				buffer.writeUInt32BE(val, offset);
+				offset += 4;
+				break;
+			case "long":
+			case "int64":
+				tag("l");
+				ints.writeInt64BE(buffer, val, offset);
+				offset += 8;
+				break;
+			case "timestamp":
+				tag("T");
+				ints.writeUInt64BE(buffer, val, offset);
+				offset += 8;
+				break;
+			case "float":
+				tag("f");
+				buffer.writeFloatBE(val, offset);
+				offset += 4;
+				break;
+			case "decimal":
+				tag("D");
+				if (val.hasOwnProperty("places") && val.hasOwnProperty("digits") && val.places >= 0 && val.places < 256) {
+					buffer[offset] = val.places;
+					offset++;
+					buffer.writeUInt32BE(val.digits, offset);
+					offset += 4;
+				} else throw new TypeError("Decimal value must be {'places': 0..255, 'digits': uint32}, got " + JSON.stringify(val));
+				break;
+			default: throw new TypeError("Unknown type to encode: " + type);
+		}
+		return offset - start;
+	}
+	function decodeFields(slice) {
+		var fields = {}, offset = 0, size = slice.length;
+		var len, key, val;
+		function decodeFieldValue() {
+			var tag = String.fromCharCode(slice[offset]);
+			offset++;
+			switch (tag) {
+				case "b":
+					val = slice.readInt8(offset);
+					offset++;
+					break;
+				case "B":
+					val = slice.readUInt8(offset);
+					offset++;
+					break;
+				case "S":
+					len = slice.readUInt32BE(offset);
+					offset += 4;
+					val = slice.toString("utf8", offset, offset + len);
+					offset += len;
+					break;
+				case "I":
+					val = slice.readInt32BE(offset);
+					offset += 4;
+					break;
+				case "i":
+					val = slice.readUInt32BE(offset);
+					offset += 4;
+					break;
+				case "D":
+					var places = slice[offset];
+					offset++;
+					var digits = slice.readUInt32BE(offset);
+					offset += 4;
+					val = {
+						"!": "decimal",
+						value: {
+							places,
+							digits
+						}
+					};
+					break;
+				case "T":
+					val = ints.readUInt64BE(slice, offset);
+					offset += 8;
+					val = {
+						"!": "timestamp",
+						value: val
+					};
+					break;
+				case "F":
+					len = slice.readUInt32BE(offset);
+					offset += 4;
+					val = decodeFields(slice.subarray(offset, offset + len));
+					offset += len;
+					break;
+				case "A":
+					len = slice.readUInt32BE(offset);
+					offset += 4;
+					decodeArray(offset + len);
+					break;
+				case "d":
+					val = slice.readDoubleBE(offset);
+					offset += 8;
+					break;
+				case "f":
+					val = slice.readFloatBE(offset);
+					offset += 4;
+					break;
+				case "l":
+					val = ints.readInt64BE(slice, offset);
+					offset += 8;
+					break;
+				case "s":
+					val = slice.readInt16BE(offset);
+					offset += 2;
+					break;
+				case "u":
+					val = slice.readUInt16BE(offset);
+					offset += 2;
+					break;
+				case "t":
+					val = slice[offset] != 0;
+					offset++;
+					break;
+				case "V":
+					val = null;
+					break;
+				case "x":
+					len = slice.readUInt32BE(offset);
+					offset += 4;
+					val = slice.subarray(offset, offset + len);
+					offset += len;
+					break;
+				default: throw new TypeError("Unexpected type tag \"" + tag + "\"");
+			}
+		}
+		function decodeArray(until) {
+			var vals = [];
+			while (offset < until) {
+				decodeFieldValue();
+				vals.push(val);
+			}
+			val = vals;
+		}
+		while (offset < size) {
+			len = slice.readUInt8(offset);
+			offset++;
+			key = slice.toString("utf8", offset, offset + len);
+			offset += len;
+			decodeFieldValue();
+			fields[key] = val;
+		}
+		return fields;
+	}
+	module.exports.encodeTable = encodeTable;
+	module.exports.decodeFields = decodeFields;
+}));
+
+//#endregion
+export default require_codec();
+
+export { require_codec };
+//# sourceMappingURL=codec.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"codec.mjs","names":[],"sources":["../../../../../../../../../node_modules/amqplib/lib/codec.js"],"sourcesContent":["//\n//\n//\n\n/*\n\nThe AMQP 0-9-1 is a mess when it comes to the types that can be\nencoded on the wire.\n\nThere are four encoding schemes, and three overlapping sets of types:\nframes, methods, (field-)tables, and properties.\n\nEach *frame type* has a set layout in which values of given types are\nconcatenated along with sections of \"raw binary\" data.\n\nIn frames there are `shortstr`s, that is length-prefixed strings of\nUTF8 chars, 8 bit unsigned integers (called `octet`), unsigned 16 bit\nintegers (called `short` or `short-uint`), unsigned 32 bit integers\n(called `long` or `long-uint`), unsigned 64 bit integers (called\n`longlong` or `longlong-uint`), and flags (called `bit`).\n\nMethods are encoded as a frame giving a method ID and a sequence of\narguments of known types. The encoded method argument values are\nconcatenated (with some fun complications around \"packing\" consecutive\nbit values into bytes).\n\nAlong with the types given in frames, method arguments may be long\nbyte strings (`longstr`, not required to be UTF8) or 64 bit unsigned\nintegers to be interpreted as timestamps (yeah I don't know why\neither), or arbitrary sets of key-value pairs (called `field-table`).\n\nInside a field table the keys are `shortstr` and the values are\nprefixed with a byte tag giving the type. The types are any of the\nabove except for bits (which are replaced by byte-wide `bool`), along\nwith a NULL value `void`, a special fixed-precision number encoding\n(`decimal`), IEEE754 `float`s and `double`s, signed integers,\n`field-array` (a sequence of tagged values), and nested field-tables.\n\nRabbitMQ and QPid use a subset of the field-table types, and different\nvalue tags, established before the AMQP 0-9-1 specification was\npublished. So far as I know, no-one uses the types and tags as\npublished. http://www.rabbitmq.com/amqp-0-9-1-errata.html gives the\nlist of field-table types.\n\nLastly, there are (sets of) properties, only one of which is given in\nAMQP 0-9-1: `BasicProperties`. These are almost the same as methods,\nexcept that they appear in content header frames, which include a\ncontent size, and they carry a set of flags indicating which\nproperties are present. This scheme can save ones of bytes per message\n(messages which take a minimum of three frames each to send).\n\n*/\n\n'use strict';\n\nvar ints = require('buffer-more-ints');\n\n// JavaScript uses only doubles so what I'm testing for is whether\n// it's *better* to encode a number as a float or double. This really\n// just amounts to testing whether there's a fractional part to the\n// number, except that see below. NB I don't use bitwise operations to\n// do this 'efficiently' -- it would mask the number to 32 bits.\n//\n// At 2^50, doubles don't have sufficient precision to distinguish\n// between floating point and integer numbers (`Math.pow(2, 50) + 0.1\n// === Math.pow(2, 50)` (and, above 2^53, doubles cannot represent all\n// integers (`Math.pow(2, 53) + 1 === Math.pow(2, 53)`)). Hence\n// anything with a magnitude at or above 2^50 may as well be encoded\n// as a 64-bit integer. Except that only signed integers are supported\n// by RabbitMQ, so anything above 2^63 - 1 must be a double.\nfunction isFloatingPoint(n) {\n    return n >= 0x8000000000000000 ||\n        (Math.abs(n) < 0x4000000000000\n         && Math.floor(n) !== n);\n}\n\nfunction encodeTable(buffer, val, offset) {\n    var start = offset;\n    offset += 4; // leave room for the table length\n    for (var key in val) {\n        if (val[key] !== undefined) {\n          var len = Buffer.byteLength(key);\n          buffer.writeUInt8(len, offset); offset++;\n          buffer.write(key, offset, 'utf8'); offset += len;\n          offset += encodeFieldValue(buffer, val[key], offset);\n        }\n    }\n    var size = offset - start;\n    buffer.writeUInt32BE(size - 4, start);\n    return size;\n}\n\nfunction encodeArray(buffer, val, offset) {\n    var start = offset;\n    offset += 4;\n    for (var i=0, num=val.length; i < num; i++) {\n        offset += encodeFieldValue(buffer, val[i], offset);\n    }\n    var size = offset - start;\n    buffer.writeUInt32BE(size - 4, start);\n    return size;\n}\n\nfunction encodeFieldValue(buffer, value, offset) {\n    var start = offset;\n    var type = typeof value, val = value;\n    // A trapdoor for specifying a type, e.g., timestamp\n    if (value && type === 'object' && value.hasOwnProperty('!')) {\n        val = value.value;\n        type = value['!'];\n    }\n\n    // If it's a JS number, we'll have to guess what type to encode it\n    // as.\n    if (type == 'number') {\n        // Making assumptions about the kind of number (floating point\n        // v integer, signed, unsigned, size) desired is dangerous in\n        // general; however, in practice RabbitMQ uses only\n        // longstrings and unsigned integers in its arguments, and\n        // other clients generally conflate number types anyway. So\n        // the only distinction we care about is floating point vs\n        // integers, preferring integers since those can be promoted\n        // if necessary. If floating point is required, we may as well\n        // use double precision.\n        if (isFloatingPoint(val)) {\n            type = 'double';\n        }\n        else { // only signed values are used in tables by\n               // RabbitMQ. It *used* to (< v3.3.0) treat the byte 'b'\n               // type as unsigned, but most clients (and the spec)\n               // think it's signed, and now RabbitMQ does too.\n            if (val < 128 && val >= -128) {\n                type = 'byte';\n            }\n            else if (val >= -0x8000 && val < 0x8000) {\n                type = 'short'\n            }\n            else if (val >= -0x80000000 && val < 0x80000000) {\n                type = 'int';\n            }\n            else {\n                type = 'long';\n            }\n        }\n    }\n\n    function tag(t) { buffer.write(t, offset); offset++; }\n\n    switch (type) {\n    case 'string': // no shortstr in field tables\n        var len = Buffer.byteLength(val, 'utf8');\n        tag('S');\n        buffer.writeUInt32BE(len, offset); offset += 4;\n        buffer.write(val, offset, 'utf8'); offset += len;\n        break;\n    case 'object':\n        if (val === null) {\n            tag('V');\n        }\n        else if (Array.isArray(val)) {\n            tag('A');\n            offset += encodeArray(buffer, val, offset);\n        }\n        else if (Buffer.isBuffer(val)) {\n            tag('x');\n            buffer.writeUInt32BE(val.length, offset); offset += 4;\n            val.copy(buffer, offset); offset += val.length;\n        }\n        else {\n            tag('F');\n            offset += encodeTable(buffer, val, offset);\n        }\n        break;\n    case 'boolean':\n        tag('t');\n        buffer.writeUInt8((val) ? 1 : 0, offset); offset++;\n        break;\n    // These are the types that are either guessed above, or\n    // explicitly given using the {'!': type} notation.\n    case 'double':\n    case 'float64':\n        tag('d');\n        buffer.writeDoubleBE(val, offset);\n        offset += 8;\n        break;\n    case 'byte':\n    case 'int8':\n        tag('b');\n        buffer.writeInt8(val, offset); offset++;\n        break;\n    case 'unsignedbyte':\n    case 'uint8':\n        tag('B');\n        buffer.writeUInt8(val, offset); offset++;\n        break;\n    case 'short':\n    case 'int16':\n        tag('s');\n        buffer.writeInt16BE(val, offset); offset += 2;\n        break;\n    case 'unsignedshort':\n    case 'uint16':\n        tag('u');\n        buffer.writeUInt16BE(val, offset); offset += 2;\n        break;\n    case 'int':\n    case 'int32':\n        tag('I');\n        buffer.writeInt32BE(val, offset); offset += 4;\n        break;\n    case 'unsignedint':\n    case 'uint32':\n        tag('i');\n        buffer.writeUInt32BE(val, offset); offset += 4;\n        break;\n    case 'long':\n    case 'int64':\n        tag('l');\n        ints.writeInt64BE(buffer, val, offset); offset += 8;\n        break;\n\n    // Now for exotic types, those can _only_ be denoted by using\n    // `{'!': type, value: val}\n    case 'timestamp':\n        tag('T');\n        ints.writeUInt64BE(buffer, val, offset); offset += 8;\n        break;\n    case 'float':\n        tag('f');\n        buffer.writeFloatBE(val, offset); offset += 4;\n        break;\n    case 'decimal':\n        tag('D');\n        if (val.hasOwnProperty('places') && val.hasOwnProperty('digits')\n            && val.places >= 0 && val.places < 256) {\n            buffer[offset] = val.places; offset++;\n            buffer.writeUInt32BE(val.digits, offset); offset += 4;\n        }\n        else throw new TypeError(\n            \"Decimal value must be {'places': 0..255, 'digits': uint32}, \" +\n                \"got \" + JSON.stringify(val));\n        break;\n    default:\n        throw new TypeError('Unknown type to encode: ' + type);\n    }\n    return offset - start;\n}\n\n// Assume we're given a slice of the buffer that contains just the\n// fields.\nfunction decodeFields(slice) {\n    var fields = {}, offset = 0, size = slice.length;\n    var len, key, val;\n\n    function decodeFieldValue() {\n        var tag = String.fromCharCode(slice[offset]); offset++;\n        switch (tag) {\n        case 'b':\n            val = slice.readInt8(offset); offset++;\n            break;\n        case 'B':\n            val = slice.readUInt8(offset); offset++;\n            break;\n        case 'S':\n            len = slice.readUInt32BE(offset); offset += 4;\n            val = slice.toString('utf8', offset, offset + len);\n            offset += len;\n            break;\n        case 'I':\n            val = slice.readInt32BE(offset); offset += 4;\n            break;\n        case 'i':\n            val = slice.readUInt32BE(offset); offset += 4;\n            break;\n        case 'D': // only positive decimals, apparently.\n            var places = slice[offset]; offset++;\n            var digits = slice.readUInt32BE(offset); offset += 4;\n            val = {'!': 'decimal', value: {places: places, digits: digits}};\n            break;\n        case 'T':\n            val = ints.readUInt64BE(slice, offset); offset += 8;\n            val = {'!': 'timestamp', value: val};\n            break;\n        case 'F':\n            len = slice.readUInt32BE(offset); offset += 4;\n            val = decodeFields(slice.subarray(offset, offset + len));\n            offset += len;\n            break;\n        case 'A':\n            len = slice.readUInt32BE(offset); offset += 4;\n            decodeArray(offset + len);\n            // NB decodeArray will itself update offset and val\n            break;\n        case 'd':\n            val = slice.readDoubleBE(offset); offset += 8;\n            break;\n        case 'f':\n            val = slice.readFloatBE(offset); offset += 4;\n            break;\n        case 'l':\n            val = ints.readInt64BE(slice, offset); offset += 8;\n            break;\n        case 's':\n            val = slice.readInt16BE(offset); offset += 2;\n            break;\n        case 'u':\n            val = slice.readUInt16BE(offset); offset += 2;\n            break;\n        case 't':\n            val = slice[offset] != 0; offset++;\n            break;\n        case 'V':\n            val = null;\n            break;\n        case 'x':\n            len = slice.readUInt32BE(offset); offset += 4;\n            val = slice.subarray(offset, offset + len);\n            offset += len;\n            break;\n        default:\n            throw new TypeError('Unexpected type tag \"' + tag +'\"');\n        }\n    }\n\n    function decodeArray(until) {\n        var vals = [];\n        while (offset < until) {\n            decodeFieldValue();\n            vals.push(val);\n        }\n        val = vals;\n    }\n\n    while (offset < size) {\n        len = slice.readUInt8(offset); offset++;\n        key = slice.toString('utf8', offset, offset + len);\n        offset += len;\n        decodeFieldValue();\n        fields[key] = val;\n    }\n    return fields;\n}\n\nmodule.exports.encodeTable = encodeTable;\nmodule.exports.decodeFields = decodeFields;\n"],"x_google_ignoreList":[0],"mappings":"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"}