@wabot-dev/framework 0.0.12 → 0.0.14

package/dist/src/node_modules/raw-body/index.js

@@ -0,0 +1,351 @@
+import { commonjsGlobal } from '../../_virtual/_commonjsHelpers.js';
+import { __require as requireBytes } from '../bytes/index.js';
+import { __require as requireHttpErrors } from '../http-errors/index.js';
+import { __require as requireLib } from '../iconv-lite/lib/index.js';
+import { __require as requireUnpipe } from '../unpipe/index.js';
+
+/*!
+ * raw-body
+ * Copyright(c) 2013-2014 Jonathan Ong
+ * Copyright(c) 2014-2022 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+var rawBody;
+var hasRequiredRawBody;
+
+function requireRawBody () {
+	if (hasRequiredRawBody) return rawBody;
+	hasRequiredRawBody = 1;
+
+	/**
+	 * Module dependencies.
+	 * @private
+	 */
+
+	var asyncHooks = tryRequireAsyncHooks();
+	var bytes = requireBytes();
+	var createError = requireHttpErrors();
+	var iconv = requireLib();
+	var unpipe = requireUnpipe();
+
+	/**
+	 * Module exports.
+	 * @public
+	 */
+
+	rawBody = getRawBody;
+
+	/**
+	 * Module variables.
+	 * @private
+	 */
+
+	var ICONV_ENCODING_MESSAGE_REGEXP = /^Encoding not recognized: /;
+
+	/**
+	 * Get the decoder for a given encoding.
+	 *
+	 * @param {string} encoding
+	 * @private
+	 */
+
+	function getDecoder (encoding) {
+	  if (!encoding) return null
+
+	  try {
+	    return iconv.getDecoder(encoding)
+	  } catch (e) {
+	    // error getting decoder
+	    if (!ICONV_ENCODING_MESSAGE_REGEXP.test(e.message)) throw e
+
+	    // the encoding was not found
+	    throw createError(415, 'specified encoding unsupported', {
+	      encoding: encoding,
+	      type: 'encoding.unsupported'
+	    })
+	  }
+	}
+
+	/**
+	 * Get the raw body of a stream (typically HTTP).
+	 *
+	 * @param {object} stream
+	 * @param {object|string|function} [options]
+	 * @param {function} [callback]
+	 * @public
+	 */
+
+	function getRawBody (stream, options, callback) {
+	  var done = callback;
+	  var opts = options || {};
+
+	  // light validation
+	  if (stream === undefined) {
+	    throw new TypeError('argument stream is required')
+	  } else if (typeof stream !== 'object' || stream === null || typeof stream.on !== 'function') {
+	    throw new TypeError('argument stream must be a stream')
+	  }
+
+	  if (options === true || typeof options === 'string') {
+	    // short cut for encoding
+	    opts = {
+	      encoding: options
+	    };
+	  }
+
+	  if (typeof options === 'function') {
+	    done = options;
+	    opts = {};
+	  }
+
+	  // validate callback is a function, if provided
+	  if (done !== undefined && typeof done !== 'function') {
+	    throw new TypeError('argument callback must be a function')
+	  }
+
+	  // require the callback without promises
+	  if (!done && !commonjsGlobal.Promise) {
+	    throw new TypeError('argument callback is required')
+	  }
+
+	  // get encoding
+	  var encoding = opts.encoding !== true
+	    ? opts.encoding
+	    : 'utf-8';
+
+	  // convert the limit to an integer
+	  var limit = bytes.parse(opts.limit);
+
+	  // convert the expected length to an integer
+	  var length = opts.length != null && !isNaN(opts.length)
+	    ? parseInt(opts.length, 10)
+	    : null;
+
+	  if (done) {
+	    // classic callback style
+	    return readStream(stream, encoding, length, limit, wrap(done))
+	  }
+
+	  return new Promise(function executor (resolve, reject) {
+	    readStream(stream, encoding, length, limit, function onRead (err, buf) {
+	      if (err) return reject(err)
+	      resolve(buf);
+	    });
+	  })
+	}
+
+	/**
+	 * Halt a stream.
+	 *
+	 * @param {Object} stream
+	 * @private
+	 */
+
+	function halt (stream) {
+	  // unpipe everything from the stream
+	  unpipe(stream);
+
+	  // pause stream
+	  if (typeof stream.pause === 'function') {
+	    stream.pause();
+	  }
+	}
+
+	/**
+	 * Read the data from the stream.
+	 *
+	 * @param {object} stream
+	 * @param {string} encoding
+	 * @param {number} length
+	 * @param {number} limit
+	 * @param {function} callback
+	 * @public
+	 */
+
+	function readStream (stream, encoding, length, limit, callback) {
+	  var complete = false;
+	  var sync = true;
+
+	  // check the length and limit options.
+	  // note: we intentionally leave the stream paused,
+	  // so users should handle the stream themselves.
+	  if (limit !== null && length !== null && length > limit) {
+	    return done(createError(413, 'request entity too large', {
+	      expected: length,
+	      length: length,
+	      limit: limit,
+	      type: 'entity.too.large'
+	    }))
+	  }
+
+	  // streams1: assert request encoding is buffer.
+	  // streams2+: assert the stream encoding is buffer.
+	  //   stream._decoder: streams1
+	  //   state.encoding: streams2
+	  //   state.decoder: streams2, specifically < 0.10.6
+	  var state = stream._readableState;
+	  if (stream._decoder || (state && (state.encoding || state.decoder))) {
+	    // developer error
+	    return done(createError(500, 'stream encoding should not be set', {
+	      type: 'stream.encoding.set'
+	    }))
+	  }
+
+	  if (typeof stream.readable !== 'undefined' && !stream.readable) {
+	    return done(createError(500, 'stream is not readable', {
+	      type: 'stream.not.readable'
+	    }))
+	  }
+
+	  var received = 0;
+	  var decoder;
+
+	  try {
+	    decoder = getDecoder(encoding);
+	  } catch (err) {
+	    return done(err)
+	  }
+
+	  var buffer = decoder
+	    ? ''
+	    : [];
+
+	  // attach listeners
+	  stream.on('aborted', onAborted);
+	  stream.on('close', cleanup);
+	  stream.on('data', onData);
+	  stream.on('end', onEnd);
+	  stream.on('error', onEnd);
+
+	  // mark sync section complete
+	  sync = false;
+
+	  function done () {
+	    var args = new Array(arguments.length);
+
+	    // copy arguments
+	    for (var i = 0; i < args.length; i++) {
+	      args[i] = arguments[i];
+	    }
+
+	    // mark complete
+	    complete = true;
+
+	    if (sync) {
+	      process.nextTick(invokeCallback);
+	    } else {
+	      invokeCallback();
+	    }
+
+	    function invokeCallback () {
+	      cleanup();
+
+	      if (args[0]) {
+	        // halt the stream on error
+	        halt(stream);
+	      }
+
+	      callback.apply(null, args);
+	    }
+	  }
+
+	  function onAborted () {
+	    if (complete) return
+
+	    done(createError(400, 'request aborted', {
+	      code: 'ECONNABORTED',
+	      expected: length,
+	      length: length,
+	      received: received,
+	      type: 'request.aborted'
+	    }));
+	  }
+
+	  function onData (chunk) {
+	    if (complete) return
+
+	    received += chunk.length;
+
+	    if (limit !== null && received > limit) {
+	      done(createError(413, 'request entity too large', {
+	        limit: limit,
+	        received: received,
+	        type: 'entity.too.large'
+	      }));
+	    } else if (decoder) {
+	      buffer += decoder.write(chunk);
+	    } else {
+	      buffer.push(chunk);
+	    }
+	  }
+
+	  function onEnd (err) {
+	    if (complete) return
+	    if (err) return done(err)
+
+	    if (length !== null && received !== length) {
+	      done(createError(400, 'request size did not match content length', {
+	        expected: length,
+	        length: length,
+	        received: received,
+	        type: 'request.size.invalid'
+	      }));
+	    } else {
+	      var string = decoder
+	        ? buffer + (decoder.end() || '')
+	        : Buffer.concat(buffer);
+	      done(null, string);
+	    }
+	  }
+
+	  function cleanup () {
+	    buffer = null;
+
+	    stream.removeListener('aborted', onAborted);
+	    stream.removeListener('data', onData);
+	    stream.removeListener('end', onEnd);
+	    stream.removeListener('error', onEnd);
+	    stream.removeListener('close', cleanup);
+	  }
+	}
+
+	/**
+	 * Try to require async_hooks
+	 * @private
+	 */
+
+	function tryRequireAsyncHooks () {
+	  try {
+	    return require('async_hooks')
+	  } catch (e) {
+	    return {}
+	  }
+	}
+
+	/**
+	 * Wrap function with async resource, if possible.
+	 * AsyncResource.bind static method backported.
+	 * @private
+	 */
+
+	function wrap (fn) {
+	  var res;
+
+	  // create anonymous resource
+	  if (asyncHooks.AsyncResource) {
+	    res = new asyncHooks.AsyncResource(fn.name || 'bound-anonymous-fn');
+	  }
+
+	  // incompatible node.js
+	  if (!res || !res.runInAsyncScope) {
+	    return fn
+	  }
+
+	  // return bound function
+	  return res.runInAsyncScope.bind(res, fn, null)
+	}
+	return rawBody;
+}
+
+export { requireRawBody as __require };

