c8y-nitro 0.1.0 → 0.1.1

package/dist/node_modules/.pnpm/tslib@2.8.1/node_modules/tslib/tslib.es6.mjs

@@ -0,0 +1,31 @@
+//#region node_modules/.pnpm/tslib@2.8.1/node_modules/tslib/tslib.es6.mjs
+function __awaiter(thisArg, _arguments, P, generator) {
+	function adopt(value) {
+		return value instanceof P ? value : new P(function(resolve) {
+			resolve(value);
+		});
+	}
+	return new (P || (P = Promise))(function(resolve, reject) {
+		function fulfilled(value) {
+			try {
+				step(generator.next(value));
+			} catch (e) {
+				reject(e);
+			}
+		}
+		function rejected(value) {
+			try {
+				step(generator["throw"](value));
+			} catch (e) {
+				reject(e);
+			}
+		}
+		function step(result) {
+			result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+		}
+		step((generator = generator.apply(thisArg, _arguments || [])).next());
+	});
+}
+
+//#endregion
+export { __awaiter };

package/dist/node_modules/.pnpm/webidl-conversions@3.0.1/node_modules/webidl-conversions/lib/index.mjs

@@ -0,0 +1,122 @@
+import { __commonJSMin } from "../../../../../../_virtual/rolldown_runtime.mjs";
+
+//#region node_modules/.pnpm/webidl-conversions@3.0.1/node_modules/webidl-conversions/lib/index.js
+var require_lib = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var conversions = {};
+	module.exports = conversions;
+	function sign(x) {
+		return x < 0 ? -1 : 1;
+	}
+	function evenRound(x) {
+		if (x % 1 === .5 && (x & 1) === 0) return Math.floor(x);
+		else return Math.round(x);
+	}
+	function createNumberConversion(bitLength, typeOpts) {
+		if (!typeOpts.unsigned) --bitLength;
+		const lowerBound = typeOpts.unsigned ? 0 : -Math.pow(2, bitLength);
+		const upperBound = Math.pow(2, bitLength) - 1;
+		const moduloVal = typeOpts.moduloBitLength ? Math.pow(2, typeOpts.moduloBitLength) : Math.pow(2, bitLength);
+		const moduloBound = typeOpts.moduloBitLength ? Math.pow(2, typeOpts.moduloBitLength - 1) : Math.pow(2, bitLength - 1);
+		return function(V, opts) {
+			if (!opts) opts = {};
+			let x = +V;
+			if (opts.enforceRange) {
+				if (!Number.isFinite(x)) throw new TypeError("Argument is not a finite number");
+				x = sign(x) * Math.floor(Math.abs(x));
+				if (x < lowerBound || x > upperBound) throw new TypeError("Argument is not in byte range");
+				return x;
+			}
+			if (!isNaN(x) && opts.clamp) {
+				x = evenRound(x);
+				if (x < lowerBound) x = lowerBound;
+				if (x > upperBound) x = upperBound;
+				return x;
+			}
+			if (!Number.isFinite(x) || x === 0) return 0;
+			x = sign(x) * Math.floor(Math.abs(x));
+			x = x % moduloVal;
+			if (!typeOpts.unsigned && x >= moduloBound) return x - moduloVal;
+			else if (typeOpts.unsigned) {
+				if (x < 0) x += moduloVal;
+				else if (x === -0) return 0;
+			}
+			return x;
+		};
+	}
+	conversions["void"] = function() {};
+	conversions["boolean"] = function(val) {
+		return !!val;
+	};
+	conversions["byte"] = createNumberConversion(8, { unsigned: false });
+	conversions["octet"] = createNumberConversion(8, { unsigned: true });
+	conversions["short"] = createNumberConversion(16, { unsigned: false });
+	conversions["unsigned short"] = createNumberConversion(16, { unsigned: true });
+	conversions["long"] = createNumberConversion(32, { unsigned: false });
+	conversions["unsigned long"] = createNumberConversion(32, { unsigned: true });
+	conversions["long long"] = createNumberConversion(32, {
+		unsigned: false,
+		moduloBitLength: 64
+	});
+	conversions["unsigned long long"] = createNumberConversion(32, {
+		unsigned: true,
+		moduloBitLength: 64
+	});
+	conversions["double"] = function(V) {
+		const x = +V;
+		if (!Number.isFinite(x)) throw new TypeError("Argument is not a finite floating-point value");
+		return x;
+	};
+	conversions["unrestricted double"] = function(V) {
+		const x = +V;
+		if (isNaN(x)) throw new TypeError("Argument is NaN");
+		return x;
+	};
+	conversions["float"] = conversions["double"];
+	conversions["unrestricted float"] = conversions["unrestricted double"];
+	conversions["DOMString"] = function(V, opts) {
+		if (!opts) opts = {};
+		if (opts.treatNullAsEmptyString && V === null) return "";
+		return String(V);
+	};
+	conversions["ByteString"] = function(V, opts) {
+		const x = String(V);
+		let c = void 0;
+		for (let i = 0; (c = x.codePointAt(i)) !== void 0; ++i) if (c > 255) throw new TypeError("Argument is not a valid bytestring");
+		return x;
+	};
+	conversions["USVString"] = function(V) {
+		const S = String(V);
+		const n = S.length;
+		const U = [];
+		for (let i = 0; i < n; ++i) {
+			const c = S.charCodeAt(i);
+			if (c < 55296 || c > 57343) U.push(String.fromCodePoint(c));
+			else if (56320 <= c && c <= 57343) U.push(String.fromCodePoint(65533));
+			else if (i === n - 1) U.push(String.fromCodePoint(65533));
+			else {
+				const d = S.charCodeAt(i + 1);
+				if (56320 <= d && d <= 57343) {
+					const a = c & 1023;
+					const b = d & 1023;
+					U.push(String.fromCodePoint(65536 + 1024 * a + b));
+					++i;
+				} else U.push(String.fromCodePoint(65533));
+			}
+		}
+		return U.join("");
+	};
+	conversions["Date"] = function(V, opts) {
+		if (!(V instanceof Date)) throw new TypeError("Argument is not a Date object");
+		if (isNaN(V)) return;
+		return V;
+	};
+	conversions["RegExp"] = function(V, opts) {
+		if (!(V instanceof RegExp)) V = new RegExp(V);
+		return V;
+	};
+}));
+
+//#endregion
+export default require_lib();
+
+export { require_lib };

