@autofleet/sadot 1.6.16 → 1.6.18-beta.0

package/dist/node_modules/body-parser/lib/types/json.mjs

@@ -0,0 +1,200 @@
+import { __commonJSMin } from "../../../../_virtual/rolldown_runtime.mjs";
+import { require_bytes } from "../../../bytes/index.mjs";
+import { require_content_type } from "../../../content-type/index.mjs";
+import { require_http_errors } from "../../../http-errors/index.mjs";
+import { require_src } from "../../../debug/src/index.mjs";
+import { require_read } from "../read.mjs";
+import { require_type_is } from "../../../type-is/index.mjs";
+
+//#region ../../node_modules/body-parser/lib/types/json.js
+/*!
+* body-parser
+* Copyright(c) 2014 Jonathan Ong
+* Copyright(c) 2014-2015 Douglas Christopher Wilson
+* MIT Licensed
+*/
+var require_json = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Module dependencies.
+	* @private
+	*/
+	var bytes = require_bytes();
+	var contentType = require_content_type();
+	var createError = require_http_errors();
+	var debug = require_src()("body-parser:json");
+	var read = require_read();
+	var typeis = require_type_is();
+	/**
+	* Module exports.
+	*/
+	module.exports = json;
+	/**
+	* RegExp to match the first non-space in a string.
+	*
+	* Allowed whitespace is defined in RFC 7159:
+	*
+	*    ws = *(
+	*            %x20 /              ; Space
+	*            %x09 /              ; Horizontal tab
+	*            %x0A /              ; Line feed or New line
+	*            %x0D )              ; Carriage return
+	*/
+	var FIRST_CHAR_REGEXP = /^[\x20\x09\x0a\x0d]*([^\x20\x09\x0a\x0d])/;
+	var JSON_SYNTAX_CHAR = "#";
+	var JSON_SYNTAX_REGEXP = /#+/g;
+	/**
+	* Create a middleware to parse JSON bodies.
+	*
+	* @param {object} [options]
+	* @return {function}
+	* @public
+	*/
+	function json(options) {
+		var opts = options || {};
+		var limit = typeof opts.limit !== "number" ? bytes.parse(opts.limit || "100kb") : opts.limit;
+		var inflate = opts.inflate !== false;
+		var reviver = opts.reviver;
+		var strict = opts.strict !== false;
+		var type = opts.type || "application/json";
+		var verify = opts.verify || false;
+		if (verify !== false && typeof verify !== "function") throw new TypeError("option verify must be function");
+		var shouldParse = typeof type !== "function" ? typeChecker(type) : type;
+		function parse(body) {
+			if (body.length === 0) return {};
+			if (strict) {
+				var first = firstchar(body);
+				if (first !== "{" && first !== "[") {
+					debug("strict violation");
+					throw createStrictSyntaxError(body, first);
+				}
+			}
+			try {
+				debug("parse json");
+				return JSON.parse(body, reviver);
+			} catch (e) {
+				throw normalizeJsonSyntaxError(e, {
+					message: e.message,
+					stack: e.stack
+				});
+			}
+		}
+		return function jsonParser(req, res, next) {
+			if (req._body) {
+				debug("body already parsed");
+				next();
+				return;
+			}
+			req.body = req.body || {};
+			if (!typeis.hasBody(req)) {
+				debug("skip empty body");
+				next();
+				return;
+			}
+			debug("content-type %j", req.headers["content-type"]);
+			if (!shouldParse(req)) {
+				debug("skip parsing");
+				next();
+				return;
+			}
+			var charset = getCharset(req) || "utf-8";
+			if (charset.slice(0, 4) !== "utf-") {
+				debug("invalid charset");
+				next(createError(415, "unsupported charset \"" + charset.toUpperCase() + "\"", {
+					charset,
+					type: "charset.unsupported"
+				}));
+				return;
+			}
+			read(req, res, next, parse, debug, {
+				encoding: charset,
+				inflate,
+				limit,
+				verify
+			});
+		};
+	}
+	/**
+	* Create strict violation syntax error matching native error.
+	*
+	* @param {string} str
+	* @param {string} char
+	* @return {Error}
+	* @private
+	*/
+	function createStrictSyntaxError(str, char) {
+		var index = str.indexOf(char);
+		var partial = "";
+		if (index !== -1) {
+			partial = str.substring(0, index) + JSON_SYNTAX_CHAR;
+			for (var i = index + 1; i < str.length; i++) partial += JSON_SYNTAX_CHAR;
+		}
+		try {
+			JSON.parse(partial);
+			/* istanbul ignore next */ throw new SyntaxError("strict violation");
+		} catch (e) {
+			return normalizeJsonSyntaxError(e, {
+				message: e.message.replace(JSON_SYNTAX_REGEXP, function(placeholder) {
+					return str.substring(index, index + placeholder.length);
+				}),
+				stack: e.stack
+			});
+		}
+	}
+	/**
+	* Get the first non-whitespace character in a string.
+	*
+	* @param {string} str
+	* @return {function}
+	* @private
+	*/
+	function firstchar(str) {
+		var match = FIRST_CHAR_REGEXP.exec(str);
+		return match ? match[1] : void 0;
+	}
+	/**
+	* Get the charset of a request.
+	*
+	* @param {object} req
+	* @api private
+	*/
+	function getCharset(req) {
+		try {
+			return (contentType.parse(req).parameters.charset || "").toLowerCase();
+		} catch (e) {
+			return;
+		}
+	}
+	/**
+	* Normalize a SyntaxError for JSON.parse.
+	*
+	* @param {SyntaxError} error
+	* @param {object} obj
+	* @return {SyntaxError}
+	*/
+	function normalizeJsonSyntaxError(error, obj) {
+		var keys = Object.getOwnPropertyNames(error);
+		for (var i = 0; i < keys.length; i++) {
+			var key = keys[i];
+			if (key !== "stack" && key !== "message") delete error[key];
+		}
+		error.stack = obj.stack.replace(error.message, obj.message);
+		error.message = obj.message;
+		return error;
+	}
+	/**
+	* Get the simple type checker.
+	*
+	* @param {string} type
+	* @return {function}
+	*/
+	function typeChecker(type) {
+		return function checkType(req) {
+			return Boolean(typeis(req, type));
+		};
+	}
+}));
+
+//#endregion
+export default require_json();
+
+export { require_json };

