c8y-nitro 0.1.0 → 0.1.1

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

@@ -0,0 +1,349 @@
+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/dbcs-codec.js
+var require_dbcs_codec = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var Buffer = require_safer().Buffer;
+	exports._dbcs = DBCSCodec;
+	var UNASSIGNED = -1, GB18030_CODE = -2, SEQ_START = -10, NODE_START = -1e3, UNASSIGNED_NODE = new Array(256), 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]);
+		if (typeof codecOptions.gb18030 === "function") {
+			this.gb18030 = codecOptions.gb18030();
+			var commonThirdByteNodeIdx = this.decodeTables.length;
+			this.decodeTables.push(UNASSIGNED_NODE.slice(0));
+			var commonFourthByteNodeIdx = this.decodeTables.length;
+			this.decodeTables.push(UNASSIGNED_NODE.slice(0));
+			var firstByteNode = this.decodeTables[0];
+			for (var i = 129; i <= 254; i++) {
+				var secondByteNode = this.decodeTables[NODE_START - firstByteNode[i]];
+				for (var j = 48; j <= 57; j++) {
+					if (secondByteNode[j] === UNASSIGNED) secondByteNode[j] = NODE_START - commonThirdByteNodeIdx;
+					else if (secondByteNode[j] > NODE_START) throw new Error("gb18030 decode tables conflict at byte 2");
+					var thirdByteNode = this.decodeTables[NODE_START - secondByteNode[j]];
+					for (var k = 129; k <= 254; k++) {
+						if (thirdByteNode[k] === UNASSIGNED) thirdByteNode[k] = NODE_START - commonFourthByteNodeIdx;
+						else if (thirdByteNode[k] === NODE_START - commonFourthByteNodeIdx) continue;
+						else if (thirdByteNode[k] > NODE_START) throw new Error("gb18030 decode tables conflict at byte 3");
+						var fourthByteNode = this.decodeTables[NODE_START - thirdByteNode[k]];
+						for (var l = 48; l <= 57; l++) if (fourthByteNode[l] === UNASSIGNED) fourthByteNode[l] = GB18030_CODE;
+					}
+				}
+			}
+		}
+		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);
+	}
+	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];
+		var hasValues = false;
+		var subNodeEmpty = {};
+		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);
+				hasValues = true;
+			} else if (uCode <= NODE_START) {
+				var subNodeIdx = NODE_START - uCode;
+				if (!subNodeEmpty[subNodeIdx]) {
+					var newPrefix = mbCode << 8 >>> 0;
+					if (this._fillEncodeTable(subNodeIdx, newPrefix, skipEncodeChars)) hasValues = true;
+					else subNodeEmpty[subNodeIdx] = true;
+				}
+			} else if (uCode <= SEQ_START) {
+				this._setEncodeSequence(this.decodeTableSeq[SEQ_START - uCode], mbCode);
+				hasValues = true;
+			}
+		}
+		return hasValues;
+	};
+	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 if (dbcsCode < 16777216) {
+				newBuf[j++] = dbcsCode >> 16;
+				newBuf[j++] = dbcsCode >> 8 & 255;
+				newBuf[j++] = dbcsCode & 255;
+			} else {
+				newBuf[j++] = dbcsCode >>> 24;
+				newBuf[j++] = dbcsCode >>> 16 & 255;
+				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.prevBytes = [];
+		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, prevBytes = this.prevBytes, prevOffset = this.prevBytes.length, seqStart = -this.prevBytes.length, uCode;
+		for (var i = 0, j = 0; i < buf.length; i++) {
+			var curByte = i >= 0 ? buf[i] : prevBytes[i + prevOffset];
+			var uCode = this.decodeTables[nodeIdx][curByte];
+			if (uCode >= 0) {} else if (uCode === UNASSIGNED) {
+				uCode = this.defaultCharUnicode.charCodeAt(0);
+				i = seqStart;
+			} else if (uCode === GB18030_CODE) {
+				if (i >= 3) var ptr = (buf[i - 3] - 129) * 12600 + (buf[i - 2] - 48) * 1260 + (buf[i - 1] - 129) * 10 + (curByte - 48);
+				else var ptr = (prevBytes[i - 3 + prevOffset] - 129) * 12600 + ((i - 2 >= 0 ? buf[i - 2] : prevBytes[i - 2 + prevOffset]) - 48) * 1260 + ((i - 1 >= 0 ? buf[i - 1] : prevBytes[i - 1 + prevOffset]) - 129) * 10 + (curByte - 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 >= 65536) {
+				uCode -= 65536;
+				var uCodeLead = 55296 | uCode >> 10;
+				newBuf[j++] = uCodeLead & 255;
+				newBuf[j++] = uCodeLead >> 8;
+				uCode = 56320 | uCode & 1023;
+			}
+			newBuf[j++] = uCode & 255;
+			newBuf[j++] = uCode >> 8;
+			nodeIdx = 0;
+			seqStart = i + 1;
+		}
+		this.nodeIdx = nodeIdx;
+		this.prevBytes = seqStart >= 0 ? Array.prototype.slice.call(buf, seqStart) : prevBytes.slice(seqStart + prevOffset).concat(Array.prototype.slice.call(buf));
+		return newBuf.slice(0, j).toString("ucs2");
+	};
+	DBCSDecoder.prototype.end = function() {
+		var ret = "";
+		while (this.prevBytes.length > 0) {
+			ret += this.defaultCharUnicode;
+			var bytesArr = this.prevBytes.slice(1);
+			this.prevBytes = [];
+			this.nodeIdx = 0;
+			if (bytesArr.length > 0) ret += this.write(bytesArr);
+		}
+		this.prevBytes = [];
+		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 + (r - l + 1 >> 1);
+			if (table[mid] <= val) l = mid;
+			else r = mid;
+		}
+		return l;
+	}
+}));
+
+//#endregion
+export default require_dbcs_codec();
+
+export { require_dbcs_codec };

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