package/dist/src/node_modules/safer-buffer/safer.js

@@ -0,0 +1,88 @@
+import require$$0 from 'buffer';
+
+/* eslint-disable node/no-deprecated-api */
+
+var safer_1;
+var hasRequiredSafer;
+
+function requireSafer () {
+	if (hasRequiredSafer) return safer_1;
+	hasRequiredSafer = 1;
+
+	var buffer = require$$0;
+	var Buffer = buffer.Buffer;
+
+	var safer = {};
+
+	var key;
+
+	for (key in buffer) {
+	  if (!buffer.hasOwnProperty(key)) continue
+	  if (key === 'SlowBuffer' || key === 'Buffer') continue
+	  safer[key] = buffer[key];
+	}
+
+	var Safer = safer.Buffer = {};
+	for (key in Buffer) {
+	  if (!Buffer.hasOwnProperty(key)) continue
+	  if (key === 'allocUnsafe' || key === 'allocUnsafeSlow') continue
+	  Safer[key] = Buffer[key];
+	}
+
+	safer.Buffer.prototype = Buffer.prototype;
+
+	if (!Safer.from || Safer.from === Uint8Array.from) {
+	  Safer.from = function (value, encodingOrOffset, length) {
+	    if (typeof value === 'number') {
+	      throw new TypeError('The "value" argument must not be of type number. Received type ' + typeof value)
+	    }
+	    if (value && typeof value.length === 'undefined') {
+	      throw new TypeError('The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type ' + typeof value)
+	    }
+	    return Buffer(value, encodingOrOffset, length)
+	  };
+	}
+
+	if (!Safer.alloc) {
+	  Safer.alloc = function (size, fill, encoding) {
+	    if (typeof size !== 'number') {
+	      throw new TypeError('The "size" argument must be of type number. Received type ' + typeof size)
+	    }
+	    if (size < 0 || size >= 2 * (1 << 30)) {
+	      throw new RangeError('The value "' + size + '" is invalid for option "size"')
+	    }
+	    var buf = Buffer(size);
+	    if (!fill || fill.length === 0) {
+	      buf.fill(0);
+	    } else if (typeof encoding === 'string') {
+	      buf.fill(fill, encoding);
+	    } else {
+	      buf.fill(fill);
+	    }
+	    return buf
+	  };
+	}
+
+	if (!safer.kStringMaxLength) {
+	  try {
+	    safer.kStringMaxLength = process.binding('buffer').kStringMaxLength;
+	  } catch (e) {
+	    // we can't determine kStringMaxLength in environments where process.binding
+	    // is unsupported, so let's not set it
+	  }
+	}
+
+	if (!safer.constants) {
+	  safer.constants = {
+	    MAX_LENGTH: safer.kMaxLength
+	  };
+	  if (safer.kStringMaxLength) {
+	    safer.constants.MAX_STRING_LENGTH = safer.kStringMaxLength;
+	  }
+	}
+
+	safer_1 = safer;
+	return safer_1;
+}
+
+export { requireSafer as __require };

