c8y-nitro 0.1.0 → 0.1.1

package/dist/node_modules/.pnpm/cross-fetch@4.1.0_encoding@0.1.13/node_modules/cross-fetch/dist/node-ponyfill.mjs

@@ -0,0 +1,24 @@
+import { __commonJSMin } from "../../../../../../_virtual/rolldown_runtime.mjs";
+import { require_lib } from "../../../../node-fetch@2.7.0_encoding@0.1.13/node_modules/node-fetch/lib/index.mjs";
+
+//#region node_modules/.pnpm/cross-fetch@4.1.0_encoding@0.1.13/node_modules/cross-fetch/dist/node-ponyfill.js
+var require_node_ponyfill = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const nodeFetch = require_lib();
+	const realFetch = nodeFetch.default || nodeFetch;
+	const fetch = function(url, options) {
+		if (/^\/\//.test(url)) url = "https:" + url;
+		return realFetch.call(this, url, options);
+	};
+	fetch.ponyfill = true;
+	module.exports = exports = fetch;
+	exports.fetch = fetch;
+	exports.Headers = nodeFetch.Headers;
+	exports.Request = nodeFetch.Request;
+	exports.Response = nodeFetch.Response;
+	exports.default = fetch;
+}));
+
+//#endregion
+export default require_node_ponyfill();
+
+export { require_node_ponyfill };

package/dist/node_modules/.pnpm/delayed-stream@1.0.0/node_modules/delayed-stream/lib/delayed_stream.mjs

@@ -0,0 +1,84 @@
+import { __commonJSMin, __require } from "../../../../../../_virtual/rolldown_runtime.mjs";
+
+//#region node_modules/.pnpm/delayed-stream@1.0.0/node_modules/delayed-stream/lib/delayed_stream.js
+var require_delayed_stream = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Stream = __require("stream").Stream;
+	var util = __require("util");
+	module.exports = DelayedStream;
+	function DelayedStream() {
+		this.source = null;
+		this.dataSize = 0;
+		this.maxDataSize = 1024 * 1024;
+		this.pauseStream = true;
+		this._maxDataSizeExceeded = false;
+		this._released = false;
+		this._bufferedEvents = [];
+	}
+	util.inherits(DelayedStream, Stream);
+	DelayedStream.create = function(source, options) {
+		var delayedStream = new this();
+		options = options || {};
+		for (var option in options) delayedStream[option] = options[option];
+		delayedStream.source = source;
+		var realEmit = source.emit;
+		source.emit = function() {
+			delayedStream._handleEmit(arguments);
+			return realEmit.apply(source, arguments);
+		};
+		source.on("error", function() {});
+		if (delayedStream.pauseStream) source.pause();
+		return delayedStream;
+	};
+	Object.defineProperty(DelayedStream.prototype, "readable", {
+		configurable: true,
+		enumerable: true,
+		get: function() {
+			return this.source.readable;
+		}
+	});
+	DelayedStream.prototype.setEncoding = function() {
+		return this.source.setEncoding.apply(this.source, arguments);
+	};
+	DelayedStream.prototype.resume = function() {
+		if (!this._released) this.release();
+		this.source.resume();
+	};
+	DelayedStream.prototype.pause = function() {
+		this.source.pause();
+	};
+	DelayedStream.prototype.release = function() {
+		this._released = true;
+		this._bufferedEvents.forEach(function(args) {
+			this.emit.apply(this, args);
+		}.bind(this));
+		this._bufferedEvents = [];
+	};
+	DelayedStream.prototype.pipe = function() {
+		var r = Stream.prototype.pipe.apply(this, arguments);
+		this.resume();
+		return r;
+	};
+	DelayedStream.prototype._handleEmit = function(args) {
+		if (this._released) {
+			this.emit.apply(this, args);
+			return;
+		}
+		if (args[0] === "data") {
+			this.dataSize += args[1].length;
+			this._checkIfMaxDataSizeExceeded();
+		}
+		this._bufferedEvents.push(args);
+	};
+	DelayedStream.prototype._checkIfMaxDataSizeExceeded = function() {
+		if (this._maxDataSizeExceeded) return;
+		if (this.dataSize <= this.maxDataSize) return;
+		this._maxDataSizeExceeded = true;
+		var message = "DelayedStream#maxDataSize of " + this.maxDataSize + " bytes exceeded.";
+		this.emit("error", new Error(message));
+	};
+}));
+
+//#endregion
+export default require_delayed_stream();
+
+export { require_delayed_stream };

