@loaders.gl/tile-converter 4.0.0-alpha.23 → 4.0.0-alpha.25

package/dist/dist.min.js

@@ -21238,13 +21238,13 @@ var require_minimatch = __commonJS({
 var require_readdir_glob = __commonJS({
   "../../node_modules/readdir-glob/index.js"(exports, module2) {
     module2.exports = readdirGlob;
-    var fs6 = require("fs");
+    var fs7 = require("fs");
     var { EventEmitter } = require("events");
     var { Minimatch } = require_minimatch();
     var { resolve: resolve2 } = require("path");
     function readdir2(dir, strict) {
       return new Promise((resolve3, reject) => {
-        fs6.readdir(dir, { withFileTypes: true }, (err, files) => {
+        fs7.readdir(dir, { withFileTypes: true }, (err, files) => {
           if (err) {
             switch (err.code) {
               case "ENOTDIR":
@@ -21273,7 +21273,7 @@ var require_readdir_glob = __commonJS({
     }
     function stat3(file, followSymlinks) {
       return new Promise((resolve3, reject) => {
-        const statFunc = followSymlinks ? fs6.stat : fs6.lstat;
+        const statFunc = followSymlinks ? fs7.stat : fs7.lstat;
         statFunc(file, (err, stats) => {
           if (err) {
             switch (err.code) {
@@ -23395,56 +23395,56 @@ var require_polyfills = __commonJS({
     }
     var chdir;
     module2.exports = patch;
-    function patch(fs6) {
+    function patch(fs7) {
       if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-        patchLchmod(fs6);
-      }
-      if (!fs6.lutimes) {
-        patchLutimes(fs6);
-      }
-      fs6.chown = chownFix(fs6.chown);
-      fs6.fchown = chownFix(fs6.fchown);
-      fs6.lchown = chownFix(fs6.lchown);
-      fs6.chmod = chmodFix(fs6.chmod);
-      fs6.fchmod = chmodFix(fs6.fchmod);
-      fs6.lchmod = chmodFix(fs6.lchmod);
-      fs6.chownSync = chownFixSync(fs6.chownSync);
-      fs6.fchownSync = chownFixSync(fs6.fchownSync);
-      fs6.lchownSync = chownFixSync(fs6.lchownSync);
-      fs6.chmodSync = chmodFixSync(fs6.chmodSync);
-      fs6.fchmodSync = chmodFixSync(fs6.fchmodSync);
-      fs6.lchmodSync = chmodFixSync(fs6.lchmodSync);
-      fs6.stat = statFix(fs6.stat);
-      fs6.fstat = statFix(fs6.fstat);
-      fs6.lstat = statFix(fs6.lstat);
-      fs6.statSync = statFixSync(fs6.statSync);
-      fs6.fstatSync = statFixSync(fs6.fstatSync);
-      fs6.lstatSync = statFixSync(fs6.lstatSync);
-      if (fs6.chmod && !fs6.lchmod) {
-        fs6.lchmod = function(path2, mode, cb) {
+        patchLchmod(fs7);
+      }
+      if (!fs7.lutimes) {
+        patchLutimes(fs7);
+      }
+      fs7.chown = chownFix(fs7.chown);
+      fs7.fchown = chownFix(fs7.fchown);
+      fs7.lchown = chownFix(fs7.lchown);
+      fs7.chmod = chmodFix(fs7.chmod);
+      fs7.fchmod = chmodFix(fs7.fchmod);
+      fs7.lchmod = chmodFix(fs7.lchmod);
+      fs7.chownSync = chownFixSync(fs7.chownSync);
+      fs7.fchownSync = chownFixSync(fs7.fchownSync);
+      fs7.lchownSync = chownFixSync(fs7.lchownSync);
+      fs7.chmodSync = chmodFixSync(fs7.chmodSync);
+      fs7.fchmodSync = chmodFixSync(fs7.fchmodSync);
+      fs7.lchmodSync = chmodFixSync(fs7.lchmodSync);
+      fs7.stat = statFix(fs7.stat);
+      fs7.fstat = statFix(fs7.fstat);
+      fs7.lstat = statFix(fs7.lstat);
+      fs7.statSync = statFixSync(fs7.statSync);
+      fs7.fstatSync = statFixSync(fs7.fstatSync);
+      fs7.lstatSync = statFixSync(fs7.lstatSync);
+      if (fs7.chmod && !fs7.lchmod) {
+        fs7.lchmod = function(path2, mode, cb) {
           if (cb)
             process.nextTick(cb);
         };
-        fs6.lchmodSync = function() {
+        fs7.lchmodSync = function() {
         };
       }
-      if (fs6.chown && !fs6.lchown) {
-        fs6.lchown = function(path2, uid, gid, cb) {
+      if (fs7.chown && !fs7.lchown) {
+        fs7.lchown = function(path2, uid, gid, cb) {
           if (cb)
             process.nextTick(cb);
         };
-        fs6.lchownSync = function() {
+        fs7.lchownSync = function() {
         };
       }
       if (platform === "win32") {
-        fs6.rename = typeof fs6.rename !== "function" ? fs6.rename : function(fs$rename) {
+        fs7.rename = typeof fs7.rename !== "function" ? fs7.rename : function(fs$rename) {
           function rename(from, to, cb) {
             var start = Date.now();
             var backoff = 0;
             fs$rename(from, to, function CB(er) {
               if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 6e4) {
                 setTimeout(function() {
-                  fs6.stat(to, function(stater, st) {
+                  fs7.stat(to, function(stater, st) {
                     if (stater && stater.code === "ENOENT")
                       fs$rename(from, to, CB);
                     else
@@ -23462,33 +23462,33 @@ var require_polyfills = __commonJS({
           if (Object.setPrototypeOf)
             Object.setPrototypeOf(rename, fs$rename);
           return rename;
-        }(fs6.rename);
+        }(fs7.rename);
       }
-      fs6.read = typeof fs6.read !== "function" ? fs6.read : function(fs$read) {
-        function read4(fd, buffer, offset, length, position, callback_) {
+      fs7.read = typeof fs7.read !== "function" ? fs7.read : function(fs$read) {
+        function read3(fd, buffer, offset, length, position, callback_) {
           var callback;
           if (callback_ && typeof callback_ === "function") {
             var eagCounter = 0;
             callback = function(er, _2, __) {
               if (er && er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
-                return fs$read.call(fs6, fd, buffer, offset, length, position, callback);
+                return fs$read.call(fs7, fd, buffer, offset, length, position, callback);
               }
               callback_.apply(this, arguments);
             };
           }
-          return fs$read.call(fs6, fd, buffer, offset, length, position, callback);
+          return fs$read.call(fs7, fd, buffer, offset, length, position, callback);
         }
         if (Object.setPrototypeOf)
-          Object.setPrototypeOf(read4, fs$read);
-        return read4;
-      }(fs6.read);
-      fs6.readSync = typeof fs6.readSync !== "function" ? fs6.readSync : function(fs$readSync) {
+          Object.setPrototypeOf(read3, fs$read);
+        return read3;
+      }(fs7.read);
+      fs7.readSync = typeof fs7.readSync !== "function" ? fs7.readSync : function(fs$readSync) {
         return function(fd, buffer, offset, length, position) {
           var eagCounter = 0;
           while (true) {
             try {
-              return fs$readSync.call(fs6, fd, buffer, offset, length, position);
+              return fs$readSync.call(fs7, fd, buffer, offset, length, position);
             } catch (er) {
               if (er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
@@ -23498,85 +23498,85 @@ var require_polyfills = __commonJS({
             }
           }
         };
-      }(fs6.readSync);
-      function patchLchmod(fs7) {
-        fs7.lchmod = function(path2, mode, callback) {
-          fs7.open(path2, constants.O_WRONLY | constants.O_SYMLINK, mode, function(err, fd) {
+      }(fs7.readSync);
+      function patchLchmod(fs8) {
+        fs8.lchmod = function(path2, mode, callback) {
+          fs8.open(path2, constants.O_WRONLY | constants.O_SYMLINK, mode, function(err, fd) {
             if (err) {
               if (callback)
                 callback(err);
               return;
             }
-            fs7.fchmod(fd, mode, function(err2) {
-              fs7.close(fd, function(err22) {
+            fs8.fchmod(fd, mode, function(err2) {
+              fs8.close(fd, function(err22) {
                 if (callback)
                   callback(err2 || err22);
               });
             });
           });
         };
-        fs7.lchmodSync = function(path2, mode) {
-          var fd = fs7.openSync(path2, constants.O_WRONLY | constants.O_SYMLINK, mode);
+        fs8.lchmodSync = function(path2, mode) {
+          var fd = fs8.openSync(path2, constants.O_WRONLY | constants.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
-            ret = fs7.fchmodSync(fd, mode);
+            ret = fs8.fchmodSync(fd, mode);
             threw = false;
           } finally {
             if (threw) {
               try {
-                fs7.closeSync(fd);
+                fs8.closeSync(fd);
               } catch (er) {
               }
             } else {
-              fs7.closeSync(fd);
+              fs8.closeSync(fd);
             }
           }
           return ret;
         };
       }
-      function patchLutimes(fs7) {
-        if (constants.hasOwnProperty("O_SYMLINK") && fs7.futimes) {
-          fs7.lutimes = function(path2, at, mt, cb) {
-            fs7.open(path2, constants.O_SYMLINK, function(er, fd) {
+      function patchLutimes(fs8) {
+        if (constants.hasOwnProperty("O_SYMLINK") && fs8.futimes) {
+          fs8.lutimes = function(path2, at, mt, cb) {
+            fs8.open(path2, constants.O_SYMLINK, function(er, fd) {
               if (er) {
                 if (cb)
                   cb(er);
                 return;
               }
-              fs7.futimes(fd, at, mt, function(er2) {
-                fs7.close(fd, function(er22) {
+              fs8.futimes(fd, at, mt, function(er2) {
+                fs8.close(fd, function(er22) {
                   if (cb)
                     cb(er2 || er22);
                 });
               });
             });
           };
-          fs7.lutimesSync = function(path2, at, mt) {
-            var fd = fs7.openSync(path2, constants.O_SYMLINK);
+          fs8.lutimesSync = function(path2, at, mt) {
+            var fd = fs8.openSync(path2, constants.O_SYMLINK);
             var ret;
             var threw = true;
             try {
-              ret = fs7.futimesSync(fd, at, mt);
+              ret = fs8.futimesSync(fd, at, mt);
               threw = false;
             } finally {
               if (threw) {
                 try {
-                  fs7.closeSync(fd);
+                  fs8.closeSync(fd);
                 } catch (er) {
                 }
               } else {
-                fs7.closeSync(fd);
+                fs8.closeSync(fd);
               }
             }
             return ret;
           };
-        } else if (fs7.futimes) {
-          fs7.lutimes = function(_a, _b, _c, cb) {
+        } else if (fs8.futimes) {
+          fs8.lutimes = function(_a, _b, _c, cb) {
             if (cb)
               process.nextTick(cb);
           };
-          fs7.lutimesSync = function() {
+          fs8.lutimesSync = function() {
           };
         }
       }
@@ -23584,7 +23584,7 @@ var require_polyfills = __commonJS({
         if (!orig)
           return orig;
         return function(target, mode, cb) {
-          return orig.call(fs6, target, mode, function(er) {
+          return orig.call(fs7, target, mode, function(er) {
             if (chownErOk(er))
               er = null;
             if (cb)
@@ -23597,7 +23597,7 @@ var require_polyfills = __commonJS({
           return orig;
         return function(target, mode) {
           try {
-            return orig.call(fs6, target, mode);
+            return orig.call(fs7, target, mode);
           } catch (er) {
             if (!chownErOk(er))
               throw er;
@@ -23608,7 +23608,7 @@ var require_polyfills = __commonJS({
         if (!orig)
           return orig;
         return function(target, uid, gid, cb) {
-          return orig.call(fs6, target, uid, gid, function(er) {
+          return orig.call(fs7, target, uid, gid, function(er) {
             if (chownErOk(er))
               er = null;
             if (cb)
@@ -23621,7 +23621,7 @@ var require_polyfills = __commonJS({
           return orig;
         return function(target, uid, gid) {
           try {
-            return orig.call(fs6, target, uid, gid);
+            return orig.call(fs7, target, uid, gid);
           } catch (er) {
             if (!chownErOk(er))
               throw er;
@@ -23646,14 +23646,14 @@ var require_polyfills = __commonJS({
             if (cb)
               cb.apply(this, arguments);
           }
-          return options ? orig.call(fs6, target, options, callback) : orig.call(fs6, target, callback);
+          return options ? orig.call(fs7, target, options, callback) : orig.call(fs7, target, callback);
         };
       }
       function statFixSync(orig) {
         if (!orig)
           return orig;
         return function(target, options) {
-          var stats = options ? orig.call(fs6, target, options) : orig.call(fs6, target);
+          var stats = options ? orig.call(fs7, target, options) : orig.call(fs7, target);
           if (stats) {
             if (stats.uid < 0)
               stats.uid += 4294967296;
@@ -23684,7 +23684,7 @@ var require_legacy_streams = __commonJS({
   "../../node_modules/graceful-fs/legacy-streams.js"(exports, module2) {
     var Stream = require("stream").Stream;
     module2.exports = legacy;
-    function legacy(fs6) {
+    function legacy(fs7) {
       return {
         ReadStream,
         WriteStream
@@ -23729,7 +23729,7 @@ var require_legacy_streams = __commonJS({
           });
           return;
         }
-        fs6.open(this.path, this.flags, this.mode, function(err, fd) {
+        fs7.open(this.path, this.flags, this.mode, function(err, fd) {
           if (err) {
             self2.emit("error", err);
             self2.readable = false;
@@ -23769,7 +23769,7 @@ var require_legacy_streams = __commonJS({
         this.busy = false;
         this._queue = [];
         if (this.fd === null) {
-          this._open = fs6.open;
+          this._open = fs7.open;
           this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
           this.flush();
         }
@@ -23804,7 +23804,7 @@ var require_clone = __commonJS({
 // ../../node_modules/graceful-fs/graceful-fs.js
 var require_graceful_fs = __commonJS({
   "../../node_modules/graceful-fs/graceful-fs.js"(exports, module2) {
-    var fs6 = require("fs");
+    var fs7 = require("fs");
     var polyfills = require_polyfills();
     var legacy = require_legacy_streams();
     var clone2 = require_clone();
@@ -23836,12 +23836,12 @@ var require_graceful_fs = __commonJS({
         m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
         console.error(m);
       };
-    if (!fs6[gracefulQueue]) {
+    if (!fs7[gracefulQueue]) {
       queue = global[gracefulQueue] || [];
-      publishQueue(fs6, queue);
-      fs6.close = function(fs$close) {
-        function close3(fd, cb) {
-          return fs$close.call(fs6, fd, function(err) {
+      publishQueue(fs7, queue);
+      fs7.close = function(fs$close) {
+        function close2(fd, cb) {
+          return fs$close.call(fs7, fd, function(err) {
             if (!err) {
               resetQueue();
             }
@@ -23849,44 +23849,44 @@ var require_graceful_fs = __commonJS({
               cb.apply(this, arguments);
           });
         }
-        Object.defineProperty(close3, previousSymbol, {
+        Object.defineProperty(close2, previousSymbol, {
           value: fs$close
         });
-        return close3;
-      }(fs6.close);
-      fs6.closeSync = function(fs$closeSync) {
+        return close2;
+      }(fs7.close);
+      fs7.closeSync = function(fs$closeSync) {
         function closeSync(fd) {
-          fs$closeSync.apply(fs6, arguments);
+          fs$closeSync.apply(fs7, arguments);
           resetQueue();
         }
         Object.defineProperty(closeSync, previousSymbol, {
           value: fs$closeSync
         });
         return closeSync;
-      }(fs6.closeSync);
+      }(fs7.closeSync);
       if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
         process.on("exit", function() {
-          debug(fs6[gracefulQueue]);
-          require("assert").equal(fs6[gracefulQueue].length, 0);
+          debug(fs7[gracefulQueue]);
+          require("assert").equal(fs7[gracefulQueue].length, 0);
         });
       }
     }
     var queue;
     if (!global[gracefulQueue]) {
-      publishQueue(global, fs6[gracefulQueue]);
-    }
-    module2.exports = patch(clone2(fs6));
-    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs6.__patched) {
-      module2.exports = patch(fs6);
-      fs6.__patched = true;
-    }
-    function patch(fs7) {
-      polyfills(fs7);
-      fs7.gracefulify = patch;
-      fs7.createReadStream = createReadStream3;
-      fs7.createWriteStream = createWriteStream3;
-      var fs$readFile = fs7.readFile;
-      fs7.readFile = readFile2;
+      publishQueue(global, fs7[gracefulQueue]);
+    }
+    module2.exports = patch(clone2(fs7));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs7.__patched) {
+      module2.exports = patch(fs7);
+      fs7.__patched = true;
+    }
+    function patch(fs8) {
+      polyfills(fs8);
+      fs8.gracefulify = patch;
+      fs8.createReadStream = createReadStream3;
+      fs8.createWriteStream = createWriteStream3;
+      var fs$readFile = fs8.readFile;
+      fs8.readFile = readFile2;
       function readFile2(path2, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
@@ -23902,8 +23902,8 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$writeFile = fs7.writeFile;
-      fs7.writeFile = writeFile4;
+      var fs$writeFile = fs8.writeFile;
+      fs8.writeFile = writeFile4;
       function writeFile4(path2, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
@@ -23919,9 +23919,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$appendFile = fs7.appendFile;
+      var fs$appendFile = fs8.appendFile;
       if (fs$appendFile)
-        fs7.appendFile = appendFile;
+        fs8.appendFile = appendFile;
       function appendFile(path2, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
@@ -23937,9 +23937,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$copyFile = fs7.copyFile;
+      var fs$copyFile = fs8.copyFile;
       if (fs$copyFile)
-        fs7.copyFile = copyFile;
+        fs8.copyFile = copyFile;
       function copyFile(src, dest, flags, cb) {
         if (typeof flags === "function") {
           cb = flags;
@@ -23957,8 +23957,8 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$readdir = fs7.readdir;
-      fs7.readdir = readdir2;
+      var fs$readdir = fs8.readdir;
+      fs8.readdir = readdir2;
       var noReaddirOptionVersions = /^v[0-5]\./;
       function readdir2(path2, options, cb) {
         if (typeof options === "function")
@@ -23989,21 +23989,21 @@ var require_graceful_fs = __commonJS({
         }
       }
       if (process.version.substr(0, 4) === "v0.8") {
-        var legStreams = legacy(fs7);
+        var legStreams = legacy(fs8);
         ReadStream = legStreams.ReadStream;
         WriteStream = legStreams.WriteStream;
       }
-      var fs$ReadStream = fs7.ReadStream;
+      var fs$ReadStream = fs8.ReadStream;
       if (fs$ReadStream) {
         ReadStream.prototype = Object.create(fs$ReadStream.prototype);
         ReadStream.prototype.open = ReadStream$open;
       }
-      var fs$WriteStream = fs7.WriteStream;
+      var fs$WriteStream = fs8.WriteStream;
       if (fs$WriteStream) {
         WriteStream.prototype = Object.create(fs$WriteStream.prototype);
         WriteStream.prototype.open = WriteStream$open;
       }
-      Object.defineProperty(fs7, "ReadStream", {
+      Object.defineProperty(fs8, "ReadStream", {
         get: function() {
           return ReadStream;
         },
@@ -24013,7 +24013,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      Object.defineProperty(fs7, "WriteStream", {
+      Object.defineProperty(fs8, "WriteStream", {
         get: function() {
           return WriteStream;
         },
@@ -24024,7 +24024,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileReadStream = ReadStream;
-      Object.defineProperty(fs7, "FileReadStream", {
+      Object.defineProperty(fs8, "FileReadStream", {
         get: function() {
           return FileReadStream;
         },
@@ -24035,7 +24035,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileWriteStream = WriteStream;
-      Object.defineProperty(fs7, "FileWriteStream", {
+      Object.defineProperty(fs8, "FileWriteStream", {
         get: function() {
           return FileWriteStream;
         },
@@ -24053,7 +24053,7 @@ var require_graceful_fs = __commonJS({
       }
       function ReadStream$open() {
         var that = this;
-        open3(that.path, that.flags, that.mode, function(err, fd) {
+        open2(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;
-        open3(that.path, that.flags, that.mode, function(err, fd) {
+        open2(that.path, that.flags, that.mode, function(err, fd) {
           if (err) {
             that.destroy();
             that.emit("error", err);
@@ -24084,14 +24084,14 @@ var require_graceful_fs = __commonJS({
         });
       }
       function createReadStream3(path2, options) {
-        return new fs7.ReadStream(path2, options);
+        return new fs8.ReadStream(path2, options);
       }
       function createWriteStream3(path2, options) {
-        return new fs7.WriteStream(path2, options);
+        return new fs8.WriteStream(path2, options);
       }
-      var fs$open = fs7.open;
-      fs7.open = open3;
-      function open3(path2, flags, mode, cb) {
+      var fs$open = fs8.open;
+      fs8.open = open2;
+      function open2(path2, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
         return go$open(path2, flags, mode, cb);
@@ -24106,20 +24106,20 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      return fs7;
+      return fs8;
     }
     function enqueue(elem) {
       debug("ENQUEUE", elem[0].name, elem[1]);
-      fs6[gracefulQueue].push(elem);
+      fs7[gracefulQueue].push(elem);
       retry();
     }
     var retryTimer;
     function resetQueue() {
       var now = Date.now();
-      for (var i = 0; i < fs6[gracefulQueue].length; ++i) {
-        if (fs6[gracefulQueue][i].length > 2) {
-          fs6[gracefulQueue][i][3] = now;
-          fs6[gracefulQueue][i][4] = now;
+      for (var i = 0; i < fs7[gracefulQueue].length; ++i) {
+        if (fs7[gracefulQueue][i].length > 2) {
+          fs7[gracefulQueue][i][3] = now;
+          fs7[gracefulQueue][i][4] = now;
         }
       }
       retry();
@@ -24127,9 +24127,9 @@ var require_graceful_fs = __commonJS({
     function retry() {
       clearTimeout(retryTimer);
       retryTimer = void 0;
-      if (fs6[gracefulQueue].length === 0)
+      if (fs7[gracefulQueue].length === 0)
         return;
-      var elem = fs6[gracefulQueue].shift();
+      var elem = fs7[gracefulQueue].shift();
       var fn = elem[0];
       var args = elem[1];
       var err = elem[2];
@@ -24151,7 +24151,7 @@ var require_graceful_fs = __commonJS({
           debug("RETRY", fn.name, args);
           fn.apply(null, args.concat([startTime]));
         } else {
-          fs6[gracefulQueue].push(elem);
+          fs7[gracefulQueue].push(elem);
         }
       }
       if (retryTimer === void 0) {
@@ -25348,7 +25348,7 @@ var require_old = __commonJS({
   "../../node_modules/fs.realpath/old.js"(exports) {
     var pathModule = require("path");
     var isWindows = process.platform === "win32";
-    var fs6 = require("fs");
+    var fs7 = require("fs");
     var DEBUG = process.env.NODE_DEBUG && /fs/.test(process.env.NODE_DEBUG);
     function rethrow() {
       var callback;
@@ -25413,7 +25413,7 @@ var require_old = __commonJS({
         base = m[0];
         previous = "";
         if (isWindows && !knownHard[base]) {
-          fs6.lstatSync(base);
+          fs7.lstatSync(base);
           knownHard[base] = true;
         }
       }
@@ -25431,7 +25431,7 @@ var require_old = __commonJS({
         if (cache3 && Object.prototype.hasOwnProperty.call(cache3, base)) {
           resolvedLink = cache3[base];
         } else {
-          var stat3 = fs6.lstatSync(base);
+          var stat3 = fs7.lstatSync(base);
           if (!stat3.isSymbolicLink()) {
             knownHard[base] = true;
             if (cache3)
@@ -25446,8 +25446,8 @@ var require_old = __commonJS({
             }
           }
           if (linkTarget === null) {
-            fs6.statSync(base);
-            linkTarget = fs6.readlinkSync(base);
+            fs7.statSync(base);
+            linkTarget = fs7.readlinkSync(base);
           }
           resolvedLink = pathModule.resolve(previous, linkTarget);
           if (cache3)
@@ -25484,7 +25484,7 @@ var require_old = __commonJS({
         base = m[0];
         previous = "";
         if (isWindows && !knownHard[base]) {
-          fs6.lstat(base, function(err) {
+          fs7.lstat(base, function(err) {
             if (err)
               return cb(err);
             knownHard[base] = true;
@@ -25512,7 +25512,7 @@ var require_old = __commonJS({
         if (cache3 && Object.prototype.hasOwnProperty.call(cache3, base)) {
           return gotResolvedLink(cache3[base]);
         }
-        return fs6.lstat(base, gotStat);
+        return fs7.lstat(base, gotStat);
       }
       function gotStat(err, stat3) {
         if (err)
@@ -25529,10 +25529,10 @@ var require_old = __commonJS({
             return gotTarget(null, seenLinks[id], base);
           }
         }
-        fs6.stat(base, function(err2) {
+        fs7.stat(base, function(err2) {
           if (err2)
             return cb(err2);
-          fs6.readlink(base, function(err3, target) {
+          fs7.readlink(base, function(err3, target) {
             if (!isWindows)
               seenLinks[id] = target;
             gotTarget(err3, target);
@@ -25564,9 +25564,9 @@ var require_fs = __commonJS({
     realpath.realpathSync = realpathSync;
     realpath.monkeypatch = monkeypatch;
     realpath.unmonkeypatch = unmonkeypatch;
-    var fs6 = require("fs");
-    var origRealpath = fs6.realpath;
-    var origRealpathSync = fs6.realpathSync;
+    var fs7 = require("fs");
+    var origRealpath = fs7.realpath;
+    var origRealpathSync = fs7.realpathSync;
     var version2 = process.version;
     var ok = /^v[0-5]\./.test(version2);
     var old = require_old();
@@ -25604,12 +25604,12 @@ var require_fs = __commonJS({
       }
     }
     function monkeypatch() {
-      fs6.realpath = realpath;
-      fs6.realpathSync = realpathSync;
+      fs7.realpath = realpath;
+      fs7.realpathSync = realpathSync;
     }
     function unmonkeypatch() {
-      fs6.realpath = origRealpath;
-      fs6.realpathSync = origRealpathSync;
+      fs7.realpath = origRealpath;
+      fs7.realpathSync = origRealpathSync;
     }
   }
 });
@@ -26399,7 +26399,7 @@ var require_common4 = __commonJS({
     function ownProp(obj, field) {
       return Object.prototype.hasOwnProperty.call(obj, field);
     }
-    var fs6 = require("fs");
+    var fs7 = require("fs");
     var path2 = require("path");
     var minimatch = require_minimatch2();
     var isAbsolute2 = require_path_is_absolute();
@@ -26454,7 +26454,7 @@ var require_common4 = __commonJS({
       self2.stat = !!options.stat;
       self2.noprocess = !!options.noprocess;
       self2.absolute = !!options.absolute;
-      self2.fs = options.fs || fs6;
+      self2.fs = options.fs || fs7;
       self2.maxLength = options.maxLength || Infinity;
       self2.cache = options.cache || Object.create(null);
       self2.statCache = options.statCache || Object.create(null);
@@ -26661,27 +26661,27 @@ var require_sync = __commonJS({
           break;
       }
       var remain = pattern.slice(n);
-      var read4;
+      var read3;
       if (prefix === null)
-        read4 = ".";
+        read3 = ".";
       else if (isAbsolute2(prefix) || isAbsolute2(pattern.map(function(p) {
         return typeof p === "string" ? p : "[*]";
       }).join("/"))) {
         if (!prefix || !isAbsolute2(prefix))
           prefix = "/" + prefix;
-        read4 = prefix;
+        read3 = prefix;
       } else
-        read4 = prefix;
-      var abs = this._makeAbs(read4);
-      if (childrenIgnored(this, read4))
+        read3 = prefix;
+      var abs = this._makeAbs(read3);
+      if (childrenIgnored(this, read3))
         return;
       var isGlobStar = remain[0] === minimatch.GLOBSTAR;
       if (isGlobStar)
-        this._processGlobStar(prefix, read4, abs, remain, index, inGlobStar);
+        this._processGlobStar(prefix, read3, abs, remain, index, inGlobStar);
       else
-        this._processReaddir(prefix, read4, abs, remain, index, inGlobStar);
+        this._processReaddir(prefix, read3, abs, remain, index, inGlobStar);
     };
-    GlobSync.prototype._processReaddir = function(prefix, read4, abs, remain, index, inGlobStar) {
+    GlobSync.prototype._processReaddir = function(prefix, read3, abs, remain, index, inGlobStar) {
       var entries = this._readdir(abs, inGlobStar);
       if (!entries)
         return;
@@ -26836,7 +26836,7 @@ var require_sync = __commonJS({
           break;
       }
     };
-    GlobSync.prototype._processGlobStar = function(prefix, read4, abs, remain, index, inGlobStar) {
+    GlobSync.prototype._processGlobStar = function(prefix, read3, abs, remain, index, inGlobStar) {
       var entries = this._readdir(abs, inGlobStar);
       if (!entries)
         return;
@@ -27285,33 +27285,33 @@ var require_glob = __commonJS({
           break;
       }
       var remain = pattern.slice(n);
-      var read4;
+      var read3;
       if (prefix === null)
-        read4 = ".";
+        read3 = ".";
       else if (isAbsolute2(prefix) || isAbsolute2(pattern.map(function(p) {
         return typeof p === "string" ? p : "[*]";
       }).join("/"))) {
         if (!prefix || !isAbsolute2(prefix))
           prefix = "/" + prefix;
-        read4 = prefix;
+        read3 = prefix;
       } else
-        read4 = prefix;
-      var abs = this._makeAbs(read4);
-      if (childrenIgnored(this, read4))
+        read3 = prefix;
+      var abs = this._makeAbs(read3);
+      if (childrenIgnored(this, read3))
         return cb();
       var isGlobStar = remain[0] === minimatch.GLOBSTAR;
       if (isGlobStar)
-        this._processGlobStar(prefix, read4, abs, remain, index, inGlobStar, cb);
+        this._processGlobStar(prefix, read3, abs, remain, index, inGlobStar, cb);
       else
-        this._processReaddir(prefix, read4, abs, remain, index, inGlobStar, cb);
+        this._processReaddir(prefix, read3, abs, remain, index, inGlobStar, cb);
     };
-    Glob.prototype._processReaddir = function(prefix, read4, abs, remain, index, inGlobStar, cb) {
+    Glob.prototype._processReaddir = function(prefix, read3, abs, remain, index, inGlobStar, cb) {
       var self2 = this;
       this._readdir(abs, inGlobStar, function(er, entries) {
-        return self2._processReaddir2(prefix, read4, abs, remain, index, inGlobStar, entries, cb);
+        return self2._processReaddir2(prefix, read3, abs, remain, index, inGlobStar, entries, cb);
       });
     };
-    Glob.prototype._processReaddir2 = function(prefix, read4, abs, remain, index, inGlobStar, entries, cb) {
+    Glob.prototype._processReaddir2 = function(prefix, read3, 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, read4, abs, remain, index, inGlobStar, cb) {
+    Glob.prototype._processGlobStar = function(prefix, read3, abs, remain, index, inGlobStar, cb) {
       var self2 = this;
       this._readdir(abs, inGlobStar, function(er, entries) {
-        self2._processGlobStar2(prefix, read4, abs, remain, index, inGlobStar, entries, cb);
+        self2._processGlobStar2(prefix, read3, abs, remain, index, inGlobStar, entries, cb);
       });
     };
-    Glob.prototype._processGlobStar2 = function(prefix, read4, abs, remain, index, inGlobStar, entries, cb) {
+    Glob.prototype._processGlobStar2 = function(prefix, read3, abs, remain, index, inGlobStar, entries, cb) {
       if (!entries)
         return cb();
       var remainWithoutGlobStar = remain.slice(1);
@@ -27613,7 +27613,7 @@ var require_glob = __commonJS({
 // ../../node_modules/archiver-utils/file.js
 var require_file = __commonJS({
   "../../node_modules/archiver-utils/file.js"(exports, module2) {
-    var fs6 = require_graceful_fs();
+    var fs7 = require_graceful_fs();
     var path2 = require("path");
     var flatten = require_lodash2();
     var difference = require_lodash3();
@@ -27640,7 +27640,7 @@ var require_file = __commonJS({
     };
     file.exists = function() {
       var filepath = path2.join.apply(path2, arguments);
-      return fs6.existsSync(filepath);
+      return fs7.existsSync(filepath);
     };
     file.expand = function(...args) {
       var options = isPlainObject(args[0]) ? args.shift() : {};
@@ -27658,7 +27658,7 @@ var require_file = __commonJS({
             if (typeof options.filter === "function") {
               return options.filter(filepath);
             } else {
-              return fs6.statSync(filepath)[options.filter]();
+              return fs7.statSync(filepath)[options.filter]();
             }
           } catch (e) {
             return false;
@@ -27766,7 +27766,7 @@ var require_file = __commonJS({
 // ../../node_modules/archiver-utils/index.js
 var require_archiver_utils = __commonJS({
   "../../node_modules/archiver-utils/index.js"(exports, module2) {
-    var fs6 = require_graceful_fs();
+    var fs7 = require_graceful_fs();
     var path2 = require("path");
     var nutil = require("util");
     var lazystream = require_lazystream();
@@ -27815,7 +27815,7 @@ var require_archiver_utils = __commonJS({
     };
     utils.lazyReadStream = function(filepath) {
       return new lazystream.Readable(function() {
-        return fs6.createReadStream(filepath);
+        return fs7.createReadStream(filepath);
       });
     };
     utils.normalizeInputSource = function(source) {
@@ -27845,7 +27845,7 @@ var require_archiver_utils = __commonJS({
         callback = base;
         base = dirpath;
       }
-      fs6.readdir(dirpath, function(err, list) {
+      fs7.readdir(dirpath, function(err, list) {
         var i = 0;
         var file;
         var filepath;
@@ -27858,7 +27858,7 @@ var require_archiver_utils = __commonJS({
             return callback(null, results);
           }
           filepath = path2.join(dirpath, file);
-          fs6.stat(filepath, function(err2, stats) {
+          fs7.stat(filepath, function(err2, stats) {
             results.push({
               path: filepath,
               relative: path2.relative(base, filepath).replace(/\\/g, "/"),
@@ -30731,7 +30731,7 @@ var require_readable2 = __commonJS({
 // ../../node_modules/archiver/lib/core.js
 var require_core = __commonJS({
   "../../node_modules/archiver/lib/core.js"(exports, module2) {
-    var fs6 = require("fs");
+    var fs7 = require("fs");
     var glob = require_readdir_glob();
     var async = require_async();
     var path2 = require("path");
@@ -30795,7 +30795,7 @@ var require_core = __commonJS({
       data.sourcePath = filepath;
       task.data = data;
       this._entriesCount++;
-      if (data.stats && data.stats instanceof fs6.Stats) {
+      if (data.stats && data.stats instanceof fs7.Stats) {
         task = this._updateQueueTaskWithStats(task, data.stats);
         if (task) {
           if (data.stats.size) {
@@ -30966,7 +30966,7 @@ var require_core = __commonJS({
         callback();
         return;
       }
-      fs6.lstat(task.filepath, function(err, stats) {
+      fs7.lstat(task.filepath, function(err, stats) {
         if (this._state.aborted) {
           setImmediate(callback);
           return;
@@ -31009,7 +31009,7 @@ var require_core = __commonJS({
         task.data.sourceType = "buffer";
         task.source = Buffer.concat([]);
       } else if (stats.isSymbolicLink() && this._moduleSupports("symlink")) {
-        var linkPath = fs6.readlinkSync(task.filepath);
+        var linkPath = fs7.readlinkSync(task.filepath);
         var dirName = path2.dirname(task.filepath);
         task.data.type = "symlink";
         task.data.linkname = path2.relative(dirName, path2.resolve(dirName, linkPath));
@@ -45517,9 +45517,9 @@ var require_geoid = __commonJS({
     var stencilsize_ = 12;
     var nterms_ = (3 + 1) * (3 + 2) / 2;
     var PIXEL_SIZE = 2;
-    var Geoid = function() {
-      function Geoid2(options) {
-        (0, _classCallCheck2.default)(this, Geoid2);
+    var Geoid2 = function() {
+      function Geoid3(options) {
+        (0, _classCallCheck2.default)(this, Geoid3);
         (0, _defineProperty2.default)(this, "_v00", 0);
         (0, _defineProperty2.default)(this, "_v01", 0);
         (0, _defineProperty2.default)(this, "_v10", 0);
@@ -45532,7 +45532,7 @@ var require_geoid = __commonJS({
         this._ix = this.options._width;
         this._iy = this.options._height;
       }
-      (0, _createClass2.default)(Geoid2, [{
+      (0, _createClass2.default)(Geoid3, [{
         key: "getHeight",
         value: function getHeight(lat, lon) {
           lat = Math.abs(lat) > 90 ? NaN : lat;
@@ -45625,9 +45625,9 @@ var require_geoid = __commonJS({
           return r;
         }
       }]);
-      return Geoid2;
+      return Geoid3;
     }();
-    exports.default = Geoid;
+    exports.default = Geoid2;
     function remainder(x, y) {
       y = Math.abs(y);
       var z = fmod(x, y);
@@ -46582,12 +46582,37 @@ var isBrowser = Boolean(typeof process !== "object" || String(process) !== "[obj
 var matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
 var nodeVersion = matches && parseFloat(matches[1]) || 0;
 
+// ../loader-utils/src/lib/option-utils/merge-loader-options.ts
+function mergeLoaderOptions(baseOptions, newOptions) {
+  return mergeOptionsRecursively(baseOptions || {}, newOptions);
+}
+function mergeOptionsRecursively(baseOptions, newOptions) {
+  const options = { ...baseOptions };
+  for (const [key, newValue] of Object.entries(newOptions)) {
+    if (newValue && typeof newValue === "object" && !Array.isArray(newValue)) {
+      options[key] = mergeOptionsRecursively(options[key] || {}, newOptions[key]);
+    } else {
+      options[key] = newOptions[key];
+    }
+  }
+  return options;
+}
+
 // ../worker-utils/src/lib/env-utils/version.ts
-var DEFAULT_VERSION = "beta";
-var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : DEFAULT_VERSION;
-if (typeof __VERSION__ === "undefined") {
-  console.error("loaders.gl: The __VERSION__ variable is not injected using babel plugin. Latest unstable workers would be fetched from the CDN.");
+var NPM_TAG = "beta";
+function getVersion() {
+  if (!globalThis._loadersgl_?.version) {
+    globalThis._loadersgl_ = globalThis._loadersgl_ || {};
+    if (typeof __VERSION__ === "undefined") {
+      console.error("loaders.gl: The __VERSION__ variable is not injected using babel plugin. Latest unstable workers would be fetched from the CDN.");
+      globalThis._loadersgl_.version = NPM_TAG;
+    } else {
+      globalThis._loadersgl_.version = __VERSION__;
+    }
+  }
+  return globalThis._loadersgl_.version;
 }
+var VERSION = getVersion();
 
 // ../worker-utils/src/lib/env-utils/assert.ts
 function assert3(condition, message) {
@@ -46994,10 +47019,8 @@ var WorkerFarm = class {
 };
 
 // ../worker-utils/src/lib/worker-api/get-worker-url.ts
-var NPM_TAG = "beta";
-var VERSION2 = typeof VERSION !== "undefined" ? VERSION : NPM_TAG;
 function getWorkerName(worker) {
-  const warning = worker.version !== VERSION2 ? ` (worker-utils@${VERSION2})` : "";
+  const warning = worker.version !== VERSION ? ` (worker-utils@${VERSION})` : "";
   return `${worker.name}@${worker.version}${warning}`;
 }
 function getWorkerURL(worker, options = {}) {
@@ -47135,8 +47158,6 @@ function requireFromString(code, filename2 = "", options) {
 }
 
 // ../worker-utils/src/lib/library-utils/library-utils.ts
-var LATEST = "beta";
-var VERSION3 = typeof VERSION !== "undefined" ? VERSION : LATEST;
 var loadLibraryPromises = {};
 async function loadLibrary(libraryUrl, moduleName = null, options = {}, libraryName = null) {
   if (moduleName) {
@@ -47159,7 +47180,7 @@ function getLibraryUrl(library, moduleName, options = {}, libraryName = null) {
   }
   if (options.CDN) {
     assert3(options.CDN.startsWith("http"));
-    return `${options.CDN}/${moduleName}@${VERSION3}/dist/libs/${libraryName}`;
+    return `${options.CDN}/${moduleName}@${VERSION}/dist/libs/${libraryName}`;
   }
   if (isWorker) {
     return `../src/libs/${libraryName}`;
@@ -47617,12 +47638,12 @@ function resolvePath(filename2) {
 }
 
 // ../loader-utils/src/json-loader.ts
-var VERSION4 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+var VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
 var JSONLoader = {
   name: "JSON",
   id: "json",
   module: "json",
-  version: VERSION4,
+  version: VERSION2,
   extensions: ["json", "geojson"],
   mimeTypes: ["application/json"],
   category: "json",
@@ -47855,43 +47876,27 @@ __export(fs_exports, {
   readFile: () => readFile,
   readFileSync: () => readFileSync,
   readdir: () => readdir,
-  stat: () => stat,
+  stat: () => stat2,
   statSync: () => statSync,
   writeFile: () => writeFile,
   writeFileSync: () => writeFileSync
 });
-var import_fs2 = __toModule(require("fs"));
-var readdir;
-var stat;
-var statSync;
-var readFile;
-var readFileSync;
-var writeFile;
-var writeFileSync;
-var open;
-var close;
-var read;
-var fstat;
-var createReadStream;
-var createWriteStream;
-var isSupported = Boolean(import_fs2.default);
-try {
-  readdir = promisify2(import_fs2.default.readdir);
-  stat = promisify2(import_fs2.default.stat);
-  statSync = import_fs2.default.statSync;
-  readFile = import_fs2.default.readFile;
-  readFileSync = import_fs2.default.readFileSync;
-  writeFile = promisify3(import_fs2.default.writeFile);
-  writeFileSync = import_fs2.default.writeFileSync;
-  open = import_fs2.default.open;
-  close = (fd) => new Promise((resolve2, reject) => import_fs2.default.close(fd, (err) => err ? reject(err) : resolve2()));
-  read = import_fs2.default.read;
-  fstat = import_fs2.default.fstat;
-  createReadStream = import_fs2.default.createReadStream;
-  createWriteStream = import_fs2.default.createWriteStream;
-  isSupported = Boolean(import_fs2.default);
-} catch {
-}
+var fs2 = __toModule(require("fs"));
+var fsPromises = __toModule(require("fs/promises"));
+var readdir = promisify2(fs2.readdir);
+var stat2 = fsPromises.stat;
+var statSync = fs2.statSync;
+var readFile = fs2.readFile;
+var readFileSync = fs2.readFileSync;
+var writeFile = promisify3(fs2.writeFile);
+var writeFileSync = fs2.writeFileSync;
+var open = fs2.open;
+var close = (fd) => new Promise((resolve2, reject) => fs2.close(fd, (err) => err ? reject(err) : resolve2()));
+var read = fs2.read;
+var fstat = fs2.fstat;
+var createReadStream = fs2.createReadStream;
+var createWriteStream = fs2.createWriteStream;
+var isSupported = Boolean(fs2);
 async function _readToArrayBuffer(fd, start, length) {
   const buffer = Buffer.alloc(length);
   const { bytesRead } = await read(fd, buffer, 0, length, start);
@@ -47907,12 +47912,11 @@ var isFileProvider = (fileProvider) => {
 };
 
 // ../loader-utils/src/lib/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 }));
+        read(this.fileDescriptor, buffer, offset, length, position, (_err, bytesRead, buffer2) => s({ bytesRead, buffer: buffer2 }));
       });
     };
     this.fileDescriptor = fileDescriptor;
@@ -47921,18 +47925,14 @@ var FileHandle = class {
   static async open(path2) {
     const [fd, stats] = await Promise.all([
       new Promise((resolve2, reject) => {
-        (0, import_fs3.open)(path2, void 0, void 0, (_err, fd2) => _err ? reject(_err) : resolve2(fd2));
+        open(path2, void 0, void 0, (_err, fd2) => _err ? reject(_err) : resolve2(fd2));
       }),
-      new Promise((resolve2, reject) => {
-        (0, import_fs3.stat)(path2, { bigint: true }, (_err, stats2) => _err ? reject(_err) : resolve2(stats2));
-      })
+      stat2(path2, { bigint: true })
     ]);
     return new FileHandle(fd, stats);
   }
   async close() {
-    return new Promise((resolve2) => {
-      (0, import_fs3.close)(this.fileDescriptor, (_err) => resolve2());
-    });
+    return close(this.fileDescriptor);
   }
   get stat() {
     return this.stats;
@@ -48268,7 +48268,7 @@ var console_ = globalThis.console;
 var navigator_ = globalThis.navigator || {};
 
 // ../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/utils/globals.js
-var VERSION5 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "untranspiled source";
+var VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "untranspiled source";
 var isBrowser4 = isBrowser3();
 
 // ../../node_modules/@probe.gl/log/dist/utils/local-storage.js
@@ -48453,7 +48453,7 @@ var Log = class {
       id: ""
     };
     _defineProperty(this, "id", void 0);
-    _defineProperty(this, "VERSION", VERSION5);
+    _defineProperty(this, "VERSION", VERSION3);
     _defineProperty(this, "_startTs", getHiResTimestamp());
     _defineProperty(this, "_deltaTs", getHiResTimestamp());
     _defineProperty(this, "_storage", void 0);
@@ -48656,7 +48656,7 @@ var Log = class {
     return noop;
   }
 };
-_defineProperty(Log, "VERSION", VERSION5);
+_defineProperty(Log, "VERSION", VERSION3);
 function normalizeLogLevel(logLevel) {
   if (!logLevel) {
     return 0;
@@ -49386,6 +49386,7 @@ async function parse(data, loaders, options, context) {
 }
 async function parseWithLoader(loader, data, options, context) {
   validateWorkerVersion(loader);
+  options = mergeLoaderOptions(loader.options, options);
   if (isResponse(data)) {
     const response = data;
     const { ok, redirected, status, statusText, type, url } = response;
@@ -49490,7 +49491,7 @@ async function encodeURLtoURL(inputUrl, outputUrl, writer, options) {
   return outputFilename;
 }
 function getIterator(data) {
-  const dataIterator = [{ table: data, start: 0, end: data.length }];
+  const dataIterator = [{ ...data, start: 0, end: data.length }];
   return dataIterator;
 }
 function getTemporaryFilename(filename2) {
@@ -49607,7 +49608,7 @@ function createSphere(sphere, transform11, result) {
 }
 
 // ../3d-tiles/src/lib/utils/version.ts
-var VERSION6 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+var VERSION4 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
 
 // ../3d-tiles/src/lib/constants.ts
 var TILE3D_TYPE = {
@@ -49641,7 +49642,7 @@ function getMagicString3(arrayBuffer, byteOffset = 0) {
 }
 
 // ../draco/src/lib/utils/version.ts
-var VERSION7 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+var VERSION5 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
 
 // ../draco/src/draco-loader.ts
 var DEFAULT_DRACO_OPTIONS = {
@@ -49656,7 +49657,7 @@ var DracoLoader = {
   name: "Draco",
   id: "draco",
   module: "draco",
-  version: VERSION7,
+  version: VERSION5,
   worker: true,
   extensions: ["drc"],
   mimeTypes: ["application/octet-stream"],
@@ -50121,7 +50122,7 @@ function getUint32Array(dracoArray) {
 }
 
 // ../draco/src/lib/draco-module-loader.ts
-var DRACO_DECODER_VERSION = "1.5.5";
+var DRACO_DECODER_VERSION = "1.5.6";
 var DRACO_ENCODER_VERSION = "1.4.1";
 var STATIC_DECODER_URL = `https://www.gstatic.com/draco/versioned/decoders/${DRACO_DECODER_VERSION}`;
 var DRACO_EXTERNAL_LIBRARIES = {
@@ -50183,7 +50184,7 @@ var DracoWriterWorker = {
   id: "draco-writer",
   name: "Draco compressed geometry writer",
   module: "draco",
-  version: VERSION7,
+  version: VERSION5,
   worker: true,
   options: {
     draco: {},
@@ -51345,12 +51346,12 @@ async function loadDraco(tile, dracoData, options, context) {
 // ../gltf/src/lib/extensions/EXT_mesh_features.ts
 var EXT_mesh_features_exports = {};
 __export(EXT_mesh_features_exports, {
-  decode: () => decode2,
-  name: () => name2
+  decode: () => decode,
+  name: () => name
 });
 
 // ../images/src/lib/utils/version.ts
-var VERSION8 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+var VERSION6 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
 
 // ../images/src/lib/category-api/image-type.ts
 var { _parseImageNode } = globalThis;
@@ -51741,7 +51742,7 @@ var ImageLoader = {
   id: "image",
   module: "images",
   name: "Images",
-  version: VERSION8,
+  version: VERSION6,
   mimeTypes: MIME_TYPES,
   extensions: EXTENSIONS,
   parse: parseImage,
@@ -51804,7 +51805,7 @@ var ImageWriter = {
   name: "Images",
   id: "image",
   module: "images",
-  version: VERSION8,
+  version: VERSION6,
   extensions: ["jpeg"],
   options: {
     image: {
@@ -51855,6 +51856,25 @@ function assert6(condition, message) {
   }
 }
 
+// ../gltf/src/lib/gltf-utils/gltf-constants.ts
+var COMPONENTS = {
+  SCALAR: 1,
+  VEC2: 2,
+  VEC3: 3,
+  VEC4: 4,
+  MAT2: 4,
+  MAT3: 9,
+  MAT4: 16
+};
+var BYTES = {
+  5120: 1,
+  5121: 1,
+  5122: 2,
+  5123: 2,
+  5125: 4,
+  5126: 4
+};
+
 // ../gltf/src/lib/gltf-utils/gltf-utils.ts
 var MIPMAP_FACTOR = 1.33;
 var TYPES = ["SCALAR", "VEC2", "VEC3", "VEC4"];
@@ -51913,6 +51933,27 @@ function getAccessorArrayTypeAndLength(accessor, bufferView) {
   assert6(byteLength >= 0 && byteLength <= bufferView.byteLength);
   return { ArrayType, length, byteLength };
 }
+function getFloat32ArrayForAccessor(gltfData, texCoordAccessor) {
+  const accessor = gltfData.json.accessors?.[texCoordAccessor];
+  if (accessor && typeof accessor.bufferView !== "undefined") {
+    const bufferView = gltfData.json.bufferViews?.[accessor.bufferView];
+    if (bufferView) {
+      const { arrayBuffer, byteOffset: bufferByteOffset } = gltfData.buffers[bufferView.buffer];
+      const byteOffset = (bufferByteOffset || 0) + (accessor.byteOffset || 0) + (bufferView.byteOffset || 0);
+      const { ArrayType, length } = getAccessorArrayTypeAndLength(accessor, bufferView);
+      const bytes = BYTES[accessor.componentType];
+      const components = COMPONENTS[accessor.type];
+      const elementAddressScale = bufferView.byteStride || bytes * components;
+      const result = new Float32Array(length);
+      for (let i = 0; i < accessor.count; i++) {
+        const uv = new ArrayType(arrayBuffer, byteOffset + i * elementAddressScale, 2);
+        result.set(uv, i * components);
+      }
+      return result;
+    }
+  }
+  return null;
+}
 function getMemoryUsageGLTF(gltf) {
   let { images, bufferViews } = gltf;
   images = images || [];
@@ -52340,7 +52381,7 @@ var GLTFScenegraph = class {
   }
 };
 
-// ../gltf/src/lib/extensions/data-processing.ts
+// ../gltf/src/lib/extensions/utils/3d-tiles-utils.ts
 var ATTRIBUTE_TYPE_TO_COMPONENTS2 = {
   SCALAR: 1,
   VEC2: 2,
@@ -52380,21 +52421,40 @@ var ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE2 = {
 function getArrayElementByteSize(attributeType, componentType) {
   return ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE2[componentType] * ATTRIBUTE_TYPE_TO_COMPONENTS2[attributeType];
 }
-function convertRawBufferToMetadataArray(typedArray, attributeType, componentType, elementCount = 1) {
+function getOffsetsForProperty(scenegraph, bufferViewIndex, offsetType, numberOfElements) {
+  if (offsetType !== "UINT8" && offsetType !== "UINT16" && offsetType !== "UINT32" && offsetType !== "UINT64") {
+    return null;
+  }
+  const arrayOffsetsBytes = scenegraph.getTypedArrayForBufferView(bufferViewIndex);
+  const arrayOffsets = convertRawBufferToMetadataArray(arrayOffsetsBytes, "SCALAR", offsetType, numberOfElements + 1);
+  if (arrayOffsets instanceof BigInt64Array || arrayOffsets instanceof BigUint64Array) {
+    return null;
+  }
+  return arrayOffsets;
+}
+function convertRawBufferToMetadataArray(data, attributeType, componentType, elementCount = 1) {
   const numberOfComponents = ATTRIBUTE_TYPE_TO_COMPONENTS2[attributeType];
   const ArrayType = ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY2[componentType];
-  const length = elementCount * numberOfComponents;
   const size = ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE2[componentType];
-  const offset = typedArray.byteOffset % size ? Math.ceil(typedArray.byteOffset / size) * size : typedArray.byteOffset;
-  return new ArrayType(typedArray.buffer, offset, length);
+  const length = elementCount * numberOfComponents;
+  const byteLength = length * size;
+  let buffer = data.buffer;
+  let offset = data.byteOffset;
+  if (offset % size !== 0) {
+    const bufferArray = new Uint8Array(buffer);
+    buffer = bufferArray.slice(offset, offset + byteLength).buffer;
+    offset = 0;
+  }
+  return new ArrayType(buffer, offset, length);
 }
 function getPrimitiveTextureData(scenegraph, textureInfo, primitive) {
   const json = scenegraph.gltf.json;
   const texCoordAccessorKey = `TEXCOORD_${textureInfo.texCoord || 0}`;
   const texCoordAccessorIndex = primitive.attributes[texCoordAccessorKey];
-  const texCoordBufferView = scenegraph.getBufferView(texCoordAccessorIndex);
-  const texCoordArray = scenegraph.getTypedArrayForBufferView(texCoordBufferView);
-  const textureCoordinates = new Float32Array(texCoordArray.buffer, texCoordArray.byteOffset, texCoordArray.length / 4);
+  const textureCoordinates = getFloat32ArrayForAccessor(scenegraph.gltf, texCoordAccessorIndex);
+  if (!textureCoordinates) {
+    return null;
+  }
   const textureIndex = textureInfo.index;
   const imageIndex = json.textures?.[textureIndex]?.source;
   if (typeof imageIndex !== "undefined") {
@@ -52412,8 +52472,9 @@ function getPrimitiveTextureData(scenegraph, textureInfo, primitive) {
   return null;
 }
 function primitivePropertyDataToAttributes(scenegraph, attributeName, propertyData, featureTable, primitive) {
-  if (propertyData === null)
+  if (!propertyData?.length) {
     return;
+  }
   const featureIndices = [];
   for (const texelData of propertyData) {
     let index = featureTable.findIndex((item) => item === texelData);
@@ -52437,12 +52498,12 @@ function primitivePropertyDataToAttributes(scenegraph, attributeName, propertyDa
   primitive.attributes[attributeName] = accessorIndex;
 }
 function getImageValueByCoordinates(parsedImage, mimeType, textureCoordinates, index, channels = [0]) {
-  const CHANNELS_MAP = [
-    { offset: 0, shift: 0 },
-    { offset: 1, shift: 8 },
-    { offset: 2, shift: 16 },
-    { offset: 3, shift: 24 }
-  ];
+  const CHANNELS_MAP = {
+    r: { offset: 0, shift: 0 },
+    g: { offset: 1, shift: 8 },
+    b: { offset: 2, shift: 16 },
+    a: { offset: 3, shift: 24 }
+  };
   const u = textureCoordinates[index];
   const v = textureCoordinates[index + 1];
   let components = 1;
@@ -52451,7 +52512,7 @@ function getImageValueByCoordinates(parsedImage, mimeType, textureCoordinates, i
   const offset = coordinatesToOffset(u, v, parsedImage, components);
   let value = 0;
   for (const c of channels) {
-    const map = CHANNELS_MAP[c];
+    const map = typeof c === "number" ? Object.values(CHANNELS_MAP)[c] : CHANNELS_MAP[c];
     const imageOffset = offset + map.offset;
     const imageData = getImageData(parsedImage);
     if (imageData.data.length <= imageOffset) {
@@ -52474,19 +52535,81 @@ function coordinatesToOffset(u, v, parsedImage, componentsCount = 1) {
   return offset;
 }
 
+// ../gltf/src/lib/extensions/EXT_mesh_features.ts
+var EXT_MESH_FEATURES_NAME = "EXT_mesh_features";
+var name = EXT_MESH_FEATURES_NAME;
+async function decode(gltfData, options) {
+  const scenegraph = new GLTFScenegraph(gltfData);
+  decodeExtMeshFeatures(scenegraph, options);
+}
+function decodeExtMeshFeatures(scenegraph, options) {
+  const json = scenegraph.gltf.json;
+  if (!json.meshes) {
+    return;
+  }
+  for (const mesh of json.meshes) {
+    for (const primitive of mesh.primitives) {
+      processMeshPrimitiveFeatures(scenegraph, primitive, options);
+    }
+  }
+}
+function processMeshPrimitiveFeatures(scenegraph, primitive, options) {
+  if (!options?.gltf?.loadBuffers) {
+    return;
+  }
+  const extension = primitive.extensions?.[EXT_MESH_FEATURES_NAME];
+  const featureIds = extension?.featureIds;
+  if (!featureIds) {
+    return;
+  }
+  for (const featureId of featureIds) {
+    let featureIdData = null;
+    if (typeof featureId.attribute !== "undefined") {
+      const accessorKey = `_FEATURE_ID_${featureId.attribute}`;
+      const accessorIndex = primitive.attributes[accessorKey];
+      featureIdData = scenegraph.getTypedArrayForAccessor(accessorIndex);
+    } else if (typeof featureId.texture !== "undefined" && options?.gltf?.loadImages) {
+      featureIdData = getPrimitiveTextureData(scenegraph, featureId.texture, primitive);
+    } else {
+    }
+    featureId.data = featureIdData;
+  }
+}
+
 // ../gltf/src/lib/extensions/EXT_structural_metadata.ts
 var EXT_structural_metadata_exports = {};
 __export(EXT_structural_metadata_exports, {
-  decode: () => decode,
+  decode: () => decode2,
+  getPropertyTableFromExtStructuralMetadata: () => getPropertyTableFromExtStructuralMetadata,
   getPropertyTablePopulated: () => getPropertyTablePopulated,
-  name: () => name
+  name: () => name2
 });
 var EXT_STRUCTURAL_METADATA_NAME = "EXT_structural_metadata";
-var name = EXT_STRUCTURAL_METADATA_NAME;
-async function decode(gltfData, options) {
+var name2 = EXT_STRUCTURAL_METADATA_NAME;
+async function decode2(gltfData, options) {
   const scenegraph = new GLTFScenegraph(gltfData);
   decodeExtStructuralMetadata(scenegraph, options);
 }
+function getPropertyTableFromExtStructuralMetadata(extension, metadataClass) {
+  if (extension.propertyTables) {
+    const firstPropertyTable = extension?.propertyTables[0];
+    const propertyTableWithData = {};
+    for (const propertyName in firstPropertyTable.properties) {
+      propertyTableWithData[propertyName] = firstPropertyTable.properties[propertyName].data;
+    }
+    return propertyTableWithData;
+  }
+  if (extension.propertyTextures) {
+    const firstPropertyTexture = extension?.propertyTextures[0];
+    const propertyTableWithData = {};
+    for (const propertyName in firstPropertyTexture.properties) {
+      propertyTableWithData[propertyName] = firstPropertyTexture.properties[propertyName].data;
+    }
+    return propertyTableWithData;
+  }
+  console.warn("Cannot get property table from EXT_structural_metadata extension. There is neither propertyTables, nor propertyTextures in the extension.");
+  return null;
+}
 function getPropertyTablePopulated(scenegraph, propertyTableIndex) {
   const extension = scenegraph.getExtension(EXT_STRUCTURAL_METADATA_NAME);
   const propertyTable = extension?.propertyTables?.[propertyTableIndex];
@@ -52497,30 +52620,53 @@ function getPropertyTablePopulated(scenegraph, propertyTableIndex) {
   throw new Error(`Incorrect data in the EXT_structural_metadata extension: no property table with index ${propertyTableIndex}`);
 }
 function decodeExtStructuralMetadata(scenegraph, options) {
+  if (!options.gltf?.loadBuffers) {
+    return;
+  }
   const extension = scenegraph.getExtension(EXT_STRUCTURAL_METADATA_NAME);
-  if (!extension?.schema) {
+  if (!extension) {
     return;
   }
+  if (options.gltf?.loadImages) {
+    decodePropertyTextures(scenegraph, extension);
+  }
+  decodePropertyTables(scenegraph, extension);
+}
+function decodePropertyTextures(scenegraph, extension) {
   const propertyTextures = extension.propertyTextures;
   const json = scenegraph.gltf.json;
-  if (propertyTextures && json.meshes && options?.gltf?.loadImages) {
+  if (propertyTextures && json.meshes) {
     for (const mesh of json.meshes) {
       for (const primitive of mesh.primitives) {
         processPrimitivePropertyTextures(scenegraph, propertyTextures, primitive, extension);
       }
     }
   }
-  const schemaClasses = extension.schema.classes;
+}
+function decodePropertyTables(scenegraph, extension) {
+  const schema = extension.schema;
+  if (!schema) {
+    return;
+  }
+  const schemaClasses = schema.classes;
   const propertyTables = extension.propertyTables;
   if (schemaClasses && propertyTables) {
     for (const schemaName in schemaClasses) {
       const propertyTable = findPropertyTableByClass(propertyTables, schemaName);
       if (propertyTable) {
-        processPropertyTable(scenegraph, extension.schema, propertyTable);
+        processPropertyTable(scenegraph, schema, propertyTable);
       }
     }
   }
 }
+function findPropertyTableByClass(propertyTables, schemaClassName) {
+  for (const propertyTable of propertyTables) {
+    if (propertyTable.class === schemaClassName) {
+      return propertyTable;
+    }
+  }
+  return null;
+}
 function processPrimitivePropertyTextures(scenegraph, propertyTextures, primitive, extension) {
   if (!propertyTextures) {
     return;
@@ -52543,9 +52689,9 @@ function processPrimitivePropertyTexture(scenegraph, propertyTexture, primitive,
     extension.dataAttributeNames = [];
   }
   const className = propertyTexture.class;
-  for (const propName in propertyTexture.properties) {
-    const attributeName = `${className}_${propName}`;
-    const textureInfoTopLevel = propertyTexture.properties?.[propName];
+  for (const propertyName in propertyTexture.properties) {
+    const attributeName = `${className}_${propertyName}`;
+    const textureInfoTopLevel = propertyTexture.properties?.[propertyName];
     if (!textureInfoTopLevel) {
       continue;
     }
@@ -52581,14 +52727,8 @@ function getPropertyDataFromBinarySource(scenegraph, schema, classProperty, numb
   let data = [];
   const valuesBufferView = propertyTableProperty.values;
   const valuesDataBytes = scenegraph.getTypedArrayForBufferView(valuesBufferView);
-  let arrayOffsets = null;
-  if (classProperty.array && typeof classProperty.count === "undefined" && typeof propertyTableProperty.arrayOffsets !== "undefined" && typeof propertyTableProperty.arrayOffsetType !== "undefined") {
-    arrayOffsets = getOffsetArray(scenegraph, propertyTableProperty.arrayOffsets, propertyTableProperty.arrayOffsetType, numberOfElements);
-  }
-  let stringOffsets = null;
-  if (typeof propertyTableProperty.stringOffsets !== "undefined" && typeof propertyTableProperty.stringOffsetType !== "undefined") {
-    stringOffsets = getOffsetArray(scenegraph, propertyTableProperty.stringOffsets, propertyTableProperty.stringOffsetType, numberOfElements);
-  }
+  const arrayOffsets = getArrayOffsetsForProperty(scenegraph, classProperty, propertyTableProperty, numberOfElements);
+  const stringOffsets = getStringOffsetsForProperty(scenegraph, propertyTableProperty, numberOfElements);
   switch (classProperty.type) {
     case "SCALAR":
     case "VEC2":
@@ -52616,11 +52756,17 @@ function getPropertyDataFromBinarySource(scenegraph, schema, classProperty, numb
   }
   return data;
 }
-function getOffsetArray(scenegraph, offsets, offsetType, numberOfElements) {
-  const arrayOffsetsBufferView = offsets;
-  const arrayOffsetsBytes = scenegraph.getTypedArrayForBufferView(arrayOffsetsBufferView);
-  const arrayOffsets = convertRawBufferToMetadataArray(arrayOffsetsBytes, "SCALAR", offsetType, numberOfElements + 1);
-  return arrayOffsets;
+function getArrayOffsetsForProperty(scenegraph, classProperty, propertyTableProperty, numberOfElements) {
+  if (classProperty.array && typeof classProperty.count === "undefined" && typeof propertyTableProperty.arrayOffsets !== "undefined") {
+    return getOffsetsForProperty(scenegraph, propertyTableProperty.arrayOffsets, propertyTableProperty.arrayOffsetType || "UINT32", numberOfElements);
+  }
+  return null;
+}
+function getStringOffsetsForProperty(scenegraph, propertyTableProperty, numberOfElements) {
+  if (typeof propertyTableProperty.stringOffsets !== "undefined") {
+    return getOffsetsForProperty(scenegraph, propertyTableProperty.stringOffsets, propertyTableProperty.stringOffsetType || "UINT32", numberOfElements);
+  }
+  return null;
 }
 function getPropertyDataNumeric(classProperty, numberOfElements, valuesDataBytes, arrayOffsets) {
   const isArray = classProperty.array;
@@ -52630,52 +52776,42 @@ function getPropertyDataNumeric(classProperty, numberOfElements, valuesDataBytes
   let valuesData;
   if (classProperty.componentType) {
     valuesData = convertRawBufferToMetadataArray(valuesDataBytes, classProperty.type, classProperty.componentType, elementCount);
+    if (!valuesData) {
+      valuesData = valuesDataBytes;
+    }
   } else {
     valuesData = valuesDataBytes;
   }
   if (isArray) {
     if (arrayOffsets) {
-      return handleVariableLengthArrayNumeric(valuesData, numberOfElements, arrayOffsets, valuesDataBytes.length, elementSize);
+      return parseVariableLengthArrayNumeric(valuesData, numberOfElements, arrayOffsets, valuesDataBytes.length, elementSize);
     }
     if (arrayCount) {
-      return handleFixedLengthArrayNumeric(valuesData, numberOfElements, arrayCount);
+      return parseFixedLengthArrayNumeric(valuesData, numberOfElements, arrayCount);
     }
     return [];
   }
-  const attributeValueArray = [];
-  for (let index = 0; index < numberOfElements; index++) {
-    const value = valuesData[index];
-    attributeValueArray.push(value);
-  }
-  return attributeValueArray;
+  return valuesData;
 }
-function handleVariableLengthArrayNumeric(valuesData, numberOfElements, arrayOffsets, valuesDataBytesLength, elementSize) {
+function parseVariableLengthArrayNumeric(valuesData, numberOfElements, arrayOffsets, valuesDataBytesLength, valueSize) {
   const attributeValueArray = [];
   for (let index = 0; index < numberOfElements; index++) {
-    const array = [];
     const arrayOffset = arrayOffsets[index];
     const arrayByteSize = arrayOffsets[index + 1] - arrayOffsets[index];
-    if (arrayByteSize + arrayOffset <= valuesDataBytesLength) {
-      const typedArrayOffset = arrayOffset / elementSize;
-      const elementCount = arrayByteSize / elementSize;
-      for (let i = 0; i < elementCount; i++) {
-        const value = valuesData[typedArrayOffset + i];
-        array.push(value);
-      }
+    if (arrayByteSize + arrayOffset > valuesDataBytesLength) {
+      break;
     }
-    attributeValueArray.push(array);
+    const typedArrayOffset = arrayOffset / valueSize;
+    const elementCount = arrayByteSize / valueSize;
+    attributeValueArray.push(valuesData.slice(typedArrayOffset, typedArrayOffset + elementCount));
   }
   return attributeValueArray;
 }
-function handleFixedLengthArrayNumeric(valuesData, numberOfElements, arrayCount) {
+function parseFixedLengthArrayNumeric(valuesData, numberOfElements, arrayCount) {
   const attributeValueArray = [];
   for (let index = 0; index < numberOfElements; index++) {
-    const array = [];
-    for (let i = 0; i < arrayCount; i++) {
-      const value = valuesData[i];
-      array.push(value);
-    }
-    attributeValueArray.push(array);
+    const elementOffset = index * arrayCount;
+    attributeValueArray.push(valuesData.slice(elementOffset, elementOffset + arrayCount));
   }
   return attributeValueArray;
 }
@@ -52701,9 +52837,6 @@ function getPropertyDataString(classProperty, numberOfElements, valuesDataBytes,
   return [];
 }
 function getPropertyDataENUM(schema, classProperty, numberOfElements, valuesDataBytes, arrayOffsets) {
-  const data = [];
-  const isArray = classProperty.array;
-  const arrayCount = classProperty.count;
   const enumType = classProperty.enumType;
   if (!enumType) {
     throw new Error("Incorrect data in the EXT_structural_metadata extension: classProperty.enumType is not set for type ENUM");
@@ -52715,69 +52848,77 @@ function getPropertyDataENUM(schema, classProperty, numberOfElements, valuesData
   const enumValueType = enumEntry.valueType || "UINT16";
   const elementSize = getArrayElementByteSize(classProperty.type, enumValueType);
   const elementCount = valuesDataBytes.byteLength / elementSize;
-  const valuesData = convertRawBufferToMetadataArray(valuesDataBytes, classProperty.type, enumValueType, elementCount);
-  if (isArray) {
+  let valuesData = convertRawBufferToMetadataArray(valuesDataBytes, classProperty.type, enumValueType, elementCount);
+  if (!valuesData) {
+    valuesData = valuesDataBytes;
+  }
+  if (classProperty.array) {
     if (arrayOffsets) {
-      return handleVariableLengthArrayENUM(valuesData, numberOfElements, arrayOffsets, valuesDataBytes.length, elementSize, enumEntry);
+      return parseVariableLengthArrayENUM({
+        valuesData,
+        numberOfElements,
+        arrayOffsets,
+        valuesDataBytesLength: valuesDataBytes.length,
+        elementSize,
+        enumEntry
+      });
     }
+    const arrayCount = classProperty.count;
     if (arrayCount) {
-      return handleFixedLengthArrayENUM(valuesData, numberOfElements, arrayCount, enumEntry);
+      return parseFixedLengthArrayENUM(valuesData, numberOfElements, arrayCount, enumEntry);
     }
     return [];
   }
-  for (let index = 0; index < numberOfElements; index++) {
-    const enumValue = valuesData[index];
-    const enumObject = getEnumByValue(enumEntry, enumValue);
-    if (enumObject) {
-      data.push(enumObject.name);
-    }
-  }
-  return data;
+  return getEnumsArray(valuesData, 0, numberOfElements, enumEntry);
 }
-function handleVariableLengthArrayENUM(valuesData, numberOfElements, arrayOffsets, valuesDataBytesLength, elementSize, enumEntry) {
+function parseVariableLengthArrayENUM(params) {
+  const {
+    valuesData,
+    numberOfElements,
+    arrayOffsets,
+    valuesDataBytesLength,
+    elementSize,
+    enumEntry
+  } = params;
   const attributeValueArray = [];
   for (let index = 0; index < numberOfElements; index++) {
-    const array = [];
     const arrayOffset = arrayOffsets[index];
     const arrayByteSize = arrayOffsets[index + 1] - arrayOffsets[index];
-    if (arrayByteSize + arrayOffset <= valuesDataBytesLength) {
-      const typedArrayOffset = arrayOffset / elementSize;
-      const elementCount = arrayByteSize / elementSize;
-      for (let i = 0; i < elementCount; i++) {
-        const value = valuesData[typedArrayOffset + i];
-        const enumObject = getEnumByValue(enumEntry, value);
-        if (enumObject) {
-          array.push(enumObject.name);
-        }
-      }
+    if (arrayByteSize + arrayOffset > valuesDataBytesLength) {
+      break;
     }
+    const typedArrayOffset = arrayOffset / elementSize;
+    const elementCount = arrayByteSize / elementSize;
+    const array = getEnumsArray(valuesData, typedArrayOffset, elementCount, enumEntry);
     attributeValueArray.push(array);
   }
   return attributeValueArray;
 }
-function handleFixedLengthArrayENUM(valuesData, numberOfElements, arrayCount, enumEntry) {
+function parseFixedLengthArrayENUM(valuesData, numberOfElements, arrayCount, enumEntry) {
   const attributeValueArray = [];
   for (let index = 0; index < numberOfElements; index++) {
-    const array = [];
-    for (let i = 0; i < arrayCount; i++) {
-      const value = valuesData[i];
-      const enumObject = getEnumByValue(enumEntry, value);
-      if (enumObject) {
-        array.push(enumObject.name);
-      }
-    }
+    const elementOffset = arrayCount * index;
+    const array = getEnumsArray(valuesData, elementOffset, arrayCount, enumEntry);
     attributeValueArray.push(array);
   }
   return attributeValueArray;
 }
-function findPropertyTableByClass(propertyTables, schemaClassName) {
-  for (let i = 0, len = propertyTables.length; i < len; i++) {
-    const propertyTable = propertyTables[i];
-    if (propertyTable.class === schemaClassName) {
-      return propertyTable;
+function getEnumsArray(valuesData, offset, count, enumEntry) {
+  const array = [];
+  for (let i = 0; i < count; i++) {
+    if (valuesData instanceof BigInt64Array || valuesData instanceof BigUint64Array) {
+      array.push("");
+    } else {
+      const value = valuesData[offset + i];
+      const enumObject = getEnumByValue(enumEntry, value);
+      if (enumObject) {
+        array.push(enumObject.name);
+      } else {
+        array.push("");
+      }
     }
   }
-  return null;
+  return array;
 }
 function getEnumByValue(enumEntry, value) {
   for (const enumValue of enumEntry.values) {
@@ -52788,63 +52929,11 @@ function getEnumByValue(enumEntry, value) {
   return null;
 }
 
-// ../gltf/src/lib/extensions/EXT_mesh_features.ts
-var EXT_MESH_FEATURES_NAME = "EXT_mesh_features";
-var name2 = EXT_MESH_FEATURES_NAME;
-async function decode2(gltfData, options) {
-  const scenegraph = new GLTFScenegraph(gltfData);
-  decodeExtMeshFeatures(scenegraph, options);
-}
-function decodeExtMeshFeatures(scenegraph, options) {
-  const json = scenegraph.gltf.json;
-  if (!json.meshes) {
-    return;
-  }
-  for (const mesh of json.meshes) {
-    for (const primitive of mesh.primitives) {
-      processMeshPrimitiveFeatures(scenegraph, primitive, options);
-    }
-  }
-}
-function processMeshPrimitiveFeatures(scenegraph, primitive, options) {
-  const extension = primitive.extensions?.[EXT_MESH_FEATURES_NAME];
-  const featureIds = extension?.featureIds;
-  if (!featureIds)
-    return;
-  if (!extension.dataAttributeNames) {
-    extension.dataAttributeNames = [];
-  }
-  let featureIdCount = 0;
-  for (const featureId of featureIds) {
-    let propertyTable = null;
-    if (typeof featureId.propertyTable === "number") {
-      propertyTable = getPropertyTablePopulated(scenegraph, featureId.propertyTable);
-    }
-    let propertyData = null;
-    if (typeof featureId.attribute !== "undefined") {
-      const accessorKey = `_FEATURE_ID_${featureId.attribute}`;
-      const accessorIndex = primitive.attributes[accessorKey];
-      const propertyDataTypedArray = scenegraph.getTypedArrayForAccessor(accessorIndex);
-      propertyData = Array.prototype.slice.call(propertyDataTypedArray);
-    } else if (typeof featureId.texture !== "undefined" && options?.gltf?.loadImages) {
-      propertyData = getPrimitiveTextureData(scenegraph, featureId.texture, primitive);
-    } else {
-    }
-    const attributeName = featureId.label || propertyTable?.name || `featureAttribute${featureIdCount}`;
-    const featureTable = [];
-    if (propertyData) {
-      primitivePropertyDataToAttributes(scenegraph, attributeName, propertyData, featureTable, primitive);
-    }
-    extension.dataAttributeNames.push(attributeName);
-    featureId.data = featureTable;
-    featureIdCount++;
-  }
-}
-
 // ../gltf/src/lib/extensions/deprecated/EXT_feature_metadata.ts
 var EXT_feature_metadata_exports = {};
 __export(EXT_feature_metadata_exports, {
   decode: () => decode3,
+  getPropertyTableFromExtFeatureMetadata: () => getPropertyTableFromExtFeatureMetadata,
   name: () => name3
 });
 var EXT_FEATURE_METADATA_NAME = "EXT_feature_metadata";
@@ -52853,6 +52942,38 @@ async function decode3(gltfData, options) {
   const scenegraph = new GLTFScenegraph(gltfData);
   decodeExtFeatureMetadata(scenegraph, options);
 }
+function getPropertyTableFromExtFeatureMetadata(extension, metadataClass) {
+  if (extension.featureTables) {
+    const firstFeatureTableName = Object.keys(extension.featureTables)?.[0];
+    if (firstFeatureTableName) {
+      const featureTable = extension.featureTables[firstFeatureTableName];
+      const propertyTable = {};
+      for (const propertyName in featureTable.properties) {
+        propertyTable[propertyName] = featureTable.properties[propertyName].data;
+      }
+      return propertyTable;
+    }
+  }
+  if (extension.featureTextures) {
+    let featureTexture;
+    for (const textureKey in extension.featureTextures) {
+      const texture = extension.featureTextures[textureKey];
+      if (texture.class === metadataClass) {
+        featureTexture = textureKey;
+      }
+    }
+    if (typeof featureTexture === "string") {
+      const featureTable = extension.featureTextures[featureTexture];
+      const propertyTable = {};
+      for (const propertyName in featureTable.properties) {
+        propertyTable[propertyName] = featureTable.properties[propertyName].data;
+      }
+      return propertyTable;
+    }
+  }
+  console.warn("Cannot get property table from EXT_feature_metadata extension. There is neither featureTables, nor featureTextures in the extension.");
+  return null;
+}
 function decodeExtFeatureMetadata(scenegraph, options) {
   const extension = scenegraph.getExtension(EXT_FEATURE_METADATA_NAME);
   if (!extension)
@@ -52903,16 +53024,43 @@ function handleFeatureTextureProperties(scenegraph, featureTexture, schemaClass)
 function getPropertyDataFromBinarySource2(scenegraph, schemaProperty, numberOfFeatures, featureTableProperty) {
   const bufferView = featureTableProperty.bufferView;
   const dataArray = scenegraph.getTypedArrayForBufferView(bufferView);
-  switch (schemaProperty.type) {
-    case "STRING": {
-      const stringOffsetBufferView = featureTableProperty.stringOffsetBufferView;
-      const offsetsData = scenegraph.getTypedArrayForBufferView(stringOffsetBufferView);
-      return getStringAttributes(dataArray, offsetsData, numberOfFeatures);
+  if (schemaProperty.type === "STRING") {
+    const offsetsData = getStringOffsets(scenegraph, featureTableProperty, numberOfFeatures);
+    if (!offsetsData) {
+      return [];
     }
-    default:
+    return getStringAttributes(dataArray, offsetsData, numberOfFeatures);
+  } else if (isNumericProperty(schemaProperty.type)) {
+    return getNumericAttributes(dataArray, schemaProperty.type, numberOfFeatures);
   }
   return dataArray;
 }
+function isNumericProperty(schemaPropertyType) {
+  return [
+    "UINT8",
+    "INT16",
+    "UINT16",
+    "INT32",
+    "UINT32",
+    "INT64",
+    "UINT64",
+    "FLOAT32",
+    "FLOAT64"
+  ].includes(schemaPropertyType);
+}
+function getStringOffsets(scenegraph, featureTableProperty, numberOfElements) {
+  if (typeof featureTableProperty.stringOffsetBufferView !== "undefined") {
+    return getOffsetsForProperty(scenegraph, featureTableProperty.stringOffsetBufferView, featureTableProperty.offsetType || "UINT32", numberOfElements);
+  }
+  return null;
+}
+function getNumericAttributes(valuesDataBytes, propertyType, elementCount) {
+  let valuesData = convertRawBufferToMetadataArray(valuesDataBytes, "SCALAR", propertyType, elementCount);
+  if (!valuesData) {
+    valuesData = valuesDataBytes;
+  }
+  return valuesData;
+}
 function getPropertyDataFromTexture(scenegraph, featureTextureProperty, attributeName) {
   const json = scenegraph.gltf.json;
   if (!json.meshes) {
@@ -52931,9 +53079,10 @@ function processPrimitiveTextures(scenegraph, attributeName, featureTexturePrope
   const textureData = [];
   const texCoordAccessorKey = `TEXCOORD_${featureTextureProperty.texture.texCoord}`;
   const texCoordAccessorIndex = primitive.attributes[texCoordAccessorKey];
-  const texCoordBufferView = scenegraph.getBufferView(texCoordAccessorIndex);
-  const texCoordArray = scenegraph.getTypedArrayForBufferView(texCoordBufferView);
-  const textureCoordinates = new Float32Array(texCoordArray.buffer, texCoordArray.byteOffset, texCoordArray.length / 4);
+  const textureCoordinates = getFloat32ArrayForAccessor(scenegraph.gltf, texCoordAccessorIndex);
+  if (!textureCoordinates) {
+    return;
+  }
   const textureIndex = featureTextureProperty.texture.index;
   const texture = json.textures?.[textureIndex];
   const imageIndex = texture?.source;
@@ -53030,23 +53179,19 @@ function findFeatureTextureByName(featureTextures, schemaClassName) {
 function getStringAttributes(data, offsetsData, stringsCount) {
   const stringsArray = [];
   const textDecoder = new TextDecoder("utf8");
-  let stringOffset = 0;
-  const bytesPerStringSize = 4;
   for (let index = 0; index < stringsCount; index++) {
-    const stringByteSize = offsetsData[(index + 1) * bytesPerStringSize] - offsetsData[index * bytesPerStringSize];
-    const stringData = data.subarray(stringOffset, stringByteSize + stringOffset);
+    const stringData = data.slice(offsetsData[index], offsetsData[index + 1]);
     const stringAttribute = textDecoder.decode(stringData);
     stringsArray.push(stringAttribute);
-    stringOffset += stringByteSize;
   }
   return stringsArray;
 }
 
 // ../gltf/src/lib/utils/version.ts
-var VERSION9 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+var VERSION7 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
 
 // ../textures/src/lib/utils/version.ts
-var VERSION10 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
+var VERSION8 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
 
 // ../textures/src/lib/parsers/basis-module-loader.ts
 var BASIS_EXTERNAL_LIBRARIES = {
@@ -53551,7 +53696,7 @@ var BasisWorkerLoader = {
   name: "Basis",
   id: "basis",
   module: "textures",
-  version: VERSION10,
+  version: VERSION8,
   worker: true,
   extensions: ["basis", "ktx2"],
   mimeTypes: ["application/octet-stream", "image/ktx2"],
@@ -53858,7 +54003,7 @@ var CompressedTextureWorkerLoader = {
   name: "Texture Containers",
   id: "compressed-texture",
   module: "textures",
-  version: VERSION10,
+  version: VERSION8,
   worker: true,
   extensions: [
     "ktx",
@@ -53906,7 +54051,7 @@ var KTX2BasisWriterWorker = {
   name: "Basis Universal Supercompressed GPU Texture",
   id: "ktx2-basis-writer",
   module: "textures",
-  version: VERSION10,
+  version: VERSION8,
   extensions: ["ktx2"],
   worker: true,
   options: {
@@ -54490,27 +54635,6 @@ __export(KHR_texture_transform_exports, {
   name: () => name8
 });
 var import_core6 = __toModule(require_es5());
-
-// ../gltf/src/lib/gltf-utils/gltf-constants.ts
-var COMPONENTS = {
-  SCALAR: 1,
-  VEC2: 2,
-  VEC3: 3,
-  VEC4: 4,
-  MAT2: 4,
-  MAT3: 9,
-  MAT4: 16
-};
-var BYTES = {
-  5120: 1,
-  5121: 1,
-  5122: 2,
-  5123: 2,
-  5125: 4,
-  5126: 4
-};
-
-// ../gltf/src/lib/extensions/KHR_texture_transform.ts
 var EXT_MESHOPT_TRANSFORM = "KHR_texture_transform";
 var name8 = EXT_MESHOPT_TRANSFORM;
 var scratchVector = new import_core6.Vector3();
@@ -54801,8 +54925,8 @@ function resolveValues(technique, gltfScenegraph) {
 
 // ../gltf/src/lib/api/gltf-extensions.ts
 var EXTENSIONS2 = [
-  EXT_mesh_features_exports,
   EXT_structural_metadata_exports,
+  EXT_mesh_features_exports,
   EXT_meshopt_compression_exports,
   EXT_texture_webp_exports,
   KHR_texture_basisu_exports,
@@ -55172,7 +55296,7 @@ var GLTFLoader = {
   name: "glTF",
   id: "gltf",
   module: "gltf",
-  version: VERSION9,
+  version: VERSION7,
   extensions: ["gltf", "glb"],
   mimeTypes: ["model/gltf+json", "model/gltf-binary"],
   text: true,
@@ -55270,7 +55394,7 @@ var GLTFWriter = {
   name: "glTF",
   id: "gltf",
   module: "gltf",
-  version: VERSION9,
+  version: VERSION7,
   extensions: ["glb"],
   mimeTypes: ["model/gltf-binary"],
   binary: true,
@@ -55990,7 +56114,7 @@ var Tile3DSubtreeLoader = {
   id: "3d-tiles-subtree",
   name: "3D Tiles Subtree",
   module: "3d-tiles",
-  version: VERSION6,
+  version: VERSION4,
   extensions: ["subtree"],
   mimeTypes: ["application/octet-stream"],
   tests: ["subtree"],
@@ -56029,7 +56153,7 @@ var console_2 = globalThis.console;
 var navigator_2 = globalThis.navigator || {};
 
 // ../3d-tiles/node_modules/@probe.gl/env/dist/utils/globals.js
-var VERSION11 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "untranspiled source";
+var VERSION9 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "untranspiled source";
 var isBrowser6 = isBrowser5();
 
 // ../3d-tiles/node_modules/@probe.gl/log/dist/utils/local-storage.js
@@ -56214,7 +56338,7 @@ var Log2 = class {
       id: ""
     };
     this.id = void 0;
-    this.VERSION = VERSION11;
+    this.VERSION = VERSION9;
     this._startTs = getHiResTimestamp2();
     this._deltaTs = getHiResTimestamp2();
     this._storage = void 0;
@@ -56417,7 +56541,7 @@ var Log2 = class {
     return noop2;
   }
 };
-Log2.VERSION = VERSION11;
+Log2.VERSION = VERSION9;
 function normalizeLogLevel2(logLevel) {
   if (!logLevel) {
     return 0;
@@ -58086,7 +58210,7 @@ var Tiles3DLoader = {
   id: "3d-tiles",
   name: "3D Tiles",
   module: "3d-tiles",
-  version: VERSION6,
+  version: VERSION4,
   extensions: ["cmpt", "pnts", "b3dm", "i3dm"],
   mimeTypes: ["application/octet-stream"],
   tests: ["cmpt", "pnts", "b3dm", "i3dm"],
@@ -58912,7 +59036,7 @@ var Tile3DWriter = {
   name: "3D Tile",
   id: "3d-tiles",
   module: "3d-tiles",
-  version: VERSION6,
+  version: VERSION4,
   extensions: ["cmpt", "pnts", "b3dm", "i3dm"],
   mimeTypes: ["application/octet-stream"],
   encodeSync: encodeSync3,
@@ -58973,21 +59097,21 @@ var METADATA = () => ({
 });
 
 // src/lib/utils/file-utils.ts
-var import_fs5 = __toModule(require("fs"));
+var import_fs3 = __toModule(require("fs"));
 var import_path3 = __toModule(require("path"));
 
 // src/lib/utils/compress-util.ts
 var import_zlib2 = __toModule(require("zlib"));
 var import_path2 = __toModule(require("path"));
-var import_fs4 = __toModule(require("fs"));
+var import_fs2 = __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_zlib2.createGzip)();
-  const input = (0, import_fs4.createReadStream)(pathFile);
-  const output = (0, import_fs4.createWriteStream)(compressedPathFile);
+  const input = (0, import_fs2.createReadStream)(pathFile);
+  const output = (0, import_fs2.createWriteStream)(compressedPathFile);
   return new Promise((resolve2, reject) => {
     input.on("end", () => {
       console.log(`${compressedPathFile} compressed and saved.`);
@@ -59047,10 +59171,10 @@ async function writeFile3(path2, data, fileName = "index.json") {
   } else {
     toWriteData = data;
   }
-  await import_fs5.promises.mkdir(path2, { recursive: true });
+  await import_fs3.promises.mkdir(path2, { recursive: true });
   const pathFile = (0, import_path3.join)(path2, fileName);
   try {
-    await import_fs5.promises.writeFile(pathFile, toWriteData);
+    await import_fs3.promises.writeFile(pathFile, toWriteData);
   } catch (err) {
     throw err;
   }
@@ -59096,17 +59220,17 @@ async function openJson(path2, fileName) {
 }
 async function isFileExists(fileName) {
   try {
-    await import_fs5.promises.stat(fileName);
+    await import_fs3.promises.stat(fileName);
     return true;
   } catch {
     return false;
   }
 }
 function removeDir(path2) {
-  return import_fs5.promises.rm(path2, { recursive: true });
+  return import_fs3.promises.rm(path2, { recursive: true });
 }
 function removeFile(path2) {
-  return import_fs5.promises.unlink(path2);
+  return import_fs3.promises.unlink(path2);
 }
 function getAbsoluteFilePath(filePath) {
   return (0, import_path3.isAbsolute)(filePath) ? filePath : (0, import_path3.join)(process.cwd(), filePath);
@@ -59293,7 +59417,7 @@ var NodePages = class {
 
 // src/lib/utils/statistic-utills.ts
 var import_path5 = __toModule(require("path"));
-var import_fs6 = __toModule(require("fs"));
+var import_fs4 = __toModule(require("fs"));
 function timeConverter(time) {
   const nanoSecondsInMillisecond = 1e6;
   let timeInSeconds = time[0];
@@ -59324,7 +59448,7 @@ async function calculateFilesSize(params) {
   try {
     if (slpk) {
       const slpkPath = (0, import_path5.join)(fullOutputPath, `${tilesetName}.slpk`);
-      const stat3 = await import_fs6.promises.stat(slpkPath);
+      const stat3 = await import_fs4.promises.stat(slpkPath);
       return stat3.size;
     }
     const directoryPath = (0, import_path5.join)(fullOutputPath, tilesetName);
@@ -59337,9 +59461,9 @@ async function calculateFilesSize(params) {
 }
 async function getTotalFilesSize(dirPath) {
   let totalFileSize = 0;
-  const files = await import_fs6.promises.readdir(dirPath);
+  const files = await import_fs4.promises.readdir(dirPath);
   for (const file of files) {
-    const fileStat = await import_fs6.promises.stat((0, import_path5.join)(dirPath, file));
+    const fileStat = await import_fs4.promises.stat((0, import_path5.join)(dirPath, file));
     if (fileStat.isDirectory()) {
       totalFileSize += await getTotalFilesSize((0, import_path5.join)(dirPath, file));
     } else {
@@ -59433,6 +59557,11 @@ function makeAttributeObjects(attributes) {
   let colorsList = new Uint8Array(colors);
   let texCoordsList = new Float32Array(texCoords);
   let uvRegionsList = new Uint16Array(uvRegions);
+  let positionsOffset = 0;
+  let normalsOffset = 0;
+  let colorsOffset = 0;
+  let uvRegionsOffset = 0;
+  let texCoordsOffset = 0;
   for (let index = 0; index < featureIds.length; index++) {
     const startIndex = faceRange[index * 2];
     const endIndex = faceRange[index * 2 + 1];
@@ -59443,19 +59572,19 @@ function makeAttributeObjects(attributes) {
     const texCoordsCount = getSliceAttributeCount("texCoords", startIndex, endIndex);
     groupedData.push({
       featureId: featureIds[index],
-      positions: positionsList.slice(0, positionsCount),
-      normals: normalsList.slice(0, normalsCount),
-      colors: colorsList.slice(0, colorsCount),
-      uvRegions: uvRegionsList.slice(0, uvRegionsCount),
-      texCoords: texCoordsList.slice(0, texCoordsCount)
+      positions: positionsList.subarray(positionsOffset, positionsOffset + positionsCount),
+      normals: normalsList.subarray(normalsOffset, normalsOffset + normalsCount),
+      colors: colorsList.subarray(colorsOffset, colorsOffset + colorsCount),
+      uvRegions: uvRegionsList.subarray(uvRegionsOffset, uvRegionsOffset + uvRegionsCount),
+      texCoords: texCoordsList.subarray(texCoordsOffset, texCoordsOffset + texCoordsCount)
     });
-    positionsList = positionsList.slice(positionsCount);
-    normalsList = normalsList.slice(normalsCount);
-    colorsList = colorsList.slice(colorsCount);
-    uvRegionsList = uvRegionsList.slice(uvRegionsCount);
-    texCoordsList = texCoordsList.slice(texCoordsCount);
+    positionsOffset += positionsCount;
+    normalsOffset += normalsCount;
+    colorsOffset += colorsCount;
+    uvRegionsOffset += uvRegionsCount;
+    texCoordsOffset += texCoordsCount;
   }
-  return groupedData.sort((first, second) => first.featureId - second.featureId);
+  return groupedData;
 }
 function getSliceAttributeCount(attributeName, startIndex, endIndex) {
   const itemsPerVertex4 = 4;
@@ -59476,50 +59605,66 @@ function getSliceAttributeCount(attributeName, startIndex, endIndex) {
   }
 }
 function unifyObjectsByFeatureId(sortedData) {
-  const uniqueObjects = [];
-  for (let index = 0; index < sortedData.length; index++) {
-    const currentObject = sortedData[index];
-    const existingObject = uniqueObjects.find((obj) => obj.featureId === currentObject.featureId);
+  const groupedMetadata = [];
+  for (const data of sortedData) {
+    const existingObject = groupedMetadata.find((obj) => obj.featureId === data.featureId);
     if (existingObject) {
-      existingObject.positions = concatenateTypedArrays(existingObject.positions, currentObject.positions);
-      existingObject.normals = concatenateTypedArrays(existingObject.normals, currentObject.normals);
-      existingObject.colors = concatenateTypedArrays(existingObject.colors, currentObject.colors);
-      existingObject.texCoords = concatenateTypedArrays(existingObject.texCoords, currentObject.texCoords);
-      existingObject.uvRegions = concatenateTypedArrays(existingObject.uvRegions, currentObject.uvRegions);
+      existingObject.attributes.push(data);
     } else {
-      uniqueObjects.push(currentObject);
+      groupedMetadata.push({
+        featureId: data.featureId,
+        attributes: [data]
+      });
     }
   }
+  const uniqueObjects = [];
+  for (const metatada of groupedMetadata) {
+    const attributes = concatenateAttributes(metatada.attributes);
+    uniqueObjects.push({
+      featureId: metatada.featureId,
+      ...attributes
+    });
+  }
   return uniqueObjects;
 }
 function groupAttributesAndRangesByFeatureId(unifiedObjects, featureCount) {
   const firstAttributeObject = unifiedObjects[0];
   const featureIds = [firstAttributeObject.featureId || 0];
-  let positions = new Float32Array(firstAttributeObject.positions);
-  let normals = new Float32Array(firstAttributeObject.normals);
-  let colors = new Uint8Array(firstAttributeObject.colors);
-  let uvRegions = new Uint16Array(firstAttributeObject.uvRegions);
-  let texCoords = new Float32Array(firstAttributeObject.texCoords);
   const range = [0];
   let objIndex = 0;
   let sum = 0;
   for (let index = 1; index < unifiedObjects.length; index++) {
     const currentAttributesObject = unifiedObjects[index];
     featureIds.push(currentAttributesObject.featureId || 0);
-    positions = concatenateTypedArrays(positions, currentAttributesObject.positions);
-    normals = concatenateTypedArrays(normals, currentAttributesObject.normals);
-    colors = concatenateTypedArrays(colors, currentAttributesObject.colors);
-    uvRegions = concatenateTypedArrays(uvRegions, currentAttributesObject.uvRegions);
-    texCoords = concatenateTypedArrays(texCoords, currentAttributesObject.texCoords);
     const groupedObject = unifiedObjects[objIndex];
     range.push(groupedObject.positions.length / POSITIONS_AND_NORMALS_PER_TRIANGLE - 1 + sum);
     range.push(groupedObject.positions.length / POSITIONS_AND_NORMALS_PER_TRIANGLE + sum);
     sum += groupedObject.positions.length / POSITIONS_AND_NORMALS_PER_TRIANGLE;
     objIndex += 1;
   }
-  range.push(positions.length / POSITIONS_AND_NORMALS_PER_TRIANGLE - 1);
+  const attributes = concatenateAttributes(unifiedObjects);
+  range.push(attributes.positions.length / POSITIONS_AND_NORMALS_PER_TRIANGLE - 1);
   const faceRange = new Uint32Array(range);
-  return { faceRange, featureIds, positions, normals, colors, uvRegions, texCoords, featureCount };
+  return { faceRange, featureIds, featureCount, ...attributes };
+}
+function concatenateAttributes(attributes) {
+  const positionGroups = attributes.map(({ positions: positions2 }) => positions2);
+  const positions = positionGroups.length > 1 ? concatenateTypedArrays(...positionGroups) : positionGroups[0];
+  const normalGroups = attributes.map(({ normals: normals2 }) => normals2);
+  const normals = normalGroups.length > 1 ? concatenateTypedArrays(...normalGroups) : normalGroups[0];
+  const colorGroups = attributes.map(({ colors: colors2 }) => colors2);
+  const colors = colorGroups.length > 1 ? concatenateTypedArrays(...colorGroups) : colorGroups[0];
+  const texCoordGroups = attributes.map(({ texCoords: texCoords2 }) => texCoords2);
+  const texCoords = texCoordGroups.length > 1 ? concatenateTypedArrays(...texCoordGroups) : texCoordGroups[0];
+  const uvRegionGroups = attributes.map(({ uvRegions: uvRegions2 }) => uvRegions2);
+  const uvRegions = uvRegionGroups.length > 1 ? concatenateTypedArrays(...uvRegionGroups) : uvRegionGroups[0];
+  return {
+    positions,
+    normals,
+    colors,
+    texCoords,
+    uvRegions
+  };
 }
 
 // src/i3s-converter/helpers/coordinate-converter.ts
@@ -59716,29 +59861,19 @@ function handleBatchIdsExtensions(attributes, primitive, images, featureTexture)
     switch (extensionName) {
       case name3:
         return handleExtFeatureMetadataExtension(attributes, extensionData, images, featureTexture);
-      case name2:
-        return handleExtMeshFeaturesExtension(attributes, extensionData);
       case name:
-        return handleExtStructuralMetadataExtension(attributes, extensionData);
+        return handleExtMeshFeaturesExtension(attributes, extensionData);
       default:
         return [];
     }
   }
   return [];
 }
-function handleExtStructuralMetadataExtension(attributes, extStructuralMetadata) {
-  const dataAttributeNames = extStructuralMetadata?.dataAttributeNames;
-  if (dataAttributeNames?.length) {
-    const batchIdsAttribute = attributes[dataAttributeNames[0]];
-    return batchIdsAttribute.value;
-  }
-  return [];
-}
 function handleExtMeshFeaturesExtension(attributes, extMeshFeatures) {
-  const dataAttributeNames = extMeshFeatures?.dataAttributeNames;
-  if (dataAttributeNames?.length) {
-    const batchIdsAttribute = attributes[dataAttributeNames[0]];
-    return batchIdsAttribute.value;
+  for (let ids of extMeshFeatures.featureIds) {
+    if (typeof ids.propertyTable !== "undefined") {
+      return ids.data;
+    }
   }
   return [];
 }
@@ -59818,19 +59953,19 @@ function generateBatchIdsFromTexture(featureIdTexture, textureCoordinates, image
 }
 
 // src/i3s-converter/helpers/feature-attributes.ts
-function flattenPropertyTableByFeatureIds(featureIds, propertyTable) {
+function flattenPropertyTableByFeatureIds(featureIdsMap, propertyTable) {
   const resultPropertyTable = {};
   for (const propertyName in propertyTable) {
     const properties = propertyTable[propertyName];
-    resultPropertyTable[propertyName] = getPropertiesByFeatureIds(properties, featureIds);
+    resultPropertyTable[propertyName] = getPropertiesByFeatureIds(properties, featureIdsMap);
   }
   return resultPropertyTable;
 }
-function getPropertiesByFeatureIds(properties, featureIds) {
+function getPropertiesByFeatureIds(properties, featureIdsMap) {
   const resultProperties = [];
   if (properties) {
-    for (const featureId of featureIds) {
-      const property = properties[featureId] || null;
+    for (const featureIdKey in featureIdsMap) {
+      const property = properties[featureIdKey] || null;
       resultProperties.push(property);
     }
   }
@@ -60047,8 +60182,9 @@ async function _makeNodeResources({
   const boundingVolumes = convertedAttributes.boundingVolumes;
   const vertexCount = convertedAttributes.positions.length / VALUES_PER_VERTEX2;
   const { faceRange, featureIds, positions, normals, colors, uvRegions, texCoords, featureCount } = generateAttributes(convertedAttributes);
-  if (tileContent.batchTableJson) {
-    makeFeatureIdsUnique(featureIds, convertedAttributes.featureIndices, featuresHashArray, tileContent.batchTableJson);
+  let featureIdsMap = {};
+  if (propertyTable) {
+    featureIdsMap = makeFeatureIdsUnique(featureIds, convertedAttributes.featureIndices, featuresHashArray, propertyTable);
   }
   const header = new Uint32Array(2);
   const typedFeatureIds = generateBigUint64Array(featureIds);
@@ -60065,7 +60201,7 @@ async function _makeNodeResources({
   }, libraries) : null;
   let attributes = [];
   if (attributeStorageInfo && propertyTable) {
-    attributes = convertPropertyTableToAttributeBuffers(featureIds, propertyTable, attributeStorageInfo);
+    attributes = convertPropertyTableToAttributeBuffers(featureIds, featureIdsMap, propertyTable, attributeStorageInfo);
   }
   return {
     nodeId,
@@ -60529,6 +60665,7 @@ function makeFeatureIdsUnique(featureIds, featureIndices, featuresHashArray, bat
   const replaceMap = getFeaturesReplaceMap(featureIds, batchTable, featuresHashArray);
   replaceIndicesByUnique(featureIndices, replaceMap);
   replaceIndicesByUnique(featureIds, replaceMap);
+  return replaceMap;
 }
 function getFeaturesReplaceMap(featureIds, batchTable, featuresHashArray) {
   const featureMap = {};
@@ -60559,10 +60696,10 @@ function replaceIndicesByUnique(indicesArray, featureMap) {
     indicesArray[index] = featureMap[indicesArray[index]];
   }
 }
-function convertPropertyTableToAttributeBuffers(featureIds, propertyTable, attributeStorageInfo) {
+function convertPropertyTableToAttributeBuffers(featureIds, featureIdsMap, propertyTable, attributeStorageInfo) {
   const attributeBuffers = [];
   const needFlattenPropertyTable = checkPropertiesLength(featureIds, propertyTable);
-  const properties = needFlattenPropertyTable ? flattenPropertyTableByFeatureIds(featureIds, propertyTable) : propertyTable;
+  const properties = needFlattenPropertyTable ? flattenPropertyTableByFeatureIds(featureIdsMap, propertyTable) : propertyTable;
   const propertyTableWithObjectIds = {
     OBJECTID: featureIds,
     ...properties
@@ -60702,17 +60839,13 @@ function getPropertyTable(tileContent, metadataClass) {
     return null;
   }
   let propertyTable;
-  const batchTableJson = tileContent?.batchTableJson;
+  const batchTableJson = tileContent.batchTableJson;
   if (batchTableJson) {
     return batchTableJson;
   }
   const { extensionName, extension } = getPropertyTableExtension(tileContent);
   switch (extensionName) {
     case name2: {
-      propertyTable = getPropertyTableFromExtMeshFeatures(extension, metadataClass);
-      return propertyTable;
-    }
-    case name: {
       propertyTable = getPropertyTableFromExtStructuralMetadata(extension, metadataClass);
       return propertyTable;
     }
@@ -60725,11 +60858,7 @@ function getPropertyTable(tileContent, metadataClass) {
   }
 }
 function getPropertyTableExtension(tileContent) {
-  const extensionsWithPropertyTables = [
-    name3,
-    name,
-    name2
-  ];
+  const extensionsWithPropertyTables = [name3, name2];
   const extensionsUsed = tileContent?.gltf?.extensionsUsed;
   if (!extensionsUsed) {
     return { extensionName: null, extension: null };
@@ -60747,72 +60876,6 @@ function getPropertyTableExtension(tileContent) {
   const extension = tileContent?.gltf?.extensions?.[extensionName];
   return { extensionName, extension };
 }
-function getPropertyTableFromExtFeatureMetadata(extension, metadataClass) {
-  if (extension?.featureTables) {
-    const firstFeatureTableName = Object.keys(extension.featureTables)?.[0];
-    if (firstFeatureTableName) {
-      const featureTable = extension?.featureTables[firstFeatureTableName];
-      const propertyTable = {};
-      for (const propertyName in featureTable.properties) {
-        propertyTable[propertyName] = featureTable.properties[propertyName].data;
-      }
-      return propertyTable;
-    }
-  }
-  if (extension?.featureTextures) {
-    let featureTexture;
-    for (const textureKey in extension.featureTextures) {
-      const texture = extension.featureTextures[textureKey];
-      if (texture.class === metadataClass) {
-        featureTexture = textureKey;
-      }
-    }
-    if (typeof featureTexture === "string") {
-      const featureTable = extension?.featureTextures[featureTexture];
-      const propertyTable = {};
-      for (const propertyName in featureTable.properties) {
-        propertyTable[propertyName] = featureTable.properties[propertyName].data;
-      }
-      return propertyTable;
-    }
-  }
-  console.warn("The I3S converter couldn't handle EXT_feature_metadata extension: There is neither featureTables, no featureTextures in the extension.");
-  return null;
-}
-function getPropertyTableFromExtStructuralMetadata(extension, metadataClass) {
-  if (extension?.propertyTables) {
-    const firstPropertyTable = extension?.propertyTables[0];
-    const propertyTableWithData = {};
-    for (const propertyName in firstPropertyTable.properties) {
-      propertyTableWithData[propertyName] = firstPropertyTable.properties[propertyName].data;
-    }
-    return propertyTableWithData;
-  }
-  if (extension?.propertyTextures) {
-    if (extension?.propertyTextures) {
-      const firstPropertyTexture = extension?.propertyTextures[0];
-      const propertyTableWithData = {};
-      for (const propertyName in firstPropertyTexture.properties) {
-        propertyTableWithData[propertyName] = firstPropertyTexture.properties[propertyName].data;
-      }
-      return propertyTableWithData;
-    }
-  }
-  console.warn("The I3S converter couldn't handle EXT_structural_metadata extension: There is neither propertyTables, no propertyTextures in the extension.");
-  return null;
-}
-function getPropertyTableFromExtMeshFeatures(extension, metadataClass) {
-  if (extension?.featureIds) {
-    const firstFeatureId = extension?.featureIds[0];
-    const propertyTableWithData = {};
-    if (!firstFeatureId.propertyTable) {
-      console.warn("Should be implemented as we have the tileset with Ext_mesh_features not linked with EXT_structural_metadata extension");
-    }
-    return propertyTableWithData;
-  }
-  console.warn("The I3S converter couldn't handle EXT_mesh_features extension: There is no featureIds in the extension.");
-  return null;
-}
 
 // src/i3s-converter/helpers/create-scene-server-path.ts
 var import_json_map_transform2 = __toModule(require_json_map_transform());
@@ -60899,17 +60962,19 @@ function convertScreenThresholdToGeometricError(node2) {
 
 // src/pgm-loader.ts
 var import_geoid = __toModule(require_es54());
-var VERSION12 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+var VERSION10 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
 var PGMLoader = {
   name: "PGM - Netpbm grayscale image format",
   id: "pgm",
   module: "tile-converter",
-  version: VERSION12,
+  version: VERSION10,
   mimeTypes: ["image/x-portable-graymap"],
-  parse: async (arrayBuffer, options) => (0, import_geoid.parsePGM)(new Uint8Array(arrayBuffer), options),
+  parse: async (arrayBuffer, options) => (0, import_geoid.parsePGM)(new Uint8Array(arrayBuffer), options?.pgm || {}),
   extensions: ["pgm"],
   options: {
-    cubic: false
+    pgm: {
+      cubic: false
+    }
   }
 };
 
@@ -61968,14 +62033,14 @@ var analyzeTileContent = async (tileContent) => {
   if (!gltf) {
     return defaultResult;
   }
-  const meshTopologyTypes = getMeshTypesFromGltf(gltf);
-  const metadataClasses = getMetadataClassesFromGltf(gltf);
+  const meshTopologyTypes = getMeshTypesFromGLTF(gltf);
+  const metadataClasses = getMetadataClassesFromGLTF(gltf);
   return {
     meshTopologyTypes,
     metadataClasses
   };
 };
-var getMeshTypesFromGltf = (gltfJson) => {
+var getMeshTypesFromGLTF = (gltfJson) => {
   const result = new Set();
   for (const mesh of gltfJson.meshes || []) {
     for (const primitive of mesh.primitives) {
@@ -61988,11 +62053,17 @@ var getMeshTypesFromGltf = (gltfJson) => {
   }
   return result;
 };
-var getMetadataClassesFromGltf = (gltfJson) => {
+var getMetadataClassesFromGLTF = (gltfJson) => {
   const result = new Set();
-  const classes = gltfJson.extensions?.[name3]?.schema?.classes;
-  if (classes) {
-    for (const classKey of Object.keys(classes)) {
+  const extFeatureMetadataClasses = gltfJson.extensions?.[name3]?.schema?.classes;
+  if (extFeatureMetadataClasses) {
+    for (const classKey of Object.keys(extFeatureMetadataClasses)) {
+      result.add(classKey);
+    }
+  }
+  const extStructuralMetadataClasses = gltfJson.extensions?.[name2]?.schema?.classes;
+  if (extStructuralMetadataClasses) {
+    for (const classKey of Object.keys(extStructuralMetadataClasses)) {
       result.add(classKey);
     }
   }
@@ -62847,12 +62918,12 @@ function parseStringsAttribute(arrayBuffer) {
 }
 
 // ../i3s/src/i3s-attribute-loader.ts
-var VERSION13 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+var VERSION11 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
 var I3SAttributeLoader = {
   name: "I3S Attribute",
   id: "i3s-attribute",
   module: "i3s",
-  version: VERSION13,
+  version: VERSION11,
   mimeTypes: ["application/binary"],
   parse: async (arrayBuffer, options) => parseI3STileAttribute(arrayBuffer, options),
   extensions: ["bin"],
@@ -63312,13 +63383,13 @@ function getFeatureIdsFromFeatureIndexMetadata(featureIndex) {
 }
 
 // ../i3s/src/i3s-content-loader.ts
-var VERSION14 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
+var VERSION12 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
 var I3SContentLoader = {
   name: "I3S Content (Indexed Scene Layers)",
   id: "i3s-content",
   module: "i3s",
   worker: true,
-  version: VERSION14,
+  version: VERSION12,
   mimeTypes: ["application/octet-stream"],
   parse: parse6,
   extensions: ["bin"],
@@ -63341,20 +63412,22 @@ var import_culling5 = __toModule(require_es53());
 var import_geospatial9 = __toModule(require_es52());
 
 // ../i3s/src/i3s-node-page-loader.ts
-var VERSION15 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
-async function parseNodePage(data, options) {
-  return JSON.parse(new TextDecoder().decode(data));
-}
+var VERSION13 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
 var I3SNodePageLoader = {
   name: "I3S Node Page",
   id: "i3s-node-page",
   module: "i3s",
-  version: VERSION15,
+  version: VERSION13,
   mimeTypes: ["application/json"],
   parse: parseNodePage,
   extensions: ["json"],
-  options: {}
+  options: {
+    i3s: {}
+  }
 };
+async function parseNodePage(data, options) {
+  return JSON.parse(new TextDecoder().decode(data));
+}
 
 // ../i3s/src/lib/helpers/i3s-nodepages-tiles.ts
 var I3SNodePagesTiles = class {
@@ -63613,7 +63686,7 @@ async function normalizeTilesetData(tileset, options, context) {
 }
 
 // ../i3s/src/i3s-loader.ts
-var VERSION16 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+var VERSION14 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
 var TILESET_REGEX = /layers\/[0-9]+$/;
 var TILE_HEADER_REGEX = /nodes\/([0-9-]+|root)$/;
 var SLPK_HEX = "504b0304";
@@ -63622,7 +63695,7 @@ var I3SLoader = {
   name: "I3S (Indexed Scene Layers)",
   id: "i3s",
   module: "i3s",
-  version: VERSION16,
+  version: VERSION14,
   mimeTypes: ["application/octet-stream"],
   parse: parseI3S,
   extensions: ["bin"],
@@ -63786,7 +63859,7 @@ var Z_UP_TO_Y_UP_MATRIX = new import_core31.Matrix4([1, 0, 0, 0, 0, 0, -1, 0, 0,
 var scratchVector6 = new import_core31.Vector3();
 var B3dmConverter = class {
   async convert(i3sAttributesData, featureAttributes = null) {
-    const gltf = await this.buildGltf(i3sAttributesData, featureAttributes);
+    const gltf = await this.buildGLTF(i3sAttributesData, featureAttributes);
     const b3dm = encodeSync({
       gltfEncoded: new Uint8Array(gltf),
       type: "b3dm",
@@ -63795,12 +63868,12 @@ var B3dmConverter = class {
     }, Tile3DWriter);
     return b3dm;
   }
-  async buildGltf(i3sAttributesData, featureAttributes) {
+  async buildGLTF(i3sAttributesData, featureAttributes) {
     const { tileContent, textureFormat, box } = i3sAttributesData;
     const { material, attributes, indices: originalIndices, modelMatrix } = tileContent;
     const gltfBuilder = new GLTFScenegraph();
-    const textureIndex = await this._addI3sTextureToGltf(tileContent, textureFormat, gltfBuilder);
-    const pbrMaterialInfo = this._convertI3sMaterialToGltfMaterial(material, textureIndex);
+    const textureIndex = await this._addI3sTextureToGLTF(tileContent, textureFormat, gltfBuilder);
+    const pbrMaterialInfo = this._convertI3sMaterialToGLTFMaterial(material, textureIndex);
     const materialIndex = gltfBuilder.addMaterial(pbrMaterialInfo);
     const positions = attributes.positions;
     const positionsValue = positions.value;
@@ -63829,7 +63902,7 @@ var B3dmConverter = class {
     const gltfBuffer = encodeSync(gltfBuilder.gltf, GLTFWriter);
     return gltfBuffer;
   }
-  async _addI3sTextureToGltf(tileContent, textureFormat, gltfBuilder) {
+  async _addI3sTextureToGLTF(tileContent, textureFormat, gltfBuilder) {
     const { texture, material, attributes } = tileContent;
     let textureIndex = null;
     let selectedTexture = texture;
@@ -63891,7 +63964,7 @@ var B3dmConverter = class {
         return "image/jpeg";
     }
   }
-  _convertI3sMaterialToGltfMaterial(material, textureIndex) {
+  _convertI3sMaterialToGLTFMaterial(material, textureIndex) {
     const isTextureIndexExists = textureIndex !== null;
     if (!material) {
       material = {
@@ -63913,11 +63986,11 @@ var B3dmConverter = class {
       return material;
     }
     if (textureIndex !== null) {
-      material = this._setGltfTexture(material, textureIndex);
+      material = this._setGLTFTexture(material, textureIndex);
     }
     return material;
   }
-  _setGltfTexture(materialDefinition, textureIndex) {
+  _setGLTFTexture(materialDefinition, textureIndex) {
     const material = {
       ...materialDefinition,
       pbrMetallicRoughness: { ...materialDefinition.pbrMetallicRoughness }