@loaders.gl/core 5.0.0-alpha.12 → 5.0.0-alpha.13

package/dist/polyfills/index.cjs

@@ -0,0 +1,2918 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/polyfills/images/node-image-formats.ts
+var NODE_FORMAT_SUPPORT;
+var init_node_image_formats = __esm({
+  "src/polyfills/images/node-image-formats.ts"() {
+    "use strict";
+    NODE_FORMAT_SUPPORT = ["image/png", "image/jpeg", "image/gif"];
+  }
+});
+
+// src/polyfills/images/parse-image-node.ts
+var parse_image_node_exports = {};
+__export(parse_image_node_exports, {
+  NODE_FORMAT_SUPPORT: () => NODE_FORMAT_SUPPORT,
+  parseImageNode: () => parseImageNode
+});
+async function parseImageNode(arrayBuffer, mimeType) {
+  if (!mimeType) {
+    throw new Error("MIMEType is required to parse image under Node.js");
+  }
+  const buffer = arrayBuffer instanceof Buffer ? arrayBuffer : Buffer.from(arrayBuffer);
+  const ndarray2 = await getPixelsAsync(buffer, mimeType);
+  return ndarray2;
+}
+function getPixelsAsync(buffer, mimeType) {
+  return new Promise(
+    (resolve) => (0, import_get_pixels.default)(buffer, mimeType, (err, ndarray2) => {
+      if (err) {
+        throw err;
+      }
+      const shape = [...ndarray2.shape];
+      const layers = ndarray2.shape.length === 4 ? ndarray2.shape.shift() : 1;
+      const data = ndarray2.data instanceof Buffer ? new Uint8Array(ndarray2.data) : ndarray2.data;
+      resolve({
+        shape,
+        data,
+        width: ndarray2.shape[0],
+        height: ndarray2.shape[1],
+        components: ndarray2.shape[2],
+        // TODO - error
+        layers: layers ? [layers] : []
+      });
+    })
+  );
+}
+var import_get_pixels;
+var init_parse_image_node = __esm({
+  "src/polyfills/images/parse-image-node.ts"() {
+    "use strict";
+    import_get_pixels = __toESM(require("get-pixels"), 1);
+    init_node_image_formats();
+  }
+});
+
+// src/polyfills/buffer/to-array-buffer.node.ts
+function bufferToArrayBuffer(buffer) {
+  if (Buffer.isBuffer(buffer)) {
+    const typedArray = new Uint8Array(buffer);
+    return typedArray.buffer;
+  }
+  return buffer;
+}
+var init_to_array_buffer_node = __esm({
+  "src/polyfills/buffer/to-array-buffer.node.ts"() {
+    "use strict";
+  }
+});
+
+// src/polyfills/images/encode-image-node.ts
+var encode_image_node_exports = {};
+__export(encode_image_node_exports, {
+  encodeImageNode: () => encodeImageNode,
+  encodeImageToStreamNode: () => encodeImageToStreamNode
+});
+function encodeImageToStreamNode(image, options) {
+  const type = options.type ? options.type.replace("image/", "") : "jpeg";
+  const pixels = (0, import_ndarray.default)(image.data, [image.width, image.height, 4], [4, image.width * 4, 1], 0);
+  return (0, import_save_pixels.default)(pixels, type, options);
+}
+function encodeImageNode(image, options) {
+  const imageStream = encodeImageToStreamNode(image, options);
+  return new Promise((resolve) => {
+    const buffers = [];
+    imageStream.on("data", (buffer) => buffers.push(buffer));
+    imageStream.on("end", () => {
+      const buffer = Buffer.concat(buffers);
+      resolve(bufferToArrayBuffer(buffer));
+    });
+  });
+}
+var import_save_pixels, import_ndarray;
+var init_encode_image_node = __esm({
+  "src/polyfills/images/encode-image-node.ts"() {
+    "use strict";
+    import_save_pixels = __toESM(require("save-pixels"), 1);
+    import_ndarray = __toESM(require("ndarray"), 1);
+    init_to_array_buffer_node();
+  }
+});
+
+// src/polyfills/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Blob: () => Blob_,
+  File: () => File_,
+  addAliases: () => addAliases,
+  installFilePolyfills: () => installFilePolyfills,
+  makeNodeStream: () => makeNodeStream,
+  nodeVersion: () => nodeVersion,
+  setPathPrefix: () => setPathPrefix
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/polyfills/utils/is-browser.ts
+var isBrowser = (
+  // @ts-ignore process.browser
+  typeof process !== "object" || String(process) !== "[object process]" || process.browser
+);
+
+// src/polyfills/text-encoder/encoding-indexes.ts
+var encoding_indexes_default = {
+  "ibm866": [1040, 1041, 1042, 1043, 1044, 1045, 1046, 1047, 1048, 1049, 1050, 1051, 1052, 1053, 1054, 1055, 1056, 1057, 1058, 1059, 1060, 1061, 1062, 1063, 1064, 1065, 1066, 1067, 1068, 1069, 1070, 1071, 1072, 1073, 1074, 1075, 1076, 1077, 1078, 1079, 1080, 1081, 1082, 1083, 1084, 1085, 1086, 1087, 9617, 9618, 9619, 9474, 9508, 9569, 9570, 9558, 9557, 9571, 9553, 9559, 9565, 9564, 9563, 9488, 9492, 9524, 9516, 9500, 9472, 9532, 9566, 9567, 9562, 9556, 9577, 9574, 9568, 9552, 9580, 9575, 9576, 9572, 9573, 9561, 9560, 9554, 9555, 9579, 9578, 9496, 9484, 9608, 9604, 9612, 9616, 9600, 1088, 1089, 1090, 1091, 1092, 1093, 1094, 1095, 1096, 1097, 1098, 1099, 1100, 1101, 1102, 1103, 1025, 1105, 1028, 1108, 1031, 1111, 1038, 1118, 176, 8729, 183, 8730, 8470, 164, 9632, 160],
+  "iso-8859-2": [128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 260, 728, 321, 164, 317, 346, 167, 168, 352, 350, 356, 377, 173, 381, 379, 176, 261, 731, 322, 180, 318, 347, 711, 184, 353, 351, 357, 378, 733, 382, 380, 340, 193, 194, 258, 196, 313, 262, 199, 268, 201, 280, 203, 282, 205, 206, 270, 272, 323, 327, 211, 212, 336, 214, 215, 344, 366, 218, 368, 220, 221, 354, 223, 341, 225, 226, 259, 228, 314, 263, 231, 269, 233, 281, 235, 283, 237, 238, 271, 273, 324, 328, 243, 244, 337, 246, 247, 345, 367, 250, 369, 252, 253, 355, 729],
+  "iso-8859-3": [128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 294, 728, 163, 164, null, 292, 167, 168, 304, 350, 286, 308, 173, null, 379, 176, 295, 178, 179, 180, 181, 293, 183, 184, 305, 351, 287, 309, 189, null, 380, 192, 193, 194, null, 196, 266, 264, 199, 200, 201, 202, 203, 204, 205, 206, 207, null, 209, 210, 211, 212, 288, 214, 215, 284, 217, 218, 219, 220, 364, 348, 223, 224, 225, 226, null, 228, 267, 265, 231, 232, 233, 234, 235, 236, 237, 238, 239, null, 241, 242, 243, 244, 289, 246, 247, 285, 249, 250, 251, 252, 365, 349, 729],
+  "iso-8859-4": [128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 260, 312, 342, 164, 296, 315, 167, 168, 352, 274, 290, 358, 173, 381, 175, 176, 261, 731, 343, 180, 297, 316, 711, 184, 353, 275, 291, 359, 330, 382, 331, 256, 193, 194, 195, 196, 197, 198, 302, 268, 201, 280, 203, 278, 205, 206, 298, 272, 325, 332, 310, 212, 213, 214, 215, 216, 370, 218, 219, 220, 360, 362, 223, 257, 225, 226, 227, 228, 229, 230, 303, 269, 233, 281, 235, 279, 237, 238, 299, 273, 326, 333, 311, 244, 245, 246, 247, 248, 371, 250, 251, 252, 361, 363, 729],
+  "iso-8859-5": [128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 1025, 1026, 1027, 1028, 1029, 1030, 1031, 1032, 1033, 1034, 1035, 1036, 173, 1038, 1039, 1040, 1041, 1042, 1043, 1044, 1045, 1046, 1047, 1048, 1049, 1050, 1051, 1052, 1053, 1054, 1055, 1056, 1057, 1058, 1059, 1060, 1061, 1062, 1063, 1064, 1065, 1066, 1067, 1068, 1069, 1070, 1071, 1072, 1073, 1074, 1075, 1076, 1077, 1078, 1079, 1080, 1081, 1082, 1083, 1084, 1085, 1086, 1087, 1088, 1089, 1090, 1091, 1092, 1093, 1094, 1095, 1096, 1097, 1098, 1099, 1100, 1101, 1102, 1103, 8470, 1105, 1106, 1107, 1108, 1109, 1110, 1111, 1112, 1113, 1114, 1115, 1116, 167, 1118, 1119],
+  "iso-8859-6": [128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, null, null, null, 164, null, null, null, null, null, null, null, 1548, 173, null, null, null, null, null, null, null, null, null, null, null, null, null, 1563, null, null, null, 1567, null, 1569, 1570, 1571, 1572, 1573, 1574, 1575, 1576, 1577, 1578, 1579, 1580, 1581, 1582, 1583, 1584, 1585, 1586, 1587, 1588, 1589, 1590, 1591, 1592, 1593, 1594, null, null, null, null, null, 1600, 1601, 1602, 1603, 1604, 1605, 1606, 1607, 1608, 1609, 1610, 1611, 1612, 1613, 1614, 1615, 1616, 1617, 1618, null, null, null, null, null, null, null, null, null, null, null, null, null],
+  "iso-8859-7": [128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 8216, 8217, 163, 8364, 8367, 166, 167, 168, 169, 890, 171, 172, 173, null, 8213, 176, 177, 178, 179, 900, 901, 902, 183, 904, 905, 906, 187, 908, 189, 910, 911, 912, 913, 914, 915, 916, 917, 918, 919, 920, 921, 922, 923, 924, 925, 926, 927, 928, 929, null, 931, 932, 933, 934, 935, 936, 937, 938, 939, 940, 941, 942, 943, 944, 945, 946, 947, 948, 949, 950, 951, 952, 953, 954, 955, 956, 957, 958, 959, 960, 961, 962, 963, 964, 965, 966, 967, 968, 969, 970, 971, 972, 973, 974, null],
+  "iso-8859-8": [128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, null, 162, 163, 164, 165, 166, 167, 168, 169, 215, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 247, 187, 188, 189, 190, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, 8215, 1488, 1489, 1490, 1491, 1492, 1493, 1494, 1495, 1496, 1497, 1498, 1499, 1500, 1501, 1502, 1503, 1504, 1505, 1506, 1507, 1508, 1509, 1510, 1511, 1512, 1513, 1514, null, null, 8206, 8207, null],
+  "iso-8859-10": [128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 260, 274, 290, 298, 296, 310, 167, 315, 272, 352, 358, 381, 173, 362, 330, 176, 261, 275, 291, 299, 297, 311, 183, 316, 273, 353, 359, 382, 8213, 363, 331, 256, 193, 194, 195, 196, 197, 198, 302, 268, 201, 280, 203, 278, 205, 206, 207, 208, 325, 332, 211, 212, 213, 214, 360, 216, 370, 218, 219, 220, 221, 222, 223, 257, 225, 226, 227, 228, 229, 230, 303, 269, 233, 281, 235, 279, 237, 238, 239, 240, 326, 333, 243, 244, 245, 246, 361, 248, 371, 250, 251, 252, 253, 254, 312],
+  "iso-8859-13": [128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 8221, 162, 163, 164, 8222, 166, 167, 216, 169, 342, 171, 172, 173, 174, 198, 176, 177, 178, 179, 8220, 181, 182, 183, 248, 185, 343, 187, 188, 189, 190, 230, 260, 302, 256, 262, 196, 197, 280, 274, 268, 201, 377, 278, 290, 310, 298, 315, 352, 323, 325, 211, 332, 213, 214, 215, 370, 321, 346, 362, 220, 379, 381, 223, 261, 303, 257, 263, 228, 229, 281, 275, 269, 233, 378, 279, 291, 311, 299, 316, 353, 324, 326, 243, 333, 245, 246, 247, 371, 322, 347, 363, 252, 380, 382, 8217],
+  "iso-8859-14": [128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 7682, 7683, 163, 266, 267, 7690, 167, 7808, 169, 7810, 7691, 7922, 173, 174, 376, 7710, 7711, 288, 289, 7744, 7745, 182, 7766, 7809, 7767, 7811, 7776, 7923, 7812, 7813, 7777, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 372, 209, 210, 211, 212, 213, 214, 7786, 216, 217, 218, 219, 220, 221, 374, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 373, 241, 242, 243, 244, 245, 246, 7787, 248, 249, 250, 251, 252, 253, 375, 255],
+  "iso-8859-15": [128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 8364, 165, 352, 167, 353, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 381, 181, 182, 183, 382, 185, 186, 187, 338, 339, 376, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255],
+  "iso-8859-16": [128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 260, 261, 321, 8364, 8222, 352, 167, 353, 169, 536, 171, 377, 173, 378, 379, 176, 177, 268, 322, 381, 8221, 182, 183, 382, 269, 537, 187, 338, 339, 376, 380, 192, 193, 194, 258, 196, 262, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 272, 323, 210, 211, 212, 336, 214, 346, 368, 217, 218, 219, 220, 280, 538, 223, 224, 225, 226, 259, 228, 263, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 273, 324, 242, 243, 244, 337, 246, 347, 369, 249, 250, 251, 252, 281, 539, 255],
+  "koi8-r": [9472, 9474, 9484, 9488, 9492, 9496, 9500, 9508, 9516, 9524, 9532, 9600, 9604, 9608, 9612, 9616, 9617, 9618, 9619, 8992, 9632, 8729, 8730, 8776, 8804, 8805, 160, 8993, 176, 178, 183, 247, 9552, 9553, 9554, 1105, 9555, 9556, 9557, 9558, 9559, 9560, 9561, 9562, 9563, 9564, 9565, 9566, 9567, 9568, 9569, 1025, 9570, 9571, 9572, 9573, 9574, 9575, 9576, 9577, 9578, 9579, 9580, 169, 1102, 1072, 1073, 1094, 1076, 1077, 1092, 1075, 1093, 1080, 1081, 1082, 1083, 1084, 1085, 1086, 1087, 1103, 1088, 1089, 1090, 1091, 1078, 1074, 1100, 1099, 1079, 1096, 1101, 1097, 1095, 1098, 1070, 1040, 1041, 1062, 1044, 1045, 1060, 1043, 1061, 1048, 1049, 1050, 1051, 1052, 1053, 1054, 1055, 1071, 1056, 1057, 1058, 1059, 1046, 1042, 1068, 1067, 1047, 1064, 1069, 1065, 1063, 1066],
+  "koi8-u": [9472, 9474, 9484, 9488, 9492, 9496, 9500, 9508, 9516, 9524, 9532, 9600, 9604, 9608, 9612, 9616, 9617, 9618, 9619, 8992, 9632, 8729, 8730, 8776, 8804, 8805, 160, 8993, 176, 178, 183, 247, 9552, 9553, 9554, 1105, 1108, 9556, 1110, 1111, 9559, 9560, 9561, 9562, 9563, 1169, 1118, 9566, 9567, 9568, 9569, 1025, 1028, 9571, 1030, 1031, 9574, 9575, 9576, 9577, 9578, 1168, 1038, 169, 1102, 1072, 1073, 1094, 1076, 1077, 1092, 1075, 1093, 1080, 1081, 1082, 1083, 1084, 1085, 1086, 1087, 1103, 1088, 1089, 1090, 1091, 1078, 1074, 1100, 1099, 1079, 1096, 1101, 1097, 1095, 1098, 1070, 1040, 1041, 1062, 1044, 1045, 1060, 1043, 1061, 1048, 1049, 1050, 1051, 1052, 1053, 1054, 1055, 1071, 1056, 1057, 1058, 1059, 1046, 1042, 1068, 1067, 1047, 1064, 1069, 1065, 1063, 1066],
+  "macintosh": [196, 197, 199, 201, 209, 214, 220, 225, 224, 226, 228, 227, 229, 231, 233, 232, 234, 235, 237, 236, 238, 239, 241, 243, 242, 244, 246, 245, 250, 249, 251, 252, 8224, 176, 162, 163, 167, 8226, 182, 223, 174, 169, 8482, 180, 168, 8800, 198, 216, 8734, 177, 8804, 8805, 165, 181, 8706, 8721, 8719, 960, 8747, 170, 186, 937, 230, 248, 191, 161, 172, 8730, 402, 8776, 8710, 171, 187, 8230, 160, 192, 195, 213, 338, 339, 8211, 8212, 8220, 8221, 8216, 8217, 247, 9674, 255, 376, 8260, 8364, 8249, 8250, 64257, 64258, 8225, 183, 8218, 8222, 8240, 194, 202, 193, 203, 200, 205, 206, 207, 204, 211, 212, 63743, 210, 218, 219, 217, 305, 710, 732, 175, 728, 729, 730, 184, 733, 731, 711],
+  "windows-874": [8364, 129, 130, 131, 132, 8230, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 8216, 8217, 8220, 8221, 8226, 8211, 8212, 152, 153, 154, 155, 156, 157, 158, 159, 160, 3585, 3586, 3587, 3588, 3589, 3590, 3591, 3592, 3593, 3594, 3595, 3596, 3597, 3598, 3599, 3600, 3601, 3602, 3603, 3604, 3605, 3606, 3607, 3608, 3609, 3610, 3611, 3612, 3613, 3614, 3615, 3616, 3617, 3618, 3619, 3620, 3621, 3622, 3623, 3624, 3625, 3626, 3627, 3628, 3629, 3630, 3631, 3632, 3633, 3634, 3635, 3636, 3637, 3638, 3639, 3640, 3641, 3642, null, null, null, null, 3647, 3648, 3649, 3650, 3651, 3652, 3653, 3654, 3655, 3656, 3657, 3658, 3659, 3660, 3661, 3662, 3663, 3664, 3665, 3666, 3667, 3668, 3669, 3670, 3671, 3672, 3673, 3674, 3675, null, null, null, null],
+  "windows-1250": [8364, 129, 8218, 131, 8222, 8230, 8224, 8225, 136, 8240, 352, 8249, 346, 356, 381, 377, 144, 8216, 8217, 8220, 8221, 8226, 8211, 8212, 152, 8482, 353, 8250, 347, 357, 382, 378, 160, 711, 728, 321, 164, 260, 166, 167, 168, 169, 350, 171, 172, 173, 174, 379, 176, 177, 731, 322, 180, 181, 182, 183, 184, 261, 351, 187, 317, 733, 318, 380, 340, 193, 194, 258, 196, 313, 262, 199, 268, 201, 280, 203, 282, 205, 206, 270, 272, 323, 327, 211, 212, 336, 214, 215, 344, 366, 218, 368, 220, 221, 354, 223, 341, 225, 226, 259, 228, 314, 263, 231, 269, 233, 281, 235, 283, 237, 238, 271, 273, 324, 328, 243, 244, 337, 246, 247, 345, 367, 250, 369, 252, 253, 355, 729],
+  "windows-1251": [1026, 1027, 8218, 1107, 8222, 8230, 8224, 8225, 8364, 8240, 1033, 8249, 1034, 1036, 1035, 1039, 1106, 8216, 8217, 8220, 8221, 8226, 8211, 8212, 152, 8482, 1113, 8250, 1114, 1116, 1115, 1119, 160, 1038, 1118, 1032, 164, 1168, 166, 167, 1025, 169, 1028, 171, 172, 173, 174, 1031, 176, 177, 1030, 1110, 1169, 181, 182, 183, 1105, 8470, 1108, 187, 1112, 1029, 1109, 1111, 1040, 1041, 1042, 1043, 1044, 1045, 1046, 1047, 1048, 1049, 1050, 1051, 1052, 1053, 1054, 1055, 1056, 1057, 1058, 1059, 1060, 1061, 1062, 1063, 1064, 1065, 1066, 1067, 1068, 1069, 1070, 1071, 1072, 1073, 1074, 1075, 1076, 1077, 1078, 1079, 1080, 1081, 1082, 1083, 1084, 1085, 1086, 1087, 1088, 1089, 1090, 1091, 1092, 1093, 1094, 1095, 1096, 1097, 1098, 1099, 1100, 1101, 1102, 1103],
+  "windows-1252": [8364, 129, 8218, 402, 8222, 8230, 8224, 8225, 710, 8240, 352, 8249, 338, 141, 381, 143, 144, 8216, 8217, 8220, 8221, 8226, 8211, 8212, 732, 8482, 353, 8250, 339, 157, 382, 376, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255],
+  "windows-1253": [8364, 129, 8218, 402, 8222, 8230, 8224, 8225, 136, 8240, 138, 8249, 140, 141, 142, 143, 144, 8216, 8217, 8220, 8221, 8226, 8211, 8212, 152, 8482, 154, 8250, 156, 157, 158, 159, 160, 901, 902, 163, 164, 165, 166, 167, 168, 169, null, 171, 172, 173, 174, 8213, 176, 177, 178, 179, 900, 181, 182, 183, 904, 905, 906, 187, 908, 189, 910, 911, 912, 913, 914, 915, 916, 917, 918, 919, 920, 921, 922, 923, 924, 925, 926, 927, 928, 929, null, 931, 932, 933, 934, 935, 936, 937, 938, 939, 940, 941, 942, 943, 944, 945, 946, 947, 948, 949, 950, 951, 952, 953, 954, 955, 956, 957, 958, 959, 960, 961, 962, 963, 964, 965, 966, 967, 968, 969, 970, 971, 972, 973, 974, null],
+  "windows-1254": [8364, 129, 8218, 402, 8222, 8230, 8224, 8225, 710, 8240, 352, 8249, 338, 141, 142, 143, 144, 8216, 8217, 8220, 8221, 8226, 8211, 8212, 732, 8482, 353, 8250, 339, 157, 158, 376, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 286, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 304, 350, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 287, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 305, 351, 255],
+  "windows-1255": [8364, 129, 8218, 402, 8222, 8230, 8224, 8225, 710, 8240, 138, 8249, 140, 141, 142, 143, 144, 8216, 8217, 8220, 8221, 8226, 8211, 8212, 732, 8482, 154, 8250, 156, 157, 158, 159, 160, 161, 162, 163, 8362, 165, 166, 167, 168, 169, 215, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 247, 187, 188, 189, 190, 191, 1456, 1457, 1458, 1459, 1460, 1461, 1462, 1463, 1464, 1465, 1466, 1467, 1468, 1469, 1470, 1471, 1472, 1473, 1474, 1475, 1520, 1521, 1522, 1523, 1524, null, null, null, null, null, null, null, 1488, 1489, 1490, 1491, 1492, 1493, 1494, 1495, 1496, 1497, 1498, 1499, 1500, 1501, 1502, 1503, 1504, 1505, 1506, 1507, 1508, 1509, 1510, 1511, 1512, 1513, 1514, null, null, 8206, 8207, null],
+  "windows-1256": [8364, 1662, 8218, 402, 8222, 8230, 8224, 8225, 710, 8240, 1657, 8249, 338, 1670, 1688, 1672, 1711, 8216, 8217, 8220, 8221, 8226, 8211, 8212, 1705, 8482, 1681, 8250, 339, 8204, 8205, 1722, 160, 1548, 162, 163, 164, 165, 166, 167, 168, 169, 1726, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 1563, 187, 188, 189, 190, 1567, 1729, 1569, 1570, 1571, 1572, 1573, 1574, 1575, 1576, 1577, 1578, 1579, 1580, 1581, 1582, 1583, 1584, 1585, 1586, 1587, 1588, 1589, 1590, 215, 1591, 1592, 1593, 1594, 1600, 1601, 1602, 1603, 224, 1604, 226, 1605, 1606, 1607, 1608, 231, 232, 233, 234, 235, 1609, 1610, 238, 239, 1611, 1612, 1613, 1614, 244, 1615, 1616, 247, 1617, 249, 1618, 251, 252, 8206, 8207, 1746],
+  "windows-1257": [8364, 129, 8218, 131, 8222, 8230, 8224, 8225, 136, 8240, 138, 8249, 140, 168, 711, 184, 144, 8216, 8217, 8220, 8221, 8226, 8211, 8212, 152, 8482, 154, 8250, 156, 175, 731, 159, 160, null, 162, 163, 164, null, 166, 167, 216, 169, 342, 171, 172, 173, 174, 198, 176, 177, 178, 179, 180, 181, 182, 183, 248, 185, 343, 187, 188, 189, 190, 230, 260, 302, 256, 262, 196, 197, 280, 274, 268, 201, 377, 278, 290, 310, 298, 315, 352, 323, 325, 211, 332, 213, 214, 215, 370, 321, 346, 362, 220, 379, 381, 223, 261, 303, 257, 263, 228, 229, 281, 275, 269, 233, 378, 279, 291, 311, 299, 316, 353, 324, 326, 243, 333, 245, 246, 247, 371, 322, 347, 363, 252, 380, 382, 729],
+  "windows-1258": [8364, 129, 8218, 402, 8222, 8230, 8224, 8225, 710, 8240, 138, 8249, 338, 141, 142, 143, 144, 8216, 8217, 8220, 8221, 8226, 8211, 8212, 732, 8482, 154, 8250, 339, 157, 158, 376, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 258, 196, 197, 198, 199, 200, 201, 202, 203, 768, 205, 206, 207, 272, 209, 777, 211, 212, 416, 214, 215, 216, 217, 218, 219, 220, 431, 771, 223, 224, 225, 226, 259, 228, 229, 230, 231, 232, 233, 234, 235, 769, 237, 238, 239, 273, 241, 803, 243, 244, 417, 246, 247, 248, 249, 250, 251, 252, 432, 8363, 255],
+  "x-mac-cyrillic": [1040, 1041, 1042, 1043, 1044, 1045, 1046, 1047, 1048, 1049, 1050, 1051, 1052, 1053, 1054, 1055, 1056, 1057, 1058, 1059, 1060, 1061, 1062, 1063, 1064, 1065, 1066, 1067, 1068, 1069, 1070, 1071, 8224, 176, 1168, 163, 167, 8226, 182, 1030, 174, 169, 8482, 1026, 1106, 8800, 1027, 1107, 8734, 177, 8804, 8805, 1110, 181, 1169, 1032, 1028, 1108, 1031, 1111, 1033, 1113, 1034, 1114, 1112, 1029, 172, 8730, 402, 8776, 8710, 171, 187, 8230, 160, 1035, 1115, 1036, 1116, 1109, 8211, 8212, 8220, 8221, 8216, 8217, 247, 8222, 1038, 1118, 1039, 1119, 8470, 1025, 1105, 1103, 1072, 1073, 1074, 1075, 1076, 1077, 1078, 1079, 1080, 1081, 1082, 1083, 1084, 1085, 1086, 1087, 1088, 1089, 1090, 1091, 1092, 1093, 1094, 1095, 1096, 1097, 1098, 1099, 1100, 1101, 1102, 8364]
+};
+
+// src/polyfills/text-encoder/text-encoder.ts
+globalThis["encoding-indexes"] = encoding_indexes_default || {};
+function inRange(a, min, max) {
+  return min <= a && a <= max;
+}
+function includes(array, item) {
+  return array.indexOf(item) !== -1;
+}
+var floor = Math.floor;
+function ToDictionary(o) {
+  if (o === void 0) return {};
+  if (o === Object(o)) return o;
+  throw TypeError("Could not convert argument to dictionary");
+}
+function stringToCodePoints(string) {
+  var s = String(string);
+  var n = s.length;
+  var i = 0;
+  var u = [];
+  while (i < n) {
+    var c = s.charCodeAt(i);
+    if (c < 55296 || c > 57343) {
+      u.push(c);
+    } else if (56320 <= c && c <= 57343) {
+      u.push(65533);
+    } else if (55296 <= c && c <= 56319) {
+      if (i === n - 1) {
+        u.push(65533);
+      } else {
+        var d = s.charCodeAt(i + 1);
+        if (56320 <= d && d <= 57343) {
+          var a = c & 1023;
+          var b = d & 1023;
+          u.push(65536 + (a << 10) + b);
+          i += 1;
+        } else {
+          u.push(65533);
+        }
+      }
+    }
+    i += 1;
+  }
+  return u;
+}
+function codePointsToString(code_points) {
+  var s = "";
+  for (var i = 0; i < code_points.length; ++i) {
+    var cp = code_points[i];
+    if (cp <= 65535) {
+      s += String.fromCharCode(cp);
+    } else {
+      cp -= 65536;
+      s += String.fromCharCode((cp >> 10) + 55296, (cp & 1023) + 56320);
+    }
+  }
+  return s;
+}
+function isASCIIByte(a) {
+  return 0 <= a && a <= 127;
+}
+var isASCIICodePoint = isASCIIByte;
+var end_of_stream = -1;
+function Stream(tokens) {
+  this.tokens = [].slice.call(tokens);
+  this.tokens.reverse();
+}
+Stream.prototype = {
+  /**
+   * @return {boolean} True if end-of-stream has been hit.
+   */
+  endOfStream: function() {
+    return !this.tokens.length;
+  },
+  /**
+   * When a token is read from a stream, the first token in the
+   * stream must be returned and subsequently removed, and
+   * end-of-stream must be returned otherwise.
+   *
+   * @return {number} Get the next token from the stream, or
+   * end_of_stream.
+   */
+  read: function() {
+    if (!this.tokens.length) return end_of_stream;
+    return this.tokens.pop();
+  },
+  /**
+   * When one or more tokens are prepended to a stream, those tokens
+   * must be inserted, in given order, before the first token in the
+   * stream.
+   *
+   * @param {(number|!Array.<number>)} token The token(s) to prepend to the
+   * stream.
+   */
+  prepend: function(token) {
+    if (Array.isArray(token)) {
+      var tokens = (
+        /**@type {!Array.<number>}*/
+        token
+      );
+      while (tokens.length) this.tokens.push(tokens.pop());
+    } else {
+      this.tokens.push(token);
+    }
+  },
+  /**
+   * When one or more tokens are pushed to a stream, those tokens
+   * must be inserted, in given order, after the last token in the
+   * stream.
+   *
+   * @param {(number|!Array.<number>)} token The tokens(s) to push to the
+   * stream.
+   */
+  push: function(token) {
+    if (Array.isArray(token)) {
+      var tokens = (
+        /**@type {!Array.<number>}*/
+        token
+      );
+      while (tokens.length) this.tokens.unshift(tokens.shift());
+    } else {
+      this.tokens.unshift(token);
+    }
+  }
+};
+var finished = -1;
+function decoderError(fatal, opt_code_point) {
+  if (fatal) throw TypeError("Decoder error");
+  return opt_code_point || 65533;
+}
+function encoderError(code_point) {
+  throw TypeError("The code point " + code_point + " could not be encoded.");
+}
+function Decoder() {
+}
+Decoder.prototype = {
+  /**
+   * @param {Stream} stream The stream of bytes being decoded.
+   * @param {number} bite The next byte read from the stream.
+   * @return {?(number|!Array.<number>)} The next code point(s)
+   *     decoded, or null if not enough data exists in the input
+   *     stream to decode a complete code point, or |finished|.
+   */
+  handler: function(stream2, bite) {
+  }
+};
+function Encoder() {
+}
+Encoder.prototype = {
+  /**
+   * @param {Stream} stream The stream of code points being encoded.
+   * @param {number} code_point Next code point read from the stream.
+   * @return {(number|!Array.<number>)} Byte(s) to emit, or |finished|.
+   */
+  handler: function(stream2, code_point) {
+  }
+};
+function getEncoding(label) {
+  label = String(label).trim().toLowerCase();
+  if (Object.prototype.hasOwnProperty.call(label_to_encoding, label)) {
+    return label_to_encoding[label];
+  }
+  return null;
+}
+var encodings = [
+  {
+    encodings: [
+      {
+        labels: ["unicode-1-1-utf-8", "utf-8", "utf8"],
+        name: "UTF-8"
+      }
+    ],
+    heading: "The Encoding"
+  },
+  {
+    encodings: [
+      {
+        labels: ["866", "cp866", "csibm866", "ibm866"],
+        name: "IBM866"
+      },
+      {
+        labels: [
+          "csisolatin2",
+          "iso-8859-2",
+          "iso-ir-101",
+          "iso8859-2",
+          "iso88592",
+          "iso_8859-2",
+          "iso_8859-2:1987",
+          "l2",
+          "latin2"
+        ],
+        name: "ISO-8859-2"
+      },
+      {
+        labels: [
+          "csisolatin3",
+          "iso-8859-3",
+          "iso-ir-109",
+          "iso8859-3",
+          "iso88593",
+          "iso_8859-3",
+          "iso_8859-3:1988",
+          "l3",
+          "latin3"
+        ],
+        name: "ISO-8859-3"
+      },
+      {
+        labels: [
+          "csisolatin4",
+          "iso-8859-4",
+          "iso-ir-110",
+          "iso8859-4",
+          "iso88594",
+          "iso_8859-4",
+          "iso_8859-4:1988",
+          "l4",
+          "latin4"
+        ],
+        name: "ISO-8859-4"
+      },
+      {
+        labels: [
+          "csisolatincyrillic",
+          "cyrillic",
+          "iso-8859-5",
+          "iso-ir-144",
+          "iso8859-5",
+          "iso88595",
+          "iso_8859-5",
+          "iso_8859-5:1988"
+        ],
+        name: "ISO-8859-5"
+      },
+      {
+        labels: [
+          "arabic",
+          "asmo-708",
+          "csiso88596e",
+          "csiso88596i",
+          "csisolatinarabic",
+          "ecma-114",
+          "iso-8859-6",
+          "iso-8859-6-e",
+          "iso-8859-6-i",
+          "iso-ir-127",
+          "iso8859-6",
+          "iso88596",
+          "iso_8859-6",
+          "iso_8859-6:1987"
+        ],
+        name: "ISO-8859-6"
+      },
+      {
+        labels: [
+          "csisolatingreek",
+          "ecma-118",
+          "elot_928",
+          "greek",
+          "greek8",
+          "iso-8859-7",
+          "iso-ir-126",
+          "iso8859-7",
+          "iso88597",
+          "iso_8859-7",
+          "iso_8859-7:1987",
+          "sun_eu_greek"
+        ],
+        name: "ISO-8859-7"
+      },
+      {
+        labels: [
+          "csiso88598e",
+          "csisolatinhebrew",
+          "hebrew",
+          "iso-8859-8",
+          "iso-8859-8-e",
+          "iso-ir-138",
+          "iso8859-8",
+          "iso88598",
+          "iso_8859-8",
+          "iso_8859-8:1988",
+          "visual"
+        ],
+        name: "ISO-8859-8"
+      },
+      {
+        labels: ["csiso88598i", "iso-8859-8-i", "logical"],
+        name: "ISO-8859-8-I"
+      },
+      {
+        labels: [
+          "csisolatin6",
+          "iso-8859-10",
+          "iso-ir-157",
+          "iso8859-10",
+          "iso885910",
+          "l6",
+          "latin6"
+        ],
+        name: "ISO-8859-10"
+      },
+      {
+        labels: ["iso-8859-13", "iso8859-13", "iso885913"],
+        name: "ISO-8859-13"
+      },
+      {
+        labels: ["iso-8859-14", "iso8859-14", "iso885914"],
+        name: "ISO-8859-14"
+      },
+      {
+        labels: ["csisolatin9", "iso-8859-15", "iso8859-15", "iso885915", "iso_8859-15", "l9"],
+        name: "ISO-8859-15"
+      },
+      {
+        labels: ["iso-8859-16"],
+        name: "ISO-8859-16"
+      },
+      {
+        labels: ["cskoi8r", "koi", "koi8", "koi8-r", "koi8_r"],
+        name: "KOI8-R"
+      },
+      {
+        labels: ["koi8-ru", "koi8-u"],
+        name: "KOI8-U"
+      },
+      {
+        labels: ["csmacintosh", "mac", "macintosh", "x-mac-roman"],
+        name: "macintosh"
+      },
+      {
+        labels: ["dos-874", "iso-8859-11", "iso8859-11", "iso885911", "tis-620", "windows-874"],
+        name: "windows-874"
+      },
+      {
+        labels: ["cp1250", "windows-1250", "x-cp1250"],
+        name: "windows-1250"
+      },
+      {
+        labels: ["cp1251", "windows-1251", "x-cp1251"],
+        name: "windows-1251"
+      },
+      {
+        labels: [
+          "ansi_x3.4-1968",
+          "ascii",
+          "cp1252",
+          "cp819",
+          "csisolatin1",
+          "ibm819",
+          "iso-8859-1",
+          "iso-ir-100",
+          "iso8859-1",
+          "iso88591",
+          "iso_8859-1",
+          "iso_8859-1:1987",
+          "l1",
+          "latin1",
+          "us-ascii",
+          "windows-1252",
+          "x-cp1252"
+        ],
+        name: "windows-1252"
+      },
+      {
+        labels: ["cp1253", "windows-1253", "x-cp1253"],
+        name: "windows-1253"
+      },
+      {
+        labels: [
+          "cp1254",
+          "csisolatin5",
+          "iso-8859-9",
+          "iso-ir-148",
+          "iso8859-9",
+          "iso88599",
+          "iso_8859-9",
+          "iso_8859-9:1989",
+          "l5",
+          "latin5",
+          "windows-1254",
+          "x-cp1254"
+        ],
+        name: "windows-1254"
+      },
+      {
+        labels: ["cp1255", "windows-1255", "x-cp1255"],
+        name: "windows-1255"
+      },
+      {
+        labels: ["cp1256", "windows-1256", "x-cp1256"],
+        name: "windows-1256"
+      },
+      {
+        labels: ["cp1257", "windows-1257", "x-cp1257"],
+        name: "windows-1257"
+      },
+      {
+        labels: ["cp1258", "windows-1258", "x-cp1258"],
+        name: "windows-1258"
+      },
+      {
+        labels: ["x-mac-cyrillic", "x-mac-ukrainian"],
+        name: "x-mac-cyrillic"
+      }
+    ],
+    heading: "Legacy single-byte encodings"
+  },
+  {
+    encodings: [
+      {
+        labels: [
+          "chinese",
+          "csgb2312",
+          "csiso58gb231280",
+          "gb2312",
+          "gb_2312",
+          "gb_2312-80",
+          "gbk",
+          "iso-ir-58",
+          "x-gbk"
+        ],
+        name: "GBK"
+      },
+      {
+        labels: ["gb18030"],
+        name: "gb18030"
+      }
+    ],
+    heading: "Legacy multi-byte Chinese (simplified) encodings"
+  },
+  {
+    encodings: [
+      {
+        labels: ["big5", "big5-hkscs", "cn-big5", "csbig5", "x-x-big5"],
+        name: "Big5"
+      }
+    ],
+    heading: "Legacy multi-byte Chinese (traditional) encodings"
+  },
+  {
+    encodings: [
+      {
+        labels: ["cseucpkdfmtjapanese", "euc-jp", "x-euc-jp"],
+        name: "EUC-JP"
+      },
+      {
+        labels: ["csiso2022jp", "iso-2022-jp"],
+        name: "ISO-2022-JP"
+      },
+      {
+        labels: [
+          "csshiftjis",
+          "ms932",
+          "ms_kanji",
+          "shift-jis",
+          "shift_jis",
+          "sjis",
+          "windows-31j",
+          "x-sjis"
+        ],
+        name: "Shift_JIS"
+      }
+    ],
+    heading: "Legacy multi-byte Japanese encodings"
+  },
+  {
+    encodings: [
+      {
+        labels: [
+          "cseuckr",
+          "csksc56011987",
+          "euc-kr",
+          "iso-ir-149",
+          "korean",
+          "ks_c_5601-1987",
+          "ks_c_5601-1989",
+          "ksc5601",
+          "ksc_5601",
+          "windows-949"
+        ],
+        name: "EUC-KR"
+      }
+    ],
+    heading: "Legacy multi-byte Korean encodings"
+  },
+  {
+    encodings: [
+      {
+        labels: ["csiso2022kr", "hz-gb-2312", "iso-2022-cn", "iso-2022-cn-ext", "iso-2022-kr"],
+        name: "replacement"
+      },
+      {
+        labels: ["utf-16be"],
+        name: "UTF-16BE"
+      },
+      {
+        labels: ["utf-16", "utf-16le"],
+        name: "UTF-16LE"
+      },
+      {
+        labels: ["x-user-defined"],
+        name: "x-user-defined"
+      }
+    ],
+    heading: "Legacy miscellaneous encodings"
+  }
+];
+var label_to_encoding = {};
+encodings.forEach(function(category) {
+  category.encodings.forEach(function(encoding) {
+    encoding.labels.forEach(function(label) {
+      label_to_encoding[label] = encoding;
+    });
+  });
+});
+var encoders = {};
+var decoders = {};
+function indexCodePointFor(pointer, index2) {
+  if (!index2) return null;
+  return index2[pointer] || null;
+}
+function indexPointerFor(code_point, index2) {
+  var pointer = index2.indexOf(code_point);
+  return pointer === -1 ? null : pointer;
+}
+function index(name) {
+  if (!("encoding-indexes" in globalThis)) {
+    throw Error("Indexes missing. Did you forget to include encoding-indexes.js first?");
+  }
+  return globalThis["encoding-indexes"][name];
+}
+function indexGB18030RangesCodePointFor(pointer) {
+  if (pointer > 39419 && pointer < 189e3 || pointer > 1237575) return null;
+  if (pointer === 7457) return 59335;
+  var offset = 0;
+  var code_point_offset = 0;
+  var idx = index("gb18030-ranges");
+  var i;
+  for (i = 0; i < idx.length; ++i) {
+    var entry = idx[i];
+    if (entry[0] <= pointer) {
+      offset = entry[0];
+      code_point_offset = entry[1];
+    } else {
+      break;
+    }
+  }
+  return code_point_offset + pointer - offset;
+}
+function indexGB18030RangesPointerFor(code_point) {
+  if (code_point === 59335) return 7457;
+  var offset = 0;
+  var pointer_offset = 0;
+  var idx = index("gb18030-ranges");
+  var i;
+  for (i = 0; i < idx.length; ++i) {
+    var entry = idx[i];
+    if (entry[1] <= code_point) {
+      offset = entry[1];
+      pointer_offset = entry[0];
+    } else {
+      break;
+    }
+  }
+  return pointer_offset + code_point - offset;
+}
+function indexShiftJISPointerFor(code_point) {
+  shift_jis_index = shift_jis_index || index("jis0208").map(function(code_point2, pointer) {
+    return inRange(pointer, 8272, 8835) ? null : code_point2;
+  });
+  var index_ = shift_jis_index;
+  return index_.indexOf(code_point);
+}
+var shift_jis_index;
+function indexBig5PointerFor(code_point) {
+  big5_index_no_hkscs = big5_index_no_hkscs || index("big5").map(function(code_point2, pointer) {
+    return pointer < (161 - 129) * 157 ? null : code_point2;
+  });
+  var index_ = big5_index_no_hkscs;
+  if (code_point === 9552 || code_point === 9566 || code_point === 9569 || code_point === 9578 || code_point === 21313 || code_point === 21317) {
+    return index_.lastIndexOf(code_point);
+  }
+  return indexPointerFor(code_point, index_);
+}
+var big5_index_no_hkscs;
+var DEFAULT_ENCODING = "utf-8";
+function TextDecoder2(label, options) {
+  if (!(this instanceof TextDecoder2))
+    throw TypeError("Called as a function. Did you forget 'new'?");
+  label = label !== void 0 ? String(label) : DEFAULT_ENCODING;
+  options = ToDictionary(options);
+  this._encoding = null;
+  this._decoder = null;
+  this._ignoreBOM = false;
+  this._BOMseen = false;
+  this._error_mode = "replacement";
+  this._do_not_flush = false;
+  var encoding = getEncoding(label);
+  if (encoding === null || encoding.name === "replacement")
+    throw RangeError("Unknown encoding: " + label);
+  if (!decoders[encoding.name]) {
+    throw Error("Decoder not present. Did you forget to include encoding-indexes.js first?");
+  }
+  var dec = this;
+  dec._encoding = encoding;
+  if (Boolean(options["fatal"])) dec._error_mode = "fatal";
+  if (Boolean(options["ignoreBOM"])) dec._ignoreBOM = true;
+  if (!Object.defineProperty) {
+    this.encoding = dec._encoding.name.toLowerCase();
+    this.fatal = dec._error_mode === "fatal";
+    this.ignoreBOM = dec._ignoreBOM;
+  }
+  return dec;
+}
+if (Object.defineProperty) {
+  Object.defineProperty(TextDecoder2.prototype, "encoding", {
+    /** @this {TextDecoder} */
+    get: function() {
+      return this._encoding.name.toLowerCase();
+    }
+  });
+  Object.defineProperty(TextDecoder2.prototype, "fatal", {
+    /** @this {TextDecoder} */
+    get: function() {
+      return this._error_mode === "fatal";
+    }
+  });
+  Object.defineProperty(TextDecoder2.prototype, "ignoreBOM", {
+    /** @this {TextDecoder} */
+    get: function() {
+      return this._ignoreBOM;
+    }
+  });
+}
+TextDecoder2.prototype.decode = function decode(input, options) {
+  var bytes;
+  if (typeof input === "object" && input instanceof ArrayBuffer) {
+    bytes = new Uint8Array(input);
+  } else if (typeof input === "object" && "buffer" in input && input.buffer instanceof ArrayBuffer) {
+    bytes = new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+  } else {
+    bytes = new Uint8Array(0);
+  }
+  options = ToDictionary(options);
+  if (!this._do_not_flush) {
+    this._decoder = decoders[this._encoding.name]({
+      fatal: this._error_mode === "fatal"
+    });
+    this._BOMseen = false;
+  }
+  this._do_not_flush = Boolean(options["stream"]);
+  var input_stream = new Stream(bytes);
+  var output = [];
+  var result;
+  while (true) {
+    var token = input_stream.read();
+    if (token === end_of_stream) break;
+    result = this._decoder.handler(input_stream, token);
+    if (result === finished) break;
+    if (result !== null) {
+      if (Array.isArray(result)) output.push.apply(
+        output,
+        /**@type {!Array.<number>}*/
+        result
+      );
+      else output.push(result);
+    }
+  }
+  if (!this._do_not_flush) {
+    do {
+      result = this._decoder.handler(input_stream, input_stream.read());
+      if (result === finished) break;
+      if (result === null) continue;
+      if (Array.isArray(result)) output.push.apply(
+        output,
+        /**@type {!Array.<number>}*/
+        result
+      );
+      else output.push(result);
+    } while (!input_stream.endOfStream());
+    this._decoder = null;
+  }
+  function serializeStream(stream2) {
+    if (includes(["UTF-8", "UTF-16LE", "UTF-16BE"], this._encoding.name) && !this._ignoreBOM && !this._BOMseen) {
+      if (stream2.length > 0 && stream2[0] === 65279) {
+        this._BOMseen = true;
+        stream2.shift();
+      } else if (stream2.length > 0) {
+        this._BOMseen = true;
+      } else {
+      }
+    }
+    return codePointsToString(stream2);
+  }
+  return serializeStream.call(this, output);
+};
+function TextEncoder2(label, options) {
+  if (!(this instanceof TextEncoder2))
+    throw TypeError("Called as a function. Did you forget 'new'?");
+  options = ToDictionary(options);
+  this._encoding = null;
+  this._encoder = null;
+  this._do_not_flush = false;
+  this._fatal = Boolean(options["fatal"]) ? "fatal" : "replacement";
+  var enc = this;
+  if (Boolean(options["NONSTANDARD_allowLegacyEncoding"])) {
+    label = label !== void 0 ? String(label) : DEFAULT_ENCODING;
+    var encoding = getEncoding(label);
+    if (encoding === null || encoding.name === "replacement")
+      throw RangeError("Unknown encoding: " + label);
+    if (!encoders[encoding.name]) {
+      throw Error("Encoder not present. Did you forget to include encoding-indexes.js first?");
+    }
+    enc._encoding = encoding;
+  } else {
+    enc._encoding = getEncoding("utf-8");
+    if (label !== void 0 && "console" in globalThis) {
+    }
+  }
+  if (!Object.defineProperty) this.encoding = enc._encoding.name.toLowerCase();
+  return enc;
+}
+if (Object.defineProperty) {
+  Object.defineProperty(TextEncoder2.prototype, "encoding", {
+    /** @this {TextEncoder} */
+    get: function() {
+      return this._encoding.name.toLowerCase();
+    }
+  });
+}
+TextEncoder2.prototype.encode = function encode(opt_string, options) {
+  opt_string = opt_string === void 0 ? "" : String(opt_string);
+  options = ToDictionary(options);
+  if (!this._do_not_flush)
+    this._encoder = encoders[this._encoding.name]({
+      fatal: this._fatal === "fatal"
+    });
+  this._do_not_flush = Boolean(options["stream"]);
+  var input = new Stream(stringToCodePoints(opt_string));
+  var output = [];
+  var result;
+  while (true) {
+    var token = input.read();
+    if (token === end_of_stream) break;
+    result = this._encoder.handler(input, token);
+    if (result === finished) break;
+    if (Array.isArray(result)) output.push.apply(
+      output,
+      /**@type {!Array.<number>}*/
+      result
+    );
+    else output.push(result);
+  }
+  if (!this._do_not_flush) {
+    while (true) {
+      result = this._encoder.handler(input, input.read());
+      if (result === finished) break;
+      if (Array.isArray(result)) output.push.apply(
+        output,
+        /**@type {!Array.<number>}*/
+        result
+      );
+      else output.push(result);
+    }
+    this._encoder = null;
+  }
+  return new Uint8Array(output);
+};
+function UTF8Decoder(options) {
+  var fatal = options.fatal;
+  var utf8_code_point = 0, utf8_bytes_seen = 0, utf8_bytes_needed = 0, utf8_lower_boundary = 128, utf8_upper_boundary = 191;
+  this.handler = function(stream2, bite) {
+    if (bite === end_of_stream && utf8_bytes_needed !== 0) {
+      utf8_bytes_needed = 0;
+      return decoderError(fatal);
+    }
+    if (bite === end_of_stream) return finished;
+    if (utf8_bytes_needed === 0) {
+      if (inRange(bite, 0, 127)) {
+        return bite;
+      } else if (inRange(bite, 194, 223)) {
+        utf8_bytes_needed = 1;
+        utf8_code_point = bite & 31;
+      } else if (inRange(bite, 224, 239)) {
+        if (bite === 224) utf8_lower_boundary = 160;
+        if (bite === 237) utf8_upper_boundary = 159;
+        utf8_bytes_needed = 2;
+        utf8_code_point = bite & 15;
+      } else if (inRange(bite, 240, 244)) {
+        if (bite === 240) utf8_lower_boundary = 144;
+        if (bite === 244) utf8_upper_boundary = 143;
+        utf8_bytes_needed = 3;
+        utf8_code_point = bite & 7;
+      } else {
+        return decoderError(fatal);
+      }
+      return null;
+    }
+    if (!inRange(bite, utf8_lower_boundary, utf8_upper_boundary)) {
+      utf8_code_point = utf8_bytes_needed = utf8_bytes_seen = 0;
+      utf8_lower_boundary = 128;
+      utf8_upper_boundary = 191;
+      stream2.prepend(bite);
+      return decoderError(fatal);
+    }
+    utf8_lower_boundary = 128;
+    utf8_upper_boundary = 191;
+    utf8_code_point = utf8_code_point << 6 | bite & 63;
+    utf8_bytes_seen += 1;
+    if (utf8_bytes_seen !== utf8_bytes_needed) return null;
+    var code_point = utf8_code_point;
+    utf8_code_point = utf8_bytes_needed = utf8_bytes_seen = 0;
+    return code_point;
+  };
+}
+function UTF8Encoder(options) {
+  var _fatal = options.fatal;
+  this.handler = function(stream2, code_point) {
+    if (code_point === end_of_stream) return finished;
+    if (isASCIICodePoint(code_point)) return code_point;
+    var count, offset;
+    if (inRange(code_point, 128, 2047)) {
+      count = 1;
+      offset = 192;
+    } else if (inRange(code_point, 2048, 65535)) {
+      count = 2;
+      offset = 224;
+    } else if (inRange(code_point, 65536, 1114111)) {
+      count = 3;
+      offset = 240;
+    }
+    var bytes = [(code_point >> 6 * count) + offset];
+    while (count > 0) {
+      var temp = code_point >> 6 * (count - 1);
+      bytes.push(128 | temp & 63);
+      count -= 1;
+    }
+    return bytes;
+  };
+}
+encoders["UTF-8"] = function(options) {
+  return new UTF8Encoder(options);
+};
+decoders["UTF-8"] = function(options) {
+  return new UTF8Decoder(options);
+};
+function SingleByteDecoder(index2, options) {
+  var fatal = options.fatal;
+  this.handler = function(stream2, bite) {
+    if (bite === end_of_stream) return finished;
+    if (isASCIIByte(bite)) return bite;
+    var code_point = index2[bite - 128];
+    if (code_point === null) return decoderError(fatal);
+    return code_point;
+  };
+}
+function SingleByteEncoder(index2, options) {
+  var _fatal = options.fatal;
+  this.handler = function(stream2, code_point) {
+    if (code_point === end_of_stream) return finished;
+    if (isASCIICodePoint(code_point)) return code_point;
+    var pointer = indexPointerFor(code_point, index2);
+    if (pointer === null) encoderError(code_point);
+    return pointer + 128;
+  };
+}
+(function() {
+  if (!("encoding-indexes" in globalThis)) return;
+  encodings.forEach(function(category) {
+    if (category.heading !== "Legacy single-byte encodings") return;
+    category.encodings.forEach(function(encoding) {
+      var name = encoding.name;
+      var idx = index(name.toLowerCase());
+      decoders[name] = function(options) {
+        return new SingleByteDecoder(idx, options);
+      };
+      encoders[name] = function(options) {
+        return new SingleByteEncoder(idx, options);
+      };
+    });
+  });
+})();
+decoders["GBK"] = function(options) {
+  return new GB18030Decoder(options);
+};
+encoders["GBK"] = function(options) {
+  return new GB18030Encoder(options, true);
+};
+function GB18030Decoder(options) {
+  var fatal = options.fatal;
+  var gb18030_first = 0, gb18030_second = 0, gb18030_third = 0;
+  this.handler = function(stream2, bite) {
+    if (bite === end_of_stream && gb18030_first === 0 && gb18030_second === 0 && gb18030_third === 0) {
+      return finished;
+    }
+    if (bite === end_of_stream && (gb18030_first !== 0 || gb18030_second !== 0 || gb18030_third !== 0)) {
+      gb18030_first = 0;
+      gb18030_second = 0;
+      gb18030_third = 0;
+      decoderError(fatal);
+    }
+    var code_point;
+    if (gb18030_third !== 0) {
+      code_point = null;
+      if (inRange(bite, 48, 57)) {
+        code_point = indexGB18030RangesCodePointFor(
+          (((gb18030_first - 129) * 10 + gb18030_second - 48) * 126 + gb18030_third - 129) * 10 + bite - 48
+        );
+      }
+      var buffer = [gb18030_second, gb18030_third, bite];
+      gb18030_first = 0;
+      gb18030_second = 0;
+      gb18030_third = 0;
+      if (code_point === null) {
+        stream2.prepend(buffer);
+        return decoderError(fatal);
+      }
+      return code_point;
+    }
+    if (gb18030_second !== 0) {
+      if (inRange(bite, 129, 254)) {
+        gb18030_third = bite;
+        return null;
+      }
+      stream2.prepend([gb18030_second, bite]);
+      gb18030_first = 0;
+      gb18030_second = 0;
+      return decoderError(fatal);
+    }
+    if (gb18030_first !== 0) {
+      if (inRange(bite, 48, 57)) {
+        gb18030_second = bite;
+        return null;
+      }
+      var lead = gb18030_first;
+      var pointer = null;
+      gb18030_first = 0;
+      var offset = bite < 127 ? 64 : 65;
+      if (inRange(bite, 64, 126) || inRange(bite, 128, 254))
+        pointer = (lead - 129) * 190 + (bite - offset);
+      code_point = pointer === null ? null : indexCodePointFor(pointer, index("gb18030"));
+      if (code_point === null && isASCIIByte(bite)) stream2.prepend(bite);
+      if (code_point === null) return decoderError(fatal);
+      return code_point;
+    }
+    if (isASCIIByte(bite)) return bite;
+    if (bite === 128) return 8364;
+    if (inRange(bite, 129, 254)) {
+      gb18030_first = bite;
+      return null;
+    }
+    return decoderError(fatal);
+  };
+}
+function GB18030Encoder(options, gbk_flag) {
+  var _fatal = options.fatal;
+  this.handler = function(stream2, code_point) {
+    if (code_point === end_of_stream) return finished;
+    if (isASCIICodePoint(code_point)) return code_point;
+    if (code_point === 58853) return encoderError(code_point);
+    if (gbk_flag && code_point === 8364) return 128;
+    var pointer = indexPointerFor(code_point, index("gb18030"));
+    if (pointer !== null) {
+      var lead = floor(pointer / 190) + 129;
+      var trail = pointer % 190;
+      var offset = trail < 63 ? 64 : 65;
+      return [lead, trail + offset];
+    }
+    if (gbk_flag) return encoderError(code_point);
+    pointer = indexGB18030RangesPointerFor(code_point);
+    var byte1 = floor(pointer / 10 / 126 / 10);
+    pointer = pointer - byte1 * 10 * 126 * 10;
+    var byte2 = floor(pointer / 10 / 126);
+    pointer = pointer - byte2 * 10 * 126;
+    var byte3 = floor(pointer / 10);
+    var byte4 = pointer - byte3 * 10;
+    return [byte1 + 129, byte2 + 48, byte3 + 129, byte4 + 48];
+  };
+}
+encoders["gb18030"] = function(options) {
+  return new GB18030Encoder(options);
+};
+decoders["gb18030"] = function(options) {
+  return new GB18030Decoder(options);
+};
+function Big5Decoder(options) {
+  var fatal = options.fatal;
+  var Big5_lead = 0;
+  this.handler = function(stream2, bite) {
+    if (bite === end_of_stream && Big5_lead !== 0) {
+      Big5_lead = 0;
+      return decoderError(fatal);
+    }
+    if (bite === end_of_stream && Big5_lead === 0) return finished;
+    if (Big5_lead !== 0) {
+      var lead = Big5_lead;
+      var pointer = null;
+      Big5_lead = 0;
+      var offset = bite < 127 ? 64 : 98;
+      if (inRange(bite, 64, 126) || inRange(bite, 161, 254))
+        pointer = (lead - 129) * 157 + (bite - offset);
+      switch (pointer) {
+        case 1133:
+          return [202, 772];
+        case 1135:
+          return [202, 780];
+        case 1164:
+          return [234, 772];
+        case 1166:
+          return [234, 780];
+      }
+      var code_point = pointer === null ? null : indexCodePointFor(pointer, index("big5"));
+      if (code_point === null && isASCIIByte(bite)) stream2.prepend(bite);
+      if (code_point === null) return decoderError(fatal);
+      return code_point;
+    }
+    if (isASCIIByte(bite)) return bite;
+    if (inRange(bite, 129, 254)) {
+      Big5_lead = bite;
+      return null;
+    }
+    return decoderError(fatal);
+  };
+}
+function Big5Encoder(options) {
+  var _fatal = options.fatal;
+  this.handler = function(stream2, code_point) {
+    if (code_point === end_of_stream) return finished;
+    if (isASCIICodePoint(code_point)) return code_point;
+    var pointer = indexBig5PointerFor(code_point);
+    if (pointer === null) return encoderError(code_point);
+    var lead = floor(pointer / 157) + 129;
+    if (lead < 161) return encoderError(code_point);
+    var trail = pointer % 157;
+    var offset = trail < 63 ? 64 : 98;
+    return [lead, trail + offset];
+  };
+}
+encoders["Big5"] = function(options) {
+  return new Big5Encoder(options);
+};
+decoders["Big5"] = function(options) {
+  return new Big5Decoder(options);
+};
+function EUCJPDecoder(options) {
+  var fatal = options.fatal;
+  var eucjp_jis0212_flag = false, eucjp_lead = 0;
+  this.handler = function(stream2, bite) {
+    if (bite === end_of_stream && eucjp_lead !== 0) {
+      eucjp_lead = 0;
+      return decoderError(fatal);
+    }
+    if (bite === end_of_stream && eucjp_lead === 0) return finished;
+    if (eucjp_lead === 142 && inRange(bite, 161, 223)) {
+      eucjp_lead = 0;
+      return 65377 - 161 + bite;
+    }
+    if (eucjp_lead === 143 && inRange(bite, 161, 254)) {
+      eucjp_jis0212_flag = true;
+      eucjp_lead = bite;
+      return null;
+    }
+    if (eucjp_lead !== 0) {
+      var lead = eucjp_lead;
+      eucjp_lead = 0;
+      var code_point = null;
+      if (inRange(lead, 161, 254) && inRange(bite, 161, 254)) {
+        code_point = indexCodePointFor(
+          (lead - 161) * 94 + (bite - 161),
+          index(!eucjp_jis0212_flag ? "jis0208" : "jis0212")
+        );
+      }
+      eucjp_jis0212_flag = false;
+      if (!inRange(bite, 161, 254)) stream2.prepend(bite);
+      if (code_point === null) return decoderError(fatal);
+      return code_point;
+    }
+    if (isASCIIByte(bite)) return bite;
+    if (bite === 142 || bite === 143 || inRange(bite, 161, 254)) {
+      eucjp_lead = bite;
+      return null;
+    }
+    return decoderError(fatal);
+  };
+}
+function EUCJPEncoder(options) {
+  var _fatal = options.fatal;
+  this.handler = function(stream2, code_point) {
+    if (code_point === end_of_stream) return finished;
+    if (isASCIICodePoint(code_point)) return code_point;
+    if (code_point === 165) return 92;
+    if (code_point === 8254) return 126;
+    if (inRange(code_point, 65377, 65439)) return [142, code_point - 65377 + 161];
+    if (code_point === 8722) code_point = 65293;
+    var pointer = indexPointerFor(code_point, index("jis0208"));
+    if (pointer === null) return encoderError(code_point);
+    var lead = floor(pointer / 94) + 161;
+    var trail = pointer % 94 + 161;
+    return [lead, trail];
+  };
+}
+encoders["EUC-JP"] = function(options) {
+  return new EUCJPEncoder(options);
+};
+decoders["EUC-JP"] = function(options) {
+  return new EUCJPDecoder(options);
+};
+function ISO2022JPDecoder(options) {
+  var fatal = options.fatal;
+  var states = {
+    ASCII: 0,
+    Roman: 1,
+    Katakana: 2,
+    LeadByte: 3,
+    TrailByte: 4,
+    EscapeStart: 5,
+    Escape: 6
+  };
+  var iso2022jp_decoder_state = states.ASCII, iso2022jp_decoder_output_state = states.ASCII, iso2022jp_lead = 0, iso2022jp_output_flag = false;
+  this.handler = function(stream2, bite) {
+    switch (iso2022jp_decoder_state) {
+      default:
+      case states.ASCII:
+        if (bite === 27) {
+          iso2022jp_decoder_state = states.EscapeStart;
+          return null;
+        }
+        if (inRange(bite, 0, 127) && bite !== 14 && bite !== 15 && bite !== 27) {
+          iso2022jp_output_flag = false;
+          return bite;
+        }
+        if (bite === end_of_stream) {
+          return finished;
+        }
+        iso2022jp_output_flag = false;
+        return decoderError(fatal);
+      case states.Roman:
+        if (bite === 27) {
+          iso2022jp_decoder_state = states.EscapeStart;
+          return null;
+        }
+        if (bite === 92) {
+          iso2022jp_output_flag = false;
+          return 165;
+        }
+        if (bite === 126) {
+          iso2022jp_output_flag = false;
+          return 8254;
+        }
+        if (inRange(bite, 0, 127) && bite !== 14 && bite !== 15 && bite !== 27 && bite !== 92 && bite !== 126) {
+          iso2022jp_output_flag = false;
+          return bite;
+        }
+        if (bite === end_of_stream) {
+          return finished;
+        }
+        iso2022jp_output_flag = false;
+        return decoderError(fatal);
+      case states.Katakana:
+        if (bite === 27) {
+          iso2022jp_decoder_state = states.EscapeStart;
+          return null;
+        }
+        if (inRange(bite, 33, 95)) {
+          iso2022jp_output_flag = false;
+          return 65377 - 33 + bite;
+        }
+        if (bite === end_of_stream) {
+          return finished;
+        }
+        iso2022jp_output_flag = false;
+        return decoderError(fatal);
+      case states.LeadByte:
+        if (bite === 27) {
+          iso2022jp_decoder_state = states.EscapeStart;
+          return null;
+        }
+        if (inRange(bite, 33, 126)) {
+          iso2022jp_output_flag = false;
+          iso2022jp_lead = bite;
+          iso2022jp_decoder_state = states.TrailByte;
+          return null;
+        }
+        if (bite === end_of_stream) {
+          return finished;
+        }
+        iso2022jp_output_flag = false;
+        return decoderError(fatal);
+      case states.TrailByte:
+        if (bite === 27) {
+          iso2022jp_decoder_state = states.EscapeStart;
+          return decoderError(fatal);
+        }
+        if (inRange(bite, 33, 126)) {
+          iso2022jp_decoder_state = states.LeadByte;
+          var pointer = (iso2022jp_lead - 33) * 94 + bite - 33;
+          var code_point = indexCodePointFor(pointer, index("jis0208"));
+          if (code_point === null) return decoderError(fatal);
+          return code_point;
+        }
+        if (bite === end_of_stream) {
+          iso2022jp_decoder_state = states.LeadByte;
+          stream2.prepend(bite);
+          return decoderError(fatal);
+        }
+        iso2022jp_decoder_state = states.LeadByte;
+        return decoderError(fatal);
+      case states.EscapeStart:
+        if (bite === 36 || bite === 40) {
+          iso2022jp_lead = bite;
+          iso2022jp_decoder_state = states.Escape;
+          return null;
+        }
+        stream2.prepend(bite);
+        iso2022jp_output_flag = false;
+        iso2022jp_decoder_state = iso2022jp_decoder_output_state;
+        return decoderError(fatal);
+      case states.Escape:
+        var lead = iso2022jp_lead;
+        iso2022jp_lead = 0;
+        var state = null;
+        if (lead === 40 && bite === 66) state = states.ASCII;
+        if (lead === 40 && bite === 74) state = states.Roman;
+        if (lead === 40 && bite === 73) state = states.Katakana;
+        if (lead === 36 && (bite === 64 || bite === 66)) state = states.LeadByte;
+        if (state !== null) {
+          iso2022jp_decoder_state = iso2022jp_decoder_state = state;
+          var output_flag = iso2022jp_output_flag;
+          iso2022jp_output_flag = true;
+          return !output_flag ? null : decoderError(fatal);
+        }
+        stream2.prepend([lead, bite]);
+        iso2022jp_output_flag = false;
+        iso2022jp_decoder_state = iso2022jp_decoder_output_state;
+        return decoderError(fatal);
+    }
+  };
+}
+function ISO2022JPEncoder(options) {
+  var _fatal = options.fatal;
+  var states = {
+    ASCII: 0,
+    Roman: 1,
+    jis0208: 2
+  };
+  var iso2022jp_state = states.ASCII;
+  this.handler = function(stream2, code_point) {
+    if (code_point === end_of_stream && iso2022jp_state !== states.ASCII) {
+      stream2.prepend(code_point);
+      iso2022jp_state = states.ASCII;
+      return [27, 40, 66];
+    }
+    if (code_point === end_of_stream && iso2022jp_state === states.ASCII) return finished;
+    if ((iso2022jp_state === states.ASCII || iso2022jp_state === states.Roman) && (code_point === 14 || code_point === 15 || code_point === 27)) {
+      return encoderError(65533);
+    }
+    if (iso2022jp_state === states.ASCII && isASCIICodePoint(code_point)) return code_point;
+    if (iso2022jp_state === states.Roman && (isASCIICodePoint(code_point) && code_point !== 92 && code_point !== 126 || code_point === 165 || code_point === 8254)) {
+      if (isASCIICodePoint(code_point)) return code_point;
+      if (code_point === 165) return 92;
+      if (code_point === 8254) return 126;
+    }
+    if (isASCIICodePoint(code_point) && iso2022jp_state !== states.ASCII) {
+      stream2.prepend(code_point);
+      iso2022jp_state = states.ASCII;
+      return [27, 40, 66];
+    }
+    if ((code_point === 165 || code_point === 8254) && iso2022jp_state !== states.Roman) {
+      stream2.prepend(code_point);
+      iso2022jp_state = states.Roman;
+      return [27, 40, 74];
+    }
+    if (code_point === 8722) code_point = 65293;
+    var pointer = indexPointerFor(code_point, index("jis0208"));
+    if (pointer === null) return encoderError(code_point);
+    if (iso2022jp_state !== states.jis0208) {
+      stream2.prepend(code_point);
+      iso2022jp_state = states.jis0208;
+      return [27, 36, 66];
+    }
+    var lead = floor(pointer / 94) + 33;
+    var trail = pointer % 94 + 33;
+    return [lead, trail];
+  };
+}
+encoders["ISO-2022-JP"] = function(options) {
+  return new ISO2022JPEncoder(options);
+};
+decoders["ISO-2022-JP"] = function(options) {
+  return new ISO2022JPDecoder(options);
+};
+function ShiftJISDecoder(options) {
+  var fatal = options.fatal;
+  var Shift_JIS_lead = 0;
+  this.handler = function(stream2, bite) {
+    if (bite === end_of_stream && Shift_JIS_lead !== 0) {
+      Shift_JIS_lead = 0;
+      return decoderError(fatal);
+    }
+    if (bite === end_of_stream && Shift_JIS_lead === 0) return finished;
+    if (Shift_JIS_lead !== 0) {
+      var lead = Shift_JIS_lead;
+      var pointer = null;
+      Shift_JIS_lead = 0;
+      var offset = bite < 127 ? 64 : 65;
+      var lead_offset = lead < 160 ? 129 : 193;
+      if (inRange(bite, 64, 126) || inRange(bite, 128, 252))
+        pointer = (lead - lead_offset) * 188 + bite - offset;
+      if (inRange(pointer, 8836, 10715)) return 57344 - 8836 + pointer;
+      var code_point = pointer === null ? null : indexCodePointFor(pointer, index("jis0208"));
+      if (code_point === null && isASCIIByte(bite)) stream2.prepend(bite);
+      if (code_point === null) return decoderError(fatal);
+      return code_point;
+    }
+    if (isASCIIByte(bite) || bite === 128) return bite;
+    if (inRange(bite, 161, 223)) return 65377 - 161 + bite;
+    if (inRange(bite, 129, 159) || inRange(bite, 224, 252)) {
+      Shift_JIS_lead = bite;
+      return null;
+    }
+    return decoderError(fatal);
+  };
+}
+function ShiftJISEncoder(options) {
+  var _fatal = options.fatal;
+  this.handler = function(stream2, code_point) {
+    if (code_point === end_of_stream) return finished;
+    if (isASCIICodePoint(code_point) || code_point === 128) return code_point;
+    if (code_point === 165) return 92;
+    if (code_point === 8254) return 126;
+    if (inRange(code_point, 65377, 65439)) return code_point - 65377 + 161;
+    if (code_point === 8722) code_point = 65293;
+    var pointer = indexShiftJISPointerFor(code_point);
+    if (pointer === null) return encoderError(code_point);
+    var lead = floor(pointer / 188);
+    var lead_offset = lead < 31 ? 129 : 193;
+    var trail = pointer % 188;
+    var offset = trail < 63 ? 64 : 65;
+    return [lead + lead_offset, trail + offset];
+  };
+}
+encoders["Shift_JIS"] = function(options) {
+  return new ShiftJISEncoder(options);
+};
+decoders["Shift_JIS"] = function(options) {
+  return new ShiftJISDecoder(options);
+};
+function EUCKRDecoder(options) {
+  var fatal = options.fatal;
+  var euckr_lead = 0;
+  this.handler = function(stream2, bite) {
+    if (bite === end_of_stream && euckr_lead !== 0) {
+      euckr_lead = 0;
+      return decoderError(fatal);
+    }
+    if (bite === end_of_stream && euckr_lead === 0) return finished;
+    if (euckr_lead !== 0) {
+      var lead = euckr_lead;
+      var pointer = null;
+      euckr_lead = 0;
+      if (inRange(bite, 65, 254)) pointer = (lead - 129) * 190 + (bite - 65);
+      var code_point = pointer === null ? null : indexCodePointFor(pointer, index("euc-kr"));
+      if (pointer === null && isASCIIByte(bite)) stream2.prepend(bite);
+      if (code_point === null) return decoderError(fatal);
+      return code_point;
+    }
+    if (isASCIIByte(bite)) return bite;
+    if (inRange(bite, 129, 254)) {
+      euckr_lead = bite;
+      return null;
+    }
+    return decoderError(fatal);
+  };
+}
+function EUCKREncoder(options) {
+  var _fatal = options.fatal;
+  this.handler = function(stream2, code_point) {
+    if (code_point === end_of_stream) return finished;
+    if (isASCIICodePoint(code_point)) return code_point;
+    var pointer = indexPointerFor(code_point, index("euc-kr"));
+    if (pointer === null) return encoderError(code_point);
+    var lead = floor(pointer / 190) + 129;
+    var trail = pointer % 190 + 65;
+    return [lead, trail];
+  };
+}
+encoders["EUC-KR"] = function(options) {
+  return new EUCKREncoder(options);
+};
+decoders["EUC-KR"] = function(options) {
+  return new EUCKRDecoder(options);
+};
+function convertCodeUnitToBytes(code_unit, utf16be) {
+  var byte1 = code_unit >> 8;
+  var byte2 = code_unit & 255;
+  if (utf16be) return [byte1, byte2];
+  return [byte2, byte1];
+}
+function UTF16Decoder(utf16_be, options) {
+  var fatal = options.fatal;
+  var utf16_lead_byte = null, utf16_lead_surrogate = null;
+  this.handler = function(stream2, bite) {
+    if (bite === end_of_stream && (utf16_lead_byte !== null || utf16_lead_surrogate !== null)) {
+      return decoderError(fatal);
+    }
+    if (bite === end_of_stream && utf16_lead_byte === null && utf16_lead_surrogate === null) {
+      return finished;
+    }
+    if (utf16_lead_byte === null) {
+      utf16_lead_byte = bite;
+      return null;
+    }
+    var code_unit;
+    if (utf16_be) {
+      code_unit = (utf16_lead_byte << 8) + bite;
+    } else {
+      code_unit = (bite << 8) + utf16_lead_byte;
+    }
+    utf16_lead_byte = null;
+    if (utf16_lead_surrogate !== null) {
+      var lead_surrogate = utf16_lead_surrogate;
+      utf16_lead_surrogate = null;
+      if (inRange(code_unit, 56320, 57343)) {
+        return 65536 + (lead_surrogate - 55296) * 1024 + (code_unit - 56320);
+      }
+      stream2.prepend(convertCodeUnitToBytes(code_unit, utf16_be));
+      return decoderError(fatal);
+    }
+    if (inRange(code_unit, 55296, 56319)) {
+      utf16_lead_surrogate = code_unit;
+      return null;
+    }
+    if (inRange(code_unit, 56320, 57343)) return decoderError(fatal);
+    return code_unit;
+  };
+}
+function UTF16Encoder(utf16_be, options) {
+  var _fatal = options.fatal;
+  this.handler = function(stream2, code_point) {
+    if (code_point === end_of_stream) return finished;
+    if (inRange(code_point, 0, 65535)) return convertCodeUnitToBytes(code_point, utf16_be);
+    var lead = convertCodeUnitToBytes((code_point - 65536 >> 10) + 55296, utf16_be);
+    var trail = convertCodeUnitToBytes((code_point - 65536 & 1023) + 56320, utf16_be);
+    return lead.concat(trail);
+  };
+}
+encoders["UTF-16BE"] = function(options) {
+  return new UTF16Encoder(true, options);
+};
+decoders["UTF-16BE"] = function(options) {
+  return new UTF16Decoder(true, options);
+};
+encoders["UTF-16LE"] = function(options) {
+  return new UTF16Encoder(false, options);
+};
+decoders["UTF-16LE"] = function(options) {
+  return new UTF16Decoder(false, options);
+};
+function XUserDefinedDecoder(options) {
+  var _fatal = options.fatal;
+  this.handler = function(stream2, bite) {
+    if (bite === end_of_stream) return finished;
+    if (isASCIIByte(bite)) return bite;
+    return 63360 + bite - 128;
+  };
+}
+function XUserDefinedEncoder(options) {
+  var _fatal = options.fatal;
+  this.handler = function(stream2, code_point) {
+    if (code_point === end_of_stream) return finished;
+    if (isASCIICodePoint(code_point)) return code_point;
+    if (inRange(code_point, 63360, 63487)) return code_point - 63360 + 128;
+    return encoderError(code_point);
+  };
+}
+encoders["x-user-defined"] = function(options) {
+  return new XUserDefinedEncoder(options);
+};
+decoders["x-user-defined"] = function(options) {
+  return new XUserDefinedDecoder(options);
+};
+
+// src/polyfills/buffer/btoa.node.ts
+function atob(string) {
+  return Buffer.from(string).toString("base64");
+}
+function btoa(base64) {
+  return Buffer.from(base64, "base64").toString("ascii");
+}
+
+// src/polyfills/images/image-codecs-node.ts
+init_node_image_formats();
+async function parseImageNode2(...parameters) {
+  let decoder;
+  try {
+    decoder = await Promise.resolve().then(() => (init_parse_image_node(), parse_image_node_exports));
+  } catch (error) {
+    throw new Error(
+      "Node image decoding requires get-pixels. Install get-pixels to decode images.",
+      { cause: error }
+    );
+  }
+  return decoder.parseImageNode(...parameters);
+}
+async function encodeImageNode2(...parameters) {
+  let encoder;
+  try {
+    encoder = await Promise.resolve().then(() => (init_encode_image_node(), encode_image_node_exports));
+  } catch (error) {
+    throw new Error(
+      "Node image encoding requires save-pixels and ndarray. Install save-pixels and ndarray to encode images.",
+      { cause: error }
+    );
+  }
+  return encoder.encodeImageNode(...parameters);
+}
+
+// src/polyfills/images/node-image-bitmap.ts
+var NodeImageBitmap = class {
+  /** Width of the decoded bitmap in pixels. */
+  width;
+  /** Height of the decoded bitmap in pixels. */
+  height;
+  /** Backing pixel data retained until `close()` is called. */
+  data;
+  /** Creates a bitmap wrapper around decoded Node.js image data. */
+  constructor(imageData) {
+    if (!imageData || !imageData.data || !imageData.width || !imageData.height) {
+      throw new Error("NodeImageBitmap requires decoded image data");
+    }
+    this.width = imageData.width;
+    this.height = imageData.height;
+    this.data = imageData.data;
+  }
+  /** Releases the backing pixel data and invalidates further reads. */
+  close() {
+    this.width = 0;
+    this.height = 0;
+    this.data = null;
+  }
+  /** Returns the decoded image data backing this bitmap. */
+  _getImageData() {
+    if (!this.data) {
+      throw new Error("ImageBitmap is closed");
+    }
+    return {
+      data: this.data,
+      width: this.width,
+      height: this.height
+    };
+  }
+};
+function isNodeImageBitmap(image) {
+  return image instanceof NodeImageBitmap;
+}
+function createImageBitmapNode(imageData) {
+  return new NodeImageBitmap(imageData);
+}
+function getImageBitmapDataNode(image) {
+  if (!isNodeImageBitmap(image)) {
+    throw new Error("getImageBitmapData");
+  }
+  return image._getImageData();
+}
+
+// src/polyfills/utils/path-utils.ts
+var pathPrefix = "";
+var fileAliases = /* @__PURE__ */ new Map();
+function setPathPrefix(prefix) {
+  pathPrefix = prefix;
+}
+function addAliases(aliases) {
+  for (const [alias, replacement] of Object.entries(aliases)) {
+    fileAliases.set(alias, replacement);
+  }
+}
+function resolvePath(filename) {
+  for (const [alias, replacement] of fileAliases) {
+    if (filename.startsWith(alias)) {
+      filename = filename.replace(alias, replacement);
+    }
+  }
+  if (!filename.startsWith("http://") && !filename.startsWith("https://")) {
+    filename = `${pathPrefix}${filename}`;
+  }
+  return filename;
+}
+
+// src/polyfills/filesystems/node-file.ts
+var import_fs = __toESM(require("fs"), 1);
+var NodeFile = class {
+  handle;
+  size;
+  bigsize;
+  url;
+  constructor(path2, flags, mode) {
+    path2 = resolvePath(path2);
+    this.handle = import_fs.default.openSync(path2, flags, mode);
+    const stats = import_fs.default.fstatSync(this.handle, { bigint: true });
+    this.size = Number(stats.size);
+    this.bigsize = stats.size;
+    this.url = path2;
+  }
+  async close() {
+    return new Promise((resolve, reject) => {
+      import_fs.default.close(this.handle, (err) => err ? reject(err) : resolve());
+    });
+  }
+  async truncate(length) {
+    return new Promise((resolve, reject) => {
+      import_fs.default.ftruncate(this.handle, length, (err) => {
+        if (err) {
+          reject(err);
+        } else {
+          this.bigsize = BigInt(length);
+          this.size = Number(this.bigsize);
+          resolve();
+        }
+      });
+    });
+  }
+  async append(data) {
+    return new Promise((resolve, reject) => {
+      import_fs.default.appendFile(this.handle, data, (err) => {
+        if (err) {
+          reject(err);
+        } else {
+          this.bigsize = this.bigsize + BigInt(data.length);
+          this.size = Number(this.bigsize);
+          resolve();
+        }
+      });
+    });
+  }
+  async stat() {
+    return await new Promise(
+      (resolve, reject) => import_fs.default.fstat(this.handle, { bigint: true }, (err, info) => {
+        const stats = {
+          size: Number(info.size),
+          bigsize: info.size,
+          isDirectory: info.isDirectory()
+        };
+        if (err) {
+          reject(err);
+        } else {
+          resolve(stats);
+        }
+      })
+    );
+  }
+  async read(offset, length) {
+    const arrayBuffer = new ArrayBuffer(length);
+    let bigOffset = BigInt(offset);
+    let totalBytesRead = 0;
+    const uint8Array = new Uint8Array(arrayBuffer);
+    let position;
+    while (length > 0) {
+      const bytesRead = await readBytes(this.handle, uint8Array, 0, length, bigOffset);
+      if (bytesRead === 0) {
+        break;
+      }
+      totalBytesRead += bytesRead;
+      bigOffset += BigInt(bytesRead);
+      length -= bytesRead;
+      if (position !== void 0) {
+        position += bytesRead;
+      }
+    }
+    return totalBytesRead < length ? arrayBuffer.slice(0, totalBytesRead) : arrayBuffer;
+  }
+  async write(arrayBuffer, offset = 0, length = arrayBuffer.byteLength) {
+    return new Promise((resolve, reject) => {
+      const nOffset = Number(offset);
+      const uint8Array = new Uint8Array(arrayBuffer, Number(offset), length);
+      import_fs.default.write(
+        this.handle,
+        uint8Array,
+        0,
+        length,
+        nOffset,
+        (err, bytesWritten) => err ? reject(err) : resolve(bytesWritten)
+      );
+    });
+  }
+};
+async function readBytes(fd, uint8Array, offset, length, position) {
+  return await new Promise(
+    (resolve, reject) => import_fs.default.read(
+      fd,
+      uint8Array,
+      offset,
+      length,
+      position,
+      (err, bytesRead) => err ? reject(err) : resolve(bytesRead)
+    )
+  );
+}
+
+// src/polyfills/filesystems/node-filesystem.ts
+var import_promises = __toESM(require("fs/promises"), 1);
+
+// src/polyfills/filesystems/fetch-node.ts
+var import_fs2 = __toESM(require("fs"), 1);
+var import_stream = require("stream");
+
+// src/polyfills/filesystems/stream-utils.node.ts
+var import_zlib = __toESM(require("zlib"), 1);
+
+// src/polyfills/utils/buffer-utils.ts
+function toArrayBuffer(data) {
+  if (data instanceof ArrayBuffer) {
+    return data;
+  }
+  if (ArrayBuffer.isView(data)) {
+    return ensureArrayBuffer(data);
+  }
+  return ensureArrayBuffer(data);
+}
+function ensureArrayBuffer(data) {
+  if (data instanceof ArrayBuffer) {
+    return data;
+  }
+  if (ArrayBuffer.isView(data)) {
+    const { buffer, byteOffset, byteLength } = data;
+    if (buffer instanceof ArrayBuffer && byteOffset === 0 && byteLength === buffer.byteLength) {
+      return buffer;
+    }
+    return copyArrayBufferRange(buffer, byteOffset, byteLength);
+  }
+  return copyArrayBufferRange(data);
+}
+function copyArrayBufferRange(buffer, offset = 0, length = buffer.byteLength - offset) {
+  const copy = new Uint8Array(length);
+  copy.set(new Uint8Array(buffer, offset, length));
+  return copy.buffer;
+}
+
+// src/polyfills/filesystems/stream-utils.node.ts
+function decompressReadStream(readStream, headers) {
+  switch (headers?.get("content-encoding")) {
+    case "br":
+      return readStream.pipe(import_zlib.default.createBrotliDecompress());
+    case "gzip":
+      return readStream.pipe(import_zlib.default.createGunzip());
+    case "deflate":
+      return readStream.pipe(import_zlib.default.createDeflate());
+    default:
+      return readStream;
+  }
+}
+async function concatenateReadStream(readStream) {
+  const arrayBufferChunks = [];
+  return await new Promise((resolve, reject) => {
+    readStream.on("error", (error) => reject(error));
+    readStream.on("readable", () => readStream.read());
+    readStream.on("data", (chunk) => {
+      if (typeof chunk === "string") {
+        reject(new Error("Read stream not binary"));
+      }
+      arrayBufferChunks.push(toArrayBuffer(chunk));
+    });
+    readStream.on("end", () => {
+      const arrayBuffer = concatenateArrayBuffers(arrayBufferChunks);
+      resolve(arrayBuffer);
+    });
+  });
+}
+function concatenateArrayBuffers(sources) {
+  const sourceArrays = sources.map(
+    (source2) => source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2
+  );
+  const byteLength = sourceArrays.reduce((length, typedArray) => length + typedArray.byteLength, 0);
+  const result = new Uint8Array(byteLength);
+  let offset = 0;
+  for (const sourceArray of sourceArrays) {
+    result.set(sourceArray, offset);
+    offset += sourceArray.byteLength;
+  }
+  return result.buffer;
+}
+
+// src/polyfills/filesystems/fetch-node.ts
+var isBoolean = (x) => typeof x === "boolean";
+var isFunction = (x) => typeof x === "function";
+var isObject = (x) => x !== null && typeof x === "object";
+var isReadableNodeStream = (x) => isObject(x) && isFunction(x.read) && isFunction(x.pipe) && isBoolean(x.readable);
+async function fetchNode(url, options) {
+  const FILE_PROTOCOL_REGEX = /^file:\/\//;
+  url.replace(FILE_PROTOCOL_REGEX, "/");
+  let noqueryUrl = url.split("?")[0];
+  noqueryUrl = resolvePath(noqueryUrl);
+  const responseHeaders = new Headers();
+  if (url.endsWith(".gz")) {
+    responseHeaders.set("content-encoding", "gzip");
+  }
+  if (url.endsWith(".br")) {
+    responseHeaders.set("content-encoding", "br");
+  }
+  try {
+    const body = await new Promise((resolve, reject) => {
+      const stream2 = import_fs2.default.createReadStream(noqueryUrl, { encoding: null });
+      stream2.once("readable", () => resolve(stream2));
+      stream2.on("error", (error) => reject(error));
+    });
+    let bodyStream = body;
+    if (isReadableNodeStream(body)) {
+      bodyStream = decompressReadStream(body, responseHeaders);
+    } else if (typeof body === "string") {
+      bodyStream = import_stream.Readable.from([new TextEncoder().encode(body)]);
+    } else {
+      bodyStream = import_stream.Readable.from([body || new ArrayBuffer(0)]);
+    }
+    const status = 200;
+    const statusText = "OK";
+    const headers = getHeadersForFile(noqueryUrl);
+    const response = new Response(bodyStream, { headers, status, statusText });
+    Object.defineProperty(response, "url", { value: url });
+    return response;
+  } catch (error) {
+    const errorMessage = error.message;
+    const status = 400;
+    const statusText = errorMessage;
+    const headers = {};
+    const response = new Response(errorMessage, { headers, status, statusText });
+    Object.defineProperty(response, "url", { value: url });
+    return response;
+  }
+}
+function getHeadersForFile(noqueryUrl) {
+  const headers = {};
+  if (!headers["content-length"]) {
+    const stats = import_fs2.default.statSync(noqueryUrl);
+    headers["content-length"] = stats.size;
+  }
+  if (noqueryUrl.endsWith(".gz")) {
+    noqueryUrl = noqueryUrl.slice(0, -3);
+    headers["content-encoding"] = "gzip";
+  }
+  return new Headers(headers);
+}
+
+// src/polyfills/filesystems/node-filesystem.ts
+var NodeFileSystem = class {
+  readable = true;
+  writable = true;
+  // implements FileSystem
+  constructor() {
+  }
+  async readdir(dirname = ".", options) {
+    return await import_promises.default.readdir(dirname, options);
+  }
+  async stat(path2) {
+    const info = await import_promises.default.stat(path2, { bigint: true });
+    return {
+      size: Number(info.size),
+      bigsize: info.size,
+      isDirectory: info.isDirectory()
+    };
+  }
+  async unlink(path2) {
+    return await import_promises.default.unlink(path2);
+  }
+  async fetch(path2, options) {
+    return await fetchNode(path2, options);
+  }
+  // implements IRandomAccessFileSystem
+  async openReadableFile(path2, flags = "r") {
+    return new NodeFile(path2, flags);
+  }
+  async openWritableFile(path2, flags = "w", mode) {
+    return new NodeFile(path2, flags, mode);
+  }
+};
+
+// src/polyfills/crypto/node-hash.ts
+var crypto = __toESM(require("crypto"), 1);
+var NodeHash = class {
+  name = "crypto-node";
+  options;
+  // @ts-ignore
+  _algorithm;
+  // @ts-ignore
+  _hash;
+  constructor(options) {
+    this.options = options;
+    this.hashBatches = this.hashBatches.bind(this);
+    if (!this.options?.crypto?.algorithm) {
+      throw new Error(this.name);
+    }
+  }
+  /** Complete the optional hash initialization step. */
+  async preload() {
+    return;
+  }
+  /**
+   * Atomic hash calculation
+   * @returns base64 encoded hash
+   */
+  async hash(input, encoding) {
+    const algorithm = this.options?.crypto?.algorithm?.toLowerCase();
+    try {
+      if (!crypto.createHash) {
+        throw new Error("crypto.createHash not available");
+      }
+      const hash = crypto.createHash?.(algorithm);
+      const inputArray = new Uint8Array(input);
+      return hash.update(inputArray).digest("base64");
+    } catch (error) {
+      throw Error(`${algorithm} hash not available. ${error}`);
+    }
+  }
+  async *hashBatches(asyncIterator, encoding = "base64") {
+    if (!crypto.createHash) {
+      throw new Error("crypto.createHash not available");
+    }
+    const hash = crypto.createHash?.(this.options?.crypto?.algorithm?.toLowerCase());
+    for await (const chunk of asyncIterator) {
+      const inputArray = new Uint8Array(chunk);
+      hash.update(inputArray);
+      yield chunk;
+    }
+    const digest = hash.digest(encoding);
+    this.options?.crypto?.onEnd?.({ hash: digest });
+  }
+};
+
+// src/polyfills/index.ts
+var import_node_process = require("node:process");
+var import_web2 = require("node:stream/web");
+
+// src/polyfills/streams/make-node-stream.ts
+var Stream2 = __toESM(require("stream"), 1);
+var _Readable = class {
+};
+var Readable3 = Stream2.Readable || _Readable;
+function makeNodeStream(source, options) {
+  const iterator = source[Symbol.asyncIterator] ? (
+    // @ts-ignore AsyncGenerator
+    source[Symbol.asyncIterator]()
+  ) : (
+    // @ts-ignore AsyncGenerator
+    source[Symbol.iterator]()
+  );
+  return new AsyncIterableReadable(iterator, options);
+}
+var AsyncIterableReadable = class extends Readable3 {
+  _pulling;
+  _bytesMode;
+  _iterator;
+  constructor(it, options) {
+    super(options);
+    this._iterator = it;
+    this._pulling = false;
+    this._bytesMode = !options || !options.objectMode;
+  }
+  async _read(size) {
+    if (!this._pulling) {
+      this._pulling = true;
+      this._pulling = await this._pull(size, this._iterator);
+    }
+  }
+  async _destroy(error, cb) {
+    if (!this._iterator) {
+      return;
+    }
+    if (error) {
+      await this._iterator?.throw?.(error);
+    } else {
+      await this._iterator?.return?.(error);
+    }
+    cb?.(null);
+  }
+  // eslint-disable-next-line complexity
+  async _pull(size, it) {
+    const bm = this._bytesMode;
+    let r = null;
+    while (this.readable) {
+      r = await it.next();
+      if (r.done) {
+        break;
+      }
+      if (size !== null) {
+        size -= bm && ArrayBuffer.isView(r.value) ? r.value.byteLength : 1;
+      }
+      if (!this.push(new Uint8Array(r.value)) || size <= 0) {
+        break;
+      }
+    }
+    if ((r?.done || !this.readable) && (this.push(null) || true)) {
+      it?.return?.();
+    }
+    return !this.readable;
+  }
+};
+
+// src/polyfills/file/readable-stream.ts
+var import_web = require("node:stream/web");
+var ReadableStreamPolyfill = class extends import_web.ReadableStream {
+};
+
+// src/polyfills/file/blob-stream-controller.ts
+var BlobStreamController = class {
+  chunks;
+  isWorking = false;
+  isCancelled = false;
+  /**
+   * @param chunks
+   */
+  constructor(chunks) {
+    this.chunks = chunks;
+  }
+  /**
+   * @param controller
+   */
+  start(controller) {
+    this.work(controller);
+  }
+  /**
+   *
+   * @param controller
+   */
+  async work(controller) {
+    const { chunks } = this;
+    this.isWorking = true;
+    while (!this.isCancelled && (controller.desiredSize || 0) > 0) {
+      let next;
+      try {
+        next = chunks.next();
+      } catch (error) {
+        controller.error(error);
+        break;
+      }
+      if (next) {
+        if (!next.done && !this.isCancelled) {
+          controller.enqueue(next.value);
+        } else {
+          controller.close();
+        }
+      }
+    }
+    this.isWorking = false;
+  }
+  /**
+   *
+   * @param {ReadableStreamDefaultController} controller
+   */
+  pull(controller) {
+    if (!this.isWorking) {
+      this.work(controller);
+    }
+  }
+  cancel() {
+    this.isCancelled = true;
+  }
+};
+
+// src/polyfills/file/blob-stream.ts
+var BlobStream = class extends ReadableStreamPolyfill {
+  _chunks;
+  /**
+   * @param chunks
+   */
+  constructor(chunks) {
+    super(new BlobStreamController(chunks.values()), { type: "bytes" });
+    this._chunks = chunks;
+  }
+  /**
+   * @property [_options.preventCancel]
+   */
+  // @ts-ignore
+  async *[Symbol.asyncIterator](_options) {
+    const reader = this.getReader();
+    yield* this._chunks;
+    reader.releaseLock();
+  }
+};
+
+// src/polyfills/file/blob.ts
+var BlobPolyfill = class _BlobPolyfill {
+  // implements Blob {
+  /** The MIME type of the data contained in the Blob. If type is unknown, string is empty. */
+  type;
+  /** The size, in bytes, of the data contained in the Blob object. */
+  size;
+  parts;
+  /**
+   * @param [init]
+   * @param [options]
+   */
+  constructor(init = [], options = {}) {
+    this.parts = [];
+    this.size = 0;
+    for (const part of init) {
+      if (typeof part === "string") {
+        const bytes = new TextEncoder().encode(part);
+        this.parts.push(bytes);
+        this.size += bytes.byteLength;
+      } else if (part instanceof _BlobPolyfill) {
+        this.size += part.size;
+        this.parts.push(...part.parts);
+      } else if (part instanceof ArrayBuffer) {
+        this.parts.push(new Uint8Array(part));
+        this.size += part.byteLength;
+      } else if (part instanceof Uint8Array) {
+        this.parts.push(part);
+        this.size += part.byteLength;
+      } else if (ArrayBuffer.isView(part)) {
+        const { buffer, byteOffset, byteLength } = part;
+        this.parts.push(new Uint8Array(buffer, byteOffset, byteLength));
+        this.size += byteLength;
+      } else {
+        const bytes = new TextEncoder().encode(String(part));
+        this.parts.push(bytes);
+        this.size += bytes.byteLength;
+      }
+    }
+    this.type = readType(options.type);
+  }
+  /**
+   * Returns a new Blob object containing the data in the specified range of
+   * bytes of the blob on which it's called.
+   * @param start=0 - An index into the Blob indicating the first
+   * byte to include in the new Blob. If you specify a negative value, it's
+   * treated as an offset from the end of the Blob toward the beginning. For
+   * example, `-10` would be the 10th from last byte in the Blob. The default
+   * value is `0`. If you specify a value for start that is larger than the
+   * size of the source Blob, the returned Blob has size 0 and contains no
+   * data.
+   * @param end - An index into the `Blob` indicating the first byte
+   *  that will *not* be included in the new `Blob` (i.e. the byte exactly at
+   * this index is not included). If you specify a negative value, it's treated
+   * as an offset from the end of the Blob toward the beginning. For example,
+   * `-10` would be the 10th from last byte in the `Blob`. The default value is
+   * size.
+   * @param type - The content type to assign to the new Blob;
+   * this will be the value of its type property. The default value is an empty
+   * string.
+   */
+  slice(start = 0, end = this.size, type = "") {
+    const { size, parts } = this;
+    let offset = start < 0 ? Math.max(size + start, 0) : Math.min(start, size);
+    let limit = end < 0 ? Math.max(size + end, 0) : Math.min(end, size);
+    const span = Math.max(limit - offset, 0);
+    const blob = new _BlobPolyfill([], { type });
+    if (span === 0) {
+      return blob;
+    }
+    let blobSize = 0;
+    const blobParts = [];
+    for (const part of parts) {
+      const { byteLength } = part;
+      if (offset > 0 && byteLength <= offset) {
+        offset -= byteLength;
+        limit -= byteLength;
+      } else {
+        const chunk = part.subarray(offset, Math.min(byteLength, limit));
+        blobParts.push(chunk);
+        blobSize += chunk.byteLength;
+        offset = 0;
+        if (blobSize >= span) {
+          break;
+        }
+      }
+    }
+    blob.parts = blobParts;
+    blob.size = blobSize;
+    return blob;
+  }
+  /**
+   * Returns a promise that resolves with an ArrayBuffer containing the entire
+   * contents of the Blob as binary data.
+   */
+  // eslint-disable-next-line require-await
+  async arrayBuffer() {
+    return this._toArrayBuffer();
+  }
+  /**
+   * Returns a promise that resolves with a USVString containing the entire
+   * contents of the Blob interpreted as UTF-8 text.
+   */
+  // eslint-disable-next-line require-await
+  async text() {
+    const decoder = new TextDecoder();
+    let text = "";
+    for (const part of this.parts) {
+      text += decoder.decode(part);
+    }
+    return text;
+  }
+  /**
+   */
+  // @ts-ignore
+  stream() {
+    return new BlobStream(this.parts);
+  }
+  /**
+   * @returns {string}
+   */
+  toString() {
+    return "[object Blob]";
+  }
+  get [Symbol.toStringTag]() {
+    return "Blob";
+  }
+  _toArrayBuffer() {
+    const buffer = new ArrayBuffer(this.size);
+    const bytes = new Uint8Array(buffer);
+    let offset = 0;
+    for (const part of this.parts) {
+      bytes.set(part, offset);
+      offset += part.byteLength;
+    }
+    return buffer;
+  }
+};
+function readType(input = "") {
+  const type = String(input).toLowerCase();
+  return /[^\u0020-\u007E]/.test(type) ? "" : type;
+}
+
+// src/polyfills/file/install-blob-polyfills.ts
+function instalBlobPolyfills() {
+  if (typeof Blob === "undefined" && !globalThis.Blob) {
+    globalThis.Blob = BlobPolyfill;
+  }
+  return globalThis.Blob;
+}
+var Blob_ = instalBlobPolyfills();
+
+// src/polyfills/file/file-reader.ts
+var FileReaderPolyfill = class {
+  // onload: ({result: any}) => void;
+  onload;
+  onabort;
+  onerror;
+  error;
+  onloadstart;
+  onloadend;
+  onprogress;
+  readyState;
+  result;
+  DONE;
+  EMPTY;
+  LOADING;
+  addEventListener;
+  removeEventListener;
+  dispatchEvent;
+  constructor() {
+    this.onload = null;
+  }
+  abort() {
+    return;
+  }
+  async readAsArrayBuffer(blob) {
+    const arrayBuffer = await blob.arrayBuffer();
+    if (this.onload) {
+      this.onload({ target: { result: arrayBuffer } });
+    }
+  }
+  async readAsBinaryString(blob) {
+    throw Error("Not implemented");
+  }
+  async readAsDataURL(blob) {
+    const text = await blob.text();
+    const dataUrl = `data://;base64,${atob(text)}`;
+    if (this.onload) {
+      this.onload({ target: { result: dataUrl } });
+    }
+  }
+  async readAsText(blob) {
+    const text = await blob.text();
+    if (this.onload) {
+      this.onload({ target: { result: text } });
+    }
+  }
+};
+
+// src/polyfills/file/file.ts
+var FilePolyfill = class extends globalThis.Blob {
+  // implements File {
+  // public API
+  /** The name of the file referenced by the File object. */
+  name = "";
+  /** The path the URL of the File is relative to. */
+  webkitRelativePath = "";
+  /**
+   * Returns the last modified time of the file, in millisecond since the UNIX
+   * epoch (January 1st, 1970 at Midnight).
+   */
+  lastModified;
+  /**
+   * @param init
+   * @param name - A USVString representing the file name or the path
+   * to the file.
+   * @param [options]
+   */
+  constructor(init, name, options = {}) {
+    super(init, options);
+    this.name = String(name).replace(/\//g, ":");
+    this.lastModified = options?.lastModified || Date.now();
+  }
+  get [Symbol.toStringTag]() {
+    return "File";
+  }
+};
+
+// src/polyfills/file/install-file-polyfills.ts
+function installFilePolyfills() {
+  if (typeof FileReader === "undefined" && !globalThis.FileReader) {
+    globalThis.FileReader = FileReaderPolyfill;
+  }
+  if (typeof File === "undefined" && !globalThis.File) {
+    globalThis.File = FilePolyfill;
+  }
+  return global;
+}
+var File_ = installFilePolyfills();
+
+// src/polyfills/load-library/require-utils.node.ts
+var import_module = __toESM(require("module"), 1);
+var import_path = __toESM(require("path"), 1);
+var import_fs3 = __toESM(require("fs"), 1);
+var import_node_url = require("node:url");
+async function readFileAsArrayBuffer(filename) {
+  if (filename.startsWith("http")) {
+    const response = await fetch(filename);
+    return await response.arrayBuffer();
+  }
+  return ensureArrayBuffer(import_fs3.default.readFileSync(resolveFilePath(filename)));
+}
+async function readFileAsText(filename) {
+  if (filename.startsWith("http")) {
+    const response = await fetch(filename);
+    return await response.text();
+  }
+  const text = import_fs3.default.readFileSync(resolveFilePath(filename), "utf8");
+  return text;
+}
+async function requireFromFile(filename) {
+  if (filename.startsWith("http")) {
+    const response = await fetch(filename);
+    const code2 = await response.text();
+    return requireFromString(code2);
+  }
+  const filePath = resolveFilePath(filename);
+  const code = import_fs3.default.readFileSync(filePath, "utf8");
+  return requireFromString(code, filePath);
+}
+function requireFromString(code, filename = "", options) {
+  if (typeof filename === "object") {
+    options = filename;
+    filename = "";
+  }
+  if (filename.startsWith("file:")) filename = (0, import_node_url.fileURLToPath)(filename);
+  if (typeof code !== "string") {
+    throw new Error(`code must be a string, not ${typeof code}`);
+  }
+  const paths = import_module.default._nodeModulePaths(import_path.default.dirname(filename));
+  const parent = typeof module !== "undefined" && module?.parent;
+  const newModule = new import_module.default(filename, parent);
+  newModule.filename = filename;
+  newModule.paths = [].concat(options?.prependPaths || []).concat(paths).concat(options?.appendPaths || []);
+  newModule._compile(code, filename);
+  if (parent && parent.children) {
+    parent.children.splice(parent.children.indexOf(newModule), 1);
+  }
+  return newModule.exports;
+}
+function resolveFilePath(filename) {
+  return filename.startsWith("file:") ? (0, import_node_url.fileURLToPath)(filename) : import_path.default.resolve(filename);
+}
+
+// src/polyfills/fetch/headers-polyfill.ts
+var Headers2 = class _Headers {
+  map;
+  constructor(headers) {
+    this.map = {};
+    if (headers instanceof _Headers) {
+      headers.forEach((value, name) => this.append(name, value));
+    } else if (Array.isArray(headers)) {
+      headers.forEach((header) => this.append(header[0], header[1]));
+    } else if (headers) {
+      Object.getOwnPropertyNames(headers).forEach((name) => this.append(name, headers[name]));
+    }
+  }
+  append(name, value) {
+    name = normalizeName(name);
+    value = normalizeValue(value);
+    const oldValue = this.map[name];
+    this.map[name] = oldValue ? `${oldValue}, ${value}` : value;
+  }
+  delete(name) {
+    delete this.map[normalizeName(name)];
+  }
+  get(name) {
+    name = normalizeName(name);
+    return this.has(name) ? this.map[name] : null;
+  }
+  has(name) {
+    return this.map.hasOwnProperty(normalizeName(name));
+  }
+  set(name, value) {
+    this.map[normalizeName(name)] = normalizeValue(value);
+  }
+  forEach(visitor, thisArg = null) {
+    for (const name in this.map) {
+      if (this.map.hasOwnProperty(name)) {
+        if (thisArg) {
+          visitor.call(thisArg, this.map[name], name, this);
+        } else {
+          visitor(this.map[name], name, this);
+        }
+      }
+    }
+  }
+  keys() {
+    const items = [];
+    this.forEach(function(value, name) {
+      items.push(name);
+    });
+    return iteratorFor(items);
+  }
+  values() {
+    const items = [];
+    this.forEach(function(value) {
+      items.push(value);
+    });
+    return iteratorFor(items);
+  }
+  entries() {
+    const items = [];
+    this.forEach(function(value, name) {
+      items.push([name, value]);
+    });
+    return iteratorFor(items);
+  }
+  *[Symbol.iterator]() {
+    yield* this.entries();
+  }
+};
+function normalizeName(name) {
+  if (typeof name !== "string") {
+    name = String(name);
+  }
+  if (/[^a-z0-9\-#$%&'*+.^_`|~]/i.test(name) || name === "") {
+    throw new TypeError("Invalid character in header field name");
+  }
+  return name.toLowerCase();
+}
+function normalizeValue(value) {
+  if (typeof value !== "string") {
+    value = String(value);
+  }
+  return value;
+}
+function iteratorFor(items) {
+  const iterator = {
+    next() {
+      const value = items.shift();
+      return { done: value === void 0, value };
+    }
+  };
+  iterator[Symbol.iterator] = function() {
+    return iterator;
+  };
+  return iterator;
+}
+
+// src/polyfills/utils/assert.ts
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(`@loaders.gl/core/polyfills assertion ${message}`);
+  }
+}
+
+// src/polyfills/fetch/response-polyfill.ts
+var stream = __toESM(require("stream"), 1);
+var isBoolean2 = (x) => typeof x === "boolean";
+var isFunction2 = (x) => typeof x === "function";
+var isObject2 = (x) => x !== null && typeof x === "object";
+var isReadableNodeStream2 = (x) => isObject2(x) && isFunction2(x.read) && isFunction2(x.pipe) && isBoolean2(x.readable);
+var Response2 = class {
+  ok;
+  status;
+  statusText;
+  headers;
+  url;
+  bodyUsed = false;
+  _body;
+  // TODO - handle ArrayBuffer, ArrayBufferView, Buffer
+  constructor(body, options) {
+    const { headers, status = 200, statusText = "OK", url } = options || {};
+    this.url = url;
+    this.ok = status === 200;
+    this.status = status;
+    this.statusText = statusText;
+    this.headers = new Headers2(options?.headers || {});
+    if (isReadableNodeStream2(body)) {
+      this._body = decompressReadStream(body, headers);
+    } else if (typeof body === "string") {
+      this._body = stream.Readable.from([new TextEncoder().encode(body)]);
+    } else {
+      this._body = stream.Readable.from([body || new ArrayBuffer(0)]);
+    }
+  }
+  // Subset of Properties
+  // Returns a readable stream to the "body" of the response (or file)
+  get body() {
+    assert(!this.bodyUsed);
+    assert(isReadableNodeStream2(this._body));
+    this.bodyUsed = true;
+    return this._body;
+  }
+  // Subset of Methods
+  async arrayBuffer() {
+    if (!isReadableNodeStream2(this._body)) {
+      return this._body || new ArrayBuffer(0);
+    }
+    const data = await concatenateReadStream(this._body);
+    return data;
+  }
+  async text() {
+    const arrayBuffer = await this.arrayBuffer();
+    const textDecoder = new TextDecoder();
+    return textDecoder.decode(arrayBuffer);
+  }
+  async json() {
+    const text = await this.text();
+    return JSON.parse(text);
+  }
+  async blob() {
+    if (typeof Blob === "undefined") {
+      throw new Error("Blob polyfill not installed");
+    }
+    return new Blob([await this.arrayBuffer()]);
+  }
+};
+
+// src/polyfills/fetch/fetch-polyfill.ts
+var import_http = __toESM(require("http"), 1);
+var import_https = __toESM(require("https"), 1);
+
+// src/polyfills/fetch/decode-data-uri.ts
+function decodeDataUri(uri) {
+  const dataIndex = uri.indexOf(",");
+  let buffer;
+  let mimeType;
+  if (uri.slice(dataIndex - 7, dataIndex) === ";base64") {
+    buffer = Buffer.from(uri.slice(dataIndex + 1), "base64");
+    mimeType = uri.slice(5, dataIndex - 7).trim();
+  } else {
+    buffer = Buffer.from(decodeURIComponent(uri.slice(dataIndex + 1)));
+    mimeType = uri.slice(5, dataIndex).trim();
+  }
+  if (!mimeType) {
+    mimeType = "text/plain;charset=US-ASCII";
+  } else if (mimeType.startsWith(";")) {
+    mimeType = `text/plain${mimeType}`;
+  }
+  return { arrayBuffer: toArrayBuffer(buffer), mimeType };
+}
+
+// src/polyfills/fetch/fetch-polyfill.ts
+var isDataURL = (url) => url.startsWith("data:");
+var isRequestURL = (url) => url.startsWith("http:") || url.startsWith("https:");
+async function fetchNode2(url, options) {
+  try {
+    if (globalThis.fetch !== fetchNode2 && (isRequestURL(url) || isDataURL(url))) {
+      return await fetch(url, options);
+    }
+    if (isDataURL(url)) {
+      const { arrayBuffer, mimeType } = decodeDataUri(url);
+      const response = new Response2(arrayBuffer, {
+        headers: { "content-type": mimeType },
+        url
+      });
+      return response;
+    }
+    const syntheticResponseHeaders = {};
+    const originalUrl = url;
+    if (url.endsWith(".gz")) {
+      url = url.slice(0, -3);
+      syntheticResponseHeaders["content-encoding"] = "gzip";
+    }
+    const body = await createHTTPRequestReadStream(originalUrl, options);
+    const headers = getHeaders(url, body, syntheticResponseHeaders);
+    const { status, statusText } = getStatus(body);
+    const followRedirect = (
+      // @ts-expect-error
+      !options || options.followRedirect || options.followRedirect === void 0
+    );
+    if (status >= 300 && status < 400 && headers.has("location") && followRedirect) {
+      const redirectUrl = generateRedirectUrl(url, headers.get("location"));
+      return await fetchNode2(redirectUrl, options);
+    }
+    return new Response2(body, { headers, status, statusText, url });
+  } catch (error) {
+    return new Response2(null, { status: 400, statusText: String(error), url });
+  }
+}
+async function createHTTPRequestReadStream(url, options) {
+  return await new Promise((resolve, reject) => {
+    const requestOptions = getRequestOptions(url, options);
+    const req = url.startsWith("https:") ? import_https.default.request(requestOptions, (res) => resolve(res)) : import_http.default.request(requestOptions, (res) => resolve(res));
+    req.on("error", (error) => reject(error));
+    req.end();
+  });
+}
+function generateRedirectUrl(originalUrl, location) {
+  if (location.startsWith("http")) {
+    return location;
+  }
+  const url = new URL(originalUrl);
+  url.pathname = location;
+  return url.href;
+}
+function getRequestOptions(url, options) {
+  const originalHeaders = options?.headers || {};
+  const headers = {};
+  for (const key of Object.keys(originalHeaders)) {
+    headers[key.toLowerCase()] = originalHeaders[key];
+  }
+  headers["accept-encoding"] = headers["accept-encoding"] || "gzip,br,deflate";
+  const urlObject = new URL(url);
+  return {
+    hostname: urlObject.hostname,
+    path: urlObject.pathname,
+    method: "GET",
+    // Add options and user provided 'options.fetch' overrides if available
+    ...options,
+    ...options?.fetch,
+    // Override with updated headers with accepted encodings:
+    headers,
+    port: urlObject.port
+  };
+}
+function getStatus(httpResponse) {
+  if (httpResponse.statusCode) {
+    return { status: httpResponse.statusCode, statusText: httpResponse.statusMessage || "NA" };
+  }
+  return { status: 200, statusText: "OK" };
+}
+function getHeaders(url, httpResponse, additionalHeaders = {}) {
+  const headers = {};
+  if (httpResponse && httpResponse.headers) {
+    const httpHeaders = httpResponse.headers;
+    for (const key in httpHeaders) {
+      const header = httpHeaders[key];
+      headers[key.toLowerCase()] = String(header);
+    }
+  }
+  if (!headers["content-length"]) {
+    const contentLength = getContentLength(url);
+    if (Number.isFinite(contentLength)) {
+      headers["content-length"] = contentLength;
+    }
+  }
+  Object.assign(headers, additionalHeaders);
+  return new Headers2(headers);
+}
+function getContentLength(url) {
+  return isDataURL(url) ? url.length - "data:".length : null;
+}
+
+// src/polyfills/index.ts
+var nodeVersion = parseInt(import_node_process.versions.node.split(".")[0]);
+if (isBrowser) {
+  console.error(
+    "loaders.gl: The @loaders.gl/core/polyfills should only be used in Node.js environments"
+  );
+}
+globalThis.loaders = globalThis.loaders || {};
+globalThis.loaders.makeNodeStream = makeNodeStream;
+globalThis.loaders.NodeFile = NodeFile;
+globalThis.loaders.NodeFileSystem = NodeFileSystem;
+globalThis.loaders.fetchNode = fetchNode;
+globalThis.loaders.NodeHash = NodeHash;
+if (!globalThis.TextEncoder) {
+  globalThis.TextEncoder = TextEncoder2;
+}
+if (!globalThis.TextDecoder) {
+  globalThis.TextDecoder = TextDecoder2;
+}
+if (!globalThis.ReadableStream) {
+  globalThis.ReadableStream = import_web2.ReadableStream;
+}
+if (!("atob" in globalThis) && atob) {
+  globalThis["atob"] = atob;
+}
+if (!("btoa" in globalThis) && btoa) {
+  globalThis["btoa"] = btoa;
+}
+globalThis.loaders.encodeImageNode = encodeImageNode2;
+globalThis.loaders.parseImageNode = parseImageNode2;
+globalThis.loaders.imageFormatsNode = NODE_FORMAT_SUPPORT;
+globalThis.loaders.createImageBitmapNode = createImageBitmapNode;
+globalThis.loaders.getImageBitmapDataNode = getImageBitmapDataNode;
+globalThis.loaders.isImageBitmapNode = isNodeImageBitmap;
+if (!globalThis.ImageBitmap) {
+  globalThis.ImageBitmap = NodeImageBitmap;
+}
+if (!("getImageBitmapData" in globalThis)) {
+  globalThis.getImageBitmapData = getImageBitmapDataNode;
+}
+globalThis._parseImageNode = parseImageNode2;
+globalThis._imageFormatsNode = NODE_FORMAT_SUPPORT;
+globalThis.loaders.readFileAsArrayBuffer = readFileAsArrayBuffer;
+globalThis.loaders.readFileAsText = readFileAsText;
+globalThis.loaders.requireFromFile = requireFromFile;
+globalThis.loaders.requireFromString = requireFromString;
+if (nodeVersion < 18) {
+  if (!("Headers" in globalThis) && Headers2) {
+    globalThis.Headers = Headers2;
+  }
+  if (!("Response" in globalThis) && Response2) {
+    globalThis.Response = Response2;
+  }
+  if (!("fetch" in globalThis) && fetchNode2) {
+    globalThis.fetch = fetchNode2;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Blob,
+  File,
+  addAliases,
+  installFilePolyfills,
+  makeNodeStream,
+  nodeVersion,
+  setPathPrefix
+});