package/dist/node_modules/.pnpm/dunder-proto@1.0.1/node_modules/dunder-proto/get.mjs

@@ -0,0 +1,27 @@
+import { __commonJSMin } from "../../../../../_virtual/rolldown_runtime.mjs";
+import { require_gopd } from "../../../gopd@1.2.0/node_modules/gopd/index.mjs";
+import { require_call_bind_apply_helpers } from "../../../call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/index.mjs";
+
+//#region node_modules/.pnpm/dunder-proto@1.0.1/node_modules/dunder-proto/get.js
+var require_get = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var callBind = require_call_bind_apply_helpers();
+	var gOPD = require_gopd();
+	var hasProtoAccessor;
+	try {
+		hasProtoAccessor = [].__proto__ === Array.prototype;
+	} catch (e) {
+		if (!e || typeof e !== "object" || !("code" in e) || e.code !== "ERR_PROTO_ACCESS") throw e;
+	}
+	var desc = !!hasProtoAccessor && gOPD && gOPD(Object.prototype, "__proto__");
+	var $Object = Object;
+	var $getPrototypeOf = $Object.getPrototypeOf;
+	/** @type {import('./get')} */
+	module.exports = desc && typeof desc.get === "function" ? callBind([desc.get]) : typeof $getPrototypeOf === "function" ? function getDunder(value) {
+		return $getPrototypeOf(value == null ? value : $Object(value));
+	} : false;
+}));
+
+//#endregion
+export default require_get();
+
+export { require_get };

package/dist/node_modules/.pnpm/encoding@0.1.13/node_modules/encoding/lib/encoding.mjs

@@ -0,0 +1,60 @@
+import { __commonJSMin } from "../../../../../../_virtual/rolldown_runtime.mjs";
+import { require_lib } from "../../../../iconv-lite@0.6.3/node_modules/iconv-lite/lib/index.mjs";
+
+//#region node_modules/.pnpm/encoding@0.1.13/node_modules/encoding/lib/encoding.js
+var require_encoding = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var iconvLite = require_lib();
+	module.exports.convert = convert;
+	/**
+	* Convert encoding of an UTF-8 string or a buffer
+	*
+	* @param {String|Buffer} str String to be converted
+	* @param {String} to Encoding to be converted to
+	* @param {String} [from='UTF-8'] Encoding to be converted from
+	* @return {Buffer} Encoded string
+	*/
+	function convert(str, to, from) {
+		from = checkEncoding(from || "UTF-8");
+		to = checkEncoding(to || "UTF-8");
+		str = str || "";
+		var result;
+		if (from !== "UTF-8" && typeof str === "string") str = Buffer.from(str, "binary");
+		if (from === to) if (typeof str === "string") result = Buffer.from(str);
+		else result = str;
+		else try {
+			result = convertIconvLite(str, to, from);
+		} catch (E) {
+			console.error(E);
+			result = str;
+		}
+		if (typeof result === "string") result = Buffer.from(result, "utf-8");
+		return result;
+	}
+	/**
+	* Convert encoding of astring with iconv-lite
+	*
+	* @param {String|Buffer} str String to be converted
+	* @param {String} to Encoding to be converted to
+	* @param {String} [from='UTF-8'] Encoding to be converted from
+	* @return {Buffer} Encoded string
+	*/
+	function convertIconvLite(str, to, from) {
+		if (to === "UTF-8") return iconvLite.decode(str, from);
+		else if (from === "UTF-8") return iconvLite.encode(str, to);
+		else return iconvLite.encode(iconvLite.decode(str, from), to);
+	}
+	/**
+	* Converts charset name if needed
+	*
+	* @param {String} name Character set
+	* @return {String} Character set name
+	*/
+	function checkEncoding(name) {
+		return (name || "").toString().trim().replace(/^latin[\-_]?(\d+)$/i, "ISO-8859-$1").replace(/^win(?:dows)?[\-_]?(\d+)$/i, "WINDOWS-$1").replace(/^utf[\-_]?(\d+)$/i, "UTF-$1").replace(/^ks_c_5601\-1987$/i, "CP949").replace(/^us[\-_]?ascii$/i, "ASCII").toUpperCase();
+	}
+}));
+
+//#endregion
+export default require_encoding();
+
+export { require_encoding };

