vinext 1.3.1 → 1.4.0

package/dist/deps/.pnpm/iconv-lite@0.4.24/deps/iconv-lite/encodings/dbcs-codec.js

@@ -0,0 +1,327 @@
+import { __commonJSMin } from "../../../../../../_virtual/_rolldown/runtime.js";
+import { require_safer } from "../../../../safer-buffer@2.1.2/deps/safer-buffer/safer.js";
+//#region ../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/dbcs-codec.js
+var require_dbcs_codec = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var Buffer = require_safer().Buffer;
+	exports._dbcs = DBCSCodec;
+	var UNASSIGNED = -1;
+	var GB18030_CODE = -2;
+	var SEQ_START = -10;
+	var NODE_START = -1e3;
+	var UNASSIGNED_NODE = new Array(256);
+	var DEF_CHAR = -1;
+	for (var i = 0; i < 256; i++) UNASSIGNED_NODE[i] = UNASSIGNED;
+	function DBCSCodec(codecOptions, iconv) {
+		this.encodingName = codecOptions.encodingName;
+		if (!codecOptions) throw new Error("DBCS codec is called without the data.");
+		if (!codecOptions.table) throw new Error("Encoding '" + this.encodingName + "' has no data.");
+		var mappingTable = codecOptions.table();
+		this.decodeTables = [];
+		this.decodeTables[0] = UNASSIGNED_NODE.slice(0);
+		this.decodeTableSeq = [];
+		for (var i = 0; i < mappingTable.length; i++) this._addDecodeChunk(mappingTable[i]);
+		this.defaultCharUnicode = iconv.defaultCharUnicode;
+		this.encodeTable = [];
+		this.encodeTableSeq = [];
+		var skipEncodeChars = {};
+		if (codecOptions.encodeSkipVals) for (var i = 0; i < codecOptions.encodeSkipVals.length; i++) {
+			var val = codecOptions.encodeSkipVals[i];
+			if (typeof val === "number") skipEncodeChars[val] = true;
+			else for (var j = val.from; j <= val.to; j++) skipEncodeChars[j] = true;
+		}
+		this._fillEncodeTable(0, 0, skipEncodeChars);
+		if (codecOptions.encodeAdd) {
+			for (var uChar in codecOptions.encodeAdd) if (Object.prototype.hasOwnProperty.call(codecOptions.encodeAdd, uChar)) this._setEncodeChar(uChar.charCodeAt(0), codecOptions.encodeAdd[uChar]);
+		}
+		this.defCharSB = this.encodeTable[0][iconv.defaultCharSingleByte.charCodeAt(0)];
+		if (this.defCharSB === UNASSIGNED) this.defCharSB = this.encodeTable[0]["?"];
+		if (this.defCharSB === UNASSIGNED) this.defCharSB = "?".charCodeAt(0);
+		if (typeof codecOptions.gb18030 === "function") {
+			this.gb18030 = codecOptions.gb18030();
+			var thirdByteNodeIdx = this.decodeTables.length;
+			var thirdByteNode = this.decodeTables[thirdByteNodeIdx] = UNASSIGNED_NODE.slice(0);
+			var fourthByteNodeIdx = this.decodeTables.length;
+			var fourthByteNode = this.decodeTables[fourthByteNodeIdx] = UNASSIGNED_NODE.slice(0);
+			for (var i = 129; i <= 254; i++) {
+				var secondByteNodeIdx = NODE_START - this.decodeTables[0][i];
+				var secondByteNode = this.decodeTables[secondByteNodeIdx];
+				for (var j = 48; j <= 57; j++) secondByteNode[j] = NODE_START - thirdByteNodeIdx;
+			}
+			for (var i = 129; i <= 254; i++) thirdByteNode[i] = NODE_START - fourthByteNodeIdx;
+			for (var i = 48; i <= 57; i++) fourthByteNode[i] = GB18030_CODE;
+		}
+	}
+	DBCSCodec.prototype.encoder = DBCSEncoder;
+	DBCSCodec.prototype.decoder = DBCSDecoder;
+	DBCSCodec.prototype._getDecodeTrieNode = function(addr) {
+		var bytes = [];
+		for (; addr > 0; addr >>= 8) bytes.push(addr & 255);
+		if (bytes.length == 0) bytes.push(0);
+		var node = this.decodeTables[0];
+		for (var i = bytes.length - 1; i > 0; i--) {
+			var val = node[bytes[i]];
+			if (val == UNASSIGNED) {
+				node[bytes[i]] = NODE_START - this.decodeTables.length;
+				this.decodeTables.push(node = UNASSIGNED_NODE.slice(0));
+			} else if (val <= NODE_START) node = this.decodeTables[NODE_START - val];
+			else throw new Error("Overwrite byte in " + this.encodingName + ", addr: " + addr.toString(16));
+		}
+		return node;
+	};
+	DBCSCodec.prototype._addDecodeChunk = function(chunk) {
+		var curAddr = parseInt(chunk[0], 16);
+		var writeTable = this._getDecodeTrieNode(curAddr);
+		curAddr = curAddr & 255;
+		for (var k = 1; k < chunk.length; k++) {
+			var part = chunk[k];
+			if (typeof part === "string") for (var l = 0; l < part.length;) {
+				var code = part.charCodeAt(l++);
+				if (55296 <= code && code < 56320) {
+					var codeTrail = part.charCodeAt(l++);
+					if (56320 <= codeTrail && codeTrail < 57344) writeTable[curAddr++] = 65536 + (code - 55296) * 1024 + (codeTrail - 56320);
+					else throw new Error("Incorrect surrogate pair in " + this.encodingName + " at chunk " + chunk[0]);
+				} else if (4080 < code && code <= 4095) {
+					var len = 4095 - code + 2;
+					var seq = [];
+					for (var m = 0; m < len; m++) seq.push(part.charCodeAt(l++));
+					writeTable[curAddr++] = SEQ_START - this.decodeTableSeq.length;
+					this.decodeTableSeq.push(seq);
+				} else writeTable[curAddr++] = code;
+			}
+			else if (typeof part === "number") {
+				var charCode = writeTable[curAddr - 1] + 1;
+				for (var l = 0; l < part; l++) writeTable[curAddr++] = charCode++;
+			} else throw new Error("Incorrect type '" + typeof part + "' given in " + this.encodingName + " at chunk " + chunk[0]);
+		}
+		if (curAddr > 255) throw new Error("Incorrect chunk in " + this.encodingName + " at addr " + chunk[0] + ": too long" + curAddr);
+	};
+	DBCSCodec.prototype._getEncodeBucket = function(uCode) {
+		var high = uCode >> 8;
+		if (this.encodeTable[high] === void 0) this.encodeTable[high] = UNASSIGNED_NODE.slice(0);
+		return this.encodeTable[high];
+	};
+	DBCSCodec.prototype._setEncodeChar = function(uCode, dbcsCode) {
+		var bucket = this._getEncodeBucket(uCode);
+		var low = uCode & 255;
+		if (bucket[low] <= SEQ_START) this.encodeTableSeq[SEQ_START - bucket[low]][DEF_CHAR] = dbcsCode;
+		else if (bucket[low] == UNASSIGNED) bucket[low] = dbcsCode;
+	};
+	DBCSCodec.prototype._setEncodeSequence = function(seq, dbcsCode) {
+		var uCode = seq[0];
+		var bucket = this._getEncodeBucket(uCode);
+		var low = uCode & 255;
+		var node;
+		if (bucket[low] <= SEQ_START) node = this.encodeTableSeq[SEQ_START - bucket[low]];
+		else {
+			node = {};
+			if (bucket[low] !== UNASSIGNED) node[DEF_CHAR] = bucket[low];
+			bucket[low] = SEQ_START - this.encodeTableSeq.length;
+			this.encodeTableSeq.push(node);
+		}
+		for (var j = 1; j < seq.length - 1; j++) {
+			var oldVal = node[uCode];
+			if (typeof oldVal === "object") node = oldVal;
+			else {
+				node = node[uCode] = {};
+				if (oldVal !== void 0) node[DEF_CHAR] = oldVal;
+			}
+		}
+		uCode = seq[seq.length - 1];
+		node[uCode] = dbcsCode;
+	};
+	DBCSCodec.prototype._fillEncodeTable = function(nodeIdx, prefix, skipEncodeChars) {
+		var node = this.decodeTables[nodeIdx];
+		for (var i = 0; i < 256; i++) {
+			var uCode = node[i];
+			var mbCode = prefix + i;
+			if (skipEncodeChars[mbCode]) continue;
+			if (uCode >= 0) this._setEncodeChar(uCode, mbCode);
+			else if (uCode <= NODE_START) this._fillEncodeTable(NODE_START - uCode, mbCode << 8, skipEncodeChars);
+			else if (uCode <= SEQ_START) this._setEncodeSequence(this.decodeTableSeq[SEQ_START - uCode], mbCode);
+		}
+	};
+	function DBCSEncoder(options, codec) {
+		this.leadSurrogate = -1;
+		this.seqObj = void 0;
+		this.encodeTable = codec.encodeTable;
+		this.encodeTableSeq = codec.encodeTableSeq;
+		this.defaultCharSingleByte = codec.defCharSB;
+		this.gb18030 = codec.gb18030;
+	}
+	DBCSEncoder.prototype.write = function(str) {
+		var newBuf = Buffer.alloc(str.length * (this.gb18030 ? 4 : 3)), leadSurrogate = this.leadSurrogate, seqObj = this.seqObj, nextChar = -1, i = 0, j = 0;
+		while (true) {
+			if (nextChar === -1) {
+				if (i == str.length) break;
+				var uCode = str.charCodeAt(i++);
+			} else {
+				var uCode = nextChar;
+				nextChar = -1;
+			}
+			if (55296 <= uCode && uCode < 57344) {
+				if (uCode < 56320) {
+					if (leadSurrogate === -1) {
+						leadSurrogate = uCode;
+						continue;
+					} else {
+						leadSurrogate = uCode;
+						uCode = UNASSIGNED;
+					}
+				} else if (leadSurrogate !== -1) {
+					uCode = 65536 + (leadSurrogate - 55296) * 1024 + (uCode - 56320);
+					leadSurrogate = -1;
+				} else uCode = UNASSIGNED;
+			} else if (leadSurrogate !== -1) {
+				nextChar = uCode;
+				uCode = UNASSIGNED;
+				leadSurrogate = -1;
+			}
+			var dbcsCode = UNASSIGNED;
+			if (seqObj !== void 0 && uCode != UNASSIGNED) {
+				var resCode = seqObj[uCode];
+				if (typeof resCode === "object") {
+					seqObj = resCode;
+					continue;
+				} else if (typeof resCode == "number") dbcsCode = resCode;
+				else if (resCode == void 0) {
+					resCode = seqObj[DEF_CHAR];
+					if (resCode !== void 0) {
+						dbcsCode = resCode;
+						nextChar = uCode;
+					}
+				}
+				seqObj = void 0;
+			} else if (uCode >= 0) {
+				var subtable = this.encodeTable[uCode >> 8];
+				if (subtable !== void 0) dbcsCode = subtable[uCode & 255];
+				if (dbcsCode <= SEQ_START) {
+					seqObj = this.encodeTableSeq[SEQ_START - dbcsCode];
+					continue;
+				}
+				if (dbcsCode == UNASSIGNED && this.gb18030) {
+					var idx = findIdx(this.gb18030.uChars, uCode);
+					if (idx != -1) {
+						var dbcsCode = this.gb18030.gbChars[idx] + (uCode - this.gb18030.uChars[idx]);
+						newBuf[j++] = 129 + Math.floor(dbcsCode / 12600);
+						dbcsCode = dbcsCode % 12600;
+						newBuf[j++] = 48 + Math.floor(dbcsCode / 1260);
+						dbcsCode = dbcsCode % 1260;
+						newBuf[j++] = 129 + Math.floor(dbcsCode / 10);
+						dbcsCode = dbcsCode % 10;
+						newBuf[j++] = 48 + dbcsCode;
+						continue;
+					}
+				}
+			}
+			if (dbcsCode === UNASSIGNED) dbcsCode = this.defaultCharSingleByte;
+			if (dbcsCode < 256) newBuf[j++] = dbcsCode;
+			else if (dbcsCode < 65536) {
+				newBuf[j++] = dbcsCode >> 8;
+				newBuf[j++] = dbcsCode & 255;
+			} else {
+				newBuf[j++] = dbcsCode >> 16;
+				newBuf[j++] = dbcsCode >> 8 & 255;
+				newBuf[j++] = dbcsCode & 255;
+			}
+		}
+		this.seqObj = seqObj;
+		this.leadSurrogate = leadSurrogate;
+		return newBuf.slice(0, j);
+	};
+	DBCSEncoder.prototype.end = function() {
+		if (this.leadSurrogate === -1 && this.seqObj === void 0) return;
+		var newBuf = Buffer.alloc(10), j = 0;
+		if (this.seqObj) {
+			var dbcsCode = this.seqObj[DEF_CHAR];
+			if (dbcsCode !== void 0) {
+				if (dbcsCode < 256) newBuf[j++] = dbcsCode;
+				else {
+					newBuf[j++] = dbcsCode >> 8;
+					newBuf[j++] = dbcsCode & 255;
+				}
+			}
+			this.seqObj = void 0;
+		}
+		if (this.leadSurrogate !== -1) {
+			newBuf[j++] = this.defaultCharSingleByte;
+			this.leadSurrogate = -1;
+		}
+		return newBuf.slice(0, j);
+	};
+	DBCSEncoder.prototype.findIdx = findIdx;
+	function DBCSDecoder(options, codec) {
+		this.nodeIdx = 0;
+		this.prevBuf = Buffer.alloc(0);
+		this.decodeTables = codec.decodeTables;
+		this.decodeTableSeq = codec.decodeTableSeq;
+		this.defaultCharUnicode = codec.defaultCharUnicode;
+		this.gb18030 = codec.gb18030;
+	}
+	DBCSDecoder.prototype.write = function(buf) {
+		var newBuf = Buffer.alloc(buf.length * 2), nodeIdx = this.nodeIdx, prevBuf = this.prevBuf, prevBufOffset = this.prevBuf.length, seqStart = -this.prevBuf.length, uCode;
+		if (prevBufOffset > 0) prevBuf = Buffer.concat([prevBuf, buf.slice(0, 10)]);
+		for (var i = 0, j = 0; i < buf.length; i++) {
+			var curByte = i >= 0 ? buf[i] : prevBuf[i + prevBufOffset];
+			var uCode = this.decodeTables[nodeIdx][curByte];
+			if (uCode >= 0) {} else if (uCode === UNASSIGNED) {
+				i = seqStart;
+				uCode = this.defaultCharUnicode.charCodeAt(0);
+			} else if (uCode === GB18030_CODE) {
+				var curSeq = seqStart >= 0 ? buf.slice(seqStart, i + 1) : prevBuf.slice(seqStart + prevBufOffset, i + 1 + prevBufOffset);
+				var ptr = (curSeq[0] - 129) * 12600 + (curSeq[1] - 48) * 1260 + (curSeq[2] - 129) * 10 + (curSeq[3] - 48);
+				var idx = findIdx(this.gb18030.gbChars, ptr);
+				uCode = this.gb18030.uChars[idx] + ptr - this.gb18030.gbChars[idx];
+			} else if (uCode <= NODE_START) {
+				nodeIdx = NODE_START - uCode;
+				continue;
+			} else if (uCode <= SEQ_START) {
+				var seq = this.decodeTableSeq[SEQ_START - uCode];
+				for (var k = 0; k < seq.length - 1; k++) {
+					uCode = seq[k];
+					newBuf[j++] = uCode & 255;
+					newBuf[j++] = uCode >> 8;
+				}
+				uCode = seq[seq.length - 1];
+			} else throw new Error("iconv-lite internal error: invalid decoding table value " + uCode + " at " + nodeIdx + "/" + curByte);
+			if (uCode > 65535) {
+				uCode -= 65536;
+				var uCodeLead = 55296 + Math.floor(uCode / 1024);
+				newBuf[j++] = uCodeLead & 255;
+				newBuf[j++] = uCodeLead >> 8;
+				uCode = 56320 + uCode % 1024;
+			}
+			newBuf[j++] = uCode & 255;
+			newBuf[j++] = uCode >> 8;
+			nodeIdx = 0;
+			seqStart = i + 1;
+		}
+		this.nodeIdx = nodeIdx;
+		this.prevBuf = seqStart >= 0 ? buf.slice(seqStart) : prevBuf.slice(seqStart + prevBufOffset);
+		return newBuf.slice(0, j).toString("ucs2");
+	};
+	DBCSDecoder.prototype.end = function() {
+		var ret = "";
+		while (this.prevBuf.length > 0) {
+			ret += this.defaultCharUnicode;
+			var buf = this.prevBuf.slice(1);
+			this.prevBuf = Buffer.alloc(0);
+			this.nodeIdx = 0;
+			if (buf.length > 0) ret += this.write(buf);
+		}
+		this.nodeIdx = 0;
+		return ret;
+	};
+	function findIdx(table, val) {
+		if (table[0] > val) return -1;
+		var l = 0, r = table.length;
+		while (l < r - 1) {
+			var mid = l + Math.floor((r - l + 1) / 2);
+			if (table[mid] <= val) l = mid;
+			else r = mid;
+		}
+		return l;
+	}
+}));
+//#endregion
+export default require_dbcs_codec();
+export { require_dbcs_codec };

