c8y-nitro 0.1.0 → 0.1.1

package/dist/node_modules/.pnpm/b2a@1.1.2/node_modules/b2a/lib/index.mjs

@@ -0,0 +1,44 @@
+import { __commonJSMin } from "../../../../../../_virtual/rolldown_runtime.mjs";
+
+//#region node_modules/.pnpm/b2a@1.1.2/node_modules/b2a/lib/index.js
+var require_lib = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	var error = function error(message) {
+		function E() {
+			this.message = message;
+		}
+		E.prototype = /* @__PURE__ */ new Error();
+		E.prototype.name = "InvalidCharacterError";
+		E.prototype.code = 5;
+		return E;
+	};
+	var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+	var E = error("The string to be encoded contains characters out of range");
+	var _btoa = typeof btoa !== "undefined" ? function(input) {
+		return btoa(input);
+	} : function(input) {
+		var str = String(input);
+		var output = "";
+		for (var block, charCode, idx = 0, map = chars; str.charAt(idx | 0) || (map = "=", idx % 1); output += map.charAt(63 & block >> 8 - idx % 1 * 8)) {
+			charCode = str.charCodeAt(idx += 3 / 4);
+			if (charCode > 255) throw new E();
+			block = block << 8 | charCode;
+		}
+		return output;
+	};
+	var utf8 = function utf8(input) {
+		return encodeURIComponent(input).replace(/%([0-9A-F]{2})/g, function(match, p1) {
+			return String.fromCharCode("0x" + p1);
+		});
+	};
+	var btoa$1 = (function(input) {
+		return _btoa(utf8(input));
+	});
+	var E$1 = error("The string to be decoded is not correctly encoded");
+	exports.btoa = btoa$1;
+}));
+
+//#endregion
+export default require_lib();
+
+export { require_lib };

package/dist/node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/actualApply.mjs

@@ -0,0 +1,20 @@
+import { __commonJSMin } from "../../../../../_virtual/rolldown_runtime.mjs";
+import { require_function_bind } from "../../../function-bind@1.1.2/node_modules/function-bind/index.mjs";
+import { require_functionCall } from "./functionCall.mjs";
+import { require_functionApply } from "./functionApply.mjs";
+import { require_reflectApply } from "./reflectApply.mjs";
+
+//#region node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/actualApply.js
+var require_actualApply = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var bind = require_function_bind();
+	var $apply = require_functionApply();
+	var $call = require_functionCall();
+	var $reflectApply = require_reflectApply();
+	/** @type {import('./actualApply')} */
+	module.exports = $reflectApply || bind.call($call, $apply);
+}));
+
+//#endregion
+export default require_actualApply();
+
+export { require_actualApply };

package/dist/node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionApply.mjs

@@ -0,0 +1,12 @@
+import { __commonJSMin } from "../../../../../_virtual/rolldown_runtime.mjs";
+
+//#region node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionApply.js
+var require_functionApply = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type {import('./functionApply')} */
+	module.exports = Function.prototype.apply;
+}));
+
+//#endregion
+export default require_functionApply();
+
+export { require_functionApply };

package/dist/node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionCall.mjs

@@ -0,0 +1,12 @@
+import { __commonJSMin } from "../../../../../_virtual/rolldown_runtime.mjs";
+
+//#region node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionCall.js
+var require_functionCall = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type {import('./functionCall')} */
+	module.exports = Function.prototype.call;
+}));
+
+//#endregion
+export default require_functionCall();
+
+export { require_functionCall };

package/dist/node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/index.mjs

@@ -0,0 +1,23 @@
+import { __commonJSMin } from "../../../../../_virtual/rolldown_runtime.mjs";
+import { require_type } from "../../../es-errors@1.3.0/node_modules/es-errors/type.mjs";
+import { require_function_bind } from "../../../function-bind@1.1.2/node_modules/function-bind/index.mjs";
+import { require_functionCall } from "./functionCall.mjs";
+import { require_actualApply } from "./actualApply.mjs";
+
+//#region node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/index.js
+var require_call_bind_apply_helpers = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var bind = require_function_bind();
+	var $TypeError = require_type();
+	var $call = require_functionCall();
+	var $actualApply = require_actualApply();
+	/** @type {(args: [Function, thisArg?: unknown, ...args: unknown[]]) => Function} TODO FIXME, find a way to use import('.') */
+	module.exports = function callBindBasic(args) {
+		if (args.length < 1 || typeof args[0] !== "function") throw new $TypeError("a function is required");
+		return $actualApply(bind, $call, args);
+	};
+}));
+
+//#endregion
+export default require_call_bind_apply_helpers();
+
+export { require_call_bind_apply_helpers };

package/dist/node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/reflectApply.mjs

@@ -0,0 +1,12 @@
+import { __commonJSMin } from "../../../../../_virtual/rolldown_runtime.mjs";
+
+//#region node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/reflectApply.js
+var require_reflectApply = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type {import('./reflectApply')} */
+	module.exports = typeof Reflect !== "undefined" && Reflect && Reflect.apply;
+}));
+
+//#endregion
+export default require_reflectApply();
+
+export { require_reflectApply };

