c8y-nitro 0.1.0 → 0.1.1

package/dist/node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/encodings/utf7.mjs

@@ -0,0 +1,183 @@
+import { __commonJSMin } from "../../../../../../_virtual/rolldown_runtime.mjs";
+import { require_safer } from "../../../../safer-buffer@2.1.2/node_modules/safer-buffer/safer.mjs";
+
+//#region node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/encodings/utf7.js
+var require_utf7 = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var Buffer = require_safer().Buffer;
+	exports.utf7 = Utf7Codec;
+	exports.unicode11utf7 = "utf7";
+	function Utf7Codec(codecOptions, iconv) {
+		this.iconv = iconv;
+	}
+	Utf7Codec.prototype.encoder = Utf7Encoder;
+	Utf7Codec.prototype.decoder = Utf7Decoder;
+	Utf7Codec.prototype.bomAware = true;
+	var nonDirectChars = /[^A-Za-z0-9'\(\),-\.\/:\? \n\r\t]+/g;
+	function Utf7Encoder(options, codec) {
+		this.iconv = codec.iconv;
+	}
+	Utf7Encoder.prototype.write = function(str) {
+		return Buffer.from(str.replace(nonDirectChars, function(chunk) {
+			return "+" + (chunk === "+" ? "" : this.iconv.encode(chunk, "utf16-be").toString("base64").replace(/=+$/, "")) + "-";
+		}.bind(this)));
+	};
+	Utf7Encoder.prototype.end = function() {};
+	function Utf7Decoder(options, codec) {
+		this.iconv = codec.iconv;
+		this.inBase64 = false;
+		this.base64Accum = "";
+	}
+	var base64Regex = /[A-Za-z0-9\/+]/;
+	var base64Chars = [];
+	for (var i = 0; i < 256; i++) base64Chars[i] = base64Regex.test(String.fromCharCode(i));
+	var plusChar = "+".charCodeAt(0), minusChar = "-".charCodeAt(0), andChar = "&".charCodeAt(0);
+	Utf7Decoder.prototype.write = function(buf) {
+		var res = "", lastI = 0, inBase64 = this.inBase64, base64Accum = this.base64Accum;
+		for (var i = 0; i < buf.length; i++) if (!inBase64) {
+			if (buf[i] == plusChar) {
+				res += this.iconv.decode(buf.slice(lastI, i), "ascii");
+				lastI = i + 1;
+				inBase64 = true;
+			}
+		} else if (!base64Chars[buf[i]]) {
+			if (i == lastI && buf[i] == minusChar) res += "+";
+			else {
+				var b64str = base64Accum + this.iconv.decode(buf.slice(lastI, i), "ascii");
+				res += this.iconv.decode(Buffer.from(b64str, "base64"), "utf16-be");
+			}
+			if (buf[i] != minusChar) i--;
+			lastI = i + 1;
+			inBase64 = false;
+			base64Accum = "";
+		}
+		if (!inBase64) res += this.iconv.decode(buf.slice(lastI), "ascii");
+		else {
+			var b64str = base64Accum + this.iconv.decode(buf.slice(lastI), "ascii");
+			var canBeDecoded = b64str.length - b64str.length % 8;
+			base64Accum = b64str.slice(canBeDecoded);
+			b64str = b64str.slice(0, canBeDecoded);
+			res += this.iconv.decode(Buffer.from(b64str, "base64"), "utf16-be");
+		}
+		this.inBase64 = inBase64;
+		this.base64Accum = base64Accum;
+		return res;
+	};
+	Utf7Decoder.prototype.end = function() {
+		var res = "";
+		if (this.inBase64 && this.base64Accum.length > 0) res = this.iconv.decode(Buffer.from(this.base64Accum, "base64"), "utf16-be");
+		this.inBase64 = false;
+		this.base64Accum = "";
+		return res;
+	};
+	exports.utf7imap = Utf7IMAPCodec;
+	function Utf7IMAPCodec(codecOptions, iconv) {
+		this.iconv = iconv;
+	}
+	Utf7IMAPCodec.prototype.encoder = Utf7IMAPEncoder;
+	Utf7IMAPCodec.prototype.decoder = Utf7IMAPDecoder;
+	Utf7IMAPCodec.prototype.bomAware = true;
+	function Utf7IMAPEncoder(options, codec) {
+		this.iconv = codec.iconv;
+		this.inBase64 = false;
+		this.base64Accum = Buffer.alloc(6);
+		this.base64AccumIdx = 0;
+	}
+	Utf7IMAPEncoder.prototype.write = function(str) {
+		var inBase64 = this.inBase64, base64Accum = this.base64Accum, base64AccumIdx = this.base64AccumIdx, buf = Buffer.alloc(str.length * 5 + 10), bufIdx = 0;
+		for (var i = 0; i < str.length; i++) {
+			var uChar = str.charCodeAt(i);
+			if (32 <= uChar && uChar <= 126) {
+				if (inBase64) {
+					if (base64AccumIdx > 0) {
+						bufIdx += buf.write(base64Accum.slice(0, base64AccumIdx).toString("base64").replace(/\//g, ",").replace(/=+$/, ""), bufIdx);
+						base64AccumIdx = 0;
+					}
+					buf[bufIdx++] = minusChar;
+					inBase64 = false;
+				}
+				if (!inBase64) {
+					buf[bufIdx++] = uChar;
+					if (uChar === andChar) buf[bufIdx++] = minusChar;
+				}
+			} else {
+				if (!inBase64) {
+					buf[bufIdx++] = andChar;
+					inBase64 = true;
+				}
+				if (inBase64) {
+					base64Accum[base64AccumIdx++] = uChar >> 8;
+					base64Accum[base64AccumIdx++] = uChar & 255;
+					if (base64AccumIdx == base64Accum.length) {
+						bufIdx += buf.write(base64Accum.toString("base64").replace(/\//g, ","), bufIdx);
+						base64AccumIdx = 0;
+					}
+				}
+			}
+		}
+		this.inBase64 = inBase64;
+		this.base64AccumIdx = base64AccumIdx;
+		return buf.slice(0, bufIdx);
+	};
+	Utf7IMAPEncoder.prototype.end = function() {
+		var buf = Buffer.alloc(10), bufIdx = 0;
+		if (this.inBase64) {
+			if (this.base64AccumIdx > 0) {
+				bufIdx += buf.write(this.base64Accum.slice(0, this.base64AccumIdx).toString("base64").replace(/\//g, ",").replace(/=+$/, ""), bufIdx);
+				this.base64AccumIdx = 0;
+			}
+			buf[bufIdx++] = minusChar;
+			this.inBase64 = false;
+		}
+		return buf.slice(0, bufIdx);
+	};
+	function Utf7IMAPDecoder(options, codec) {
+		this.iconv = codec.iconv;
+		this.inBase64 = false;
+		this.base64Accum = "";
+	}
+	var base64IMAPChars = base64Chars.slice();
+	base64IMAPChars[",".charCodeAt(0)] = true;
+	Utf7IMAPDecoder.prototype.write = function(buf) {
+		var res = "", lastI = 0, inBase64 = this.inBase64, base64Accum = this.base64Accum;
+		for (var i = 0; i < buf.length; i++) if (!inBase64) {
+			if (buf[i] == andChar) {
+				res += this.iconv.decode(buf.slice(lastI, i), "ascii");
+				lastI = i + 1;
+				inBase64 = true;
+			}
+		} else if (!base64IMAPChars[buf[i]]) {
+			if (i == lastI && buf[i] == minusChar) res += "&";
+			else {
+				var b64str = base64Accum + this.iconv.decode(buf.slice(lastI, i), "ascii").replace(/,/g, "/");
+				res += this.iconv.decode(Buffer.from(b64str, "base64"), "utf16-be");
+			}
+			if (buf[i] != minusChar) i--;
+			lastI = i + 1;
+			inBase64 = false;
+			base64Accum = "";
+		}
+		if (!inBase64) res += this.iconv.decode(buf.slice(lastI), "ascii");
+		else {
+			var b64str = base64Accum + this.iconv.decode(buf.slice(lastI), "ascii").replace(/,/g, "/");
+			var canBeDecoded = b64str.length - b64str.length % 8;
+			base64Accum = b64str.slice(canBeDecoded);
+			b64str = b64str.slice(0, canBeDecoded);
+			res += this.iconv.decode(Buffer.from(b64str, "base64"), "utf16-be");
+		}
+		this.inBase64 = inBase64;
+		this.base64Accum = base64Accum;
+		return res;
+	};
+	Utf7IMAPDecoder.prototype.end = function() {
+		var res = "";
+		if (this.inBase64 && this.base64Accum.length > 0) res = this.iconv.decode(Buffer.from(this.base64Accum, "base64"), "utf16-be");
+		this.inBase64 = false;
+		this.base64Accum = "";
+		return res;
+	};
+}));
+
+//#endregion
+export default require_utf7();
+
+export { require_utf7 };

package/dist/node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/lib/bom-handling.mjs

@@ -0,0 +1,45 @@
+import { __commonJSMin } from "../../../../../../_virtual/rolldown_runtime.mjs";
+
+//#region node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/lib/bom-handling.js
+var require_bom_handling = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var BOMChar = "";
+	exports.PrependBOM = PrependBOMWrapper;
+	function PrependBOMWrapper(encoder, options) {
+		this.encoder = encoder;
+		this.addBOM = true;
+	}
+	PrependBOMWrapper.prototype.write = function(str) {
+		if (this.addBOM) {
+			str = BOMChar + str;
+			this.addBOM = false;
+		}
+		return this.encoder.write(str);
+	};
+	PrependBOMWrapper.prototype.end = function() {
+		return this.encoder.end();
+	};
+	exports.StripBOM = StripBOMWrapper;
+	function StripBOMWrapper(decoder, options) {
+		this.decoder = decoder;
+		this.pass = false;
+		this.options = options || {};
+	}
+	StripBOMWrapper.prototype.write = function(buf) {
+		var res = this.decoder.write(buf);
+		if (this.pass || !res) return res;
+		if (res[0] === BOMChar) {
+			res = res.slice(1);
+			if (typeof this.options.stripBOM === "function") this.options.stripBOM();
+		}
+		this.pass = true;
+		return res;
+	};
+	StripBOMWrapper.prototype.end = function() {
+		return this.decoder.end();
+	};
+}));
+
+//#endregion
+export default require_bom_handling();
+
+export { require_bom_handling };

package/dist/node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/lib/index.mjs

@@ -0,0 +1,110 @@
+import { __commonJSMin, __require } from "../../../../../../_virtual/rolldown_runtime.mjs";
+import { require_safer } from "../../../../safer-buffer@2.1.2/node_modules/safer-buffer/safer.mjs";
+import { require_bom_handling } from "./bom-handling.mjs";
+import { require_encodings } from "../encodings/index.mjs";
+import { require_streams } from "./streams.mjs";
+
+//#region node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/lib/index.js
+var require_lib = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Buffer = require_safer().Buffer;
+	var bomHandling = require_bom_handling(), iconv = module.exports;
+	iconv.encodings = null;
+	iconv.defaultCharUnicode = "�";
+	iconv.defaultCharSingleByte = "?";
+	iconv.encode = function encode(str, encoding, options) {
+		str = "" + (str || "");
+		var encoder = iconv.getEncoder(encoding, options);
+		var res = encoder.write(str);
+		var trail = encoder.end();
+		return trail && trail.length > 0 ? Buffer.concat([res, trail]) : res;
+	};
+	iconv.decode = function decode(buf, encoding, options) {
+		if (typeof buf === "string") {
+			if (!iconv.skipDecodeWarning) {
+				console.error("Iconv-lite warning: decode()-ing strings is deprecated. Refer to https://github.com/ashtuchkin/iconv-lite/wiki/Use-Buffers-when-decoding");
+				iconv.skipDecodeWarning = true;
+			}
+			buf = Buffer.from("" + (buf || ""), "binary");
+		}
+		var decoder = iconv.getDecoder(encoding, options);
+		var res = decoder.write(buf);
+		var trail = decoder.end();
+		return trail ? res + trail : res;
+	};
+	iconv.encodingExists = function encodingExists(enc) {
+		try {
+			iconv.getCodec(enc);
+			return true;
+		} catch (e) {
+			return false;
+		}
+	};
+	iconv.toEncoding = iconv.encode;
+	iconv.fromEncoding = iconv.decode;
+	iconv._codecDataCache = {};
+	iconv.getCodec = function getCodec(encoding) {
+		if (!iconv.encodings) iconv.encodings = require_encodings();
+		var enc = iconv._canonicalizeEncoding(encoding);
+		var codecOptions = {};
+		while (true) {
+			var codec = iconv._codecDataCache[enc];
+			if (codec) return codec;
+			var codecDef = iconv.encodings[enc];
+			switch (typeof codecDef) {
+				case "string":
+					enc = codecDef;
+					break;
+				case "object":
+					for (var key in codecDef) codecOptions[key] = codecDef[key];
+					if (!codecOptions.encodingName) codecOptions.encodingName = enc;
+					enc = codecDef.type;
+					break;
+				case "function":
+					if (!codecOptions.encodingName) codecOptions.encodingName = enc;
+					codec = new codecDef(codecOptions, iconv);
+					iconv._codecDataCache[codecOptions.encodingName] = codec;
+					return codec;
+				default: throw new Error("Encoding not recognized: '" + encoding + "' (searched as: '" + enc + "')");
+			}
+		}
+	};
+	iconv._canonicalizeEncoding = function(encoding) {
+		return ("" + encoding).toLowerCase().replace(/:\d{4}$|[^0-9a-z]/g, "");
+	};
+	iconv.getEncoder = function getEncoder(encoding, options) {
+		var codec = iconv.getCodec(encoding), encoder = new codec.encoder(options, codec);
+		if (codec.bomAware && options && options.addBOM) encoder = new bomHandling.PrependBOM(encoder, options);
+		return encoder;
+	};
+	iconv.getDecoder = function getDecoder(encoding, options) {
+		var codec = iconv.getCodec(encoding), decoder = new codec.decoder(options, codec);
+		if (codec.bomAware && !(options && options.stripBOM === false)) decoder = new bomHandling.StripBOM(decoder, options);
+		return decoder;
+	};
+	iconv.enableStreamingAPI = function enableStreamingAPI(stream_module) {
+		if (iconv.supportsStreams) return;
+		var streams = require_streams()(stream_module);
+		iconv.IconvLiteEncoderStream = streams.IconvLiteEncoderStream;
+		iconv.IconvLiteDecoderStream = streams.IconvLiteDecoderStream;
+		iconv.encodeStream = function encodeStream(encoding, options) {
+			return new iconv.IconvLiteEncoderStream(iconv.getEncoder(encoding, options), options);
+		};
+		iconv.decodeStream = function decodeStream(encoding, options) {
+			return new iconv.IconvLiteDecoderStream(iconv.getDecoder(encoding, options), options);
+		};
+		iconv.supportsStreams = true;
+	};
+	var stream_module;
+	try {
+		stream_module = __require("stream");
+	} catch (e) {}
+	if (stream_module && stream_module.Transform) iconv.enableStreamingAPI(stream_module);
+	else iconv.encodeStream = iconv.decodeStream = function() {
+		throw new Error("iconv-lite Streaming API is not enabled. Use iconv.enableStreamingAPI(require('stream')); to enable it.");
+	};
+}));
+
+//#endregion
+export default require_lib();
+
+export { require_lib };