@@ -0,0 +1,194 @@
+import { __commonJSMin } from "../../../../../../_virtual/rolldown_runtime.mjs";
+import { require_shiftjis } from "./tables/shiftjis.mjs";
+import { require_eucjp } from "./tables/eucjp.mjs";
+import { require_cp936 } from "./tables/cp936.mjs";
+import { require_gbk_added } from "./tables/gbk-added.mjs";
+import { require_gb18030_ranges } from "./tables/gb18030-ranges.mjs";
+import { require_cp949 } from "./tables/cp949.mjs";
+import { require_cp950 } from "./tables/cp950.mjs";
+import { require_big5_added } from "./tables/big5-added.mjs";
+
+//#region node_modules/.pnpm/iconv-lite@0.6.3/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: [
+				36457,
+				36463,
+				36478,
+				36523,
+				36532,
+				36557,
+				36560,
+				36695,
+				36713,
+				36718,
+				36811,
+				36862,
+				36973,
+				36986,
+				37060,
+				37084,
+				37105,
+				37311,
+				37551,
+				37552,
+				37553,
+				37554,
+				37585,
+				37959,
+				38090,
+				38361,
+				38652,
+				39285,
+				39798,
+				39800,
+				39803,
+				39878,
+				39902,
+				39916,
+				39926,
+				40002,
+				40019,
+				40034,
+				40040,
+				40043,
+				40055,
+				40124,
+				40125,
+				40144,
+				40279,
+				40282,
+				40388,
+				40431,
+				40443,
+				40617,
+				40687,
+				40701,
+				40800,
+				40907,
+				41079,
+				41180,
+				41183,
+				36812,
+				37576,
+				38468,
+				38637,
+				41636,
+				41637,
+				41639,
+				41638,
+				41676,
+				41678
+			]
+		},
+		"cnbig5": "big5hkscs",
+		"csbig5": "big5hkscs",
+		"xxbig5": "big5hkscs"
+	};
+}));
+
+//#endregion
+export default require_dbcs_data();
+
+export { require_dbcs_data };

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

@@ -0,0 +1,34 @@
+import { __commonJSMin } from "../../../../../../_virtual/rolldown_runtime.mjs";
+import { require_internal } from "./internal.mjs";
+import { require_utf32 } from "./utf32.mjs";
+import { require_utf16 } from "./utf16.mjs";
+import { require_utf7 } from "./utf7.mjs";
+import { require_sbcs_codec } from "./sbcs-codec.mjs";
+import { require_sbcs_data } from "./sbcs-data.mjs";
+import { require_sbcs_data_generated } from "./sbcs-data-generated.mjs";
+import { require_dbcs_codec } from "./dbcs-codec.mjs";
+import { require_dbcs_data } from "./dbcs-data.mjs";
+
+//#region node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/encodings/index.js
+var require_encodings = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var modules = [
+		require_internal(),
+		require_utf32(),
+		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 };