package/dist/node_modules/body-parser/lib/types/raw.mjs

@@ -0,0 +1,85 @@
+import { __commonJSMin } from "../../../../_virtual/rolldown_runtime.mjs";
+import { require_bytes } from "../../../bytes/index.mjs";
+import { require_src } from "../../../debug/src/index.mjs";
+import { require_read } from "../read.mjs";
+import { require_type_is } from "../../../type-is/index.mjs";
+
+//#region ../../node_modules/body-parser/lib/types/raw.js
+/*!
+* body-parser
+* Copyright(c) 2014-2015 Douglas Christopher Wilson
+* MIT Licensed
+*/
+var require_raw = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Module dependencies.
+	*/
+	var bytes = require_bytes();
+	var debug = require_src()("body-parser:raw");
+	var read = require_read();
+	var typeis = require_type_is();
+	/**
+	* Module exports.
+	*/
+	module.exports = raw;
+	/**
+	* Create a middleware to parse raw bodies.
+	*
+	* @param {object} [options]
+	* @return {function}
+	* @api public
+	*/
+	function raw(options) {
+		var opts = options || {};
+		var inflate = opts.inflate !== false;
+		var limit = typeof opts.limit !== "number" ? bytes.parse(opts.limit || "100kb") : opts.limit;
+		var type = opts.type || "application/octet-stream";
+		var verify = opts.verify || false;
+		if (verify !== false && typeof verify !== "function") throw new TypeError("option verify must be function");
+		var shouldParse = typeof type !== "function" ? typeChecker(type) : type;
+		function parse(buf) {
+			return buf;
+		}
+		return function rawParser(req, res, next) {
+			if (req._body) {
+				debug("body already parsed");
+				next();
+				return;
+			}
+			req.body = req.body || {};
+			if (!typeis.hasBody(req)) {
+				debug("skip empty body");
+				next();
+				return;
+			}
+			debug("content-type %j", req.headers["content-type"]);
+			if (!shouldParse(req)) {
+				debug("skip parsing");
+				next();
+				return;
+			}
+			read(req, res, next, parse, debug, {
+				encoding: null,
+				inflate,
+				limit,
+				verify
+			});
+		};
+	}
+	/**
+	* Get the simple type checker.
+	*
+	* @param {string} type
+	* @return {function}
+	*/
+	function typeChecker(type) {
+		return function checkType(req) {
+			return Boolean(typeis(req, type));
+		};
+	}
+}));
+
+//#endregion
+export default require_raw();
+
+export { require_raw };