package/dist/src/node_modules/setprototypeof/index.js

@@ -0,0 +1,26 @@
+var setprototypeof;
+var hasRequiredSetprototypeof;
+
+function requireSetprototypeof () {
+	if (hasRequiredSetprototypeof) return setprototypeof;
+	hasRequiredSetprototypeof = 1;
+	/* eslint no-proto: 0 */
+	setprototypeof = Object.setPrototypeOf || ({ __proto__: [] } instanceof Array ? setProtoOf : mixinProperties);
+
+	function setProtoOf (obj, proto) {
+	  obj.__proto__ = proto;
+	  return obj
+	}
+
+	function mixinProperties (obj, proto) {
+	  for (var prop in proto) {
+	    if (!Object.prototype.hasOwnProperty.call(obj, prop)) {
+	      obj[prop] = proto[prop];
+	    }
+	  }
+	  return obj
+	}
+	return setprototypeof;
+}
+
+export { requireSetprototypeof as __require };

package/dist/src/node_modules/side-channel/index.js

@@ -0,0 +1,58 @@
+import { __require as requireType } from '../es-errors/type.js';
+import { __require as requireObjectInspect } from '../object-inspect/index.js';
+import { __require as requireSideChannelList } from '../side-channel-list/index.js';
+import { __require as requireSideChannelMap } from '../side-channel-map/index.js';
+import { __require as requireSideChannelWeakmap } from '../side-channel-weakmap/index.js';
+
+var sideChannel;
+var hasRequiredSideChannel;
+
+function requireSideChannel () {
+	if (hasRequiredSideChannel) return sideChannel;
+	hasRequiredSideChannel = 1;
+
+	var $TypeError = /*@__PURE__*/ requireType();
+	var inspect = /*@__PURE__*/ requireObjectInspect();
+	var getSideChannelList = requireSideChannelList();
+	var getSideChannelMap = requireSideChannelMap();
+	var getSideChannelWeakMap = requireSideChannelWeakmap();
+
+	var makeChannel = getSideChannelWeakMap || getSideChannelMap || getSideChannelList;
+
+	/** @type {import('.')} */
+	sideChannel = function getSideChannel() {
+		/** @typedef {ReturnType<typeof getSideChannel>} Channel */
+
+		/** @type {Channel | undefined} */ var $channelData;
+
+		/** @type {Channel} */
+		var channel = {
+			assert: function (key) {
+				if (!channel.has(key)) {
+					throw new $TypeError('Side channel does not contain ' + inspect(key));
+				}
+			},
+			'delete': function (key) {
+				return !!$channelData && $channelData['delete'](key);
+			},
+			get: function (key) {
+				return $channelData && $channelData.get(key);
+			},
+			has: function (key) {
+				return !!$channelData && $channelData.has(key);
+			},
+			set: function (key, value) {
+				if (!$channelData) {
+					$channelData = makeChannel();
+				}
+
+				$channelData.set(key, value);
+			}
+		};
+		// @ts-expect-error TODO: figure out why this is erroring
+		return channel;
+	};
+	return sideChannel;
+}
+
+export { requireSideChannel as __require };

