c8y-nitro 0.1.0 → 0.1.1

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

@@ -0,0 +1,141 @@
+import { __commonJSMin, __require } 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/internal.js
+var require_internal = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Buffer = require_safer().Buffer;
+	module.exports = {
+		utf8: {
+			type: "_internal",
+			bomAware: true
+		},
+		cesu8: {
+			type: "_internal",
+			bomAware: true
+		},
+		unicode11utf8: "utf8",
+		ucs2: {
+			type: "_internal",
+			bomAware: true
+		},
+		utf16le: "ucs2",
+		binary: { type: "_internal" },
+		base64: { type: "_internal" },
+		hex: { type: "_internal" },
+		_internal: InternalCodec
+	};
+	function InternalCodec(codecOptions, iconv) {
+		this.enc = codecOptions.encodingName;
+		this.bomAware = codecOptions.bomAware;
+		if (this.enc === "base64") this.encoder = InternalEncoderBase64;
+		else if (this.enc === "cesu8") {
+			this.enc = "utf8";
+			this.encoder = InternalEncoderCesu8;
+			if (Buffer.from("eda0bdedb2a9", "hex").toString() !== "💩") {
+				this.decoder = InternalDecoderCesu8;
+				this.defaultCharUnicode = iconv.defaultCharUnicode;
+			}
+		}
+	}
+	InternalCodec.prototype.encoder = InternalEncoder;
+	InternalCodec.prototype.decoder = InternalDecoder;
+	var StringDecoder = __require("string_decoder").StringDecoder;
+	if (!StringDecoder.prototype.end) StringDecoder.prototype.end = function() {};
+	function InternalDecoder(options, codec) {
+		this.decoder = new StringDecoder(codec.enc);
+	}
+	InternalDecoder.prototype.write = function(buf) {
+		if (!Buffer.isBuffer(buf)) buf = Buffer.from(buf);
+		return this.decoder.write(buf);
+	};
+	InternalDecoder.prototype.end = function() {
+		return this.decoder.end();
+	};
+	function InternalEncoder(options, codec) {
+		this.enc = codec.enc;
+	}
+	InternalEncoder.prototype.write = function(str) {
+		return Buffer.from(str, this.enc);
+	};
+	InternalEncoder.prototype.end = function() {};
+	function InternalEncoderBase64(options, codec) {
+		this.prevStr = "";
+	}
+	InternalEncoderBase64.prototype.write = function(str) {
+		str = this.prevStr + str;
+		var completeQuads = str.length - str.length % 4;
+		this.prevStr = str.slice(completeQuads);
+		str = str.slice(0, completeQuads);
+		return Buffer.from(str, "base64");
+	};
+	InternalEncoderBase64.prototype.end = function() {
+		return Buffer.from(this.prevStr, "base64");
+	};
+	function InternalEncoderCesu8(options, codec) {}
+	InternalEncoderCesu8.prototype.write = function(str) {
+		var buf = Buffer.alloc(str.length * 3), bufIdx = 0;
+		for (var i = 0; i < str.length; i++) {
+			var charCode = str.charCodeAt(i);
+			if (charCode < 128) buf[bufIdx++] = charCode;
+			else if (charCode < 2048) {
+				buf[bufIdx++] = 192 + (charCode >>> 6);
+				buf[bufIdx++] = 128 + (charCode & 63);
+			} else {
+				buf[bufIdx++] = 224 + (charCode >>> 12);
+				buf[bufIdx++] = 128 + (charCode >>> 6 & 63);
+				buf[bufIdx++] = 128 + (charCode & 63);
+			}
+		}
+		return buf.slice(0, bufIdx);
+	};
+	InternalEncoderCesu8.prototype.end = function() {};
+	function InternalDecoderCesu8(options, codec) {
+		this.acc = 0;
+		this.contBytes = 0;
+		this.accBytes = 0;
+		this.defaultCharUnicode = codec.defaultCharUnicode;
+	}
+	InternalDecoderCesu8.prototype.write = function(buf) {
+		var acc = this.acc, contBytes = this.contBytes, accBytes = this.accBytes, res = "";
+		for (var i = 0; i < buf.length; i++) {
+			var curByte = buf[i];
+			if ((curByte & 192) !== 128) {
+				if (contBytes > 0) {
+					res += this.defaultCharUnicode;
+					contBytes = 0;
+				}
+				if (curByte < 128) res += String.fromCharCode(curByte);
+				else if (curByte < 224) {
+					acc = curByte & 31;
+					contBytes = 1;
+					accBytes = 1;
+				} else if (curByte < 240) {
+					acc = curByte & 15;
+					contBytes = 2;
+					accBytes = 1;
+				} else res += this.defaultCharUnicode;
+			} else if (contBytes > 0) {
+				acc = acc << 6 | curByte & 63;
+				contBytes--;
+				accBytes++;
+				if (contBytes === 0) if (accBytes === 2 && acc < 128 && acc > 0) res += this.defaultCharUnicode;
+				else if (accBytes === 3 && acc < 2048) res += this.defaultCharUnicode;
+				else res += String.fromCharCode(acc);
+			} else res += this.defaultCharUnicode;
+		}
+		this.acc = acc;
+		this.contBytes = contBytes;
+		this.accBytes = accBytes;
+		return res;
+	};
+	InternalDecoderCesu8.prototype.end = function() {
+		var res = 0;
+		if (this.contBytes > 0) res += this.defaultCharUnicode;
+		return res;
+	};
+}));
+
+//#endregion
+export default require_internal();
+
+export { require_internal };

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