package/dist/node_modules/.pnpm/es-define-property@1.0.1/node_modules/es-define-property/index.mjs

@@ -0,0 +1,18 @@
+import { __commonJSMin } from "../../../../../_virtual/rolldown_runtime.mjs";
+
+//#region node_modules/.pnpm/es-define-property@1.0.1/node_modules/es-define-property/index.js
+var require_es_define_property = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type {import('.')} */
+	var $defineProperty = Object.defineProperty || false;
+	if ($defineProperty) try {
+		$defineProperty({}, "a", { value: 1 });
+	} catch (e) {
+		$defineProperty = false;
+	}
+	module.exports = $defineProperty;
+}));
+
+//#endregion
+export default require_es_define_property();
+
+export { require_es_define_property };

package/dist/node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/eval.mjs

@@ -0,0 +1,12 @@
+import { __commonJSMin } from "../../../../../_virtual/rolldown_runtime.mjs";
+
+//#region node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/eval.js
+var require_eval = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type {import('./eval')} */
+	module.exports = EvalError;
+}));
+
+//#endregion
+export default require_eval();
+
+export { require_eval };

package/dist/node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/index.mjs

@@ -0,0 +1,12 @@
+import { __commonJSMin } from "../../../../../_virtual/rolldown_runtime.mjs";
+
+//#region node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/index.js
+var require_es_errors = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type {import('.')} */
+	module.exports = Error;
+}));
+
+//#endregion
+export default require_es_errors();
+
+export { require_es_errors };

package/dist/node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/range.mjs

@@ -0,0 +1,12 @@
+import { __commonJSMin } from "../../../../../_virtual/rolldown_runtime.mjs";
+
+//#region node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/range.js
+var require_range = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type {import('./range')} */
+	module.exports = RangeError;
+}));
+
+//#endregion
+export default require_range();
+
+export { require_range };

package/dist/node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/ref.mjs

@@ -0,0 +1,12 @@
+import { __commonJSMin } from "../../../../../_virtual/rolldown_runtime.mjs";
+
+//#region node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/ref.js
+var require_ref = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type {import('./ref')} */
+	module.exports = ReferenceError;
+}));
+
+//#endregion
+export default require_ref();
+
+export { require_ref };

package/dist/node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/syntax.mjs

@@ -0,0 +1,12 @@
+import { __commonJSMin } from "../../../../../_virtual/rolldown_runtime.mjs";
+
+//#region node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/syntax.js
+var require_syntax = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type {import('./syntax')} */
+	module.exports = SyntaxError;
+}));
+
+//#endregion
+export default require_syntax();
+
+export { require_syntax };

package/dist/node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/type.mjs

@@ -0,0 +1,12 @@
+import { __commonJSMin } from "../../../../../_virtual/rolldown_runtime.mjs";
+
+//#region node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/type.js
+var require_type = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type {import('./type')} */
+	module.exports = TypeError;
+}));
+
+//#endregion
+export default require_type();
+
+export { require_type };

package/dist/node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/uri.mjs

@@ -0,0 +1,12 @@
+import { __commonJSMin } from "../../../../../_virtual/rolldown_runtime.mjs";
+
+//#region node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/uri.js
+var require_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type {import('./uri')} */
+	module.exports = URIError;
+}));
+
+//#endregion
+export default require_uri();
+
+export { require_uri };