package/dist/node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/lib/streams.mjs

@@ -0,0 +1,93 @@
+import { __commonJSMin } from "../../../../../../_virtual/rolldown_runtime.mjs";
+import { require_safer } from "../../../../safer-buffer@2.1.2/node_modules/safer-buffer/safer.mjs";
+
+//#region node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/lib/streams.js
+var require_streams = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Buffer = require_safer().Buffer;
+	module.exports = function(stream_module) {
+		var Transform = stream_module.Transform;
+		function IconvLiteEncoderStream(conv, options) {
+			this.conv = conv;
+			options = options || {};
+			options.decodeStrings = false;
+			Transform.call(this, options);
+		}
+		IconvLiteEncoderStream.prototype = Object.create(Transform.prototype, { constructor: { value: IconvLiteEncoderStream } });
+		IconvLiteEncoderStream.prototype._transform = function(chunk, encoding, done) {
+			if (typeof chunk != "string") return done(/* @__PURE__ */ new Error("Iconv encoding stream needs strings as its input."));
+			try {
+				var res = this.conv.write(chunk);
+				if (res && res.length) this.push(res);
+				done();
+			} catch (e) {
+				done(e);
+			}
+		};
+		IconvLiteEncoderStream.prototype._flush = function(done) {
+			try {
+				var res = this.conv.end();
+				if (res && res.length) this.push(res);
+				done();
+			} catch (e) {
+				done(e);
+			}
+		};
+		IconvLiteEncoderStream.prototype.collect = function(cb) {
+			var chunks = [];
+			this.on("error", cb);
+			this.on("data", function(chunk) {
+				chunks.push(chunk);
+			});
+			this.on("end", function() {
+				cb(null, Buffer.concat(chunks));
+			});
+			return this;
+		};
+		function IconvLiteDecoderStream(conv, options) {
+			this.conv = conv;
+			options = options || {};
+			options.encoding = this.encoding = "utf8";
+			Transform.call(this, options);
+		}
+		IconvLiteDecoderStream.prototype = Object.create(Transform.prototype, { constructor: { value: IconvLiteDecoderStream } });
+		IconvLiteDecoderStream.prototype._transform = function(chunk, encoding, done) {
+			if (!Buffer.isBuffer(chunk) && !(chunk instanceof Uint8Array)) return done(/* @__PURE__ */ new Error("Iconv decoding stream needs buffers as its input."));
+			try {
+				var res = this.conv.write(chunk);
+				if (res && res.length) this.push(res, this.encoding);
+				done();
+			} catch (e) {
+				done(e);
+			}
+		};
+		IconvLiteDecoderStream.prototype._flush = function(done) {
+			try {
+				var res = this.conv.end();
+				if (res && res.length) this.push(res, this.encoding);
+				done();
+			} catch (e) {
+				done(e);
+			}
+		};
+		IconvLiteDecoderStream.prototype.collect = function(cb) {
+			var res = "";
+			this.on("error", cb);
+			this.on("data", function(chunk) {
+				res += chunk;
+			});
+			this.on("end", function() {
+				cb(null, res);
+			});
+			return this;
+		};
+		return {
+			IconvLiteEncoderStream,
+			IconvLiteDecoderStream
+		};
+	};
+}));
+
+//#endregion
+export default require_streams();
+
+export { require_streams };