package/dist/src/node_modules/side-channel-list/index.js

@@ -0,0 +1,125 @@
+import { __require as requireObjectInspect } from '../object-inspect/index.js';
+import { __require as requireType } from '../es-errors/type.js';
+
+var sideChannelList;
+var hasRequiredSideChannelList;
+
+function requireSideChannelList () {
+	if (hasRequiredSideChannelList) return sideChannelList;
+	hasRequiredSideChannelList = 1;
+
+	var inspect = /*@__PURE__*/ requireObjectInspect();
+
+	var $TypeError = /*@__PURE__*/ requireType();
+
+	/*
+	* This function traverses the list returning the node corresponding to the given key.
+	*
+	* That node is also moved to the head of the list, so that if it's accessed again we don't need to traverse the whole list.
+	* By doing so, all the recently used nodes can be accessed relatively quickly.
+	*/
+	/** @type {import('./list.d.ts').listGetNode} */
+	// eslint-disable-next-line consistent-return
+	var listGetNode = function (list, key, isDelete) {
+		/** @type {typeof list | NonNullable<(typeof list)['next']>} */
+		var prev = list;
+		/** @type {(typeof list)['next']} */
+		var curr;
+		// eslint-disable-next-line eqeqeq
+		for (; (curr = prev.next) != null; prev = curr) {
+			if (curr.key === key) {
+				prev.next = curr.next;
+				if (!isDelete) {
+					// eslint-disable-next-line no-extra-parens
+					curr.next = /** @type {NonNullable<typeof list.next>} */ (list.next);
+					list.next = curr; // eslint-disable-line no-param-reassign
+				}
+				return curr;
+			}
+		}
+	};
+
+	/** @type {import('./list.d.ts').listGet} */
+	var listGet = function (objects, key) {
+		if (!objects) {
+			return void 0;
+		}
+		var node = listGetNode(objects, key);
+		return node && node.value;
+	};
+	/** @type {import('./list.d.ts').listSet} */
+	var listSet = function (objects, key, value) {
+		var node = listGetNode(objects, key);
+		if (node) {
+			node.value = value;
+		} else {
+			// Prepend the new node to the beginning of the list
+			objects.next = /** @type {import('./list.d.ts').ListNode<typeof value, typeof key>} */ ({ // eslint-disable-line no-param-reassign, no-extra-parens
+				key: key,
+				next: objects.next,
+				value: value
+			});
+		}
+	};
+	/** @type {import('./list.d.ts').listHas} */
+	var listHas = function (objects, key) {
+		if (!objects) {
+			return false;
+		}
+		return !!listGetNode(objects, key);
+	};
+	/** @type {import('./list.d.ts').listDelete} */
+	// eslint-disable-next-line consistent-return
+	var listDelete = function (objects, key) {
+		if (objects) {
+			return listGetNode(objects, key, true);
+		}
+	};
+
+	/** @type {import('.')} */
+	sideChannelList = function getSideChannelList() {
+		/** @typedef {ReturnType<typeof getSideChannelList>} Channel */
+		/** @typedef {Parameters<Channel['get']>[0]} K */
+		/** @typedef {Parameters<Channel['set']>[1]} V */
+
+		/** @type {import('./list.d.ts').RootNode<V, K> | undefined} */ var $o;
+
+		/** @type {Channel} */
+		var channel = {
+			assert: function (key) {
+				if (!channel.has(key)) {
+					throw new $TypeError('Side channel does not contain ' + inspect(key));
+				}
+			},
+			'delete': function (key) {
+				var root = $o && $o.next;
+				var deletedNode = listDelete($o, key);
+				if (deletedNode && root && root === deletedNode) {
+					$o = void 0;
+				}
+				return !!deletedNode;
+			},
+			get: function (key) {
+				return listGet($o, key);
+			},
+			has: function (key) {
+				return listHas($o, key);
+			},
+			set: function (key, value) {
+				if (!$o) {
+					// Initialize the linked list as an empty node, so that we don't have to special-case handling of the first node: we can always refer to it as (previous node).next, instead of something like (list).head
+					$o = {
+						next: void 0
+					};
+				}
+				// eslint-disable-next-line no-extra-parens
+				listSet(/** @type {NonNullable<typeof $o>} */ ($o), key, value);
+			}
+		};
+		// @ts-expect-error TODO: figure out why this is erroring
+		return channel;
+	};
+	return sideChannelList;
+}
+
+export { requireSideChannelList as __require };