package/dist/node_modules/.pnpm/es-object-atoms@1.1.1/node_modules/es-object-atoms/index.mjs

@@ -0,0 +1,12 @@
+import { __commonJSMin } from "../../../../../_virtual/rolldown_runtime.mjs";
+
+//#region node_modules/.pnpm/es-object-atoms@1.1.1/node_modules/es-object-atoms/index.js
+var require_es_object_atoms = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type {import('.')} */
+	module.exports = Object;
+}));
+
+//#endregion
+export default require_es_object_atoms();
+
+export { require_es_object_atoms };

package/dist/node_modules/.pnpm/es-set-tostringtag@2.1.0/node_modules/es-set-tostringtag/index.mjs

@@ -0,0 +1,32 @@
+import { __commonJSMin } from "../../../../../_virtual/rolldown_runtime.mjs";
+import { require_type } from "../../../es-errors@1.3.0/node_modules/es-errors/type.mjs";
+import { require_hasown } from "../../../hasown@2.0.2/node_modules/hasown/index.mjs";
+import { require_get_intrinsic } from "../../../get-intrinsic@1.3.0/node_modules/get-intrinsic/index.mjs";
+import { require_shams } from "../../../has-tostringtag@1.0.2/node_modules/has-tostringtag/shams.mjs";
+
+//#region node_modules/.pnpm/es-set-tostringtag@2.1.0/node_modules/es-set-tostringtag/index.js
+var require_es_set_tostringtag = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var $defineProperty = require_get_intrinsic()("%Object.defineProperty%", true);
+	var hasToStringTag = require_shams()();
+	var hasOwn = require_hasown();
+	var $TypeError = require_type();
+	var toStringTag = hasToStringTag ? Symbol.toStringTag : null;
+	/** @type {import('.')} */
+	module.exports = function setToStringTag(object, value) {
+		var overrideIfSet = arguments.length > 2 && !!arguments[2] && arguments[2].force;
+		var nonConfigurable = arguments.length > 2 && !!arguments[2] && arguments[2].nonConfigurable;
+		if (typeof overrideIfSet !== "undefined" && typeof overrideIfSet !== "boolean" || typeof nonConfigurable !== "undefined" && typeof nonConfigurable !== "boolean") throw new $TypeError("if provided, the `overrideIfSet` and `nonConfigurable` options must be booleans");
+		if (toStringTag && (overrideIfSet || !hasOwn(object, toStringTag))) if ($defineProperty) $defineProperty(object, toStringTag, {
+			configurable: !nonConfigurable,
+			enumerable: false,
+			value,
+			writable: false
+		});
+		else object[toStringTag] = value;
+	};
+}));
+
+//#endregion
+export default require_es_set_tostringtag();
+
+export { require_es_set_tostringtag };

package/dist/node_modules/.pnpm/form-data@4.0.4/node_modules/form-data/index.d.mts

@@ -0,0 +1,50 @@
+/// <reference types="node" />
+import * as stream from "stream";
+import * as http from "http";
+
+//#region node_modules/.pnpm/form-data@4.0.4/node_modules/form-data/index.d.ts
+// Extracted because @types/node doesn't export interfaces.
+interface ReadableOptions {
+  highWaterMark?: number;
+  encoding?: string;
+  objectMode?: boolean;
+  read?(this: stream.Readable, size: number): void;
+  destroy?(this: stream.Readable, error: Error | null, callback: (error: Error | null) => void): void;
+  autoDestroy?: boolean;
+}
+interface Options extends ReadableOptions {
+  writable?: boolean;
+  readable?: boolean;
+  dataSize?: number;
+  maxDataSize?: number;
+  pauseStreams?: boolean;
+}
+declare class FormData extends stream.Readable {
+  constructor(options?: Options);
+  append(key: string, value: any, options?: FormData.AppendOptions | string): void;
+  getHeaders(userHeaders?: FormData.Headers): FormData.Headers;
+  submit(params: string | FormData.SubmitOptions, callback?: (error: Error | null, response: http.IncomingMessage) => void): http.ClientRequest;
+  getBuffer(): Buffer;
+  setBoundary(boundary: string): void;
+  getBoundary(): string;
+  getLength(callback: (err: Error | null, length: number) => void): void;
+  getLengthSync(): number;
+  hasKnownLength(): boolean;
+}
+declare namespace FormData {
+  interface Headers {
+    [key: string]: any;
+  }
+  interface AppendOptions {
+    header?: string | Headers;
+    knownLength?: number;
+    filename?: string;
+    filepath?: string;
+    contentType?: string;
+  }
+  interface SubmitOptions extends http.RequestOptions {
+    protocol?: 'https:' | 'http:';
+  }
+}
+//#endregion
+export { FormData };