package/dist/node_modules/.pnpm/isomorphic-cometd@1.1.0_cometd-nodejs-client@1.0.2_cometd@4.0.8/node_modules/isomorphic-cometd/node.mjs

@@ -0,0 +1,18 @@
+import { __commonJSMin } from "../../../../../_virtual/rolldown_runtime.mjs";
+import { require_cometd_nodejs_client } from "../../../cometd-nodejs-client@1.0.2/node_modules/cometd-nodejs-client/cometd-nodejs-client.mjs";
+import { require_cometd } from "../../../cometd@4.0.8/node_modules/cometd/cometd.mjs";
+
+//#region node_modules/.pnpm/isomorphic-cometd@1.1.0_cometd-nodejs-client@1.0.2_cometd@4.0.8/node_modules/isomorphic-cometd/node.js
+var require_node = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	require_cometd_nodejs_client().adapt();
+	const lib = require_cometd();
+	module.exports = {
+		CometD: lib.CometD,
+		default: lib
+	};
+}));
+
+//#endregion
+export default require_node();
+
+export { require_node };

package/dist/node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/abs.mjs

@@ -0,0 +1,12 @@
+import { __commonJSMin } from "../../../../../_virtual/rolldown_runtime.mjs";
+
+//#region node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/abs.js
+var require_abs = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type {import('./abs')} */
+	module.exports = Math.abs;
+}));
+
+//#endregion
+export default require_abs();
+
+export { require_abs };