package/dist/node_modules/body-parser/lib/types/text.mjs

@@ -0,0 +1,101 @@
+import { __commonJSMin } from "../../../../_virtual/rolldown_runtime.mjs";
+import { require_bytes } from "../../../bytes/index.mjs";
+import { require_content_type } from "../../../content-type/index.mjs";
+import { require_src } from "../../../debug/src/index.mjs";
+import { require_read } from "../read.mjs";
+import { require_type_is } from "../../../type-is/index.mjs";
+
+//#region ../../node_modules/body-parser/lib/types/text.js
+/*!
+* body-parser
+* Copyright(c) 2014-2015 Douglas Christopher Wilson
+* MIT Licensed
+*/
+var require_text = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Module dependencies.
+	*/
+	var bytes = require_bytes();
+	var contentType = require_content_type();
+	var debug = require_src()("body-parser:text");
+	var read = require_read();
+	var typeis = require_type_is();
+	/**
+	* Module exports.
+	*/
+	module.exports = text;
+	/**
+	* Create a middleware to parse text bodies.
+	*
+	* @param {object} [options]
+	* @return {function}
+	* @api public
+	*/
+	function text(options) {
+		var opts = options || {};
+		var defaultCharset = opts.defaultCharset || "utf-8";
+		var inflate = opts.inflate !== false;
+		var limit = typeof opts.limit !== "number" ? bytes.parse(opts.limit || "100kb") : opts.limit;
+		var type = opts.type || "text/plain";
+		var verify = opts.verify || false;
+		if (verify !== false && typeof verify !== "function") throw new TypeError("option verify must be function");
+		var shouldParse = typeof type !== "function" ? typeChecker(type) : type;
+		function parse(buf) {
+			return buf;
+		}
+		return function textParser(req, res, next) {
+			if (req._body) {
+				debug("body already parsed");
+				next();
+				return;
+			}
+			req.body = req.body || {};
+			if (!typeis.hasBody(req)) {
+				debug("skip empty body");
+				next();
+				return;
+			}
+			debug("content-type %j", req.headers["content-type"]);
+			if (!shouldParse(req)) {
+				debug("skip parsing");
+				next();
+				return;
+			}
+			read(req, res, next, parse, debug, {
+				encoding: getCharset(req) || defaultCharset,
+				inflate,
+				limit,
+				verify
+			});
+		};
+	}
+	/**
+	* Get the charset of a request.
+	*
+	* @param {object} req
+	* @api private
+	*/
+	function getCharset(req) {
+		try {
+			return (contentType.parse(req).parameters.charset || "").toLowerCase();
+		} catch (e) {
+			return;
+		}
+	}
+	/**
+	* Get the simple type checker.
+	*
+	* @param {string} type
+	* @return {function}
+	*/
+	function typeChecker(type) {
+		return function checkType(req) {
+			return Boolean(typeis(req, type));
+		};
+	}
+}));
+
+//#endregion
+export default require_text();
+
+export { require_text };

package/dist/node_modules/body-parser/lib/types/urlencoded.mjs