package/dist/node_modules/.pnpm/whatwg-url@5.0.0/node_modules/whatwg-url/lib/URL-impl.mjs

@@ -0,0 +1,145 @@
+import { __commonJSMin } from "../../../../../../_virtual/rolldown_runtime.mjs";
+import { require_url_state_machine } from "./url-state-machine.mjs";
+
+//#region node_modules/.pnpm/whatwg-url@5.0.0/node_modules/whatwg-url/lib/URL-impl.js
+var require_URL_impl = /* @__PURE__ */ __commonJSMin(((exports) => {
+	const usm = require_url_state_machine();
+	exports.implementation = class URLImpl {
+		constructor(constructorArgs) {
+			const url = constructorArgs[0];
+			const base = constructorArgs[1];
+			let parsedBase = null;
+			if (base !== void 0) {
+				parsedBase = usm.basicURLParse(base);
+				if (parsedBase === "failure") throw new TypeError("Invalid base URL");
+			}
+			const parsedURL = usm.basicURLParse(url, { baseURL: parsedBase });
+			if (parsedURL === "failure") throw new TypeError("Invalid URL");
+			this._url = parsedURL;
+		}
+		get href() {
+			return usm.serializeURL(this._url);
+		}
+		set href(v) {
+			const parsedURL = usm.basicURLParse(v);
+			if (parsedURL === "failure") throw new TypeError("Invalid URL");
+			this._url = parsedURL;
+		}
+		get origin() {
+			return usm.serializeURLOrigin(this._url);
+		}
+		get protocol() {
+			return this._url.scheme + ":";
+		}
+		set protocol(v) {
+			usm.basicURLParse(v + ":", {
+				url: this._url,
+				stateOverride: "scheme start"
+			});
+		}
+		get username() {
+			return this._url.username;
+		}
+		set username(v) {
+			if (usm.cannotHaveAUsernamePasswordPort(this._url)) return;
+			usm.setTheUsername(this._url, v);
+		}
+		get password() {
+			return this._url.password;
+		}
+		set password(v) {
+			if (usm.cannotHaveAUsernamePasswordPort(this._url)) return;
+			usm.setThePassword(this._url, v);
+		}
+		get host() {
+			const url = this._url;
+			if (url.host === null) return "";
+			if (url.port === null) return usm.serializeHost(url.host);
+			return usm.serializeHost(url.host) + ":" + usm.serializeInteger(url.port);
+		}
+		set host(v) {
+			if (this._url.cannotBeABaseURL) return;
+			usm.basicURLParse(v, {
+				url: this._url,
+				stateOverride: "host"
+			});
+		}
+		get hostname() {
+			if (this._url.host === null) return "";
+			return usm.serializeHost(this._url.host);
+		}
+		set hostname(v) {
+			if (this._url.cannotBeABaseURL) return;
+			usm.basicURLParse(v, {
+				url: this._url,
+				stateOverride: "hostname"
+			});
+		}
+		get port() {
+			if (this._url.port === null) return "";
+			return usm.serializeInteger(this._url.port);
+		}
+		set port(v) {
+			if (usm.cannotHaveAUsernamePasswordPort(this._url)) return;
+			if (v === "") this._url.port = null;
+			else usm.basicURLParse(v, {
+				url: this._url,
+				stateOverride: "port"
+			});
+		}
+		get pathname() {
+			if (this._url.cannotBeABaseURL) return this._url.path[0];
+			if (this._url.path.length === 0) return "";
+			return "/" + this._url.path.join("/");
+		}
+		set pathname(v) {
+			if (this._url.cannotBeABaseURL) return;
+			this._url.path = [];
+			usm.basicURLParse(v, {
+				url: this._url,
+				stateOverride: "path start"
+			});
+		}
+		get search() {
+			if (this._url.query === null || this._url.query === "") return "";
+			return "?" + this._url.query;
+		}
+		set search(v) {
+			const url = this._url;
+			if (v === "") {
+				url.query = null;
+				return;
+			}
+			const input = v[0] === "?" ? v.substring(1) : v;
+			url.query = "";
+			usm.basicURLParse(input, {
+				url,
+				stateOverride: "query"
+			});
+		}
+		get hash() {
+			if (this._url.fragment === null || this._url.fragment === "") return "";
+			return "#" + this._url.fragment;
+		}
+		set hash(v) {
+			if (v === "") {
+				this._url.fragment = null;
+				return;
+			}
+			const input = v[0] === "#" ? v.substring(1) : v;
+			this._url.fragment = "";
+			usm.basicURLParse(input, {
+				url: this._url,
+				stateOverride: "fragment"
+			});
+		}
+		toJSON() {
+			return this.href;
+		}
+	};
+}));
+
+//#endregion
+export default require_URL_impl();
+
+export { require_URL_impl };