package/dist/node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/floor.mjs

@@ -0,0 +1,12 @@
+import { __commonJSMin } from "../../../../../_virtual/rolldown_runtime.mjs";
+
+//#region node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/floor.js
+var require_floor = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type {import('./floor')} */
+	module.exports = Math.floor;
+}));
+
+//#endregion
+export default require_floor();
+
+export { require_floor };

package/dist/node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/isNaN.mjs

@@ -0,0 +1,14 @@
+import { __commonJSMin } from "../../../../../_virtual/rolldown_runtime.mjs";
+
+//#region node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/isNaN.js
+var require_isNaN = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type {import('./isNaN')} */
+	module.exports = Number.isNaN || function isNaN(a) {
+		return a !== a;
+	};
+}));
+
+//#endregion
+export default require_isNaN();
+
+export { require_isNaN };

package/dist/node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/max.mjs

@@ -0,0 +1,12 @@
+import { __commonJSMin } from "../../../../../_virtual/rolldown_runtime.mjs";
+
+//#region node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/max.js
+var require_max = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type {import('./max')} */
+	module.exports = Math.max;
+}));
+
+//#endregion
+export default require_max();
+
+export { require_max };

package/dist/node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/min.mjs

@@ -0,0 +1,12 @@
+import { __commonJSMin } from "../../../../../_virtual/rolldown_runtime.mjs";
+
+//#region node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/min.js
+var require_min = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type {import('./min')} */
+	module.exports = Math.min;
+}));
+
+//#endregion
+export default require_min();
+
+export { require_min };