@@ -0,0 +1,217 @@
+import { __commonJSMin, __require } from "../../../../_virtual/rolldown_runtime.mjs";
+import { require_depd } from "../../../depd/index.mjs";
+import { require_bytes } from "../../../bytes/index.mjs";
+import { require_content_type } from "../../../content-type/index.mjs";
+import { require_http_errors } from "../../../http-errors/index.mjs";
+import { require_src } from "../../../debug/src/index.mjs";
+import { require_read } from "../read.mjs";
+import { require_type_is } from "../../../type-is/index.mjs";
+import { require_lib } from "../../node_modules/qs/lib/index.mjs";
+
+//#region ../../node_modules/body-parser/lib/types/urlencoded.js
+/*!
+* body-parser
+* Copyright(c) 2014 Jonathan Ong
+* Copyright(c) 2014-2015 Douglas Christopher Wilson
+* MIT Licensed
+*/
+var require_urlencoded = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Module dependencies.
+	* @private
+	*/
+	var bytes = require_bytes();
+	var contentType = require_content_type();
+	var createError = require_http_errors();
+	var debug = require_src()("body-parser:urlencoded");
+	var deprecate = require_depd()("body-parser");
+	var read = require_read();
+	var typeis = require_type_is();
+	/**
+	* Module exports.
+	*/
+	module.exports = urlencoded;
+	/**
+	* Cache of parser modules.
+	*/
+	var parsers = Object.create(null);
+	/**
+	* Create a middleware to parse urlencoded bodies.
+	*
+	* @param {object} [options]
+	* @return {function}
+	* @public
+	*/
+	function urlencoded(options) {
+		var opts = options || {};
+		if (opts.extended === void 0) deprecate("undefined extended: provide extended option");
+		var extended = opts.extended !== false;
+		var inflate = opts.inflate !== false;
+		var limit = typeof opts.limit !== "number" ? bytes.parse(opts.limit || "100kb") : opts.limit;
+		var type = opts.type || "application/x-www-form-urlencoded";
+		var verify = opts.verify || false;
+		var depth = typeof opts.depth !== "number" ? Number(opts.depth || 32) : opts.depth;
+		if (verify !== false && typeof verify !== "function") throw new TypeError("option verify must be function");
+		var queryparse = extended ? extendedparser(opts) : simpleparser(opts);
+		var shouldParse = typeof type !== "function" ? typeChecker(type) : type;
+		function parse(body) {
+			return body.length ? queryparse(body) : {};
+		}
+		return function urlencodedParser(req, res, next) {
+			if (req._body) {
+				debug("body already parsed");
+				next();
+				return;
+			}
+			req.body = req.body || {};
+			if (!typeis.hasBody(req)) {
+				debug("skip empty body");
+				next();
+				return;
+			}
+			debug("content-type %j", req.headers["content-type"]);
+			if (!shouldParse(req)) {
+				debug("skip parsing");
+				next();
+				return;
+			}
+			var charset = getCharset(req) || "utf-8";
+			if (charset !== "utf-8") {
+				debug("invalid charset");
+				next(createError(415, "unsupported charset \"" + charset.toUpperCase() + "\"", {
+					charset,
+					type: "charset.unsupported"
+				}));
+				return;
+			}
+			read(req, res, next, parse, debug, {
+				debug,
+				encoding: charset,
+				inflate,
+				limit,
+				verify,
+				depth
+			});
+		};
+	}
+	/**
+	* Get the extended query parser.
+	*
+	* @param {object} options
+	*/
+	function extendedparser(options) {
+		var parameterLimit = options.parameterLimit !== void 0 ? options.parameterLimit : 1e3;
+		var depth = typeof options.depth !== "number" ? Number(options.depth || 32) : options.depth;
+		var parse = parser("qs");
+		if (isNaN(parameterLimit) || parameterLimit < 1) throw new TypeError("option parameterLimit must be a positive number");
+		if (isNaN(depth) || depth < 0) throw new TypeError("option depth must be a zero or a positive number");
+		if (isFinite(parameterLimit)) parameterLimit = parameterLimit | 0;
+		return function queryparse(body) {
+			var paramCount = parameterCount(body, parameterLimit);
+			if (paramCount === void 0) {
+				debug("too many parameters");
+				throw createError(413, "too many parameters", { type: "parameters.too.many" });
+			}
+			var arrayLimit = Math.max(100, paramCount);
+			debug("parse extended urlencoding");
+			try {
+				return parse(body, {
+					allowPrototypes: true,
+					arrayLimit,
+					depth,
+					strictDepth: true,
+					parameterLimit
+				});
+			} catch (err) {
+				if (err instanceof RangeError) throw createError(400, "The input exceeded the depth", { type: "querystring.parse.rangeError" });
+				else throw err;
+			}
+		};
+	}
+	/**
+	* Get the charset of a request.
+	*
+	* @param {object} req
+	* @api private
+	*/
+	function getCharset(req) {
+		try {
+			return (contentType.parse(req).parameters.charset || "").toLowerCase();
+		} catch (e) {
+			return;
+		}
+	}
+	/**
+	* Count the number of parameters, stopping once limit reached
+	*
+	* @param {string} body
+	* @param {number} limit
+	* @api private
+	*/
+	function parameterCount(body, limit) {
+		var count = 0;
+		var index = 0;
+		while ((index = body.indexOf("&", index)) !== -1) {
+			count++;
+			index++;
+			if (count === limit) return;
+		}
+		return count;
+	}
+	/**
+	* Get parser for module name dynamically.
+	*
+	* @param {string} name
+	* @return {function}
+	* @api private
+	*/
+	function parser(name) {
+		var mod = parsers[name];
+		if (mod !== void 0) return mod.parse;
+		switch (name) {
+			case "qs":
+				mod = require_lib();
+				break;
+			case "querystring":
+				mod = __require("querystring");
+				break;
+		}
+		parsers[name] = mod;
+		return mod.parse;
+	}
+	/**
+	* Get the simple query parser.
+	*
+	* @param {object} options
+	*/
+	function simpleparser(options) {
+		var parameterLimit = options.parameterLimit !== void 0 ? options.parameterLimit : 1e3;
+		var parse = parser("querystring");
+		if (isNaN(parameterLimit) || parameterLimit < 1) throw new TypeError("option parameterLimit must be a positive number");
+		if (isFinite(parameterLimit)) parameterLimit = parameterLimit | 0;
+		return function queryparse(body) {
+			if (parameterCount(body, parameterLimit) === void 0) {
+				debug("too many parameters");
+				throw createError(413, "too many parameters", { type: "parameters.too.many" });
+			}
+			debug("parse urlencoding");
+			return parse(body, void 0, void 0, { maxKeys: parameterLimit });
+		};
+	}
+	/**
+	* Get the simple type checker.
+	*
+	* @param {string} type
+	* @return {function}
+	*/
+	function typeChecker(type) {
+		return function checkType(req) {
+			return Boolean(typeis(req, type));
+		};
+	}
+}));
+
+//#endregion
+export default require_urlencoded();
+
+export { require_urlencoded };