package/dist/node_modules/.pnpm/whatwg-url@5.0.0/node_modules/whatwg-url/lib/URL.mjs

@@ -0,0 +1,174 @@
+import { __commonJSMin } from "../../../../../../_virtual/rolldown_runtime.mjs";
+import { require_lib } from "../../../../webidl-conversions@3.0.1/node_modules/webidl-conversions/lib/index.mjs";
+import { require_utils } from "./utils.mjs";
+import { require_URL_impl } from "./URL-impl.mjs";
+
+//#region node_modules/.pnpm/whatwg-url@5.0.0/node_modules/whatwg-url/lib/URL.js
+var require_URL = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const conversions = require_lib();
+	const utils = require_utils();
+	const Impl = require_URL_impl();
+	const impl = utils.implSymbol;
+	function URL(url) {
+		if (!this || this[impl] || !(this instanceof URL)) throw new TypeError("Failed to construct 'URL': Please use the 'new' operator, this DOM object constructor cannot be called as a function.");
+		if (arguments.length < 1) throw new TypeError("Failed to construct 'URL': 1 argument required, but only " + arguments.length + " present.");
+		const args = [];
+		for (let i = 0; i < arguments.length && i < 2; ++i) args[i] = arguments[i];
+		args[0] = conversions["USVString"](args[0]);
+		if (args[1] !== void 0) args[1] = conversions["USVString"](args[1]);
+		module.exports.setup(this, args);
+	}
+	URL.prototype.toJSON = function toJSON() {
+		if (!this || !module.exports.is(this)) throw new TypeError("Illegal invocation");
+		const args = [];
+		for (let i = 0; i < arguments.length && i < 0; ++i) args[i] = arguments[i];
+		return this[impl].toJSON.apply(this[impl], args);
+	};
+	Object.defineProperty(URL.prototype, "href", {
+		get() {
+			return this[impl].href;
+		},
+		set(V) {
+			V = conversions["USVString"](V);
+			this[impl].href = V;
+		},
+		enumerable: true,
+		configurable: true
+	});
+	URL.prototype.toString = function() {
+		if (!this || !module.exports.is(this)) throw new TypeError("Illegal invocation");
+		return this.href;
+	};
+	Object.defineProperty(URL.prototype, "origin", {
+		get() {
+			return this[impl].origin;
+		},
+		enumerable: true,
+		configurable: true
+	});
+	Object.defineProperty(URL.prototype, "protocol", {
+		get() {
+			return this[impl].protocol;
+		},
+		set(V) {
+			V = conversions["USVString"](V);
+			this[impl].protocol = V;
+		},
+		enumerable: true,
+		configurable: true
+	});
+	Object.defineProperty(URL.prototype, "username", {
+		get() {
+			return this[impl].username;
+		},
+		set(V) {
+			V = conversions["USVString"](V);
+			this[impl].username = V;
+		},
+		enumerable: true,
+		configurable: true
+	});
+	Object.defineProperty(URL.prototype, "password", {
+		get() {
+			return this[impl].password;
+		},
+		set(V) {
+			V = conversions["USVString"](V);
+			this[impl].password = V;
+		},
+		enumerable: true,
+		configurable: true
+	});
+	Object.defineProperty(URL.prototype, "host", {
+		get() {
+			return this[impl].host;
+		},
+		set(V) {
+			V = conversions["USVString"](V);
+			this[impl].host = V;
+		},
+		enumerable: true,
+		configurable: true
+	});
+	Object.defineProperty(URL.prototype, "hostname", {
+		get() {
+			return this[impl].hostname;
+		},
+		set(V) {
+			V = conversions["USVString"](V);
+			this[impl].hostname = V;
+		},
+		enumerable: true,
+		configurable: true
+	});
+	Object.defineProperty(URL.prototype, "port", {
+		get() {
+			return this[impl].port;
+		},
+		set(V) {
+			V = conversions["USVString"](V);
+			this[impl].port = V;
+		},
+		enumerable: true,
+		configurable: true
+	});
+	Object.defineProperty(URL.prototype, "pathname", {
+		get() {
+			return this[impl].pathname;
+		},
+		set(V) {
+			V = conversions["USVString"](V);
+			this[impl].pathname = V;
+		},
+		enumerable: true,
+		configurable: true
+	});
+	Object.defineProperty(URL.prototype, "search", {
+		get() {
+			return this[impl].search;
+		},
+		set(V) {
+			V = conversions["USVString"](V);
+			this[impl].search = V;
+		},
+		enumerable: true,
+		configurable: true
+	});
+	Object.defineProperty(URL.prototype, "hash", {
+		get() {
+			return this[impl].hash;
+		},
+		set(V) {
+			V = conversions["USVString"](V);
+			this[impl].hash = V;
+		},
+		enumerable: true,
+		configurable: true
+	});
+	module.exports = {
+		is(obj) {
+			return !!obj && obj[impl] instanceof Impl.implementation;
+		},
+		create(constructorArgs, privateData) {
+			let obj = Object.create(URL.prototype);
+			this.setup(obj, constructorArgs, privateData);
+			return obj;
+		},
+		setup(obj, constructorArgs, privateData) {
+			if (!privateData) privateData = {};
+			privateData.wrapper = obj;
+			obj[impl] = new Impl.implementation(constructorArgs, privateData);
+			obj[impl][utils.wrapperSymbol] = obj;
+		},
+		interface: URL,
+		expose: {
+			Window: { URL },
+			Worker: { URL }
+		}
+	};
+}));
+
+//#endregion
+export default require_URL();
+
+export { require_URL };