package/dist/node_modules/.pnpm/combined-stream@1.0.8/node_modules/combined-stream/lib/combined_stream.mjs

@@ -0,0 +1,158 @@
+import { __commonJSMin, __require } from "../../../../../../_virtual/rolldown_runtime.mjs";
+import { require_delayed_stream } from "../../../../delayed-stream@1.0.0/node_modules/delayed-stream/lib/delayed_stream.mjs";
+
+//#region node_modules/.pnpm/combined-stream@1.0.8/node_modules/combined-stream/lib/combined_stream.js
+var require_combined_stream = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var util = __require("util");
+	var Stream = __require("stream").Stream;
+	var DelayedStream = require_delayed_stream();
+	module.exports = CombinedStream;
+	function CombinedStream() {
+		this.writable = false;
+		this.readable = true;
+		this.dataSize = 0;
+		this.maxDataSize = 2 * 1024 * 1024;
+		this.pauseStreams = true;
+		this._released = false;
+		this._streams = [];
+		this._currentStream = null;
+		this._insideLoop = false;
+		this._pendingNext = false;
+	}
+	util.inherits(CombinedStream, Stream);
+	CombinedStream.create = function(options) {
+		var combinedStream = new this();
+		options = options || {};
+		for (var option in options) combinedStream[option] = options[option];
+		return combinedStream;
+	};
+	CombinedStream.isStreamLike = function(stream) {
+		return typeof stream !== "function" && typeof stream !== "string" && typeof stream !== "boolean" && typeof stream !== "number" && !Buffer.isBuffer(stream);
+	};
+	CombinedStream.prototype.append = function(stream) {
+		if (CombinedStream.isStreamLike(stream)) {
+			if (!(stream instanceof DelayedStream)) {
+				var newStream = DelayedStream.create(stream, {
+					maxDataSize: Infinity,
+					pauseStream: this.pauseStreams
+				});
+				stream.on("data", this._checkDataSize.bind(this));
+				stream = newStream;
+			}
+			this._handleErrors(stream);
+			if (this.pauseStreams) stream.pause();
+		}
+		this._streams.push(stream);
+		return this;
+	};
+	CombinedStream.prototype.pipe = function(dest, options) {
+		Stream.prototype.pipe.call(this, dest, options);
+		this.resume();
+		return dest;
+	};
+	CombinedStream.prototype._getNext = function() {
+		this._currentStream = null;
+		if (this._insideLoop) {
+			this._pendingNext = true;
+			return;
+		}
+		this._insideLoop = true;
+		try {
+			do {
+				this._pendingNext = false;
+				this._realGetNext();
+			} while (this._pendingNext);
+		} finally {
+			this._insideLoop = false;
+		}
+	};
+	CombinedStream.prototype._realGetNext = function() {
+		var stream = this._streams.shift();
+		if (typeof stream == "undefined") {
+			this.end();
+			return;
+		}
+		if (typeof stream !== "function") {
+			this._pipeNext(stream);
+			return;
+		}
+		stream(function(stream) {
+			if (CombinedStream.isStreamLike(stream)) {
+				stream.on("data", this._checkDataSize.bind(this));
+				this._handleErrors(stream);
+			}
+			this._pipeNext(stream);
+		}.bind(this));
+	};
+	CombinedStream.prototype._pipeNext = function(stream) {
+		this._currentStream = stream;
+		if (CombinedStream.isStreamLike(stream)) {
+			stream.on("end", this._getNext.bind(this));
+			stream.pipe(this, { end: false });
+			return;
+		}
+		var value = stream;
+		this.write(value);
+		this._getNext();
+	};
+	CombinedStream.prototype._handleErrors = function(stream) {
+		var self = this;
+		stream.on("error", function(err) {
+			self._emitError(err);
+		});
+	};
+	CombinedStream.prototype.write = function(data) {
+		this.emit("data", data);
+	};
+	CombinedStream.prototype.pause = function() {
+		if (!this.pauseStreams) return;
+		if (this.pauseStreams && this._currentStream && typeof this._currentStream.pause == "function") this._currentStream.pause();
+		this.emit("pause");
+	};
+	CombinedStream.prototype.resume = function() {
+		if (!this._released) {
+			this._released = true;
+			this.writable = true;
+			this._getNext();
+		}
+		if (this.pauseStreams && this._currentStream && typeof this._currentStream.resume == "function") this._currentStream.resume();
+		this.emit("resume");
+	};
+	CombinedStream.prototype.end = function() {
+		this._reset();
+		this.emit("end");
+	};
+	CombinedStream.prototype.destroy = function() {
+		this._reset();
+		this.emit("close");
+	};
+	CombinedStream.prototype._reset = function() {
+		this.writable = false;
+		this._streams = [];
+		this._currentStream = null;
+	};
+	CombinedStream.prototype._checkDataSize = function() {
+		this._updateDataSize();
+		if (this.dataSize <= this.maxDataSize) return;
+		var message = "DelayedStream#maxDataSize of " + this.maxDataSize + " bytes exceeded.";
+		this._emitError(new Error(message));
+	};
+	CombinedStream.prototype._updateDataSize = function() {
+		this.dataSize = 0;
+		var self = this;
+		this._streams.forEach(function(stream) {
+			if (!stream.dataSize) return;
+			self.dataSize += stream.dataSize;
+		});
+		if (this._currentStream && this._currentStream.dataSize) this.dataSize += this._currentStream.dataSize;
+	};
+	CombinedStream.prototype._emitError = function(err) {
+		this._reset();
+		this.emit("error", err);
+	};
+}));
+
+//#endregion
+export default require_combined_stream();
+
+export { require_combined_stream };

