@wabot-dev/framework 0.0.12 → 0.0.14

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

@@ -0,0 +1,26 @@
+import { __require as requireGOPD } from './gOPD.js';
+
+var gopd;
+var hasRequiredGopd;
+
+function requireGopd () {
+	if (hasRequiredGopd) return gopd;
+	hasRequiredGopd = 1;
+
+	/** @type {import('.')} */
+	var $gOPD = /*@__PURE__*/ requireGOPD();
+
+	if ($gOPD) {
+		try {
+			$gOPD([], 'length');
+		} catch (e) {
+			// IE 8 has a broken gOPD
+			$gOPD = null;
+		}
+	}
+
+	gopd = $gOPD;
+	return gopd;
+}
+
+export { requireGopd as __require };

package/dist/src/node_modules/has-symbols/index.js

@@ -0,0 +1,25 @@
+import { __require as requireShams } from './shams.js';
+
+var hasSymbols;
+var hasRequiredHasSymbols;
+
+function requireHasSymbols () {
+	if (hasRequiredHasSymbols) return hasSymbols;
+	hasRequiredHasSymbols = 1;
+
+	var origSymbol = typeof Symbol !== 'undefined' && Symbol;
+	var hasSymbolSham = requireShams();
+
+	/** @type {import('.')} */
+	hasSymbols = function hasNativeSymbols() {
+		if (typeof origSymbol !== 'function') { return false; }
+		if (typeof Symbol !== 'function') { return false; }
+		if (typeof origSymbol('foo') !== 'symbol') { return false; }
+		if (typeof Symbol('bar') !== 'symbol') { return false; }
+
+		return hasSymbolSham();
+	};
+	return hasSymbols;
+}
+
+export { requireHasSymbols as __require };

package/dist/src/node_modules/has-symbols/shams.js

@@ -0,0 +1,54 @@
+var shams;
+var hasRequiredShams;
+
+function requireShams () {
+	if (hasRequiredShams) return shams;
+	hasRequiredShams = 1;
+
+	/** @type {import('./shams')} */
+	/* eslint complexity: [2, 18], max-statements: [2, 33] */
+	shams = function hasSymbols() {
+		if (typeof Symbol !== 'function' || typeof Object.getOwnPropertySymbols !== 'function') { return false; }
+		if (typeof Symbol.iterator === 'symbol') { return true; }
+
+		/** @type {{ [k in symbol]?: unknown }} */
+		var obj = {};
+		var sym = Symbol('test');
+		var symObj = Object(sym);
+		if (typeof sym === 'string') { return false; }
+
+		if (Object.prototype.toString.call(sym) !== '[object Symbol]') { return false; }
+		if (Object.prototype.toString.call(symObj) !== '[object Symbol]') { return false; }
+
+		// temp disabled per https://github.com/ljharb/object.assign/issues/17
+		// if (sym instanceof Symbol) { return false; }
+		// temp disabled per https://github.com/WebReflection/get-own-property-symbols/issues/4
+		// if (!(symObj instanceof Symbol)) { return false; }
+
+		// if (typeof Symbol.prototype.toString !== 'function') { return false; }
+		// if (String(sym) !== Symbol.prototype.toString.call(sym)) { return false; }
+
+		var symVal = 42;
+		obj[sym] = symVal;
+		for (var _ in obj) { return false; } // eslint-disable-line no-restricted-syntax, no-unreachable-loop
+		if (typeof Object.keys === 'function' && Object.keys(obj).length !== 0) { return false; }
+
+		if (typeof Object.getOwnPropertyNames === 'function' && Object.getOwnPropertyNames(obj).length !== 0) { return false; }
+
+		var syms = Object.getOwnPropertySymbols(obj);
+		if (syms.length !== 1 || syms[0] !== sym) { return false; }
+
+		if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) { return false; }
+
+		if (typeof Object.getOwnPropertyDescriptor === 'function') {
+			// eslint-disable-next-line no-extra-parens
+			var descriptor = /** @type {PropertyDescriptor} */ (Object.getOwnPropertyDescriptor(obj, sym));
+			if (descriptor.value !== symVal || descriptor.enumerable !== true) { return false; }
+		}
+
+		return true;
+	};
+	return shams;
+}
+
+export { requireShams as __require };

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