package/dist/node_modules/.pnpm/whatwg-url@5.0.0/node_modules/whatwg-url/lib/public-api.mjs

@@ -0,0 +1,21 @@
+import { __commonJSMin } from "../../../../../../_virtual/rolldown_runtime.mjs";
+import { require_url_state_machine } from "./url-state-machine.mjs";
+import { require_URL } from "./URL.mjs";
+
+//#region node_modules/.pnpm/whatwg-url@5.0.0/node_modules/whatwg-url/lib/public-api.js
+var require_public_api = /* @__PURE__ */ __commonJSMin(((exports) => {
+	exports.URL = require_URL().interface;
+	exports.serializeURL = require_url_state_machine().serializeURL;
+	exports.serializeURLOrigin = require_url_state_machine().serializeURLOrigin;
+	exports.basicURLParse = require_url_state_machine().basicURLParse;
+	exports.setTheUsername = require_url_state_machine().setTheUsername;
+	exports.setThePassword = require_url_state_machine().setThePassword;
+	exports.serializeHost = require_url_state_machine().serializeHost;
+	exports.serializeInteger = require_url_state_machine().serializeInteger;
+	exports.parseURL = require_url_state_machine().parseURL;
+}));
+
+//#endregion
+export default require_public_api();
+
+export { require_public_api };