package/dist/node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/pow.mjs

@@ -0,0 +1,12 @@
+import { __commonJSMin } from "../../../../../_virtual/rolldown_runtime.mjs";
+
+//#region node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/pow.js
+var require_pow = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type {import('./pow')} */
+	module.exports = Math.pow;
+}));
+
+//#endregion
+export default require_pow();
+
+export { require_pow };

package/dist/node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/round.mjs

@@ -0,0 +1,12 @@
+import { __commonJSMin } from "../../../../../_virtual/rolldown_runtime.mjs";
+
+//#region node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/round.js
+var require_round = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type {import('./round')} */
+	module.exports = Math.round;
+}));
+
+//#endregion
+export default require_round();
+
+export { require_round };

package/dist/node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/sign.mjs

@@ -0,0 +1,17 @@
+import { __commonJSMin } from "../../../../../_virtual/rolldown_runtime.mjs";
+import { require_isNaN } from "./isNaN.mjs";
+
+//#region node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/sign.js
+var require_sign = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var $isNaN = require_isNaN();
+	/** @type {import('./sign')} */
+	module.exports = function sign(number) {
+		if ($isNaN(number) || number === 0) return number;
+		return number < 0 ? -1 : 1;
+	};
+}));
+
+//#endregion
+export default require_sign();
+
+export { require_sign };