@loaders.gl/tile-converter 4.0.0-alpha.21 → 4.0.0-alpha.22

package/dist/dist.min.js

@@ -18286,9 +18286,9 @@ var require_pako = __commonJS({
     var deflate = require_deflate2();
     var inflate = require_inflate2();
     var constants = require_constants3();
-    var pako = {};
-    assign(pako, deflate, inflate, constants);
-    module2.exports = pako;
+    var pako2 = {};
+    assign(pako2, deflate, inflate, constants);
+    module2.exports = pako2;
   }
 });
 
@@ -18297,7 +18297,7 @@ var require_flate = __commonJS({
   "../../node_modules/jszip/lib/flate.js"(exports) {
     "use strict";
     var USE_TYPEDARRAY = typeof Uint8Array !== "undefined" && typeof Uint16Array !== "undefined" && typeof Uint32Array !== "undefined";
-    var pako = require_pako();
+    var pako2 = require_pako();
     var utils = require_utils();
     var GenericWorker = require_GenericWorker();
     var ARRAY_TYPE = USE_TYPEDARRAY ? "uint8array" : "array";
@@ -18329,7 +18329,7 @@ var require_flate = __commonJS({
       this._pako = null;
     };
     FlateWorker.prototype._createPako = function() {
-      this._pako = new pako[this._pakoAction]({
+      this._pako = new pako2[this._pakoAction]({
         raw: true,
         level: this._pakoOptions.level || -1
       });
@@ -18389,7 +18389,7 @@ var require_ZipFileWorker = __commonJS({
     var GenericWorker = require_GenericWorker();
     var utf8 = require_utf8();
     var crc32 = require_crc32();
-    var signature = require_signature();
+    var signature3 = require_signature();
     var decToHex = function(dec, bytes) {
       var hex = "", i;
       for (i = 0; i < bytes; i++) {
@@ -18468,8 +18468,8 @@ var require_ZipFileWorker = __commonJS({
       header += decToHex(dataInfo.uncompressedSize, 4);
       header += decToHex(encodedFileName.length, 2);
       header += decToHex(extraFields.length, 2);
-      var fileRecord = signature.LOCAL_FILE_HEADER + header + encodedFileName + extraFields;
-      var dirRecord = signature.CENTRAL_FILE_HEADER + decToHex(versionMadeBy, 2) + header + decToHex(encodedComment.length, 2) + "\0\0\0\0" + decToHex(extFileAttr, 4) + decToHex(offset, 4) + encodedFileName + extraFields + encodedComment;
+      var fileRecord = signature3.LOCAL_FILE_HEADER + header + encodedFileName + extraFields;
+      var dirRecord = signature3.CENTRAL_FILE_HEADER + decToHex(versionMadeBy, 2) + header + decToHex(encodedComment.length, 2) + "\0\0\0\0" + decToHex(extFileAttr, 4) + decToHex(offset, 4) + encodedFileName + extraFields + encodedComment;
       return {
         fileRecord,
         dirRecord
@@ -18478,12 +18478,12 @@ var require_ZipFileWorker = __commonJS({
     var generateCentralDirectoryEnd = function(entriesCount, centralDirLength, localDirLength, comment, encodeFileName) {
       var dirEnd = "";
       var encodedComment = utils.transformTo("string", encodeFileName(comment));
-      dirEnd = signature.CENTRAL_DIRECTORY_END + "\0\0\0\0" + decToHex(entriesCount, 2) + decToHex(entriesCount, 2) + decToHex(centralDirLength, 4) + decToHex(localDirLength, 4) + decToHex(encodedComment.length, 2) + encodedComment;
+      dirEnd = signature3.CENTRAL_DIRECTORY_END + "\0\0\0\0" + decToHex(entriesCount, 2) + decToHex(entriesCount, 2) + decToHex(centralDirLength, 4) + decToHex(localDirLength, 4) + decToHex(encodedComment.length, 2) + encodedComment;
       return dirEnd;
     };
     var generateDataDescriptors = function(streamInfo) {
       var descriptor = "";
-      descriptor = signature.DATA_DESCRIPTOR + decToHex(streamInfo["crc32"], 4) + decToHex(streamInfo["compressedSize"], 4) + decToHex(streamInfo["uncompressedSize"], 4);
+      descriptor = signature3.DATA_DESCRIPTOR + decToHex(streamInfo["crc32"], 4) + decToHex(streamInfo["compressedSize"], 4) + decToHex(streamInfo["uncompressedSize"], 4);
       return descriptor;
     };
     function ZipFileWorker(streamFiles, comment, platform, encodeFileName) {
@@ -19349,15 +19349,15 @@ var require_zipEntries = __commonJS({
       checkSignature: function(expectedSignature) {
         if (!this.reader.readAndCheckSignature(expectedSignature)) {
           this.reader.index -= 4;
-          var signature = this.reader.readString(4);
-          throw new Error("Corrupted zip or bug: unexpected signature (" + utils.pretty(signature) + ", expected " + utils.pretty(expectedSignature) + ")");
+          var signature3 = this.reader.readString(4);
+          throw new Error("Corrupted zip or bug: unexpected signature (" + utils.pretty(signature3) + ", expected " + utils.pretty(expectedSignature) + ")");
         }
       },
       isSignature: function(askedIndex, expectedSignature) {
         var currentIndex = this.reader.index;
         this.reader.setIndex(askedIndex);
-        var signature = this.reader.readString(4);
-        var result = signature === expectedSignature;
+        var signature3 = this.reader.readString(4);
+        var result = signature3 === expectedSignature;
         this.reader.setIndex(currentIndex);
         return result;
       },
@@ -19730,7 +19730,7 @@ var require_is_buffer = __commonJS({
 var require_md5 = __commonJS({
   "../../node_modules/md5/md5.js"(exports, module2) {
     (function() {
-      var crypt2 = require_crypt(), utf8 = require_charenc().utf8, isBuffer3 = require_is_buffer(), bin = require_charenc().bin, md53 = function(message, options) {
+      var crypt2 = require_crypt(), utf8 = require_charenc().utf8, isBuffer3 = require_is_buffer(), bin = require_charenc().bin, md55 = function(message, options) {
         if (message.constructor == String)
           if (options && options.encoding === "binary")
             message = bin.stringToBytes(message);
@@ -19746,7 +19746,7 @@ var require_md5 = __commonJS({
         }
         m[l >>> 5] |= 128 << l % 32;
         m[(l + 64 >>> 9 << 4) + 14] = l;
-        var FF = md53._ff, GG = md53._gg, HH = md53._hh, II = md53._ii;
+        var FF = md55._ff, GG = md55._gg, HH = md55._hh, II = md55._ii;
         for (var i = 0; i < m.length; i += 16) {
           var aa = a, bb = b, cc = c, dd = d;
           a = FF(a, b, c, d, m[i + 0], 7, -680876936);
@@ -19820,28 +19820,28 @@ var require_md5 = __commonJS({
         }
         return crypt2.endian([a, b, c, d]);
       };
-      md53._ff = function(a, b, c, d, x, s, t) {
+      md55._ff = function(a, b, c, d, x, s, t) {
         var n = a + (b & c | ~b & d) + (x >>> 0) + t;
         return (n << s | n >>> 32 - s) + b;
       };
-      md53._gg = function(a, b, c, d, x, s, t) {
+      md55._gg = function(a, b, c, d, x, s, t) {
         var n = a + (b & d | c & ~d) + (x >>> 0) + t;
         return (n << s | n >>> 32 - s) + b;
       };
-      md53._hh = function(a, b, c, d, x, s, t) {
+      md55._hh = function(a, b, c, d, x, s, t) {
         var n = a + (b ^ c ^ d) + (x >>> 0) + t;
         return (n << s | n >>> 32 - s) + b;
       };
-      md53._ii = function(a, b, c, d, x, s, t) {
+      md55._ii = function(a, b, c, d, x, s, t) {
         var n = a + (c ^ (b | ~d)) + (x >>> 0) + t;
         return (n << s | n >>> 32 - s) + b;
       };
-      md53._blocksize = 16;
-      md53._digestsize = 16;
+      md55._blocksize = 16;
+      md55._digestsize = 16;
       module2.exports = function(message, options) {
         if (message === void 0 || message === null)
           throw new Error("Illegal argument " + message);
-        var digestbytes = crypt2.wordsToBytes(md53(message, options));
+        var digestbytes = crypt2.wordsToBytes(md55(message, options));
         return options && options.asBytes ? digestbytes : options && options.asString ? bin.bytesToString(digestbytes) : crypt2.bytesToHex(digestbytes);
       };
     })();
@@ -20124,7 +20124,7 @@ var require_md52 = __commonJS({
     function _interopRequireDefault(obj) {
       return obj && obj.__esModule ? obj : { default: obj };
     }
-    function md53(bytes) {
+    function md55(bytes) {
       if (Array.isArray(bytes)) {
         bytes = Buffer.from(bytes);
       } else if (typeof bytes === "string") {
@@ -20132,7 +20132,7 @@ var require_md52 = __commonJS({
       }
       return _crypto.default.createHash("md5").update(bytes).digest();
     }
-    var _default = md53;
+    var _default = md55;
     exports.default = _default;
   }
 });
@@ -21271,7 +21271,7 @@ var require_readdir_glob = __commonJS({
         });
       });
     }
-    function stat2(file, followSymlinks) {
+    function stat3(file, followSymlinks) {
       return new Promise((resolve3, reject) => {
         const statFunc = followSymlinks ? fs6.stat : fs6.lstat;
         statFunc(file, (err, stats) => {
@@ -21279,7 +21279,7 @@ var require_readdir_glob = __commonJS({
             switch (err.code) {
               case "ENOENT":
                 if (followSymlinks) {
-                  resolve3(stat2(file, false));
+                  resolve3(stat3(file, false));
                 } else {
                   resolve3(null);
                 }
@@ -21307,7 +21307,7 @@ var require_readdir_glob = __commonJS({
         const absolute = path2 + "/" + relative;
         let stats = null;
         if (useStat || followSymlinks) {
-          stats = await stat2(absolute, followSymlinks);
+          stats = await stat3(absolute, followSymlinks);
         }
         if (!stats && file.name !== void 0) {
           stats = file;
@@ -23465,7 +23465,7 @@ var require_polyfills = __commonJS({
         }(fs6.rename);
       }
       fs6.read = typeof fs6.read !== "function" ? fs6.read : function(fs$read) {
-        function read3(fd, buffer, offset, length, position, callback_) {
+        function read4(fd, buffer, offset, length, position, callback_) {
           var callback;
           if (callback_ && typeof callback_ === "function") {
             var eagCounter = 0;
@@ -23480,8 +23480,8 @@ var require_polyfills = __commonJS({
           return fs$read.call(fs6, fd, buffer, offset, length, position, callback);
         }
         if (Object.setPrototypeOf)
-          Object.setPrototypeOf(read3, fs$read);
-        return read3;
+          Object.setPrototypeOf(read4, fs$read);
+        return read4;
       }(fs6.read);
       fs6.readSync = typeof fs6.readSync !== "function" ? fs6.readSync : function(fs$readSync) {
         return function(fd, buffer, offset, length, position) {
@@ -23840,7 +23840,7 @@ var require_graceful_fs = __commonJS({
       queue = global[gracefulQueue] || [];
       publishQueue(fs6, queue);
       fs6.close = function(fs$close) {
-        function close2(fd, cb) {
+        function close3(fd, cb) {
           return fs$close.call(fs6, fd, function(err) {
             if (!err) {
               resetQueue();
@@ -23849,10 +23849,10 @@ var require_graceful_fs = __commonJS({
               cb.apply(this, arguments);
           });
         }
-        Object.defineProperty(close2, previousSymbol, {
+        Object.defineProperty(close3, previousSymbol, {
           value: fs$close
         });
-        return close2;
+        return close3;
       }(fs6.close);
       fs6.closeSync = function(fs$closeSync) {
         function closeSync(fd) {
@@ -24053,7 +24053,7 @@ var require_graceful_fs = __commonJS({
       }
       function ReadStream$open() {
         var that = this;
-        open2(that.path, that.flags, that.mode, function(err, fd) {
+        open3(that.path, that.flags, that.mode, function(err, fd) {
           if (err) {
             if (that.autoClose)
               that.destroy();
@@ -24073,7 +24073,7 @@ var require_graceful_fs = __commonJS({
       }
       function WriteStream$open() {
         var that = this;
-        open2(that.path, that.flags, that.mode, function(err, fd) {
+        open3(that.path, that.flags, that.mode, function(err, fd) {
           if (err) {
             that.destroy();
             that.emit("error", err);
@@ -24090,8 +24090,8 @@ var require_graceful_fs = __commonJS({
         return new fs7.WriteStream(path2, options);
       }
       var fs$open = fs7.open;
-      fs7.open = open2;
-      function open2(path2, flags, mode, cb) {
+      fs7.open = open3;
+      function open3(path2, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
         return go$open(path2, flags, mode, cb);
@@ -25431,8 +25431,8 @@ var require_old = __commonJS({
         if (cache3 && Object.prototype.hasOwnProperty.call(cache3, base)) {
           resolvedLink = cache3[base];
         } else {
-          var stat2 = fs6.lstatSync(base);
-          if (!stat2.isSymbolicLink()) {
+          var stat3 = fs6.lstatSync(base);
+          if (!stat3.isSymbolicLink()) {
             knownHard[base] = true;
             if (cache3)
               cache3[base] = base;
@@ -25440,7 +25440,7 @@ var require_old = __commonJS({
           }
           var linkTarget = null;
           if (!isWindows) {
-            var id = stat2.dev.toString(32) + ":" + stat2.ino.toString(32);
+            var id = stat3.dev.toString(32) + ":" + stat3.ino.toString(32);
             if (seenLinks.hasOwnProperty(id)) {
               linkTarget = seenLinks[id];
             }
@@ -25514,17 +25514,17 @@ var require_old = __commonJS({
         }
         return fs6.lstat(base, gotStat);
       }
-      function gotStat(err, stat2) {
+      function gotStat(err, stat3) {
         if (err)
           return cb(err);
-        if (!stat2.isSymbolicLink()) {
+        if (!stat3.isSymbolicLink()) {
           knownHard[base] = true;
           if (cache3)
             cache3[base] = base;
           return process.nextTick(LOOP);
         }
         if (!isWindows) {
-          var id = stat2.dev.toString(32) + ":" + stat2.ino.toString(32);
+          var id = stat3.dev.toString(32) + ":" + stat3.ino.toString(32);
           if (seenLinks.hasOwnProperty(id)) {
             return gotTarget(null, seenLinks[id], base);
           }
@@ -26661,27 +26661,27 @@ var require_sync = __commonJS({
           break;
       }
       var remain = pattern.slice(n);
-      var read3;
+      var read4;
       if (prefix === null)
-        read3 = ".";
+        read4 = ".";
       else if (isAbsolute2(prefix) || isAbsolute2(pattern.map(function(p) {
         return typeof p === "string" ? p : "[*]";
       }).join("/"))) {
         if (!prefix || !isAbsolute2(prefix))
           prefix = "/" + prefix;
-        read3 = prefix;
+        read4 = prefix;
       } else
-        read3 = prefix;
-      var abs = this._makeAbs(read3);
-      if (childrenIgnored(this, read3))
+        read4 = prefix;
+      var abs = this._makeAbs(read4);
+      if (childrenIgnored(this, read4))
         return;
       var isGlobStar = remain[0] === minimatch.GLOBSTAR;
       if (isGlobStar)
-        this._processGlobStar(prefix, read3, abs, remain, index, inGlobStar);
+        this._processGlobStar(prefix, read4, abs, remain, index, inGlobStar);
       else
-        this._processReaddir(prefix, read3, abs, remain, index, inGlobStar);
+        this._processReaddir(prefix, read4, abs, remain, index, inGlobStar);
     };
-    GlobSync.prototype._processReaddir = function(prefix, read3, abs, remain, index, inGlobStar) {
+    GlobSync.prototype._processReaddir = function(prefix, read4, abs, remain, index, inGlobStar) {
       var entries = this._readdir(abs, inGlobStar);
       if (!entries)
         return;
@@ -26760,7 +26760,7 @@ var require_sync = __commonJS({
         return this._readdir(abs, false);
       var entries;
       var lstat;
-      var stat2;
+      var stat3;
       try {
         lstat = this.fs.lstatSync(abs);
       } catch (er) {
@@ -26836,7 +26836,7 @@ var require_sync = __commonJS({
           break;
       }
     };
-    GlobSync.prototype._processGlobStar = function(prefix, read3, abs, remain, index, inGlobStar) {
+    GlobSync.prototype._processGlobStar = function(prefix, read4, abs, remain, index, inGlobStar) {
       var entries = this._readdir(abs, inGlobStar);
       if (!entries)
         return;
@@ -26893,8 +26893,8 @@ var require_sync = __commonJS({
           return false;
       }
       var exists;
-      var stat2 = this.statCache[abs];
-      if (!stat2) {
+      var stat3 = this.statCache[abs];
+      if (!stat3) {
         var lstat;
         try {
           lstat = this.fs.lstatSync(abs);
@@ -26906,18 +26906,18 @@ var require_sync = __commonJS({
         }
         if (lstat && lstat.isSymbolicLink()) {
           try {
-            stat2 = this.fs.statSync(abs);
+            stat3 = this.fs.statSync(abs);
           } catch (er) {
-            stat2 = lstat;
+            stat3 = lstat;
           }
         } else {
-          stat2 = lstat;
+          stat3 = lstat;
         }
       }
-      this.statCache[abs] = stat2;
+      this.statCache[abs] = stat3;
       var c = true;
-      if (stat2)
-        c = stat2.isDirectory() ? "DIR" : "FILE";
+      if (stat3)
+        c = stat3.isDirectory() ? "DIR" : "FILE";
       this.cache[abs] = this.cache[abs] || c;
       if (needDir && c === "FILE")
         return false;
@@ -27285,33 +27285,33 @@ var require_glob = __commonJS({
           break;
       }
       var remain = pattern.slice(n);
-      var read3;
+      var read4;
       if (prefix === null)
-        read3 = ".";
+        read4 = ".";
       else if (isAbsolute2(prefix) || isAbsolute2(pattern.map(function(p) {
         return typeof p === "string" ? p : "[*]";
       }).join("/"))) {
         if (!prefix || !isAbsolute2(prefix))
           prefix = "/" + prefix;
-        read3 = prefix;
+        read4 = prefix;
       } else
-        read3 = prefix;
-      var abs = this._makeAbs(read3);
-      if (childrenIgnored(this, read3))
+        read4 = prefix;
+      var abs = this._makeAbs(read4);
+      if (childrenIgnored(this, read4))
         return cb();
       var isGlobStar = remain[0] === minimatch.GLOBSTAR;
       if (isGlobStar)
-        this._processGlobStar(prefix, read3, abs, remain, index, inGlobStar, cb);
+        this._processGlobStar(prefix, read4, abs, remain, index, inGlobStar, cb);
       else
-        this._processReaddir(prefix, read3, abs, remain, index, inGlobStar, cb);
+        this._processReaddir(prefix, read4, abs, remain, index, inGlobStar, cb);
     };
-    Glob.prototype._processReaddir = function(prefix, read3, abs, remain, index, inGlobStar, cb) {
+    Glob.prototype._processReaddir = function(prefix, read4, abs, remain, index, inGlobStar, cb) {
       var self2 = this;
       this._readdir(abs, inGlobStar, function(er, entries) {
-        return self2._processReaddir2(prefix, read3, abs, remain, index, inGlobStar, entries, cb);
+        return self2._processReaddir2(prefix, read4, abs, remain, index, inGlobStar, entries, cb);
       });
     };
-    Glob.prototype._processReaddir2 = function(prefix, read3, abs, remain, index, inGlobStar, entries, cb) {
+    Glob.prototype._processReaddir2 = function(prefix, read4, abs, remain, index, inGlobStar, entries, cb) {
       if (!entries)
         return cb();
       var pn = remain[0];
@@ -27492,13 +27492,13 @@ var require_glob = __commonJS({
       }
       return cb();
     };
-    Glob.prototype._processGlobStar = function(prefix, read3, abs, remain, index, inGlobStar, cb) {
+    Glob.prototype._processGlobStar = function(prefix, read4, abs, remain, index, inGlobStar, cb) {
       var self2 = this;
       this._readdir(abs, inGlobStar, function(er, entries) {
-        self2._processGlobStar2(prefix, read3, abs, remain, index, inGlobStar, entries, cb);
+        self2._processGlobStar2(prefix, read4, abs, remain, index, inGlobStar, entries, cb);
       });
     };
-    Glob.prototype._processGlobStar2 = function(prefix, read3, abs, remain, index, inGlobStar, entries, cb) {
+    Glob.prototype._processGlobStar2 = function(prefix, read4, abs, remain, index, inGlobStar, entries, cb) {
       if (!entries)
         return cb();
       var remainWithoutGlobStar = remain.slice(1);
@@ -27561,16 +27561,16 @@ var require_glob = __commonJS({
           return cb();
       }
       var exists;
-      var stat2 = this.statCache[abs];
-      if (stat2 !== void 0) {
-        if (stat2 === false)
-          return cb(null, stat2);
+      var stat3 = this.statCache[abs];
+      if (stat3 !== void 0) {
+        if (stat3 === false)
+          return cb(null, stat3);
         else {
-          var type = stat2.isDirectory() ? "DIR" : "FILE";
+          var type = stat3.isDirectory() ? "DIR" : "FILE";
           if (needDir && type === "FILE")
             return cb();
           else
-            return cb(null, type, stat2);
+            return cb(null, type, stat3);
         }
       }
       var self2 = this;
@@ -27579,33 +27579,33 @@ var require_glob = __commonJS({
         self2.fs.lstat(abs, statcb);
       function lstatcb_(er, lstat) {
         if (lstat && lstat.isSymbolicLink()) {
-          return self2.fs.stat(abs, function(er2, stat3) {
+          return self2.fs.stat(abs, function(er2, stat4) {
             if (er2)
               self2._stat2(f, abs, null, lstat, cb);
             else
-              self2._stat2(f, abs, er2, stat3, cb);
+              self2._stat2(f, abs, er2, stat4, cb);
           });
         } else {
           self2._stat2(f, abs, er, lstat, cb);
         }
       }
     };
-    Glob.prototype._stat2 = function(f, abs, er, stat2, cb) {
+    Glob.prototype._stat2 = function(f, abs, er, stat3, cb) {
       if (er && (er.code === "ENOENT" || er.code === "ENOTDIR")) {
         this.statCache[abs] = false;
         return cb();
       }
       var needDir = f.slice(-1) === "/";
-      this.statCache[abs] = stat2;
-      if (abs.slice(-1) === "/" && stat2 && !stat2.isDirectory())
-        return cb(null, false, stat2);
+      this.statCache[abs] = stat3;
+      if (abs.slice(-1) === "/" && stat3 && !stat3.isDirectory())
+        return cb(null, false, stat3);
       var c = true;
-      if (stat2)
-        c = stat2.isDirectory() ? "DIR" : "FILE";
+      if (stat3)
+        c = stat3.isDirectory() ? "DIR" : "FILE";
       this.cache[abs] = this.cache[abs] || c;
       if (needDir && c === "FILE")
         return cb();
-      return cb(null, c, stat2);
+      return cb(null, c, stat3);
     };
   }
 });
@@ -44982,7 +44982,7 @@ var require_tar_stream = __commonJS({
 // ../../node_modules/archiver/lib/plugins/tar.js
 var require_tar = __commonJS({
   "../../node_modules/archiver/lib/plugins/tar.js"(exports, module2) {
-    var zlib = require("zlib");
+    var zlib2 = require("zlib");
     var engine = require_tar_stream();
     var util = require_archiver_utils();
     var Tar = function(options) {
@@ -45002,7 +45002,7 @@ var require_tar = __commonJS({
       this.engine = engine.pack(options);
       this.compressor = false;
       if (options.gzip) {
-        this.compressor = zlib.createGzip(options.gzipOptions);
+        this.compressor = zlib2.createGzip(options.gzipOptions);
         this.compressor.on("error", this._onCompressorError.bind(this));
       }
     };
@@ -46555,6 +46555,11 @@ __export(exports, {
   Tiles3DConverter: () => Tiles3DConverter
 });
 
+// ../loader-utils/src/loader-types.ts
+async function parseFromContext(data, loaders, options, context) {
+  return context._parse(data, loaders, options, context);
+}
+
 // ../loader-utils/src/lib/env-utils/assert.ts
 function assert2(condition, message) {
   if (!condition) {
@@ -47683,6 +47688,9 @@ function toArrayBuffer2(data) {
 }
 
 // ../loader-utils/src/lib/node/promisify.ts
+function promisify1(fn) {
+  return (args) => new Promise((resolve2, reject) => fn(args, (error, callbackArgs) => error ? reject(error) : resolve2(callbackArgs)));
+}
 function promisify2(fn) {
   return (arg1, arg2) => new Promise((resolve2, reject) => fn(arg1, arg2, (error, callbackArgs) => error ? reject(error) : resolve2(callbackArgs)));
 }
@@ -48748,11 +48756,11 @@ function getGlobalLoaderState() {
   loaders._state = loaders._state || {};
   return loaders._state;
 }
-var getGlobalLoaderOptions = () => {
+function getGlobalLoaderOptions() {
   const state = getGlobalLoaderState();
   state.globalOptions = state.globalOptions || { ...DEFAULT_LOADER_OPTIONS };
   return state.globalOptions;
-};
+}
 function normalizeOptions(options, loader, loaders, url) {
   loaders = loaders || [];
   loaders = Array.isArray(loaders) ? loaders : [loaders];
@@ -48935,8 +48943,10 @@ function selectLoaderInternal(data, loaders, options, context) {
   reason = reason || (loader ? `matched MIME type ${type}` : "");
   loader = loader || findLoaderByInitialBytes(loaders, data);
   reason = reason || (loader ? `matched initial data ${getFirstCharacters2(data)}` : "");
-  loader = loader || findLoaderByMIMEType(loaders, options?.fallbackMimeType);
-  reason = reason || (loader ? `matched fallback MIME type ${type}` : "");
+  if (options?.fallbackMimeType) {
+    loader = loader || findLoaderByMIMEType(loaders, options?.fallbackMimeType);
+    reason = reason || (loader ? `matched fallback MIME type ${type}` : "");
+  }
   if (reason) {
     log.log(1, `selectLoader selected ${loader?.name}: ${reason}.`);
   }
@@ -49032,7 +49042,7 @@ function testBinary(data, byteOffset, loader, test) {
   }
   switch (typeof test) {
     case "function":
-      return test(data, loader);
+      return test(data);
     case "string":
       const magic = getMagicString2(data, byteOffset, test.length);
       return test === magic;
@@ -49247,7 +49257,7 @@ function getLoaderContext(context, options, parentContext) {
   return newContext;
 }
 function getLoadersFromContext(loaders, context) {
-  if (!context && loaders && !Array.isArray(loaders)) {
+  if (loaders && !Array.isArray(loaders)) {
     return loaders;
   }
   let candidateLoaders;
@@ -49258,12 +49268,11 @@ function getLoadersFromContext(loaders, context) {
     const contextLoaders = Array.isArray(context.loaders) ? context.loaders : [context.loaders];
     candidateLoaders = candidateLoaders ? [...candidateLoaders, ...contextLoaders] : contextLoaders;
   }
-  return candidateLoaders && candidateLoaders.length ? candidateLoaders : null;
+  return candidateLoaders && candidateLoaders.length ? candidateLoaders : void 0;
 }
 
 // ../core/src/lib/api/parse.ts
 async function parse(data, loaders, options, context) {
-  assert3(!context || typeof context === "object");
   if (loaders && !Array.isArray(loaders) && !isLoaderObject(loaders)) {
     context = void 0;
     options = loaders;
@@ -49279,7 +49288,7 @@ async function parse(data, loaders, options, context) {
     return null;
   }
   options = normalizeOptions(options, loader, candidateLoaders, url);
-  context = getLoaderContext({ url, parse, loaders: candidateLoaders }, options, context || null);
+  context = getLoaderContext({ url, _parse: parse, loaders: candidateLoaders }, options, context || null);
   return await parseWithLoader(loader, data, options, context);
 }
 async function parseWithLoader(loader, data, options, context) {
@@ -51191,7 +51200,6 @@ async function loadDraco(tile, dracoData, options, context) {
   if (!context) {
     return;
   }
-  const { parse: parse7 } = context;
   const dracoOptions = {
     ...options,
     draco: {
@@ -51200,7 +51208,7 @@ async function loadDraco(tile, dracoData, options, context) {
     }
   };
   delete dracoOptions["3d-tiles"];
-  const data = await parse7(dracoData.buffer, DracoLoader2, dracoOptions);
+  const data = await parseFromContext(dracoData.buffer, DracoLoader2, dracoOptions, context);
   const decodedPositions = data.attributes.POSITION && data.attributes.POSITION.value;
   const decodedColors = data.attributes.COLOR_0 && data.attributes.COLOR_0.value;
   const decodedNormals = data.attributes.NORMAL && data.attributes.NORMAL.value;
@@ -53610,10 +53618,9 @@ async function decompressPrimitive(scenegraph, primitive, options, context) {
   }
   const buffer = scenegraph.getTypedArrayForBufferView(dracoExtension.bufferView);
   const bufferCopy = sliceArrayBuffer(buffer.buffer, buffer.byteOffset);
-  const { parse: parse7 } = context;
   const dracoOptions = { ...options };
   delete dracoOptions["3d-tiles"];
-  const decodedData = await parse7(bufferCopy, DracoLoader2, dracoOptions, context);
+  const decodedData = await parseFromContext(bufferCopy, DracoLoader2, dracoOptions, context);
   const decodedAttributes = getGLTFAccessors(decodedData.attributes);
   for (const [attributeName, decodedAttribute] of Object.entries(decodedAttributes)) {
     if (attributeName in primitive.attributes) {
@@ -54523,10 +54530,10 @@ function getReferencesImageIndices(gltf) {
   return Array.from(imageIndices).sort();
 }
 async function loadImage(gltf, image, index, options, context) {
-  const { fetch: fetch2, parse: parse7 } = context;
   let arrayBuffer;
   if (image.uri && !image.hasOwnProperty("bufferView")) {
     const uri = resolveUrl(image.uri, options);
+    const { fetch: fetch2 } = context;
     const response = await fetch2(uri);
     arrayBuffer = await response.arrayBuffer();
     image.bufferView = {
@@ -54538,7 +54545,7 @@ async function loadImage(gltf, image, index, options, context) {
     arrayBuffer = sliceArrayBuffer(array.buffer, array.byteOffset, array.byteLength);
   }
   assert6(arrayBuffer, "glTF image has no data");
-  let parsedImage = await parse7(arrayBuffer, [ImageLoader, BasisLoader], {
+  let parsedImage = await parseFromContext(arrayBuffer, [ImageLoader, BasisLoader], {
     ...options,
     mimeType: image.mimeType,
     basis: options.basis || { format: selectSupportedBasisFormat() }
@@ -55072,14 +55079,14 @@ async function extractGLTF(tile, gltfFormat, options, context) {
     if (!context) {
       return;
     }
-    const { parse: parse7, fetch: fetch2 } = context;
     if (tile.gltfUrl) {
+      const { fetch: fetch2 } = context;
       const response = await fetch2(tile.gltfUrl, options);
       tile.gltfArrayBuffer = await response.arrayBuffer();
       tile.gltfByteOffset = 0;
     }
     if (tile.gltfArrayBuffer) {
-      const gltfWithBuffers = await parse7(tile.gltfArrayBuffer, GLTFLoader, options, context);
+      const gltfWithBuffers = await parseFromContext(tile.gltfArrayBuffer, GLTFLoader, options, context);
       tile.gltf = postProcessGLTF(gltfWithBuffers);
       tile.gpuMemoryUsageInBytes = getMemoryUsageGLTF(tile.gltf);
       delete tile.gltfArrayBuffer;
@@ -55278,13 +55285,12 @@ async function parseComposite3DTile(tile, arrayBuffer, byteOffset, options, cont
 // ../3d-tiles/src/lib/parsers/parse-3d-tile-gltf.ts
 async function parseGltf3DTile(tile, arrayBuffer, options, context) {
   tile.rotateYtoZ = true;
-  tile.gltfUpAxis = options?.["3d-tiles"] && options["3d-tiles"].assetGltfUpAxis ? options["3d-tiles"].assetGltfUpAxis : "Y";
+  tile.gltfUpAxis = options?.["3d-tiles"]?.assetGltfUpAxis ? options["3d-tiles"].assetGltfUpAxis : "Y";
   if (options?.["3d-tiles"]?.loadGLTF) {
     if (!context) {
       return;
     }
-    const { parse: parse7 } = context;
-    const gltfWithBuffers = await parse7(arrayBuffer, GLTFLoader, options, context);
+    const gltfWithBuffers = await parseFromContext(arrayBuffer, GLTFLoader, options, context);
     tile.gltf = postProcessGLTF(gltfWithBuffers);
     tile.gpuMemoryUsageInBytes = getMemoryUsageGLTF(tile.gltf);
   } else {
@@ -57346,7 +57352,7 @@ function resolveUri(uri = "", basePath) {
   } else if (uri.startsWith("/")) {
     return uri;
   }
-  return `${basePath}/${uri}`;
+  return path_exports.resolve(basePath, uri);
 }
 function normalizeTileData(tile, basePath) {
   if (!tile) {
@@ -57611,6 +57617,629 @@ var CesiumIonLoader = {
   }
 };
 
+// ../zip/src/file-provider/file-handle.ts
+var import_fs3 = __toModule(require("fs"));
+var _FileHandle = class {
+  constructor(fileDescriptor, stats) {
+    this.read = (buffer, offset, length, position) => {
+      return new Promise((s) => {
+        (0, import_fs3.read)(this.fileDescriptor, buffer, offset, length, position, (_err, bytesRead, buffer2) => s({ bytesRead, buffer: buffer2 }));
+      });
+    };
+    this.fileDescriptor = fileDescriptor;
+    this.stats = stats;
+  }
+  async close() {
+    return new Promise((resolve2) => {
+      (0, import_fs3.close)(this.fileDescriptor, (_err) => resolve2());
+    });
+  }
+  get stat() {
+    return this.stats;
+  }
+};
+var FileHandle = _FileHandle;
+FileHandle.open = async (path2) => {
+  const [fd, stats] = await Promise.all([
+    new Promise((s) => {
+      (0, import_fs3.open)(path2, void 0, void 0, (_err, fd2) => s(fd2));
+    }),
+    new Promise((s) => {
+      (0, import_fs3.stat)(path2, { bigint: true }, (_err, stats2) => s(stats2));
+    })
+  ]);
+  return new _FileHandle(fd, stats);
+};
+
+// ../zip/src/file-provider/file-handle-file.ts
+var FileHandleFile = class {
+  static async from(path2) {
+    const fileDescriptor = await FileHandle.open(path2);
+    return new FileHandleFile(fileDescriptor, fileDescriptor.stat.size);
+  }
+  constructor(fileDescriptor, size) {
+    this.fileDescriptor = fileDescriptor;
+    this.size = size;
+  }
+  async destroy() {
+    await this.fileDescriptor.close();
+  }
+  async getUint8(offset) {
+    const val = new Uint8Array((await this.fileDescriptor.read(Buffer.alloc(1), 0, 1, offset)).buffer.buffer).at(0);
+    if (val === void 0) {
+      throw new Error("something went wrong");
+    }
+    return val;
+  }
+  async getUint16(offset) {
+    const val = new Uint16Array((await this.fileDescriptor.read(Buffer.alloc(2), 0, 2, offset)).buffer.buffer).at(0);
+    if (val === void 0) {
+      throw new Error("something went wrong");
+    }
+    return val;
+  }
+  async getUint32(offset) {
+    const val = new Uint32Array((await this.fileDescriptor.read(Buffer.alloc(4), 0, 4, offset)).buffer.buffer).at(0);
+    if (val === void 0) {
+      throw new Error("something went wrong");
+    }
+    return val;
+  }
+  async getBigUint64(offset) {
+    const val = new BigInt64Array((await this.fileDescriptor.read(Buffer.alloc(8), 0, 8, offset)).buffer.buffer).at(0);
+    if (val === void 0) {
+      throw new Error("something went wrong");
+    }
+    return val;
+  }
+  async slice(startOffsset, endOffset) {
+    const bigLength = endOffset - startOffsset;
+    if (bigLength > Number.MAX_SAFE_INTEGER) {
+      throw new Error("too big slice");
+    }
+    const length = Number(bigLength);
+    return (await this.fileDescriptor.read(Buffer.alloc(length), 0, length, startOffsset)).buffer.buffer;
+  }
+  get length() {
+    return this.size;
+  }
+};
+
+// ../zip/src/parse-zip/search-from-the-end.ts
+var searchFromTheEnd = async (file, target) => {
+  const searchWindow = [
+    await file.getUint8(file.length - 1n),
+    await file.getUint8(file.length - 2n),
+    await file.getUint8(file.length - 3n),
+    void 0
+  ];
+  let targetOffset = 0n;
+  for (let i = file.length - 4n; i > -1; i--) {
+    searchWindow[3] = searchWindow[2];
+    searchWindow[2] = searchWindow[1];
+    searchWindow[1] = searchWindow[0];
+    searchWindow[0] = await file.getUint8(i);
+    if (searchWindow.every((val, index) => val === target[index])) {
+      targetOffset = i;
+      break;
+    }
+  }
+  return targetOffset;
+};
+
+// ../zip/src/parse-zip/end-of-central-directory.ts
+var eoCDSignature = [80, 75, 5, 6];
+var zip64EoCDLocatorSignature = Buffer.from([80, 75, 6, 7]);
+var zip64EoCDSignature = Buffer.from([80, 75, 6, 6]);
+var CD_RECORDS_NUMBER_OFFSET = 8n;
+var CD_START_OFFSET_OFFSET = 16n;
+var ZIP64_EOCD_START_OFFSET_OFFSET = 8n;
+var ZIP64_CD_RECORDS_NUMBER_OFFSET = 24n;
+var ZIP64_CD_START_OFFSET_OFFSET = 48n;
+var parseEoCDRecord = async (fileProvider) => {
+  const zipEoCDOffset = await searchFromTheEnd(fileProvider, eoCDSignature);
+  let cdRecordsNumber = BigInt(await fileProvider.getUint16(zipEoCDOffset + CD_RECORDS_NUMBER_OFFSET));
+  let cdStartOffset = BigInt(await fileProvider.getUint32(zipEoCDOffset + CD_START_OFFSET_OFFSET));
+  if (cdStartOffset === BigInt(4294967295) || cdRecordsNumber === BigInt(4294967295)) {
+    const zip64EoCDLocatorOffset = zipEoCDOffset - 20n;
+    if (Buffer.from(await fileProvider.slice(zip64EoCDLocatorOffset, zip64EoCDLocatorOffset + 4n)).compare(zip64EoCDLocatorSignature) !== 0) {
+      throw new Error("zip64 EoCD locator not found");
+    }
+    const zip64EoCDOffset = await fileProvider.getBigUint64(zip64EoCDLocatorOffset + ZIP64_EOCD_START_OFFSET_OFFSET);
+    if (Buffer.from(await fileProvider.slice(zip64EoCDOffset, zip64EoCDOffset + 4n)).compare(zip64EoCDSignature) !== 0) {
+      throw new Error("zip64 EoCD not found");
+    }
+    cdRecordsNumber = await fileProvider.getBigUint64(zip64EoCDOffset + ZIP64_CD_RECORDS_NUMBER_OFFSET);
+    cdStartOffset = await fileProvider.getBigUint64(zip64EoCDOffset + ZIP64_CD_START_OFFSET_OFFSET);
+  }
+  return {
+    cdRecordsNumber,
+    cdStartOffset
+  };
+};
+
+// ../zip/src/parse-zip/cd-file-header.ts
+var CD_COMPRESSED_SIZE_OFFSET = 20n;
+var CD_UNCOMPRESSED_SIZE_OFFSET = 24n;
+var CD_FILE_NAME_LENGTH_OFFSET = 28n;
+var CD_EXTRA_FIELD_LENGTH_OFFSET = 30n;
+var CD_LOCAL_HEADER_OFFSET_OFFSET = 42n;
+var CD_FILE_NAME_OFFSET = 46n;
+var signature = [80, 75, 1, 2];
+var parseZipCDFileHeader = async (headerOffset, buffer) => {
+  if (Buffer.from(await buffer.slice(headerOffset, headerOffset + 4n)).compare(Buffer.from(signature)) !== 0) {
+    return null;
+  }
+  let compressedSize = BigInt(await buffer.getUint32(headerOffset + CD_COMPRESSED_SIZE_OFFSET));
+  let uncompressedSize = BigInt(await buffer.getUint32(headerOffset + CD_UNCOMPRESSED_SIZE_OFFSET));
+  const extraFieldLength = await buffer.getUint16(headerOffset + CD_EXTRA_FIELD_LENGTH_OFFSET);
+  const fileNameLength = await buffer.getUint16(headerOffset + CD_FILE_NAME_LENGTH_OFFSET);
+  const fileName = new TextDecoder().decode(await buffer.slice(headerOffset + CD_FILE_NAME_OFFSET, headerOffset + CD_FILE_NAME_OFFSET + BigInt(fileNameLength)));
+  const extraOffset = headerOffset + CD_FILE_NAME_OFFSET + BigInt(fileNameLength);
+  const oldFormatOffset = await buffer.getUint32(headerOffset + CD_LOCAL_HEADER_OFFSET_OFFSET);
+  let fileDataOffset = BigInt(oldFormatOffset);
+  let offsetInZip64Data = 4n;
+  if (uncompressedSize === BigInt(4294967295)) {
+    uncompressedSize = await buffer.getBigUint64(extraOffset + offsetInZip64Data);
+    offsetInZip64Data += 8n;
+  }
+  if (compressedSize === BigInt(4294967295)) {
+    compressedSize = await buffer.getBigUint64(extraOffset + offsetInZip64Data);
+    offsetInZip64Data += 8n;
+  }
+  if (fileDataOffset === BigInt(4294967295)) {
+    fileDataOffset = await buffer.getBigUint64(extraOffset + offsetInZip64Data);
+  }
+  const localHeaderOffset = fileDataOffset;
+  return {
+    compressedSize,
+    uncompressedSize,
+    extraFieldLength,
+    fileNameLength,
+    fileName,
+    extraOffset,
+    localHeaderOffset
+  };
+};
+async function* zipCDFileHeaderGenerator(fileProvider) {
+  const { cdStartOffset } = await parseEoCDRecord(fileProvider);
+  let cdHeader = await parseZipCDFileHeader(cdStartOffset, fileProvider);
+  while (cdHeader) {
+    yield cdHeader;
+    cdHeader = await parseZipCDFileHeader(cdHeader.extraOffset + BigInt(cdHeader.extraFieldLength), fileProvider);
+  }
+}
+
+// ../zip/src/parse-zip/local-file-header.ts
+var COMPRESSION_METHOD_OFFSET = 8n;
+var COMPRESSED_SIZE_OFFSET = 18n;
+var UNCOMPRESSED_SIZE_OFFSET = 22n;
+var FILE_NAME_LENGTH_OFFSET = 26n;
+var EXTRA_FIELD_LENGTH_OFFSET = 28n;
+var FILE_NAME_OFFSET = 30n;
+var signature2 = Buffer.from([80, 75, 3, 4]);
+var parseZipLocalFileHeader = async (headerOffset, buffer) => {
+  if (Buffer.from(await buffer.slice(headerOffset, headerOffset + 4n)).compare(signature2) !== 0) {
+    return null;
+  }
+  const fileNameLength = await buffer.getUint16(headerOffset + FILE_NAME_LENGTH_OFFSET);
+  const fileName = new TextDecoder().decode(await buffer.slice(headerOffset + FILE_NAME_OFFSET, headerOffset + FILE_NAME_OFFSET + BigInt(fileNameLength))).split("\\").join("/");
+  const extraFieldLength = await buffer.getUint16(headerOffset + EXTRA_FIELD_LENGTH_OFFSET);
+  let fileDataOffset = headerOffset + FILE_NAME_OFFSET + BigInt(fileNameLength + extraFieldLength);
+  const compressionMethod = await buffer.getUint16(headerOffset + COMPRESSION_METHOD_OFFSET);
+  let compressedSize = BigInt(await buffer.getUint32(headerOffset + COMPRESSED_SIZE_OFFSET));
+  let uncompressedSize = BigInt(await buffer.getUint32(headerOffset + UNCOMPRESSED_SIZE_OFFSET));
+  const extraOffset = headerOffset + FILE_NAME_OFFSET + BigInt(fileNameLength);
+  let offsetInZip64Data = 4n;
+  if (uncompressedSize === BigInt(4294967295)) {
+    uncompressedSize = await buffer.getBigUint64(extraOffset + offsetInZip64Data);
+    offsetInZip64Data += 8n;
+  }
+  if (compressedSize === BigInt(4294967295)) {
+    compressedSize = await buffer.getBigUint64(extraOffset + offsetInZip64Data);
+    offsetInZip64Data += 8n;
+  }
+  if (fileDataOffset === BigInt(4294967295)) {
+    fileDataOffset = await buffer.getBigUint64(extraOffset + offsetInZip64Data);
+  }
+  return {
+    fileNameLength,
+    fileName,
+    extraFieldLength,
+    fileDataOffset,
+    compressedSize,
+    compressionMethod
+  };
+};
+
+// ../zip/src/hash-file-utility.ts
+var import_md5 = __toModule(require_md5());
+var compareHashes = (hash1, hash2) => {
+  const h1 = new BigUint64Array(hash1.buffer, hash1.byteOffset, 2);
+  const h2 = new BigUint64Array(hash2.buffer, hash2.byteOffset, 2);
+  const diff = h1[0] === h2[0] ? h1[1] - h2[1] : h1[0] - h2[0];
+  if (diff < 0n) {
+    return -1;
+  } else if (diff === 0n) {
+    return 0;
+  }
+  return 1;
+};
+var parseHashFile = (hashFile) => {
+  const hashFileBuffer = Buffer.from(hashFile);
+  const hashArray = [];
+  for (let i = 0; i < hashFileBuffer.buffer.byteLength; i = i + 24) {
+    const offsetBuffer = new DataView(hashFileBuffer.buffer.slice(hashFileBuffer.byteOffset + i + 16, hashFileBuffer.byteOffset + i + 24));
+    const offset = offsetBuffer.getBigUint64(offsetBuffer.byteOffset, true);
+    hashArray.push({
+      hash: Buffer.from(hashFileBuffer.subarray(hashFileBuffer.byteOffset + i, hashFileBuffer.byteOffset + i + 16)),
+      offset
+    });
+  }
+  return hashArray;
+};
+var findBin = (hashToSearch, hashArray) => {
+  let lowerBorder = 0;
+  let upperBorder = hashArray.length;
+  while (upperBorder - lowerBorder > 1) {
+    const middle = lowerBorder + Math.floor((upperBorder - lowerBorder) / 2);
+    const value = compareHashes(hashArray[middle].hash, hashToSearch);
+    if (value === 0) {
+      return hashArray[middle];
+    } else if (value < 0) {
+      lowerBorder = middle;
+    } else {
+      upperBorder = middle;
+    }
+  }
+  return void 0;
+};
+
+// ../zip/src/file-provider/file-provider.ts
+var isFileProvider = (fileProvider) => {
+  return fileProvider?.getUint8 && fileProvider?.slice && fileProvider?.length;
+};
+
+// ../compression/src/lib/compression.ts
+var Compression = class {
+  constructor(options) {
+    this.compressBatches = this.compressBatches.bind(this);
+    this.decompressBatches = this.decompressBatches.bind(this);
+  }
+  async preload() {
+    return;
+  }
+  async compress(input) {
+    await this.preload();
+    return this.compressSync(input);
+  }
+  async decompress(input, size) {
+    await this.preload();
+    return this.decompressSync(input, size);
+  }
+  compressSync(input) {
+    throw new Error(`${this.name}: sync compression not supported`);
+  }
+  decompressSync(input, size) {
+    throw new Error(`${this.name}: sync decompression not supported`);
+  }
+  async *compressBatches(asyncIterator) {
+    const input = await this.concatenate(asyncIterator);
+    yield this.compress(input);
+  }
+  async *decompressBatches(asyncIterator) {
+    const input = await this.concatenate(asyncIterator);
+    yield this.decompress(input);
+  }
+  concatenate(asyncIterator) {
+    return concatenateArrayBuffersAsync(asyncIterator);
+  }
+  improveError(error) {
+    if (!error.message.includes(this.name)) {
+      error.message = `${this.name} ${error.message}`;
+    }
+    return error;
+  }
+};
+
+// ../compression/src/lib/no-compression.ts
+var NoCompression = class extends Compression {
+  constructor(options) {
+    super(options);
+    this.name = "uncompressed";
+    this.extensions = [];
+    this.contentEncodings = [];
+    this.isSupported = true;
+    this.options = options || {};
+  }
+  compressSync(input) {
+    return input;
+  }
+  decompressSync(input) {
+    return input;
+  }
+  async *compressBatches(asyncIterator) {
+    return yield* asyncIterator;
+  }
+  async *decompressBatches(asyncIterator) {
+    return yield* asyncIterator;
+  }
+};
+
+// ../compression/src/lib/deflate-compression.ts
+var import_pako = __toModule(require_pako());
+var import_zlib = __toModule(require("zlib"));
+var DeflateCompression = class extends Compression {
+  constructor(options = {}) {
+    super(options);
+    this.name = "deflate";
+    this.extensions = [];
+    this.contentEncodings = ["deflate"];
+    this.isSupported = true;
+    this._chunks = [];
+    this.options = options;
+  }
+  async compress(input) {
+    if (!isBrowser && this.options.deflate?.useZlib) {
+      const buffer = this.options.deflate?.gzip ? await promisify1(import_zlib.default.gzip)(input) : await promisify1(import_zlib.default.deflate)(input);
+      return toArrayBuffer2(buffer);
+    }
+    return this.compressSync(input);
+  }
+  async decompress(input) {
+    if (!isBrowser && this.options.deflate?.useZlib) {
+      const buffer = this.options.deflate?.gzip ? await promisify1(import_zlib.default.gunzip)(input) : await promisify1(import_zlib.default.inflate)(input);
+      return toArrayBuffer2(buffer);
+    }
+    return this.decompressSync(input);
+  }
+  compressSync(input) {
+    if (!isBrowser && this.options.deflate?.useZlib) {
+      const buffer = this.options.deflate?.gzip ? import_zlib.default.gzipSync(input) : import_zlib.default.deflateSync(input);
+      return toArrayBuffer2(buffer);
+    }
+    const pakoOptions = this.options?.deflate || {};
+    const inputArray = new Uint8Array(input);
+    const deflate = this.options?.raw ? import_pako.default.deflateRaw : import_pako.default.deflate;
+    return deflate(inputArray, pakoOptions).buffer;
+  }
+  decompressSync(input) {
+    if (!isBrowser && this.options.deflate?.useZlib) {
+      const buffer = this.options.deflate?.gzip ? import_zlib.default.gunzipSync(input) : import_zlib.default.inflateSync(input);
+      return toArrayBuffer2(buffer);
+    }
+    const pakoOptions = this.options?.deflate || {};
+    const inputArray = new Uint8Array(input);
+    const inflate = this.options?.raw ? import_pako.default.inflateRaw : import_pako.default.inflate;
+    return inflate(inputArray, pakoOptions).buffer;
+  }
+  async *compressBatches(asyncIterator) {
+    const pakoOptions = this.options?.deflate || {};
+    const pakoProcessor = new import_pako.default.Deflate(pakoOptions);
+    yield* this.transformBatches(pakoProcessor, asyncIterator);
+  }
+  async *decompressBatches(asyncIterator) {
+    const pakoOptions = this.options?.deflate || {};
+    const pakoProcessor = new import_pako.default.Inflate(pakoOptions);
+    yield* this.transformBatches(pakoProcessor, asyncIterator);
+  }
+  async *transformBatches(pakoProcessor, asyncIterator) {
+    pakoProcessor.onData = this._onData.bind(this);
+    pakoProcessor.onEnd = this._onEnd.bind(this);
+    for await (const chunk of asyncIterator) {
+      const uint8Array = new Uint8Array(chunk);
+      const ok2 = pakoProcessor.push(uint8Array, false);
+      if (!ok2) {
+        throw new Error(`${this._getError()}write`);
+      }
+      const chunks2 = this._getChunks();
+      yield* chunks2;
+    }
+    const emptyChunk = new Uint8Array(0);
+    const ok = pakoProcessor.push(emptyChunk, true);
+    if (!ok) {
+    }
+    const chunks = this._getChunks();
+    yield* chunks;
+  }
+  _onData(chunk) {
+    this._chunks.push(chunk);
+  }
+  _onEnd(status) {
+    if (status !== 0) {
+      throw new Error(this._getError(status) + this._chunks.length);
+    }
+  }
+  _getChunks() {
+    const chunks = this._chunks;
+    this._chunks = [];
+    return chunks;
+  }
+  _getError(code = 0) {
+    const MESSAGES = {
+      2: "need dictionary",
+      1: "stream end",
+      0: "",
+      "-1": "file error",
+      "-2": "stream error",
+      "-3": "data error",
+      "-4": "insufficient memory",
+      "-5": "buffer error",
+      "-6": "incompatible version"
+    };
+    return `${this.name}: ${MESSAGES[code]}`;
+  }
+};
+
+// ../zip/src/filesystems/zip-filesystem.ts
+var COMPRESSION_METHODS = {
+  0: async (compressedFile) => compressedFile,
+  8: async (compressedFile) => {
+    const compression = new DeflateCompression({ raw: true });
+    const decompressedData = await compression.decompress(compressedFile);
+    return decompressedData;
+  }
+};
+var ZipFileSystem = class {
+  constructor(file) {
+    this.fileProvider = Promise.resolve(null);
+    if (typeof file === "string") {
+      this.fileName = file;
+      if (!isBrowser) {
+        this.fileProvider = FileHandleFile.from(file);
+      } else {
+        throw new Error("Cannot open file for random access in a WEB browser");
+      }
+    } else if (isFileProvider(file)) {
+      this.fileProvider = Promise.resolve(file);
+    }
+  }
+  async destroy() {
+    const fileProvider = await this.fileProvider;
+    if (fileProvider) {
+      await fileProvider.destroy();
+    }
+  }
+  async readdir() {
+    const fileProvider = await this.fileProvider;
+    if (!fileProvider) {
+      throw new Error("No data detected in the zip archive");
+    }
+    const fileNames = [];
+    const zipCDIterator = zipCDFileHeaderGenerator(fileProvider);
+    for await (const cdHeader of zipCDIterator) {
+      fileNames.push(cdHeader.fileName);
+    }
+    return fileNames;
+  }
+  async stat(filename2) {
+    const cdFileHeader = await this.getCDFileHeader(filename2);
+    return { ...cdFileHeader, size: Number(cdFileHeader.uncompressedSize) };
+  }
+  async fetch(filename2) {
+    const fileProvider = await this.fileProvider;
+    if (!fileProvider) {
+      throw new Error("No data detected in the zip archive");
+    }
+    const cdFileHeader = await this.getCDFileHeader(filename2);
+    const localFileHeader = await parseZipLocalFileHeader(cdFileHeader.localHeaderOffset, fileProvider);
+    if (!localFileHeader) {
+      throw new Error("Local file header has not been found in the zip archive`");
+    }
+    const compressionHandler = COMPRESSION_METHODS[localFileHeader.compressionMethod.toString()];
+    if (!compressionHandler) {
+      throw Error("Only Deflation compression is supported");
+    }
+    const compressedFile = await fileProvider.slice(localFileHeader.fileDataOffset, localFileHeader.fileDataOffset + localFileHeader.compressedSize);
+    const uncompressedFile = await compressionHandler(compressedFile);
+    const response = new Response(uncompressedFile);
+    Object.defineProperty(response, "url", { value: `${this.fileName || ""}/${filename2}` });
+    return response;
+  }
+  async getCDFileHeader(filename2) {
+    const fileProvider = await this.fileProvider;
+    if (!fileProvider) {
+      throw new Error("No data detected in the zip archive");
+    }
+    const zipCDIterator = zipCDFileHeaderGenerator(fileProvider);
+    let result = null;
+    for await (const cdHeader of zipCDIterator) {
+      if (cdHeader.fileName === filename2) {
+        result = cdHeader;
+        break;
+      }
+    }
+    if (!result) {
+      throw new Error("File has not been found in the zip archive");
+    }
+    return result;
+  }
+};
+
+// ../3d-tiles/src/3d-tiles-archive/3d-tiles-archive-archive.ts
+var import_md52 = __toModule(require_md5());
+var COMPRESSION_METHODS2 = {
+  0: (data) => new NoCompression().decompress(data),
+  8: (data) => new DeflateCompression({ raw: true }).decompress(data)
+};
+var Tiles3DArchive = class {
+  constructor(fileProvider, hashFile) {
+    this.fileProvider = fileProvider;
+    this.hashArray = hashFile;
+  }
+  async getFile(path2) {
+    let data = await this.getFileBytes(path2.toLocaleLowerCase());
+    if (!data) {
+      data = await this.getFileBytes(path2);
+    }
+    if (!data) {
+      throw new Error("No such file in the archive");
+    }
+    return data;
+  }
+  async getFileBytes(path2) {
+    const nameHash = Buffer.from((0, import_md52.default)(path2), "hex");
+    const fileInfo = findBin(nameHash, this.hashArray);
+    if (!fileInfo) {
+      return null;
+    }
+    const localFileHeader = await parseZipLocalFileHeader(fileInfo.offset, this.fileProvider);
+    if (!localFileHeader) {
+      return null;
+    }
+    const compressedFile = await this.fileProvider.slice(localFileHeader.fileDataOffset, localFileHeader.fileDataOffset + localFileHeader.compressedSize);
+    const compressionMethod = COMPRESSION_METHODS2[localFileHeader.compressionMethod];
+    if (!compressionMethod) {
+      throw Error("Only Deflation compression is supported");
+    }
+    return compressionMethod(compressedFile);
+  }
+};
+
+// ../3d-tiles/src/lib/filesystems/tiles-3d-archive-file-system.ts
+var Tiles3DArchiveFileSystem = class extends ZipFileSystem {
+  constructor(file) {
+    super(file);
+  }
+  async fetch(filename2) {
+    const fileProvider = await this.fileProvider;
+    if (!fileProvider) {
+      throw new Error("No data detected in the zip archive");
+    }
+    await this.parseHashFile();
+    if (this.hashData) {
+      const archive = new Tiles3DArchive(fileProvider, this.hashData);
+      const fileData = await archive.getFile(filename2);
+      const response = new Response(fileData);
+      Object.defineProperty(response, "url", { value: `${this.fileName || ""}/${filename2}` });
+      return response;
+    }
+    return super.fetch(filename2);
+  }
+  async parseHashFile() {
+    if (this.hashData !== void 0) {
+      return;
+    }
+    const fileProvider = await this.fileProvider;
+    if (!fileProvider) {
+      throw new Error("No data detected in the zip archive");
+    }
+    const hashCDOffset = await searchFromTheEnd(fileProvider, signature);
+    const cdFileHeader = await parseZipCDFileHeader(hashCDOffset, fileProvider);
+    if (cdFileHeader?.fileName === "@3dtilesIndex1@") {
+      const localFileHeader = await parseZipLocalFileHeader(cdFileHeader.localHeaderOffset, fileProvider);
+      if (!localFileHeader) {
+        throw new Error("corrupted 3tz");
+      }
+      const fileDataOffset = localFileHeader.fileDataOffset;
+      const hashFile = await fileProvider.slice(fileDataOffset, fileDataOffset + localFileHeader.compressedSize);
+      this.hashData = parseHashFile(hashFile);
+    } else {
+      this.hashData = null;
+    }
+  }
+};
+
 // ../3d-tiles/src/lib/encoders/helpers/encode-3d-tile-header.ts
 function encode3DTileHeader(tile, dataView, byteOffset) {
   const HEADER_SIZE = 12;
@@ -57800,7 +58429,7 @@ var parse5 = import_dist.default.parse;
 // src/i3s-converter/i3s-converter.ts
 var import_process2 = __toModule(require("process"));
 var import_json_map_transform8 = __toModule(require_json_map_transform());
-var import_md52 = __toModule(require_md5());
+var import_md54 = __toModule(require_md5());
 
 // src/i3s-converter/helpers/node-pages.ts
 var import_path4 = __toModule(require("path"));
@@ -57830,21 +58459,21 @@ var METADATA = () => ({
 });
 
 // src/lib/utils/file-utils.ts
-var import_fs4 = __toModule(require("fs"));
+var import_fs5 = __toModule(require("fs"));
 var import_path3 = __toModule(require("path"));
 
 // src/lib/utils/compress-util.ts
-var import_zlib = __toModule(require("zlib"));
+var import_zlib2 = __toModule(require("zlib"));
 var import_path2 = __toModule(require("path"));
-var import_fs3 = __toModule(require("fs"));
+var import_fs4 = __toModule(require("fs"));
 var import_archiver = __toModule(require_archiver());
 var import_jszip = __toModule(require_lib3());
 var import_crypt = __toModule(require_crypt());
 function compressFileWithGzip(pathFile) {
   const compressedPathFile = `${pathFile}.gz`;
-  const gzip = (0, import_zlib.createGzip)();
-  const input = (0, import_fs3.createReadStream)(pathFile);
-  const output = (0, import_fs3.createWriteStream)(compressedPathFile);
+  const gzip = (0, import_zlib2.createGzip)();
+  const input = (0, import_fs4.createReadStream)(pathFile);
+  const output = (0, import_fs4.createWriteStream)(compressedPathFile);
   return new Promise((resolve2, reject) => {
     input.on("end", () => {
       console.log(`${compressedPathFile} compressed and saved.`);
@@ -57904,10 +58533,10 @@ async function writeFile3(path2, data, fileName = "index.json") {
   } else {
     toWriteData = data;
   }
-  await import_fs4.promises.mkdir(path2, { recursive: true });
+  await import_fs5.promises.mkdir(path2, { recursive: true });
   const pathFile = (0, import_path3.join)(path2, fileName);
   try {
-    await import_fs4.promises.writeFile(pathFile, toWriteData);
+    await import_fs5.promises.writeFile(pathFile, toWriteData);
   } catch (err) {
     throw err;
   }
@@ -57953,17 +58582,17 @@ async function openJson(path2, fileName) {
 }
 async function isFileExists(fileName) {
   try {
-    await import_fs4.promises.stat(fileName);
+    await import_fs5.promises.stat(fileName);
     return true;
   } catch {
     return false;
   }
 }
 function removeDir(path2) {
-  return import_fs4.promises.rm(path2, { recursive: true });
+  return import_fs5.promises.rm(path2, { recursive: true });
 }
 function removeFile(path2) {
-  return import_fs4.promises.unlink(path2);
+  return import_fs5.promises.unlink(path2);
 }
 function getAbsoluteFilePath(filePath) {
   return (0, import_path3.isAbsolute)(filePath) ? filePath : (0, import_path3.join)(process.cwd(), filePath);
@@ -58150,7 +58779,7 @@ var NodePages = class {
 
 // src/lib/utils/statistic-utills.ts
 var import_path5 = __toModule(require("path"));
-var import_fs5 = __toModule(require("fs"));
+var import_fs6 = __toModule(require("fs"));
 function timeConverter(time) {
   const nanoSecondsInMillisecond = 1e6;
   let timeInSeconds = time[0];
@@ -58181,8 +58810,8 @@ async function calculateFilesSize(params) {
   try {
     if (slpk) {
       const slpkPath = (0, import_path5.join)(fullOutputPath, `${tilesetName}.slpk`);
-      const stat2 = await import_fs5.promises.stat(slpkPath);
-      return stat2.size;
+      const stat3 = await import_fs6.promises.stat(slpkPath);
+      return stat3.size;
     }
     const directoryPath = (0, import_path5.join)(fullOutputPath, tilesetName);
     const totalSize = await getTotalFilesSize(directoryPath);
@@ -58194,9 +58823,9 @@ async function calculateFilesSize(params) {
 }
 async function getTotalFilesSize(dirPath) {
   let totalFileSize = 0;
-  const files = await import_fs5.promises.readdir(dirPath);
+  const files = await import_fs6.promises.readdir(dirPath);
   for (const file of files) {
-    const fileStat = await import_fs5.promises.stat((0, import_path5.join)(dirPath, file));
+    const fileStat = await import_fs6.promises.stat((0, import_path5.join)(dirPath, file));
     if (fileStat.isDirectory()) {
       totalFileSize += await getTotalFilesSize((0, import_path5.join)(dirPath, file));
     } else {
@@ -58207,9 +58836,9 @@ async function getTotalFilesSize(dirPath) {
 }
 
 // src/i3s-converter/helpers/geometry-converter.ts
-var import_core16 = __toModule(require_es5());
+var import_core17 = __toModule(require_es5());
 var import_geospatial6 = __toModule(require_es52());
-var import_md5 = __toModule(require_md5());
+var import_md53 = __toModule(require_md5());
 
 // src/i3s-converter/helpers/geometry-attributes.ts
 var VALUES_PER_VERTEX = 3;
@@ -58380,23 +59009,23 @@ function groupAttributesAndRangesByFeatureId(unifiedObjects, featureCount) {
 }
 
 // src/i3s-converter/helpers/coordinate-converter.ts
-var import_core14 = __toModule(require_es5());
+var import_core15 = __toModule(require_es5());
 var import_geospatial4 = __toModule(require_es52());
 var import_culling3 = __toModule(require_es53());
 function createBoundingVolumes(sourceBoundingVolume, geoidHeightModel) {
   let radius;
   let halfSize;
   let quaternion;
-  const cartographicCenter = import_geospatial4.Ellipsoid.WGS84.cartesianToCartographic(sourceBoundingVolume.center, new import_core14.Vector3());
+  const cartographicCenter = import_geospatial4.Ellipsoid.WGS84.cartesianToCartographic(sourceBoundingVolume.center, new import_core15.Vector3());
   cartographicCenter[2] = cartographicCenter[2] - geoidHeightModel.getHeight(cartographicCenter[1], cartographicCenter[0]);
   if (sourceBoundingVolume instanceof import_culling3.OrientedBoundingBox) {
     halfSize = sourceBoundingVolume.halfSize;
-    radius = new import_core14.Vector3(halfSize[0], halfSize[1], halfSize[2]).len();
+    radius = new import_core15.Vector3(halfSize[0], halfSize[1], halfSize[2]).len();
     quaternion = sourceBoundingVolume.quaternion;
   } else {
     radius = sourceBoundingVolume.radius;
     halfSize = [radius, radius, radius];
-    quaternion = new import_core14.Quaternion().fromMatrix3(new import_core14.Matrix3([halfSize[0], 0, 0, 0, halfSize[1], 0, 0, 0, halfSize[2]])).normalize();
+    quaternion = new import_core15.Quaternion().fromMatrix3(new import_core15.Matrix3([halfSize[0], 0, 0, 0, halfSize[1], 0, 0, 0, halfSize[2]])).normalize();
   }
   return {
     mbs: [cartographicCenter[0], cartographicCenter[1], cartographicCenter[2], radius],
@@ -58411,8 +59040,8 @@ function createBoundingVolumesFromGeometry(cartesianPositions, geoidHeightModel)
   const positionVectors = convertPositionsToVectors(cartesianPositions);
   const geometryObb = (0, import_culling3.makeOrientedBoundingBoxFromPoints)(positionVectors);
   const geometryMbs = (0, import_culling3.makeBoundingSphereFromPoints)(positionVectors);
-  let mbsCenter = import_geospatial4.Ellipsoid.WGS84.cartesianToCartographic(geometryMbs.center, new import_core14.Vector3());
-  let obbCenter = import_geospatial4.Ellipsoid.WGS84.cartesianToCartographic(geometryObb.center, new import_core14.Vector3());
+  let mbsCenter = import_geospatial4.Ellipsoid.WGS84.cartesianToCartographic(geometryMbs.center, new import_core15.Vector3());
+  let obbCenter = import_geospatial4.Ellipsoid.WGS84.cartesianToCartographic(geometryObb.center, new import_core15.Vector3());
   mbsCenter[2] = mbsCenter[2] - geoidHeightModel.getHeight(mbsCenter[1], mbsCenter[0]);
   obbCenter[2] = obbCenter[2] - geoidHeightModel.getHeight(obbCenter[1], obbCenter[0]);
   return {
@@ -58427,7 +59056,7 @@ function createBoundingVolumesFromGeometry(cartesianPositions, geoidHeightModel)
 function convertPositionsToVectors(positions) {
   const result = [];
   for (let i = 0; i < positions.length; i += 3) {
-    const positionVector = new import_core14.Vector3([positions[i], positions[i + 1], positions[i + 2]]);
+    const positionVector = new import_core15.Vector3([positions[i], positions[i + 1], positions[i + 2]]);
     result.push(positionVector);
   }
   return result;
@@ -58441,8 +59070,8 @@ function convertBoundingVolumeToI3SFullExtent(boundingVolume) {
   }
   const center = sphere.center;
   const radius = sphere.radius;
-  const vertexMax = import_geospatial4.Ellipsoid.WGS84.cartesianToCartographic(new import_core14.Vector3(center[0] + radius, center[1] + radius, center[2] + radius), new import_core14.Vector3());
-  const vertexMin = import_geospatial4.Ellipsoid.WGS84.cartesianToCartographic(new import_core14.Vector3(center[0] - radius, center[1] - radius, center[2] - radius), new import_core14.Vector3());
+  const vertexMax = import_geospatial4.Ellipsoid.WGS84.cartesianToCartographic(new import_core15.Vector3(center[0] + radius, center[1] + radius, center[2] + radius), new import_core15.Vector3());
+  const vertexMin = import_geospatial4.Ellipsoid.WGS84.cartesianToCartographic(new import_core15.Vector3(center[0] - radius, center[1] - radius, center[2] - radius), new import_core15.Vector3());
   return {
     xmin: Math.min(vertexMin[0], vertexMax[0]),
     xmax: Math.max(vertexMin[0], vertexMax[0]),
@@ -58454,13 +59083,13 @@ function convertBoundingVolumeToI3SFullExtent(boundingVolume) {
 }
 function createObbFromMbs(mbs) {
   const radius = mbs[3];
-  const center = new import_core14.Vector3(mbs[0], mbs[1], mbs[2]);
-  const halfAxex = new import_core14.Matrix3([radius, 0, 0, 0, radius, 0, 0, 0, radius]);
+  const center = new import_core15.Vector3(mbs[0], mbs[1], mbs[2]);
+  const halfAxex = new import_core15.Matrix3([radius, 0, 0, 0, radius, 0, 0, 0, radius]);
   return new import_culling3.OrientedBoundingBox(center, halfAxex);
 }
 
 // src/i3s-converter/helpers/gltf-attributes.ts
-var import_core15 = __toModule(require_es5());
+var import_core16 = __toModule(require_es5());
 var import_geospatial5 = __toModule(require_es52());
 function prepareDataForAttributesConversion(tileContent, tileTransform, boundingVolume) {
   let nodes = tileContent.gltf?.scene?.nodes || tileContent.gltf?.scenes?.[0]?.nodes || tileContent.gltf?.nodes || [];
@@ -58502,7 +59131,7 @@ function getB3DMAttributesWithoutBufferView(attributes) {
 function calculateTransformProps(tileContent, tileTransform, boundingVolume) {
   const { rtcCenter, gltfUpAxis } = tileContent;
   const { center } = boundingVolume;
-  let modelMatrix = new import_core15.Matrix4(tileTransform);
+  let modelMatrix = new import_core16.Matrix4(tileTransform);
   if (rtcCenter) {
     modelMatrix.translate(rtcCenter);
   }
@@ -58510,18 +59139,18 @@ function calculateTransformProps(tileContent, tileTransform, boundingVolume) {
     case "Z":
       break;
     case "Y":
-      const rotationY = new import_core15.Matrix4().rotateX(Math.PI / 2);
+      const rotationY = new import_core16.Matrix4().rotateX(Math.PI / 2);
       modelMatrix = modelMatrix.multiplyRight(rotationY);
       break;
     case "X":
-      const rotationX = new import_core15.Matrix4().rotateY(-Math.PI / 2);
+      const rotationX = new import_core16.Matrix4().rotateY(-Math.PI / 2);
       modelMatrix = modelMatrix.multiplyRight(rotationX);
       break;
     default:
       break;
   }
-  const cartesianOrigin = new import_core15.Vector3(center);
-  const cartographicOrigin = import_geospatial5.Ellipsoid.WGS84.cartesianToCartographic(cartesianOrigin, new import_core15.Vector3());
+  const cartesianOrigin = new import_core16.Vector3(center);
+  const cartographicOrigin = import_geospatial5.Ellipsoid.WGS84.cartesianToCartographic(cartesianOrigin, new import_core16.Vector3());
   return { modelMatrix, cartographicOrigin };
 }
 function prepareNodes(nodes) {
@@ -58824,7 +59453,7 @@ var SHORT_INT_TYPE2 = "Int32";
 var DOUBLE_TYPE2 = "Float64";
 var OBJECT_ID_TYPE2 = "Oid32";
 var BATCHED_ID_POSSIBLE_ATTRIBUTE_NAMES = ["CUSTOM_ATTRIBUTE_2", "_BATCHID", "BATCHID"];
-var scratchVector4 = new import_core16.Vector3();
+var scratchVector4 = new import_core17.Vector3();
 async function convertB3dmToI3sGeometry(tileContent, tileTransform, tileBoundingVolume, addNodeToNodePage, propertyTable, featuresHashArray, attributeStorageInfo, draco, generateBoundingVolumes, shouldMergeMaterials, geoidHeightModel, libraries, metadataClass) {
   const useCartesianPositions = generateBoundingVolumes;
   const materialAndTextureList = await convertMaterials(tileContent.gltf?.materials, shouldMergeMaterials);
@@ -58963,7 +59592,7 @@ async function convertAttributes(attributesData, materialAndTextureList, useCart
   }
   return attributesMap;
 }
-function convertNodes(nodes, images, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions, matrix = new import_core16.Matrix4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]), featureTexture) {
+function convertNodes(nodes, images, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions, matrix = new import_core17.Matrix4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]), featureTexture) {
   if (nodes) {
     for (const node2 of nodes) {
       convertNode(node2, images, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions, matrix, featureTexture);
@@ -58987,7 +59616,7 @@ function getCompositeTransformationMatrix(node2, matrix) {
   }
   return transformationMatrix;
 }
-function convertNode(node2, images, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions, matrix = new import_core16.Matrix4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]), featureTexture) {
+function convertNode(node2, images, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions, matrix = new import_core17.Matrix4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]), featureTexture) {
   const transformationMatrix = getCompositeTransformationMatrix(node2, matrix);
   const mesh = node2.mesh;
   if (mesh) {
@@ -58995,7 +59624,7 @@ function convertNode(node2, images, cartographicOrigin, cartesianModelMatrix, at
   }
   convertNodes(node2.children || [], images, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions, transformationMatrix, featureTexture);
 }
-function convertMesh(mesh, images, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions = false, matrix = new import_core16.Matrix4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]), featureTexture) {
+function convertMesh(mesh, images, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions = false, matrix = new import_core17.Matrix4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]), featureTexture) {
   for (const primitive of mesh.primitives) {
     let outputAttributes = null;
     let materialUvRegion;
@@ -59073,7 +59702,7 @@ function transformVertexArray(args) {
   for (let i = 0; i < indices.length; i++) {
     const coordIndex = indices[i] * VALUES_PER_VERTEX2;
     const vertex = vertices.subarray(coordIndex, coordIndex + VALUES_PER_VERTEX2);
-    let vertexVector = new import_core16.Vector3(Array.from(vertex));
+    let vertexVector = new import_core17.Vector3(Array.from(vertex));
     vertexVector = attributeSpecificTransformation(vertexVector, args);
     newVertices[i * VALUES_PER_VERTEX2] = vertexVector.x;
     newVertices[i * VALUES_PER_VERTEX2 + 1] = vertexVector.y;
@@ -59325,10 +59954,10 @@ function convertGLTFMaterialToI3sSharedResources(gltfMaterial, nodeId) {
 }
 function extractSharedResourcesMaterialInfo(baseColorFactor, metallicFactor = 1) {
   const matDielectricColorComponent = 0.04 / 255;
-  const black = new import_core16.Vector4(0, 0, 0, 1);
-  const unitVector = new import_core16.Vector4(1, 1, 1, 1);
-  const dielectricSpecular = new import_core16.Vector4(matDielectricColorComponent, matDielectricColorComponent, matDielectricColorComponent, 0);
-  const baseColorVector = new import_core16.Vector4(baseColorFactor);
+  const black = new import_core17.Vector4(0, 0, 0, 1);
+  const unitVector = new import_core17.Vector4(1, 1, 1, 1);
+  const dielectricSpecular = new import_core17.Vector4(matDielectricColorComponent, matDielectricColorComponent, matDielectricColorComponent, 0);
+  const baseColorVector = new import_core17.Vector4(baseColorFactor);
   const firstOperand = unitVector.subtract(dielectricSpecular).multiply(baseColorVector);
   const diffuse = firstOperand.lerp(firstOperand, black, metallicFactor);
   dielectricSpecular[3] = 1;
@@ -59394,7 +60023,7 @@ function generateStringFromBatchTableByIndex(batchTable, index) {
 }
 function getOrCreateUniqueFeatureId(index, batchTable, featuresHashArray) {
   const batchTableStr = generateStringFromBatchTableByIndex(batchTable, index);
-  const hash = (0, import_md5.default)(batchTableStr);
+  const hash = (0, import_md53.default)(batchTableStr);
   if (featuresHashArray.includes(hash)) {
     return featuresHashArray.indexOf(hash);
   }
@@ -60150,7 +60779,7 @@ function transfromTextureDefinitions(textureDefinitionInfos, thisObject, origina
 
 // src/i3s-converter/helpers/node-debug.ts
 var import_culling4 = __toModule(require_es53());
-var import_core18 = __toModule(require_es5());
+var import_core19 = __toModule(require_es5());
 var import_geospatial7 = __toModule(require_es52());
 var CUBE_POSITIONS = new Float32Array([
   -1,
@@ -60267,7 +60896,7 @@ function getTileObbVertices(node2) {
   const obbCenterCartesian = import_geospatial7.Ellipsoid.WGS84.cartographicToCartesian(node2.obb.center);
   let vertices = [];
   for (let i = 0; i < positions.length; i += 3) {
-    const positionsVector = new import_core18.Vector3(positions[i] *= halfSize[0], positions[i + 1] *= halfSize[1], positions[i + 2] *= halfSize[2]);
+    const positionsVector = new import_core19.Vector3(positions[i] *= halfSize[0], positions[i + 1] *= halfSize[1], positions[i + 2] *= halfSize[2]);
     const rotatedPositions = positionsVector.transformByQuaternion(node2.obb.quaternion).add(obbCenterCartesian);
     vertices = vertices.concat(rotatedPositions);
   }
@@ -60653,7 +61282,7 @@ var NodeIndexDocument = class {
 
 // src/i3s-converter/helpers/load-3d-tiles.ts
 var loadNestedTileset = async (sourceTileset, sourceTile, tilesetLoadOptions) => {
-  const isTileset = sourceTile.type === "json";
+  const isTileset = isNestedTileset(sourceTile);
   if (!sourceTileset || !sourceTile.contentUrl || !isTileset) {
     return;
   }
@@ -60664,13 +61293,13 @@ var loadNestedTileset = async (sourceTileset, sourceTile, tilesetLoadOptions) =>
       assetGltfUpAxis: sourceTileset.asset && sourceTileset.asset.gltfUpAxis || "Y"
     }
   };
-  const tileContent = await load(sourceTile.contentUrl, sourceTileset.loader, loadOptions);
+  const tileContent = await loadFromArchive(sourceTile.contentUrl, sourceTileset.loader, loadOptions);
   if (tileContent.root) {
     sourceTile.children = [tileContent.root];
   }
 };
 var loadTile3DContent = async (sourceTileset, sourceTile, tilesetLoadOptions) => {
-  const isTileset = sourceTile.type === "json";
+  const isTileset = isNestedTileset(sourceTile);
   if (!sourceTileset || !sourceTile.contentUrl || isTileset) {
     return null;
   }
@@ -60682,12 +61311,40 @@ var loadTile3DContent = async (sourceTileset, sourceTile, tilesetLoadOptions) =>
       assetGltfUpAxis: sourceTileset.asset && sourceTileset.asset.gltfUpAxis || "Y"
     }
   };
-  const tileContent = await load(sourceTile.contentUrl, sourceTileset.loader, loadOptions);
+  const tileContent = await loadFromArchive(sourceTile.contentUrl, sourceTileset.loader, loadOptions);
   return tileContent;
 };
+async function loadFromArchive(url, loader, loadOptions) {
+  const tz3UrlParts = url.split(".3tz");
+  let filename2;
+  if (tz3UrlParts.length === 1) {
+    filename2 = null;
+  } else if (tz3UrlParts.length === 2) {
+    filename2 = tz3UrlParts[1].slice(1);
+    if (filename2 === "") {
+      filename2 = "tileset.json";
+    }
+  } else {
+    throw new Error("Unexpected URL format");
+  }
+  if (filename2) {
+    const tz3Path = `${tz3UrlParts[0]}.3tz`;
+    const fileSystem = new Tiles3DArchiveFileSystem(tz3Path);
+    const content = await load(filename2, loader, {
+      ...loadOptions,
+      fetch: fileSystem.fetch.bind(fileSystem)
+    });
+    await fileSystem.destroy();
+    return content;
+  }
+  return await load(url, loader, loadOptions);
+}
+function isNestedTileset(tile) {
+  return tile?.type === "json" || tile?.type === "3tz";
+}
 
 // src/i3s-converter/i3s-converter.ts
-var import_core22 = __toModule(require_es5());
+var import_core23 = __toModule(require_es5());
 
 // src/i3s-converter/helpers/tileset-traversal.ts
 var traverseDatasetWith = async (tile, traversalProps, processTile, postprocessTile, maxDepth, level = 0) => {
@@ -60880,7 +61537,7 @@ var I3SConverter = class {
       if (preloadOptions.headers) {
         this.loadOptions.fetch = { headers: preloadOptions.headers };
       }
-      this.sourceTileset = await load(tilesetUrl, this.Loader, this.loadOptions);
+      this.sourceTileset = await loadFromArchive(tilesetUrl, this.Loader, this.loadOptions);
       const preprocessResult = await this.preprocessConversion();
       if (preprocessResult) {
         await this._createAndSaveTileset(outputPath, tilesetName);
@@ -60937,7 +61594,8 @@ var I3SConverter = class {
     return true;
   }
   async analyzeTile(sourceTile, traversalProps) {
-    if (sourceTile.type === "json") {
+    const isTileset = isNestedTileset(sourceTile);
+    if (isTileset) {
       await loadNestedTileset(this.sourceTileset, sourceTile, this.loadOptions);
       return null;
     }
@@ -60967,7 +61625,7 @@ var I3SConverter = class {
     this.materialDefinitions = [];
     this.materialMap = new Map();
     const sourceRootTile = this.sourceTileset.root;
-    const sourceBoundingVolume = createBoundingVolume(sourceRootTile.boundingVolume, new import_core22.Matrix4(sourceRootTile.transform), null);
+    const sourceBoundingVolume = createBoundingVolume(sourceRootTile.boundingVolume, new import_core23.Matrix4(sourceRootTile.transform), null);
     this._formLayers0(tilesetName, sourceBoundingVolume, this.sourceTileset?.root?.boundingVolume?.region);
     const boundingVolumes = createBoundingVolumes(sourceBoundingVolume, this.geoidHeightModel);
     await this.nodePages.push({
@@ -60978,7 +61636,7 @@ var I3SConverter = class {
     });
     const rootNode = await NodeIndexDocument.createRootNode(boundingVolumes, this);
     await traverseDatasetWith(sourceRootTile, {
-      transform: new import_core22.Matrix4(sourceRootTile.transform),
+      transform: new import_core23.Matrix4(sourceRootTile.transform),
       parentNodes: [rootNode]
     }, this.convertTile.bind(this), this.finalizeTile.bind(this), this.options.maxDepth);
     this.layers0.materialDefinitions = this.materialDefinitions;
@@ -61049,8 +61707,9 @@ var I3SConverter = class {
     }
   }
   async convertTile(sourceTile, traversalProps) {
-    if (sourceTile.type === "json" || sourceTile.type === "empty") {
-      if (sourceTile.type === "json") {
+    const isTileset = isNestedTileset(sourceTile);
+    if (isTileset || sourceTile.type === "empty") {
+      if (isTileset) {
         if (sourceTile.id) {
           console.log(`[load]: ${sourceTile.id}`);
         }
@@ -61356,7 +62015,7 @@ var I3SConverter = class {
     }
   }
   _findOrCreateMaterial(material) {
-    const hash = (0, import_md52.default)(JSON.stringify(material));
+    const hash = (0, import_md54.default)(JSON.stringify(material));
     if (this.materialMap.has(hash)) {
       return this.materialMap.get(hash) || 0;
     }
@@ -61366,7 +62025,7 @@ var I3SConverter = class {
   }
   findOrCreateGeometryDefinition(hasTexture, hasUvRegions) {
     const geometryConfig = { hasTexture, hasUvRegions };
-    const hash = (0, import_md52.default)(JSON.stringify(geometryConfig));
+    const hash = (0, import_md54.default)(JSON.stringify(geometryConfig));
     if (this.geometryMap.has(hash)) {
       return this.geometryMap.get(hash) || 0;
     }
@@ -61510,7 +62169,7 @@ var COORDINATE_SYSTEM;
 })(COORDINATE_SYSTEM || (COORDINATE_SYSTEM = {}));
 
 // ../i3s/src/lib/parsers/parse-i3s-tile-content.ts
-var import_core25 = __toModule(require_es5());
+var import_core26 = __toModule(require_es5());
 var import_geospatial8 = __toModule(require_es52());
 
 // ../i3s/src/types.ts
@@ -61689,7 +62348,7 @@ async function loadFeatureAttributeData(attributeName, { attributeUrls }, { attr
 }
 
 // ../i3s/src/lib/parsers/parse-i3s-tile-content.ts
-var scratchVector5 = new import_core25.Vector3([0, 0, 0]);
+var scratchVector5 = new import_core26.Vector3([0, 0, 0]);
 function getLoaderForTextureFormat(textureFormat) {
   switch (textureFormat) {
     case "ktx-etc2":
@@ -61710,7 +62369,7 @@ async function parseI3STileContent(arrayBuffer, tileOptions, tilesetOptions, opt
     indices: null,
     featureIds: [],
     vertexCount: 0,
-    modelMatrix: new import_core25.Matrix4(),
+    modelMatrix: new import_core26.Matrix4(),
     coordinateSystem: 0,
     byteLength: 0,
     texture: null
@@ -61724,9 +62383,11 @@ async function parseI3STileContent(arrayBuffer, tileOptions, tilesetOptions, opt
       if (loader === ImageLoader) {
         const options2 = { ...tileOptions.textureLoaderOptions, image: { type: "data" } };
         try {
-          content.texture = await context.parse(arrayBuffer2, options2);
+          const texture = await parseFromContext(arrayBuffer2, [], options2, context);
+          content.texture = texture;
         } catch (e) {
-          content.texture = await parse(arrayBuffer2, loader, options2);
+          const texture = await parse(arrayBuffer2, loader, options2, context);
+          content.texture = texture;
         }
       } else if (loader === CompressedTextureLoader || loader === BasisLoader) {
         let texture = await load(arrayBuffer2, loader, tileOptions.textureLoaderOptions);
@@ -61935,9 +62596,9 @@ function parsePositions2(attribute, options) {
   const mbs = options.mbs;
   const value = attribute.value;
   const metadata = attribute.metadata;
-  const enuMatrix = new import_core25.Matrix4();
-  const cartographicOrigin = new import_core25.Vector3(mbs[0], mbs[1], mbs[2]);
-  const cartesianOrigin = new import_core25.Vector3();
+  const enuMatrix = new import_core26.Matrix4();
+  const cartographicOrigin = new import_core26.Vector3(mbs[0], mbs[1], mbs[2]);
+  const cartesianOrigin = new import_core26.Vector3();
   import_geospatial8.Ellipsoid.WGS84.cartographicToCartesian(cartographicOrigin, cartesianOrigin);
   import_geospatial8.Ellipsoid.WGS84.eastNorthUpToFixedFrame(cartesianOrigin, enuMatrix);
   attribute.value = offsetsToCartesians(value, metadata, cartographicOrigin);
@@ -61964,7 +62625,7 @@ function getModelMatrix(positions) {
   const metadata = positions.metadata;
   const scaleX = metadata?.["i3s-scale_x"]?.double || 1;
   const scaleY = metadata?.["i3s-scale_y"]?.double || 1;
-  const modelMatrix = new import_core25.Matrix4();
+  const modelMatrix = new import_core26.Matrix4();
   modelMatrix[0] = scaleX;
   modelMatrix[5] = scaleY;
   return modelMatrix;
@@ -62446,7 +63107,7 @@ function getMagicNumber(data) {
 }
 
 // src/3d-tiles-converter/helpers/i3s-obb-to-3d-tiles-obb.ts
-var import_core29 = __toModule(require_es5());
+var import_core30 = __toModule(require_es5());
 var import_geospatial10 = __toModule(require_es52());
 var import_culling6 = __toModule(require_es53());
 function i3sObbTo3dTilesObb(i3SObb, geoidHeightModel) {
@@ -62455,7 +63116,7 @@ function i3sObbTo3dTilesObb(i3SObb, geoidHeightModel) {
     i3SObb.center[1],
     i3SObb.center[2] + geoidHeightModel.getHeight(i3SObb.center[1], i3SObb.center[0])
   ];
-  const cartesianCenter = import_geospatial10.Ellipsoid.WGS84.cartographicToCartesian(tiles3DCenter, new import_core29.Vector3());
+  const cartesianCenter = import_geospatial10.Ellipsoid.WGS84.cartographicToCartesian(tiles3DCenter, new import_core30.Vector3());
   const tiles3DObb = new import_culling6.OrientedBoundingBox().fromCenterHalfSizeQuaternion(cartesianCenter, i3SObb.halfSize, i3SObb.quaternion);
   return [...tiles3DObb.center, ...tiles3DObb.halfAxes.toArray()];
 }
@@ -62499,7 +63160,7 @@ var TILESET = () => ({
 });
 
 // src/3d-tiles-converter/helpers/b3dm-converter.ts
-var import_core31 = __toModule(require_es5());
+var import_core32 = __toModule(require_es5());
 var import_geospatial11 = __toModule(require_es52());
 
 // src/3d-tiles-converter/helpers/texture-atlas.ts
@@ -62534,8 +63195,8 @@ function normalizeRegions(regions) {
 }
 
 // src/3d-tiles-converter/helpers/b3dm-converter.ts
-var Z_UP_TO_Y_UP_MATRIX = new import_core31.Matrix4([1, 0, 0, 0, 0, 0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 1]);
-var scratchVector6 = new import_core31.Vector3();
+var Z_UP_TO_Y_UP_MATRIX = new import_core32.Matrix4([1, 0, 0, 0, 0, 0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 1]);
+var scratchVector6 = new import_core32.Vector3();
 var B3dmConverter = class {
   async convert(i3sAttributesData, featureAttributes = null) {
     const gltf = await this.buildGltf(i3sAttributesData, featureAttributes);
@@ -62559,8 +63220,8 @@ var B3dmConverter = class {
     if (attributes.uvRegions && attributes.texCoords) {
       attributes.texCoords.value = convertTextureAtlas(attributes.texCoords.value, attributes.uvRegions.value);
     }
-    const cartesianOrigin = new import_core31.Vector3(box);
-    const cartographicOrigin = import_geospatial11.Ellipsoid.WGS84.cartesianToCartographic(cartesianOrigin, new import_core31.Vector3());
+    const cartesianOrigin = new import_core32.Vector3(box);
+    const cartographicOrigin = import_geospatial11.Ellipsoid.WGS84.cartesianToCartographic(cartesianOrigin, new import_core32.Vector3());
     attributes.positions.value = this._normalizePositions(positionsValue, cartesianOrigin, cartographicOrigin, modelMatrix);
     this._createBatchIds(tileContent, featureAttributes);
     if (attributes.normals && !this._checkNormals(attributes.normals.value)) {
@@ -62600,8 +63261,8 @@ var B3dmConverter = class {
     const newPositionsValue = new Float32Array(positionsValue.length);
     for (let index = 0; index < positionsValue.length; index += 3) {
       const vertex = positionsValue.subarray(index, index + 3);
-      const cartesianOriginVector = new import_core31.Vector3(cartesianOrigin);
-      let vertexVector = new import_core31.Vector3(Array.from(vertex)).transform(modelMatrix).add(cartographicOrigin);
+      const cartesianOriginVector = new import_core32.Vector3(cartesianOrigin);
+      let vertexVector = new import_core32.Vector3(Array.from(vertex)).transform(modelMatrix).add(cartographicOrigin);
       import_geospatial11.Ellipsoid.WGS84.cartographicToCartesian(vertexVector, scratchVector6);
       vertexVector = scratchVector6.subtract(cartesianOriginVector);
       newPositionsValue.set(vertexVector, index);
@@ -62609,7 +63270,7 @@ var B3dmConverter = class {
     return newPositionsValue;
   }
   _generateTransformMatrix(cartesianOrigin) {
-    const translateOriginMatrix = new import_core31.Matrix4().translate(cartesianOrigin);
+    const translateOriginMatrix = new import_core32.Matrix4().translate(cartesianOrigin);
     const result = translateOriginMatrix.multiplyLeft(Z_UP_TO_Y_UP_MATRIX);
     return result;
   }