@@ -0,0 +1,19 @@
+import { __require as requireFunctionBind } from '../function-bind/index.js';
+
+var hasown;
+var hasRequiredHasown;
+
+function requireHasown () {
+	if (hasRequiredHasown) return hasown;
+	hasRequiredHasown = 1;
+
+	var call = Function.prototype.call;
+	var $hasOwn = Object.prototype.hasOwnProperty;
+	var bind = requireFunctionBind();
+
+	/** @type {import('.')} */
+	hasown = bind.call(call, $hasOwn);
+	return hasown;
+}
+
+export { requireHasown as __require };

package/dist/src/node_modules/http-errors/index.js

@@ -0,0 +1,306 @@
+import { __module as httpErrors } from '../../_virtual/index12.js';
+import { __require as requireDepd } from '../depd/index.js';
+import { __require as requireSetprototypeof } from '../setprototypeof/index.js';
+import { __require as requireStatuses } from '../statuses/index.js';
+import { __require as requireInherits } from '../inherits/inherits.js';
+import { __require as requireToidentifier } from '../toidentifier/index.js';
+
+/*!
+ * http-errors
+ * Copyright(c) 2014 Jonathan Ong
+ * Copyright(c) 2016 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+var hasRequiredHttpErrors;
+
+function requireHttpErrors () {
+	if (hasRequiredHttpErrors) return httpErrors.exports;
+	hasRequiredHttpErrors = 1;
+	(function (module) {
+
+		/**
+		 * Module dependencies.
+		 * @private
+		 */
+
+		var deprecate = requireDepd()('http-errors');
+		var setPrototypeOf = requireSetprototypeof();
+		var statuses = requireStatuses();
+		var inherits = requireInherits();
+		var toIdentifier = requireToidentifier();
+
+		/**
+		 * Module exports.
+		 * @public
+		 */
+
+		module.exports = createError;
+		module.exports.HttpError = createHttpErrorConstructor();
+		module.exports.isHttpError = createIsHttpErrorFunction(module.exports.HttpError);
+
+		// Populate exports for all constructors
+		populateConstructorExports(module.exports, statuses.codes, module.exports.HttpError);
+
+		/**
+		 * Get the code class of a status code.
+		 * @private
+		 */
+
+		function codeClass (status) {
+		  return Number(String(status).charAt(0) + '00')
+		}
+
+		/**
+		 * Create a new HTTP Error.
+		 *
+		 * @returns {Error}
+		 * @public
+		 */
+
+		function createError () {
+		  // so much arity going on ~_~
+		  var err;
+		  var msg;
+		  var status = 500;
+		  var props = {};
+		  for (var i = 0; i < arguments.length; i++) {
+		    var arg = arguments[i];
+		    var type = typeof arg;
+		    if (type === 'object' && arg instanceof Error) {
+		      err = arg;
+		      status = err.status || err.statusCode || status;
+		    } else if (type === 'number' && i === 0) {
+		      status = arg;
+		    } else if (type === 'string') {
+		      msg = arg;
+		    } else if (type === 'object') {
+		      props = arg;
+		    } else {
+		      throw new TypeError('argument #' + (i + 1) + ' unsupported type ' + type)
+		    }
+		  }
+
+		  if (typeof status === 'number' && (status < 400 || status >= 600)) {
+		    deprecate('non-error status code; use only 4xx or 5xx status codes');
+		  }
+
+		  if (typeof status !== 'number' ||
+		    (!statuses.message[status] && (status < 400 || status >= 600))) {
+		    status = 500;
+		  }
+
+		  // constructor
+		  var HttpError = createError[status] || createError[codeClass(status)];
+
+		  if (!err) {
+		    // create error
+		    err = HttpError
+		      ? new HttpError(msg)
+		      : new Error(msg || statuses.message[status]);
+		    Error.captureStackTrace(err, createError);
+		  }
+
+		  if (!HttpError || !(err instanceof HttpError) || err.status !== status) {
+		    // add properties to generic error
+		    err.expose = status < 500;
+		    err.status = err.statusCode = status;
+		  }
+
+		  for (var key in props) {
+		    if (key !== 'status' && key !== 'statusCode') {
+		      err[key] = props[key];
+		    }
+		  }
+
+		  return err
+		}
+
+		/**
+		 * Create HTTP error abstract base class.
+		 * @private
+		 */
+
+		function createHttpErrorConstructor () {
+		  function HttpError () {
+		    throw new TypeError('cannot construct abstract class')
+		  }
+
+		  inherits(HttpError, Error);
+
+		  return HttpError
+		}
+
+		/**
+		 * Create a constructor for a client error.
+		 * @private
+		 */
+
+		function createClientErrorConstructor (HttpError, name, code) {
+		  var className = toClassName(name);
+
+		  function ClientError (message) {
+		    // create the error object
+		    var msg = message != null ? message : statuses.message[code];
+		    var err = new Error(msg);
+
+		    // capture a stack trace to the construction point
+		    Error.captureStackTrace(err, ClientError);
+
+		    // adjust the [[Prototype]]
+		    setPrototypeOf(err, ClientError.prototype);
+
+		    // redefine the error message
+		    Object.defineProperty(err, 'message', {
+		      enumerable: true,
+		      configurable: true,
+		      value: msg,
+		      writable: true
+		    });
+
+		    // redefine the error name
+		    Object.defineProperty(err, 'name', {
+		      enumerable: false,
+		      configurable: true,
+		      value: className,
+		      writable: true
+		    });
+
+		    return err
+		  }
+
+		  inherits(ClientError, HttpError);
+		  nameFunc(ClientError, className);
+
+		  ClientError.prototype.status = code;
+		  ClientError.prototype.statusCode = code;
+		  ClientError.prototype.expose = true;
+
+		  return ClientError
+		}
+
+		/**
+		 * Create function to test is a value is a HttpError.
+		 * @private
+		 */
+
+		function createIsHttpErrorFunction (HttpError) {
+		  return function isHttpError (val) {
+		    if (!val || typeof val !== 'object') {
+		      return false
+		    }
+
+		    if (val instanceof HttpError) {
+		      return true
+		    }
+
+		    return val instanceof Error &&
+		      typeof val.expose === 'boolean' &&
+		      typeof val.statusCode === 'number' && val.status === val.statusCode
+		  }
+		}
+
+		/**
+		 * Create a constructor for a server error.
+		 * @private
+		 */
+
+		function createServerErrorConstructor (HttpError, name, code) {
+		  var className = toClassName(name);
+
+		  function ServerError (message) {
+		    // create the error object
+		    var msg = message != null ? message : statuses.message[code];
+		    var err = new Error(msg);
+
+		    // capture a stack trace to the construction point
+		    Error.captureStackTrace(err, ServerError);
+
+		    // adjust the [[Prototype]]
+		    setPrototypeOf(err, ServerError.prototype);
+
+		    // redefine the error message
+		    Object.defineProperty(err, 'message', {
+		      enumerable: true,
+		      configurable: true,
+		      value: msg,
+		      writable: true
+		    });
+
+		    // redefine the error name
+		    Object.defineProperty(err, 'name', {
+		      enumerable: false,
+		      configurable: true,
+		      value: className,
+		      writable: true
+		    });
+
+		    return err
+		  }
+
+		  inherits(ServerError, HttpError);
+		  nameFunc(ServerError, className);
+
+		  ServerError.prototype.status = code;
+		  ServerError.prototype.statusCode = code;
+		  ServerError.prototype.expose = false;
+
+		  return ServerError
+		}
+
+		/**
+		 * Set the name of a function, if possible.
+		 * @private
+		 */
+
+		function nameFunc (func, name) {
+		  var desc = Object.getOwnPropertyDescriptor(func, 'name');
+
+		  if (desc && desc.configurable) {
+		    desc.value = name;
+		    Object.defineProperty(func, 'name', desc);
+		  }
+		}
+
+		/**
+		 * Populate the exports object with constructors for every error class.
+		 * @private
+		 */
+
+		function populateConstructorExports (exports, codes, HttpError) {
+		  codes.forEach(function forEachCode (code) {
+		    var CodeError;
+		    var name = toIdentifier(statuses.message[code]);
+
+		    switch (codeClass(code)) {
+		      case 400:
+		        CodeError = createClientErrorConstructor(HttpError, name, code);
+		        break
+		      case 500:
+		        CodeError = createServerErrorConstructor(HttpError, name, code);
+		        break
+		    }
+
+		    if (CodeError) {
+		      // export the constructor
+		      exports[code] = CodeError;
+		      exports[name] = CodeError;
+		    }
+		  });
+		}
+
+		/**
+		 * Get a class name from a name identifier.
+		 * @private
+		 */
+
+		function toClassName (name) {
+		  return name.substr(-5) !== 'Error'
+		    ? name + 'Error'
+		    : name
+		} 
+	} (httpErrors));
+	return httpErrors.exports;
+}
+
+export { requireHttpErrors as __require };