package/dist/node_modules/.pnpm/form-data@4.0.4/node_modules/form-data/lib/form_data.mjs

@@ -0,0 +1,247 @@
+import { __commonJSMin, __require } from "../../../../../../_virtual/rolldown_runtime.mjs";
+import { require_combined_stream } from "../../../../combined-stream@1.0.8/node_modules/combined-stream/lib/combined_stream.mjs";
+import { require_mime_types } from "../../../../mime-types@2.1.35/node_modules/mime-types/index.mjs";
+import { require_asynckit } from "../../../../asynckit@0.4.0/node_modules/asynckit/index.mjs";
+import { require_hasown } from "../../../../hasown@2.0.2/node_modules/hasown/index.mjs";
+import { require_es_set_tostringtag } from "../../../../es-set-tostringtag@2.1.0/node_modules/es-set-tostringtag/index.mjs";
+import { require_populate } from "./populate.mjs";
+
+//#region node_modules/.pnpm/form-data@4.0.4/node_modules/form-data/lib/form_data.js
+var require_form_data = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var CombinedStream = require_combined_stream();
+	var util = __require("util");
+	var path = __require("path");
+	var http = __require("http");
+	var https = __require("https");
+	var parseUrl = __require("url").parse;
+	var fs = __require("fs");
+	var Stream = __require("stream").Stream;
+	var crypto = __require("crypto");
+	var mime = require_mime_types();
+	var asynckit = require_asynckit();
+	var setToStringTag = require_es_set_tostringtag();
+	var hasOwn = require_hasown();
+	var populate = require_populate();
+	/**
+	* Create readable "multipart/form-data" streams.
+	* Can be used to submit forms
+	* and file uploads to other web applications.
+	*
+	* @constructor
+	* @param {object} options - Properties to be added/overriden for FormData and CombinedStream
+	*/
+	function FormData(options) {
+		if (!(this instanceof FormData)) return new FormData(options);
+		this._overheadLength = 0;
+		this._valueLength = 0;
+		this._valuesToMeasure = [];
+		CombinedStream.call(this);
+		options = options || {};
+		for (var option in options) this[option] = options[option];
+	}
+	util.inherits(FormData, CombinedStream);
+	FormData.LINE_BREAK = "\r\n";
+	FormData.DEFAULT_CONTENT_TYPE = "application/octet-stream";
+	FormData.prototype.append = function(field, value, options) {
+		options = options || {};
+		if (typeof options === "string") options = { filename: options };
+		var append = CombinedStream.prototype.append.bind(this);
+		if (typeof value === "number" || value == null) value = String(value);
+		if (Array.isArray(value)) {
+			this._error(/* @__PURE__ */ new Error("Arrays are not supported."));
+			return;
+		}
+		var header = this._multiPartHeader(field, value, options);
+		var footer = this._multiPartFooter();
+		append(header);
+		append(value);
+		append(footer);
+		this._trackLength(header, value, options);
+	};
+	FormData.prototype._trackLength = function(header, value, options) {
+		var valueLength = 0;
+		if (options.knownLength != null) valueLength += Number(options.knownLength);
+		else if (Buffer.isBuffer(value)) valueLength = value.length;
+		else if (typeof value === "string") valueLength = Buffer.byteLength(value);
+		this._valueLength += valueLength;
+		this._overheadLength += Buffer.byteLength(header) + FormData.LINE_BREAK.length;
+		if (!value || !value.path && !(value.readable && hasOwn(value, "httpVersion")) && !(value instanceof Stream)) return;
+		if (!options.knownLength) this._valuesToMeasure.push(value);
+	};
+	FormData.prototype._lengthRetriever = function(value, callback) {
+		if (hasOwn(value, "fd")) if (value.end != void 0 && value.end != Infinity && value.start != void 0) callback(null, value.end + 1 - (value.start ? value.start : 0));
+		else fs.stat(value.path, function(err, stat) {
+			if (err) {
+				callback(err);
+				return;
+			}
+			callback(null, stat.size - (value.start ? value.start : 0));
+		});
+		else if (hasOwn(value, "httpVersion")) callback(null, Number(value.headers["content-length"]));
+		else if (hasOwn(value, "httpModule")) {
+			value.on("response", function(response) {
+				value.pause();
+				callback(null, Number(response.headers["content-length"]));
+			});
+			value.resume();
+		} else callback("Unknown stream");
+	};
+	FormData.prototype._multiPartHeader = function(field, value, options) {
+		if (typeof options.header === "string") return options.header;
+		var contentDisposition = this._getContentDisposition(value, options);
+		var contentType = this._getContentType(value, options);
+		var contents = "";
+		var headers = {
+			"Content-Disposition": ["form-data", "name=\"" + field + "\""].concat(contentDisposition || []),
+			"Content-Type": [].concat(contentType || [])
+		};
+		if (typeof options.header === "object") populate(headers, options.header);
+		var header;
+		for (var prop in headers) if (hasOwn(headers, prop)) {
+			header = headers[prop];
+			if (header == null) continue;
+			if (!Array.isArray(header)) header = [header];
+			if (header.length) contents += prop + ": " + header.join("; ") + FormData.LINE_BREAK;
+		}
+		return "--" + this.getBoundary() + FormData.LINE_BREAK + contents + FormData.LINE_BREAK;
+	};
+	FormData.prototype._getContentDisposition = function(value, options) {
+		var filename;
+		if (typeof options.filepath === "string") filename = path.normalize(options.filepath).replace(/\\/g, "/");
+		else if (options.filename || value && (value.name || value.path)) filename = path.basename(options.filename || value && (value.name || value.path));
+		else if (value && value.readable && hasOwn(value, "httpVersion")) filename = path.basename(value.client._httpMessage.path || "");
+		if (filename) return "filename=\"" + filename + "\"";
+	};
+	FormData.prototype._getContentType = function(value, options) {
+		var contentType = options.contentType;
+		if (!contentType && value && value.name) contentType = mime.lookup(value.name);
+		if (!contentType && value && value.path) contentType = mime.lookup(value.path);
+		if (!contentType && value && value.readable && hasOwn(value, "httpVersion")) contentType = value.headers["content-type"];
+		if (!contentType && (options.filepath || options.filename)) contentType = mime.lookup(options.filepath || options.filename);
+		if (!contentType && value && typeof value === "object") contentType = FormData.DEFAULT_CONTENT_TYPE;
+		return contentType;
+	};
+	FormData.prototype._multiPartFooter = function() {
+		return function(next) {
+			var footer = FormData.LINE_BREAK;
+			if (this._streams.length === 0) footer += this._lastBoundary();
+			next(footer);
+		}.bind(this);
+	};
+	FormData.prototype._lastBoundary = function() {
+		return "--" + this.getBoundary() + "--" + FormData.LINE_BREAK;
+	};
+	FormData.prototype.getHeaders = function(userHeaders) {
+		var header;
+		var formHeaders = { "content-type": "multipart/form-data; boundary=" + this.getBoundary() };
+		for (header in userHeaders) if (hasOwn(userHeaders, header)) formHeaders[header.toLowerCase()] = userHeaders[header];
+		return formHeaders;
+	};
+	FormData.prototype.setBoundary = function(boundary) {
+		if (typeof boundary !== "string") throw new TypeError("FormData boundary must be a string");
+		this._boundary = boundary;
+	};
+	FormData.prototype.getBoundary = function() {
+		if (!this._boundary) this._generateBoundary();
+		return this._boundary;
+	};
+	FormData.prototype.getBuffer = function() {
+		var dataBuffer = new Buffer.alloc(0);
+		var boundary = this.getBoundary();
+		for (var i = 0, len = this._streams.length; i < len; i++) if (typeof this._streams[i] !== "function") {
+			if (Buffer.isBuffer(this._streams[i])) dataBuffer = Buffer.concat([dataBuffer, this._streams[i]]);
+			else dataBuffer = Buffer.concat([dataBuffer, Buffer.from(this._streams[i])]);
+			if (typeof this._streams[i] !== "string" || this._streams[i].substring(2, boundary.length + 2) !== boundary) dataBuffer = Buffer.concat([dataBuffer, Buffer.from(FormData.LINE_BREAK)]);
+		}
+		return Buffer.concat([dataBuffer, Buffer.from(this._lastBoundary())]);
+	};
+	FormData.prototype._generateBoundary = function() {
+		this._boundary = "--------------------------" + crypto.randomBytes(12).toString("hex");
+	};
+	FormData.prototype.getLengthSync = function() {
+		var knownLength = this._overheadLength + this._valueLength;
+		if (this._streams.length) knownLength += this._lastBoundary().length;
+		if (!this.hasKnownLength()) this._error(/* @__PURE__ */ new Error("Cannot calculate proper length in synchronous way."));
+		return knownLength;
+	};
+	FormData.prototype.hasKnownLength = function() {
+		var hasKnownLength = true;
+		if (this._valuesToMeasure.length) hasKnownLength = false;
+		return hasKnownLength;
+	};
+	FormData.prototype.getLength = function(cb) {
+		var knownLength = this._overheadLength + this._valueLength;
+		if (this._streams.length) knownLength += this._lastBoundary().length;
+		if (!this._valuesToMeasure.length) {
+			process.nextTick(cb.bind(this, null, knownLength));
+			return;
+		}
+		asynckit.parallel(this._valuesToMeasure, this._lengthRetriever, function(err, values) {
+			if (err) {
+				cb(err);
+				return;
+			}
+			values.forEach(function(length) {
+				knownLength += length;
+			});
+			cb(null, knownLength);
+		});
+	};
+	FormData.prototype.submit = function(params, cb) {
+		var request;
+		var options;
+		var defaults = { method: "post" };
+		if (typeof params === "string") {
+			params = parseUrl(params);
+			options = populate({
+				port: params.port,
+				path: params.pathname,
+				host: params.hostname,
+				protocol: params.protocol
+			}, defaults);
+		} else {
+			options = populate(params, defaults);
+			if (!options.port) options.port = options.protocol === "https:" ? 443 : 80;
+		}
+		options.headers = this.getHeaders(params.headers);
+		if (options.protocol === "https:") request = https.request(options);
+		else request = http.request(options);
+		this.getLength(function(err, length) {
+			if (err && err !== "Unknown stream") {
+				this._error(err);
+				return;
+			}
+			if (length) request.setHeader("Content-Length", length);
+			this.pipe(request);
+			if (cb) {
+				var onResponse;
+				var callback = function(error, responce) {
+					request.removeListener("error", callback);
+					request.removeListener("response", onResponse);
+					return cb.call(this, error, responce);
+				};
+				onResponse = callback.bind(this, null);
+				request.on("error", callback);
+				request.on("response", onResponse);
+			}
+		}.bind(this));
+		return request;
+	};
+	FormData.prototype._error = function(err) {
+		if (!this.error) {
+			this.error = err;
+			this.pause();
+			this.emit("error", err);
+		}
+	};
+	FormData.prototype.toString = function() {
+		return "[object FormData]";
+	};
+	setToStringTag(FormData, "FormData");
+	module.exports = FormData;
+}));
+
+//#endregion
+export default require_form_data();
+
+export { require_form_data };