package/dist/node_modules/.pnpm/cometd-nodejs-client@1.0.2/node_modules/cometd-nodejs-client/cometd-nodejs-client.mjs

@@ -0,0 +1,120 @@
+import { __commonJSMin, __require } from "../../../../../_virtual/rolldown_runtime.mjs";
+
+//#region node_modules/.pnpm/cometd-nodejs-client@1.0.2/node_modules/cometd-nodejs-client/cometd-nodejs-client.js
+var require_cometd_nodejs_client = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = { adapt: function() {
+		var url = __require("url");
+		var httpc = __require("http");
+		var https = __require("https");
+		global.window = {};
+		window.setTimeout = setTimeout;
+		window.clearTimeout = clearTimeout;
+		window.console = console;
+		window.console.debug = window.console.log;
+		var _agentc = new httpc.Agent({ keepAlive: true });
+		var _agents = new https.Agent({ keepAlive: true });
+		var _cookieStore = {};
+		function _secure(uri) {
+			return /^https/i.test(uri.protocol);
+		}
+		window.XMLHttpRequest = function() {
+			var _config;
+			var _request;
+			this.status = 0;
+			this.statusText = "";
+			this.readyState = window.XMLHttpRequest.UNSENT;
+			this.responseText = "";
+			this.open = function(method, uri) {
+				_config = url.parse(uri);
+				_config.method = method;
+				_config.agent = _secure(_config) ? _agents : _agentc;
+				_config.headers = {};
+				this.readyState = window.XMLHttpRequest.OPENED;
+			};
+			this.setRequestHeader = function(name, value) {
+				_config.headers[name] = value;
+			};
+			this.send = function(data) {
+				var cookieStore = this.context && this.context.cookieStore;
+				if (!cookieStore) cookieStore = _cookieStore;
+				var jar = cookieStore[_config.hostname];
+				if (jar) {
+					var cookies = "";
+					for (var name in jar) if (jar.hasOwnProperty(name)) {
+						if (cookies) cookies += "; ";
+						cookies += jar[name];
+					}
+					if (cookies) _config.headers["Cookie"] = cookies;
+				}
+				var self = this;
+				_request = (_secure(_config) ? https : httpc).request(_config, function(response) {
+					var success = false;
+					self.status = response.statusCode;
+					self.statusText = response.statusMessage;
+					self.readyState = window.XMLHttpRequest.HEADERS_RECEIVED;
+					var headers = response.headers;
+					for (var name in headers) if (headers.hasOwnProperty(name)) {
+						if (/^set-cookie$/i.test(name)) {
+							var header = headers[name];
+							for (var i = 0; i < header.length; ++i) {
+								var cookie = header[i].split(";")[0];
+								var host = _config.hostname;
+								var jar = cookieStore[host];
+								if (jar === void 0) cookieStore[host] = jar = {};
+								var equal = cookie.indexOf("=");
+								if (equal > 0) jar[cookie.substring(0, equal)] = cookie;
+							}
+						}
+					}
+					response.on("data", function(chunk) {
+						self.readyState = window.XMLHttpRequest.LOADING;
+						self.responseText += chunk;
+					});
+					response.on("end", function() {
+						success = true;
+						self.readyState = window.XMLHttpRequest.DONE;
+						if (self.onload) self.onload();
+					});
+					response.on("close", function() {
+						if (!success) {
+							self.readyState = window.XMLHttpRequest.DONE;
+							if (self.onerror) self.onerror();
+						}
+					});
+				});
+				[
+					"abort",
+					"aborted",
+					"error"
+				].forEach(function(event) {
+					_request.on(event, function(x) {
+						self.readyState = window.XMLHttpRequest.DONE;
+						if (x) {
+							var error = x.message;
+							if (error) self.statusText = error;
+						}
+						if (self.onerror) self.onerror(x);
+					});
+				});
+				if (data) _request.write(data);
+				_request.end();
+			};
+			this.abort = function() {
+				if (_request) _request.abort();
+			};
+			this._config = function() {
+				return _config;
+			};
+		};
+		window.XMLHttpRequest.UNSENT = 0;
+		window.XMLHttpRequest.OPENED = 1;
+		window.XMLHttpRequest.HEADERS_RECEIVED = 2;
+		window.XMLHttpRequest.LOADING = 3;
+		window.XMLHttpRequest.DONE = 4;
+	} };
+}));
+
+//#endregion
+export default require_cometd_nodejs_client();
+
+export { require_cometd_nodejs_client };