@@ -0,0 +1,53 @@
+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/sbcs-codec.js
+var require_sbcs_codec = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var Buffer = require_safer().Buffer;
+	exports._sbcs = SBCSCodec;
+	function SBCSCodec(codecOptions, iconv) {
+		if (!codecOptions) throw new Error("SBCS codec is called without the data.");
+		if (!codecOptions.chars || codecOptions.chars.length !== 128 && codecOptions.chars.length !== 256) throw new Error("Encoding '" + codecOptions.type + "' has incorrect 'chars' (must be of len 128 or 256)");
+		if (codecOptions.chars.length === 128) {
+			var asciiString = "";
+			for (var i = 0; i < 128; i++) asciiString += String.fromCharCode(i);
+			codecOptions.chars = asciiString + codecOptions.chars;
+		}
+		this.decodeBuf = Buffer.from(codecOptions.chars, "ucs2");
+		var encodeBuf = Buffer.alloc(65536, iconv.defaultCharSingleByte.charCodeAt(0));
+		for (var i = 0; i < codecOptions.chars.length; i++) encodeBuf[codecOptions.chars.charCodeAt(i)] = i;
+		this.encodeBuf = encodeBuf;
+	}
+	SBCSCodec.prototype.encoder = SBCSEncoder;
+	SBCSCodec.prototype.decoder = SBCSDecoder;
+	function SBCSEncoder(options, codec) {
+		this.encodeBuf = codec.encodeBuf;
+	}
+	SBCSEncoder.prototype.write = function(str) {
+		var buf = Buffer.alloc(str.length);
+		for (var i = 0; i < str.length; i++) buf[i] = this.encodeBuf[str.charCodeAt(i)];
+		return buf;
+	};
+	SBCSEncoder.prototype.end = function() {};
+	function SBCSDecoder(options, codec) {
+		this.decodeBuf = codec.decodeBuf;
+	}
+	SBCSDecoder.prototype.write = function(buf) {
+		var decodeBuf = this.decodeBuf;
+		var newBuf = Buffer.alloc(buf.length * 2);
+		var idx1 = 0, idx2 = 0;
+		for (var i = 0; i < buf.length; i++) {
+			idx1 = buf[i] * 2;
+			idx2 = i * 2;
+			newBuf[idx2] = decodeBuf[idx1];
+			newBuf[idx2 + 1] = decodeBuf[idx1 + 1];
+		}
+		return newBuf.toString("ucs2");
+	};
+	SBCSDecoder.prototype.end = function() {};
+}));
+
+//#endregion
+export default require_sbcs_codec();
+
+export { require_sbcs_codec };