package/dist/deps/.pnpm/iconv-lite@0.4.24/deps/iconv-lite/encodings/dbcs-data.js

@@ -0,0 +1,123 @@
+import { __commonJSMin } from "../../../../../../_virtual/_rolldown/runtime.js";
+import { require_shiftjis } from "./tables/shiftjis.json.js";
+import { require_eucjp } from "./tables/eucjp.json.js";
+import { require_cp936 } from "./tables/cp936.json.js";
+import { require_gbk_added } from "./tables/gbk-added.json.js";
+import { require_gb18030_ranges } from "./tables/gb18030-ranges.json.js";
+import { require_cp949 } from "./tables/cp949.json.js";
+import { require_cp950 } from "./tables/cp950.json.js";
+import { require_big5_added } from "./tables/big5-added.json.js";
+//#region ../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/dbcs-data.js
+var require_dbcs_data = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = {
+		"shiftjis": {
+			type: "_dbcs",
+			table: function() {
+				return require_shiftjis();
+			},
+			encodeAdd: {
+				"¥": 92,
+				"‾": 126
+			},
+			encodeSkipVals: [{
+				from: 60736,
+				to: 63808
+			}]
+		},
+		"csshiftjis": "shiftjis",
+		"mskanji": "shiftjis",
+		"sjis": "shiftjis",
+		"windows31j": "shiftjis",
+		"ms31j": "shiftjis",
+		"xsjis": "shiftjis",
+		"windows932": "shiftjis",
+		"ms932": "shiftjis",
+		"932": "shiftjis",
+		"cp932": "shiftjis",
+		"eucjp": {
+			type: "_dbcs",
+			table: function() {
+				return require_eucjp();
+			},
+			encodeAdd: {
+				"¥": 92,
+				"‾": 126
+			}
+		},
+		"gb2312": "cp936",
+		"gb231280": "cp936",
+		"gb23121980": "cp936",
+		"csgb2312": "cp936",
+		"csiso58gb231280": "cp936",
+		"euccn": "cp936",
+		"windows936": "cp936",
+		"ms936": "cp936",
+		"936": "cp936",
+		"cp936": {
+			type: "_dbcs",
+			table: function() {
+				return require_cp936();
+			}
+		},
+		"gbk": {
+			type: "_dbcs",
+			table: function() {
+				return require_cp936().concat(require_gbk_added());
+			}
+		},
+		"xgbk": "gbk",
+		"isoir58": "gbk",
+		"gb18030": {
+			type: "_dbcs",
+			table: function() {
+				return require_cp936().concat(require_gbk_added());
+			},
+			gb18030: function() {
+				return require_gb18030_ranges();
+			},
+			encodeSkipVals: [128],
+			encodeAdd: { "€": 41699 }
+		},
+		"chinese": "gb18030",
+		"windows949": "cp949",
+		"ms949": "cp949",
+		"949": "cp949",
+		"cp949": {
+			type: "_dbcs",
+			table: function() {
+				return require_cp949();
+			}
+		},
+		"cseuckr": "cp949",
+		"csksc56011987": "cp949",
+		"euckr": "cp949",
+		"isoir149": "cp949",
+		"korean": "cp949",
+		"ksc56011987": "cp949",
+		"ksc56011989": "cp949",
+		"ksc5601": "cp949",
+		"windows950": "cp950",
+		"ms950": "cp950",
+		"950": "cp950",
+		"cp950": {
+			type: "_dbcs",
+			table: function() {
+				return require_cp950();
+			}
+		},
+		"big5": "big5hkscs",
+		"big5hkscs": {
+			type: "_dbcs",
+			table: function() {
+				return require_cp950().concat(require_big5_added());
+			},
+			encodeSkipVals: [41676]
+		},
+		"cnbig5": "big5hkscs",
+		"csbig5": "big5hkscs",
+		"xxbig5": "big5hkscs"
+	};
+}));
+//#endregion
+export default require_dbcs_data();
+export { require_dbcs_data };