package/dist/node_modules/body-parser/node_modules/qs/lib/formats.mjs

@@ -0,0 +1,29 @@
+import { __commonJSMin } from "../../../../../_virtual/rolldown_runtime.mjs";
+
+//#region ../../node_modules/body-parser/node_modules/qs/lib/formats.js
+var require_formats = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var replace = String.prototype.replace;
+	var percentTwenties = /%20/g;
+	var Format = {
+		RFC1738: "RFC1738",
+		RFC3986: "RFC3986"
+	};
+	module.exports = {
+		"default": Format.RFC3986,
+		formatters: {
+			RFC1738: function(value) {
+				return replace.call(value, percentTwenties, "+");
+			},
+			RFC3986: function(value) {
+				return String(value);
+			}
+		},
+		RFC1738: Format.RFC1738,
+		RFC3986: Format.RFC3986
+	};
+}));
+
+//#endregion
+export default require_formats();
+
+export { require_formats };

package/dist/node_modules/body-parser/node_modules/qs/lib/index.mjs

@@ -0,0 +1,21 @@
+import { __commonJSMin } from "../../../../../_virtual/rolldown_runtime.mjs";
+import { require_formats } from "./formats.mjs";
+import { require_stringify } from "./stringify.mjs";
+import { require_parse } from "./parse.mjs";
+
+//#region ../../node_modules/body-parser/node_modules/qs/lib/index.js
+var require_lib = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var stringify = require_stringify();
+	var parse = require_parse();
+	var formats = require_formats();
+	module.exports = {
+		formats,
+		parse,
+		stringify
+	};
+}));
+
+//#endregion
+export default require_lib();
+
+export { require_lib };