package/dist/deps/.pnpm/iconv-lite@0.4.24/deps/iconv-lite/encodings/index.js

@@ -0,0 +1,29 @@
+import { __commonJSMin } from "../../../../../../_virtual/_rolldown/runtime.js";
+import { require_internal } from "./internal.js";
+import { require_utf16 } from "./utf16.js";
+import { require_utf7 } from "./utf7.js";
+import { require_sbcs_codec } from "./sbcs-codec.js";
+import { require_sbcs_data } from "./sbcs-data.js";
+import { require_sbcs_data_generated } from "./sbcs-data-generated.js";
+import { require_dbcs_codec } from "./dbcs-codec.js";
+import { require_dbcs_data } from "./dbcs-data.js";
+//#region ../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/index.js
+var require_encodings = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var modules = [
+		require_internal(),
+		require_utf16(),
+		require_utf7(),
+		require_sbcs_codec(),
+		require_sbcs_data(),
+		require_sbcs_data_generated(),
+		require_dbcs_codec(),
+		require_dbcs_data()
+	];
+	for (var i = 0; i < modules.length; i++) {
+		var module = modules[i];
+		for (var enc in module) if (Object.prototype.hasOwnProperty.call(module, enc)) exports[enc] = module[enc];
+	}
+}));
+//#endregion
+export default require_encodings();
+export { require_encodings };

package/dist/deps/.pnpm/iconv-lite@0.4.24/deps/iconv-lite/encodings/internal.js

@@ -0,0 +1,134 @@
+import { __commonJSMin, __require } from "../../../../../../_virtual/_rolldown/runtime.js";
+import { require_safer } from "../../../../safer-buffer@2.1.2/deps/safer-buffer/safer.js";
+//#region ../../node_modules/.pnpm/iconv-lite@0.4.24/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) {
+		StringDecoder.call(this, codec.enc);
+	}
+	InternalDecoder.prototype = StringDecoder.prototype;
+	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/deps/.pnpm/iconv-lite@0.4.24/deps/iconv-lite/encodings/sbcs-codec.js

@@ -0,0 +1,50 @@
+import { __commonJSMin } from "../../../../../../_virtual/_rolldown/runtime.js";
+import { require_safer } from "../../../../safer-buffer@2.1.2/deps/safer-buffer/safer.js";
+//#region ../../node_modules/.pnpm/iconv-lite@0.4.24/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 };