@loaders.gl/compression 4.2.0-alpha.5 → 4.2.0-beta.1

package/dist/dist.dev.js

@@ -12,6 +12,7 @@ var __exports__ = (() => {
   var __getOwnPropNames = Object.getOwnPropertyNames;
   var __getProtoOf = Object.getPrototypeOf;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
   var __commonJS = (cb, mod) => function __require() {
     return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
   };
@@ -37,6 +38,10 @@ var __exports__ = (() => {
     mod
   ));
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+  var __publicField = (obj, key, value) => {
+    __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+    return value;
+  };
 
   // external-global-plugin:@loaders.gl/core
   var require_core = __commonJS({
@@ -4686,6 +4691,607 @@ var __exports__ = (() => {
   var matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
   var nodeVersion = matches && parseFloat(matches[1]) || 0;
 
+  // ../../node_modules/@babel/runtime/helpers/esm/typeof.js
+  function _typeof(obj) {
+    "@babel/helpers - typeof";
+    return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj2) {
+      return typeof obj2;
+    } : function(obj2) {
+      return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+    }, _typeof(obj);
+  }
+
+  // ../../node_modules/@babel/runtime/helpers/esm/toPrimitive.js
+  function _toPrimitive(input, hint) {
+    if (_typeof(input) !== "object" || input === null)
+      return input;
+    var prim = input[Symbol.toPrimitive];
+    if (prim !== void 0) {
+      var res = prim.call(input, hint || "default");
+      if (_typeof(res) !== "object")
+        return res;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return (hint === "string" ? String : Number)(input);
+  }
+
+  // ../../node_modules/@babel/runtime/helpers/esm/toPropertyKey.js
+  function _toPropertyKey(arg) {
+    var key = _toPrimitive(arg, "string");
+    return _typeof(key) === "symbol" ? key : String(key);
+  }
+
+  // ../../node_modules/@babel/runtime/helpers/esm/defineProperty.js
+  function _defineProperty(obj, key, value) {
+    key = _toPropertyKey(key);
+    if (key in obj) {
+      Object.defineProperty(obj, key, {
+        value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    } else {
+      obj[key] = value;
+    }
+    return obj;
+  }
+
+  // ../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/lib/is-electron.js
+  function isElectron(mockUserAgent) {
+    if (typeof window !== "undefined" && typeof window.process === "object" && window.process.type === "renderer") {
+      return true;
+    }
+    if (typeof process !== "undefined" && typeof process.versions === "object" && Boolean(process.versions["electron"])) {
+      return true;
+    }
+    const realUserAgent = typeof navigator === "object" && typeof navigator.userAgent === "string" && navigator.userAgent;
+    const userAgent = mockUserAgent || realUserAgent;
+    if (userAgent && userAgent.indexOf("Electron") >= 0) {
+      return true;
+    }
+    return false;
+  }
+
+  // ../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/lib/is-browser.js
+  function isBrowser2() {
+    const isNode = typeof process === "object" && String(process) === "[object process]" && !process.browser;
+    return !isNode || isElectron();
+  }
+
+  // ../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/lib/globals.js
+  var self_2 = globalThis.self || globalThis.window || globalThis.global;
+  var window_2 = globalThis.window || globalThis.self || globalThis.global;
+  var document_2 = globalThis.document || {};
+  var process_ = globalThis.process || {};
+  var console_ = globalThis.console;
+  var navigator_ = globalThis.navigator || {};
+
+  // ../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/utils/globals.js
+  var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "untranspiled source";
+  var isBrowser3 = isBrowser2();
+
+  // ../../node_modules/@probe.gl/log/dist/utils/local-storage.js
+  function getStorage(type) {
+    try {
+      const storage = window[type];
+      const x = "__storage_test__";
+      storage.setItem(x, x);
+      storage.removeItem(x);
+      return storage;
+    } catch (e) {
+      return null;
+    }
+  }
+  var LocalStorage = class {
+    constructor(id, defaultConfig) {
+      let type = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "sessionStorage";
+      _defineProperty(this, "storage", void 0);
+      _defineProperty(this, "id", void 0);
+      _defineProperty(this, "config", void 0);
+      this.storage = getStorage(type);
+      this.id = id;
+      this.config = defaultConfig;
+      this._loadConfiguration();
+    }
+    getConfiguration() {
+      return this.config;
+    }
+    setConfiguration(configuration) {
+      Object.assign(this.config, configuration);
+      if (this.storage) {
+        const serialized = JSON.stringify(this.config);
+        this.storage.setItem(this.id, serialized);
+      }
+    }
+    _loadConfiguration() {
+      let configuration = {};
+      if (this.storage) {
+        const serializedConfiguration = this.storage.getItem(this.id);
+        configuration = serializedConfiguration ? JSON.parse(serializedConfiguration) : {};
+      }
+      Object.assign(this.config, configuration);
+      return this;
+    }
+  };
+
+  // ../../node_modules/@probe.gl/log/dist/utils/formatters.js
+  function formatTime(ms) {
+    let formatted;
+    if (ms < 10) {
+      formatted = "".concat(ms.toFixed(2), "ms");
+    } else if (ms < 100) {
+      formatted = "".concat(ms.toFixed(1), "ms");
+    } else if (ms < 1e3) {
+      formatted = "".concat(ms.toFixed(0), "ms");
+    } else {
+      formatted = "".concat((ms / 1e3).toFixed(2), "s");
+    }
+    return formatted;
+  }
+  function leftPad(string) {
+    let length = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 8;
+    const padLength = Math.max(length - string.length, 0);
+    return "".concat(" ".repeat(padLength)).concat(string);
+  }
+  function formatImage(image, message, scale) {
+    let maxWidth = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : 600;
+    const imageUrl = image.src.replace(/\(/g, "%28").replace(/\)/g, "%29");
+    if (image.width > maxWidth) {
+      scale = Math.min(scale, maxWidth / image.width);
+    }
+    const width = image.width * scale;
+    const height = image.height * scale;
+    const style = ["font-size:1px;", "padding:".concat(Math.floor(height / 2), "px ").concat(Math.floor(width / 2), "px;"), "line-height:".concat(height, "px;"), "background:url(".concat(imageUrl, ");"), "background-size:".concat(width, "px ").concat(height, "px;"), "color:transparent;"].join("");
+    return ["".concat(message, " %c+"), style];
+  }
+
+  // ../../node_modules/@probe.gl/log/dist/utils/color.js
+  var COLOR;
+  (function(COLOR2) {
+    COLOR2[COLOR2["BLACK"] = 30] = "BLACK";
+    COLOR2[COLOR2["RED"] = 31] = "RED";
+    COLOR2[COLOR2["GREEN"] = 32] = "GREEN";
+    COLOR2[COLOR2["YELLOW"] = 33] = "YELLOW";
+    COLOR2[COLOR2["BLUE"] = 34] = "BLUE";
+    COLOR2[COLOR2["MAGENTA"] = 35] = "MAGENTA";
+    COLOR2[COLOR2["CYAN"] = 36] = "CYAN";
+    COLOR2[COLOR2["WHITE"] = 37] = "WHITE";
+    COLOR2[COLOR2["BRIGHT_BLACK"] = 90] = "BRIGHT_BLACK";
+    COLOR2[COLOR2["BRIGHT_RED"] = 91] = "BRIGHT_RED";
+    COLOR2[COLOR2["BRIGHT_GREEN"] = 92] = "BRIGHT_GREEN";
+    COLOR2[COLOR2["BRIGHT_YELLOW"] = 93] = "BRIGHT_YELLOW";
+    COLOR2[COLOR2["BRIGHT_BLUE"] = 94] = "BRIGHT_BLUE";
+    COLOR2[COLOR2["BRIGHT_MAGENTA"] = 95] = "BRIGHT_MAGENTA";
+    COLOR2[COLOR2["BRIGHT_CYAN"] = 96] = "BRIGHT_CYAN";
+    COLOR2[COLOR2["BRIGHT_WHITE"] = 97] = "BRIGHT_WHITE";
+  })(COLOR || (COLOR = {}));
+  var BACKGROUND_INCREMENT = 10;
+  function getColor(color) {
+    if (typeof color !== "string") {
+      return color;
+    }
+    color = color.toUpperCase();
+    return COLOR[color] || COLOR.WHITE;
+  }
+  function addColor(string, color, background) {
+    if (!isBrowser2 && typeof string === "string") {
+      if (color) {
+        const colorCode = getColor(color);
+        string = "\x1B[".concat(colorCode, "m").concat(string, "\x1B[39m");
+      }
+      if (background) {
+        const colorCode = getColor(background);
+        string = "\x1B[".concat(colorCode + BACKGROUND_INCREMENT, "m").concat(string, "\x1B[49m");
+      }
+    }
+    return string;
+  }
+
+  // ../../node_modules/@probe.gl/log/dist/utils/autobind.js
+  function autobind(obj) {
+    let predefined = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : ["constructor"];
+    const proto = Object.getPrototypeOf(obj);
+    const propNames = Object.getOwnPropertyNames(proto);
+    const object = obj;
+    for (const key of propNames) {
+      const value = object[key];
+      if (typeof value === "function") {
+        if (!predefined.find((name) => key === name)) {
+          object[key] = value.bind(obj);
+        }
+      }
+    }
+  }
+
+  // ../../node_modules/@probe.gl/log/dist/utils/assert.js
+  function assert(condition, message) {
+    if (!condition) {
+      throw new Error(message || "Assertion failed");
+    }
+  }
+
+  // ../../node_modules/@probe.gl/log/dist/utils/hi-res-timestamp.js
+  function getHiResTimestamp() {
+    let timestamp;
+    if (isBrowser2() && window_2.performance) {
+      var _window$performance, _window$performance$n;
+      timestamp = window_2 === null || window_2 === void 0 ? void 0 : (_window$performance = window_2.performance) === null || _window$performance === void 0 ? void 0 : (_window$performance$n = _window$performance.now) === null || _window$performance$n === void 0 ? void 0 : _window$performance$n.call(_window$performance);
+    } else if ("hrtime" in process_) {
+      var _process$hrtime;
+      const timeParts = process_ === null || process_ === void 0 ? void 0 : (_process$hrtime = process_.hrtime) === null || _process$hrtime === void 0 ? void 0 : _process$hrtime.call(process_);
+      timestamp = timeParts[0] * 1e3 + timeParts[1] / 1e6;
+    } else {
+      timestamp = Date.now();
+    }
+    return timestamp;
+  }
+
+  // ../../node_modules/@probe.gl/log/dist/log.js
+  var originalConsole = {
+    debug: isBrowser2() ? console.debug || console.log : console.log,
+    log: console.log,
+    info: console.info,
+    warn: console.warn,
+    error: console.error
+  };
+  var DEFAULT_LOG_CONFIGURATION = {
+    enabled: true,
+    level: 0
+  };
+  function noop() {
+  }
+  var cache = {};
+  var ONCE = {
+    once: true
+  };
+  var Log = class {
+    constructor() {
+      let {
+        id
+      } = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {
+        id: ""
+      };
+      _defineProperty(this, "id", void 0);
+      _defineProperty(this, "VERSION", VERSION);
+      _defineProperty(this, "_startTs", getHiResTimestamp());
+      _defineProperty(this, "_deltaTs", getHiResTimestamp());
+      _defineProperty(this, "_storage", void 0);
+      _defineProperty(this, "userData", {});
+      _defineProperty(this, "LOG_THROTTLE_TIMEOUT", 0);
+      this.id = id;
+      this.userData = {};
+      this._storage = new LocalStorage("__probe-".concat(this.id, "__"), DEFAULT_LOG_CONFIGURATION);
+      this.timeStamp("".concat(this.id, " started"));
+      autobind(this);
+      Object.seal(this);
+    }
+    set level(newLevel) {
+      this.setLevel(newLevel);
+    }
+    get level() {
+      return this.getLevel();
+    }
+    isEnabled() {
+      return this._storage.config.enabled;
+    }
+    getLevel() {
+      return this._storage.config.level;
+    }
+    getTotal() {
+      return Number((getHiResTimestamp() - this._startTs).toPrecision(10));
+    }
+    getDelta() {
+      return Number((getHiResTimestamp() - this._deltaTs).toPrecision(10));
+    }
+    set priority(newPriority) {
+      this.level = newPriority;
+    }
+    get priority() {
+      return this.level;
+    }
+    getPriority() {
+      return this.level;
+    }
+    enable() {
+      let enabled = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
+      this._storage.setConfiguration({
+        enabled
+      });
+      return this;
+    }
+    setLevel(level) {
+      this._storage.setConfiguration({
+        level
+      });
+      return this;
+    }
+    get(setting) {
+      return this._storage.config[setting];
+    }
+    set(setting, value) {
+      this._storage.setConfiguration({
+        [setting]: value
+      });
+    }
+    settings() {
+      if (console.table) {
+        console.table(this._storage.config);
+      } else {
+        console.log(this._storage.config);
+      }
+    }
+    assert(condition, message) {
+      assert(condition, message);
+    }
+    warn(message) {
+      return this._getLogFunction(0, message, originalConsole.warn, arguments, ONCE);
+    }
+    error(message) {
+      return this._getLogFunction(0, message, originalConsole.error, arguments);
+    }
+    deprecated(oldUsage, newUsage) {
+      return this.warn("`".concat(oldUsage, "` is deprecated and will be removed in a later version. Use `").concat(newUsage, "` instead"));
+    }
+    removed(oldUsage, newUsage) {
+      return this.error("`".concat(oldUsage, "` has been removed. Use `").concat(newUsage, "` instead"));
+    }
+    probe(logLevel, message) {
+      return this._getLogFunction(logLevel, message, originalConsole.log, arguments, {
+        time: true,
+        once: true
+      });
+    }
+    log(logLevel, message) {
+      return this._getLogFunction(logLevel, message, originalConsole.debug, arguments);
+    }
+    info(logLevel, message) {
+      return this._getLogFunction(logLevel, message, console.info, arguments);
+    }
+    once(logLevel, message) {
+      return this._getLogFunction(logLevel, message, originalConsole.debug || originalConsole.info, arguments, ONCE);
+    }
+    table(logLevel, table, columns) {
+      if (table) {
+        return this._getLogFunction(logLevel, table, console.table || noop, columns && [columns], {
+          tag: getTableHeader(table)
+        });
+      }
+      return noop;
+    }
+    image(_ref) {
+      let {
+        logLevel,
+        priority,
+        image,
+        message = "",
+        scale = 1
+      } = _ref;
+      if (!this._shouldLog(logLevel || priority)) {
+        return noop;
+      }
+      return isBrowser2() ? logImageInBrowser({
+        image,
+        message,
+        scale
+      }) : logImageInNode({
+        image,
+        message,
+        scale
+      });
+    }
+    time(logLevel, message) {
+      return this._getLogFunction(logLevel, message, console.time ? console.time : console.info);
+    }
+    timeEnd(logLevel, message) {
+      return this._getLogFunction(logLevel, message, console.timeEnd ? console.timeEnd : console.info);
+    }
+    timeStamp(logLevel, message) {
+      return this._getLogFunction(logLevel, message, console.timeStamp || noop);
+    }
+    group(logLevel, message) {
+      let opts = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {
+        collapsed: false
+      };
+      const options = normalizeArguments({
+        logLevel,
+        message,
+        opts
+      });
+      const {
+        collapsed
+      } = opts;
+      options.method = (collapsed ? console.groupCollapsed : console.group) || console.info;
+      return this._getLogFunction(options);
+    }
+    groupCollapsed(logLevel, message) {
+      let opts = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+      return this.group(logLevel, message, Object.assign({}, opts, {
+        collapsed: true
+      }));
+    }
+    groupEnd(logLevel) {
+      return this._getLogFunction(logLevel, "", console.groupEnd || noop);
+    }
+    withGroup(logLevel, message, func) {
+      this.group(logLevel, message)();
+      try {
+        func();
+      } finally {
+        this.groupEnd(logLevel)();
+      }
+    }
+    trace() {
+      if (console.trace) {
+        console.trace();
+      }
+    }
+    _shouldLog(logLevel) {
+      return this.isEnabled() && this.getLevel() >= normalizeLogLevel(logLevel);
+    }
+    _getLogFunction(logLevel, message, method, args, opts) {
+      if (this._shouldLog(logLevel)) {
+        opts = normalizeArguments({
+          logLevel,
+          message,
+          args,
+          opts
+        });
+        method = method || opts.method;
+        assert(method);
+        opts.total = this.getTotal();
+        opts.delta = this.getDelta();
+        this._deltaTs = getHiResTimestamp();
+        const tag = opts.tag || opts.message;
+        if (opts.once && tag) {
+          if (!cache[tag]) {
+            cache[tag] = getHiResTimestamp();
+          } else {
+            return noop;
+          }
+        }
+        message = decorateMessage(this.id, opts.message, opts);
+        return method.bind(console, message, ...opts.args);
+      }
+      return noop;
+    }
+  };
+  _defineProperty(Log, "VERSION", VERSION);
+  function normalizeLogLevel(logLevel) {
+    if (!logLevel) {
+      return 0;
+    }
+    let resolvedLevel;
+    switch (typeof logLevel) {
+      case "number":
+        resolvedLevel = logLevel;
+        break;
+      case "object":
+        resolvedLevel = logLevel.logLevel || logLevel.priority || 0;
+        break;
+      default:
+        return 0;
+    }
+    assert(Number.isFinite(resolvedLevel) && resolvedLevel >= 0);
+    return resolvedLevel;
+  }
+  function normalizeArguments(opts) {
+    const {
+      logLevel,
+      message
+    } = opts;
+    opts.logLevel = normalizeLogLevel(logLevel);
+    const args = opts.args ? Array.from(opts.args) : [];
+    while (args.length && args.shift() !== message) {
+    }
+    switch (typeof logLevel) {
+      case "string":
+      case "function":
+        if (message !== void 0) {
+          args.unshift(message);
+        }
+        opts.message = logLevel;
+        break;
+      case "object":
+        Object.assign(opts, logLevel);
+        break;
+      default:
+    }
+    if (typeof opts.message === "function") {
+      opts.message = opts.message();
+    }
+    const messageType = typeof opts.message;
+    assert(messageType === "string" || messageType === "object");
+    return Object.assign(opts, {
+      args
+    }, opts.opts);
+  }
+  function decorateMessage(id, message, opts) {
+    if (typeof message === "string") {
+      const time = opts.time ? leftPad(formatTime(opts.total)) : "";
+      message = opts.time ? "".concat(id, ": ").concat(time, "  ").concat(message) : "".concat(id, ": ").concat(message);
+      message = addColor(message, opts.color, opts.background);
+    }
+    return message;
+  }
+  function logImageInNode(_ref2) {
+    let {
+      image,
+      message = "",
+      scale = 1
+    } = _ref2;
+    console.warn("removed");
+    return noop;
+  }
+  function logImageInBrowser(_ref3) {
+    let {
+      image,
+      message = "",
+      scale = 1
+    } = _ref3;
+    if (typeof image === "string") {
+      const img = new Image();
+      img.onload = () => {
+        const args = formatImage(img, message, scale);
+        console.log(...args);
+      };
+      img.src = image;
+      return noop;
+    }
+    const element = image.nodeName || "";
+    if (element.toLowerCase() === "img") {
+      console.log(...formatImage(image, message, scale));
+      return noop;
+    }
+    if (element.toLowerCase() === "canvas") {
+      const img = new Image();
+      img.onload = () => console.log(...formatImage(img, message, scale));
+      img.src = image.toDataURL();
+      return noop;
+    }
+    return noop;
+  }
+  function getTableHeader(table) {
+    for (const key in table) {
+      for (const title in table[key]) {
+        return title || "untitled";
+      }
+    }
+    return "empty";
+  }
+
+  // ../../node_modules/@probe.gl/log/dist/index.js
+  var dist_default = new Log({
+    id: "@probe.gl/log"
+  });
+
+  // ../loader-utils/src/lib/log-utils/log.ts
+  var log = new Log({ id: "loaders.gl" });
+
+  // ../loader-utils/src/lib/module-utils/js-module-utils.ts
+  function registerJSModules(modules) {
+    globalThis.loaders ||= {};
+    globalThis.loaders.modules ||= {};
+    Object.assign(globalThis.loaders.modules, modules);
+  }
+  function checkJSModule(name, caller) {
+    const module = globalThis.loaders?.modules?.[name];
+    if (!module) {
+      log.warn(`${caller}: ${name} library not installed`)();
+    }
+  }
+  function getJSModule(name, caller) {
+    const module = globalThis.loaders?.modules?.[name];
+    if (!module) {
+      throw new Error(`${caller}: ${name} library not installed`);
+    }
+    return module;
+  }
+  function getJSModuleOrNull(name) {
+    const module = globalThis.loaders?.modules?.[name];
+    return module || null;
+  }
+
   // ../worker-utils/src/lib/env-utils/version.ts
   var NPM_TAG = "latest";
   function getVersion() {
@@ -4702,10 +5308,10 @@ var __exports__ = (() => {
     }
     return globalThis._loadersgl_.version;
   }
-  var VERSION = getVersion();
+  var VERSION2 = getVersion();
 
   // ../worker-utils/src/lib/env-utils/assert.ts
-  function assert(condition, message) {
+  function assert2(condition, message) {
     if (!condition) {
       throw new Error(message || "loaders.gl assertion failed.");
     }
@@ -4718,11 +5324,11 @@ var __exports__ = (() => {
     global: typeof global !== "undefined" && global,
     document: typeof document !== "undefined" && document
   };
-  var self_2 = globals2.self || globals2.window || globals2.global || {};
-  var window_2 = globals2.window || globals2.self || globals2.global || {};
-  var global_2 = globals2.global || globals2.self || globals2.window || {};
-  var document_2 = globals2.document || {};
-  var isBrowser2 = (
+  var self_3 = globals2.self || globals2.window || globals2.global || {};
+  var window_3 = globals2.window || globals2.self || globals2.global || {};
+  var global_3 = globals2.global || globals2.self || globals2.window || {};
+  var document_3 = globals2.document || {};
+  var isBrowser4 = (
     // @ts-ignore process.browser
     typeof process !== "object" || String(process) !== "[object process]" || process.browser
   );
@@ -4732,12 +5338,16 @@ var __exports__ = (() => {
 
   // ../worker-utils/src/lib/worker-farm/worker-job.ts
   var WorkerJob = class {
+    name;
+    workerThread;
+    isRunning = true;
+    /** Promise that resolves when Job is done */
+    result;
+    _resolve = () => {
+    };
+    _reject = () => {
+    };
     constructor(jobName, workerThread) {
-      this.isRunning = true;
-      this._resolve = () => {
-      };
-      this._reject = () => {
-      };
       this.name = jobName;
       this.workerThread = workerThread;
       this.result = new Promise((resolve, reject) => {
@@ -4761,7 +5371,7 @@ var __exports__ = (() => {
      * Call to resolve the `result` Promise with the supplied value
      */
     done(value) {
-      assert(this.isRunning);
+      assert2(this.isRunning);
       this.isRunning = false;
       this._resolve(value);
     }
@@ -4769,7 +5379,7 @@ var __exports__ = (() => {
      * Call to reject the `result` Promise with the supplied error
      */
     error(error) {
-      assert(this.isRunning);
+      assert2(this.isRunning);
       this.isRunning = false;
       this._reject(error);
     }
@@ -4784,7 +5394,7 @@ var __exports__ = (() => {
   // ../worker-utils/src/lib/worker-utils/get-loadable-worker-url.ts
   var workerURLCache = /* @__PURE__ */ new Map();
   function getLoadableWorkerURL(props) {
-    assert(props.source && !props.url || !props.source && props.url);
+    assert2(props.source && !props.url || !props.source && props.url);
     let workerURL = workerURLCache.get(props.source || props.url);
     if (!workerURL) {
       if (props.url) {
@@ -4796,7 +5406,7 @@ var __exports__ = (() => {
         workerURLCache.set(props.source, workerURL);
       }
     }
-    assert(workerURL);
+    assert2(workerURL);
     return workerURL;
   }
   function getLoadableWorkerURLFromURL(url) {
@@ -4874,21 +5484,27 @@ var __exports__ = (() => {
   var NOOP = () => {
   };
   var WorkerThread = class {
+    name;
+    source;
+    url;
+    terminated = false;
+    worker;
+    onMessage;
+    onError;
+    _loadableURL = "";
+    /** Checks if workers are supported on this platform */
+    static isSupported() {
+      return typeof Worker !== "undefined" && isBrowser4 || typeof NodeWorker !== "undefined" && !isBrowser4;
+    }
     constructor(props) {
-      this.terminated = false;
-      this._loadableURL = "";
       const { name, source, url } = props;
-      assert(source || url);
+      assert2(source || url);
       this.name = name;
       this.source = source;
       this.url = url;
       this.onMessage = NOOP;
       this.onError = (error) => console.log(error);
-      this.worker = isBrowser2 ? this._createBrowserWorker() : this._createNodeWorker();
-    }
-    /** Checks if workers are supported on this platform */
-    static isSupported() {
-      return typeof Worker !== "undefined" && isBrowser2 || typeof NodeWorker !== "undefined" && !isBrowser2;
+      this.worker = isBrowser4 ? this._createBrowserWorker() : this._createNodeWorker();
     }
     /**
      * Terminate this worker thread
@@ -4977,30 +5593,33 @@ var __exports__ = (() => {
 
   // ../worker-utils/src/lib/worker-farm/worker-pool.ts
   var WorkerPool = class {
+    name = "unnamed";
+    source;
+    // | Function;
+    url;
+    maxConcurrency = 1;
+    maxMobileConcurrency = 1;
+    onDebug = () => {
+    };
+    reuseWorkers = true;
+    props = {};
+    jobQueue = [];
+    idleQueue = [];
+    count = 0;
+    isDestroyed = false;
+    /** Checks if workers are supported on this platform */
+    static isSupported() {
+      return WorkerThread.isSupported();
+    }
     /**
      * @param processor - worker function
      * @param maxConcurrency - max count of workers
      */
     constructor(props) {
-      this.name = "unnamed";
-      this.maxConcurrency = 1;
-      this.maxMobileConcurrency = 1;
-      this.onDebug = () => {
-      };
-      this.reuseWorkers = true;
-      this.props = {};
-      this.jobQueue = [];
-      this.idleQueue = [];
-      this.count = 0;
-      this.isDestroyed = false;
       this.source = props.source;
       this.url = props.url;
       this.setProps(props);
     }
-    /** Checks if workers are supported on this platform */
-    static isSupported() {
-      return WorkerThread.isSupported();
-    }
     /**
      * Terminates all workers in the pool
      * @note Can free up significant memory
@@ -5081,7 +5700,7 @@ var __exports__ = (() => {
       const shouldDestroyWorker = (
         // Workers on Node.js prevent the process from exiting.
         // Until we figure out how to close them before exit, we always destroy them
-        !isBrowser2 || // If the pool is destroyed, there is no reason to keep the worker around
+        !isBrowser4 || // If the pool is destroyed, there is no reason to keep the worker around
         this.isDestroyed || // If the app has disabled worker reuse, any completed workers should be destroyed
         !this.reuseWorkers || // If concurrency has been lowered, this worker might be surplus to requirements
         this.count > this._getMaxConcurrency()
@@ -5123,23 +5742,24 @@ var __exports__ = (() => {
     onDebug: () => {
     }
   };
-  var WorkerFarm = class {
-    /** get global instance with WorkerFarm.getWorkerFarm() */
-    constructor(props) {
-      this.workerPools = /* @__PURE__ */ new Map();
-      this.props = { ...DEFAULT_PROPS };
-      this.setProps(props);
-      this.workerPools = /* @__PURE__ */ new Map();
-    }
+  var _WorkerFarm = class {
+    props;
+    workerPools = /* @__PURE__ */ new Map();
     /** Checks if workers are supported on this platform */
     static isSupported() {
       return WorkerThread.isSupported();
     }
     /** Get the singleton instance of the global worker farm */
     static getWorkerFarm(props = {}) {
-      WorkerFarm._workerFarm = WorkerFarm._workerFarm || new WorkerFarm({});
-      WorkerFarm._workerFarm.setProps(props);
-      return WorkerFarm._workerFarm;
+      _WorkerFarm._workerFarm = _WorkerFarm._workerFarm || new _WorkerFarm({});
+      _WorkerFarm._workerFarm.setProps(props);
+      return _WorkerFarm._workerFarm;
+    }
+    /** get global instance with WorkerFarm.getWorkerFarm() */
+    constructor(props) {
+      this.props = { ...DEFAULT_PROPS };
+      this.setProps(props);
+      this.workerPools = /* @__PURE__ */ new Map();
     }
     /**
      * Terminate all workers in the farm
@@ -5193,21 +5813,24 @@ var __exports__ = (() => {
       };
     }
   };
+  var WorkerFarm = _WorkerFarm;
+  // singleton
+  __publicField(WorkerFarm, "_workerFarm");
 
   // ../worker-utils/src/lib/worker-api/get-worker-url.ts
   function getWorkerName(worker) {
-    const warning = worker.version !== VERSION ? ` (worker-utils@${VERSION})` : "";
+    const warning = worker.version !== VERSION2 ? ` (worker-utils@${VERSION2})` : "";
     return `${worker.name}@${worker.version}${warning}`;
   }
   function getWorkerURL(worker, options = {}) {
     const workerOptions = options[worker.id] || {};
-    const workerFile = isBrowser2 ? `${worker.id}-worker.js` : `${worker.id}-worker-node.js`;
+    const workerFile = isBrowser4 ? `${worker.id}-worker.js` : `${worker.id}-worker-node.js`;
     let url = workerOptions.workerUrl;
     if (!url && worker.id === "compression") {
       url = options.workerUrl;
     }
     if (options._workerType === "test") {
-      if (isBrowser2) {
+      if (isBrowser4) {
         url = `modules/${worker.module}/dist/${workerFile}`;
       } else {
         url = `modules/${worker.module}/src/workers/${worker.id}-worker-node.ts`;
@@ -5221,7 +5844,7 @@ var __exports__ = (() => {
       const versionTag = version ? `@${version}` : "";
       url = `https://unpkg.com/@loaders.gl/${worker.module}${versionTag}/dist/${workerFile}`;
     }
-    assert(url);
+    assert2(url);
     return url;
   }
 
@@ -5353,7 +5976,8 @@ var __exports__ = (() => {
       this.decompressBatches = this.decompressBatches.bind(this);
     }
     /** Preloads any dynamic libraries. May enable sync functions */
-    async preload() {
+    async preload(modules = {}) {
+      registerJSModules(modules);
       return;
     }
     /** Asynchronously compress data */
@@ -5398,12 +6022,13 @@ var __exports__ = (() => {
 
   // src/lib/no-compression.ts
   var NoCompression = class extends Compression {
+    name = "uncompressed";
+    extensions = [];
+    contentEncodings = [];
+    isSupported = true;
+    options;
     constructor(options) {
       super(options);
-      this.name = "uncompressed";
-      this.extensions = [];
-      this.contentEncodings = [];
-      this.isSupported = true;
       this.options = options || {};
     }
     compressSync(input) {
@@ -5424,13 +6049,14 @@ var __exports__ = (() => {
   var import_pako = __toESM(require_pako(), 1);
   var import_zlib = __toESM(require_zlib(), 1);
   var DeflateCompression = class extends Compression {
+    name = "deflate";
+    extensions = [];
+    contentEncodings = ["deflate"];
+    isSupported = true;
+    options;
+    _chunks = [];
     constructor(options = {}) {
       super(options);
-      this.name = "deflate";
-      this.extensions = [];
-      this.contentEncodings = ["deflate"];
-      this.isSupported = true;
-      this._chunks = [];
       this.options = options;
     }
     async compress(input) {
@@ -5537,12 +6163,12 @@ var __exports__ = (() => {
 
   // src/lib/gzip-compression.ts
   var GZipCompression = class extends DeflateCompression {
+    name = "gzip";
+    extensions = ["gz", "gzip"];
+    contentEncodings = ["gzip", "x-gzip"];
+    isSupported = true;
     constructor(options) {
       super({ ...options, deflate: { ...options?.gzip, gzip: true } });
-      this.name = "gzip";
-      this.extensions = ["gz", "gzip"];
-      this.contentEncodings = ["gzip", "x-gzip"];
-      this.isSupported = true;
     }
   };
 
@@ -7621,25 +8247,23 @@ var __exports__ = (() => {
       lgwin: 22
     }
   };
-  var brotli;
   var BrotliCompression = class extends Compression {
+    name = "brotli";
+    extensions = ["br"];
+    contentEncodings = ["br"];
+    isSupported = true;
+    options;
     constructor(options) {
       super(options);
-      this.name = "brotli";
-      this.extensions = ["br"];
-      this.contentEncodings = ["br"];
-      this.isSupported = true;
       this.options = options;
+      registerJSModules(options?.modules);
     }
     /**
      * brotli is an injectable dependency due to big size
      * @param options
      */
-    async preload() {
-      brotli = brotli || this.options?.modules?.brotli;
-      if (!brotli) {
-        console.warn(`${this.name} library not installed`);
-      }
+    async preload(modules = {}) {
+      registerJSModules(modules);
     }
     async compress(input) {
       if (!isBrowser && this.options.brotli?.useZlib) {
@@ -7655,9 +8279,7 @@ var __exports__ = (() => {
       }
       const brotliOptions = { ...DEFAULT_BROTLI_OPTIONS.brotli, ...this.options?.brotli };
       const inputArray = new Uint8Array(input);
-      if (!brotli) {
-        throw new Error("brotli compression: brotli module not installed");
-      }
+      const brotli = getJSModule("brotli", this.name);
       const outputArray = brotli.compress(inputArray, brotliOptions);
       return outputArray.buffer;
     }
@@ -7675,6 +8297,7 @@ var __exports__ = (() => {
       }
       const brotliOptions = { ...DEFAULT_BROTLI_OPTIONS.brotli, ...this.options?.brotli };
       const inputArray = new Uint8Array(input);
+      const brotli = getJSModuleOrNull("brotli");
       if (brotli) {
         const outputArray2 = brotli.decompress(inputArray, brotliOptions);
         return outputArray2.buffer;
@@ -7687,12 +8310,13 @@ var __exports__ = (() => {
   // src/lib/snappy-compression.ts
   var import_snappyjs = __toESM(require_snappyjs(), 1);
   var SnappyCompression = class extends Compression {
+    name = "snappy";
+    extensions = [];
+    contentEncodings = [];
+    isSupported = true;
+    options;
     constructor(options) {
       super(options);
-      this.name = "snappy";
-      this.extensions = [];
-      this.contentEncodings = [];
-      this.isSupported = true;
       this.options = options || {};
     }
     compressSync(input) {
@@ -7705,21 +8329,22 @@ var __exports__ = (() => {
 
   // src/lib/lz4-compression.ts
   var LZ4_MAGIC_NUMBER = 407708164;
-  var lz4js;
   var LZ4Compression = class extends Compression {
+    name = "lz4";
+    extensions = ["lz4"];
+    contentEncodings = ["x-lz4"];
+    isSupported = true;
+    options;
     constructor(options) {
       super(options);
-      this.name = "lz4";
-      this.extensions = ["lz4"];
-      this.contentEncodings = ["x-lz4"];
-      this.isSupported = true;
       this.options = options;
-      lz4js = lz4js || this.options?.modules?.lz4js;
-      if (!lz4js) {
-        throw new Error(this.name);
-      }
+      registerJSModules(options?.modules);
+    }
+    async preload(modules = {}) {
+      registerJSModules(modules);
     }
     compressSync(input) {
+      const lz4js = getJSModule("lz4js", this.name);
       const inputArray = new Uint8Array(input);
       return lz4js.compress(inputArray).buffer;
     }
@@ -7730,6 +8355,7 @@ var __exports__ = (() => {
      * If data provided without magic number we will parse it as block
      */
     decompressSync(data, maxSize) {
+      const lz4js = getJSModule("lz4js", this.name);
       try {
         const isMagicNumberExists = this.checkMagicNumber(data);
         const inputArray = new Uint8Array(data);
@@ -7807,71 +8433,88 @@ var __exports__ = (() => {
   };
 
   // src/lib/zstd-compression.ts
-  var ZstdCodec;
+  var CHUNK_SIZE = 1e6;
+  var zstdPromise;
   var zstd;
   var ZstdCompression = class extends Compression {
+    name = "zstd";
+    extensions = [];
+    contentEncodings = [];
+    isSupported = true;
+    options;
     /**
      * zstd-codec is an injectable dependency due to big size
      * @param options
      */
     constructor(options) {
       super(options);
-      this.name = "zstd";
-      this.extensions = [];
-      this.contentEncodings = [];
-      this.isSupported = true;
       this.options = options;
-      ZstdCodec = this.options?.modules?.["zstd-codec"];
-      if (!ZstdCodec) {
-        console.warn(`${this.name} library not installed`);
-      }
+      registerJSModules(options?.modules);
     }
-    async preload() {
-      if (!zstd && ZstdCodec) {
-        zstd = await new Promise((resolve) => ZstdCodec.run((zstd2) => resolve(zstd2)));
+    async preload(modules = {}) {
+      registerJSModules(modules);
+      checkJSModule("zstd-codec", this.name);
+      const ZstdCodec = getJSModuleOrNull("zstd-codec");
+      if (!zstdPromise && ZstdCodec) {
+        zstdPromise = new Promise((resolve) => ZstdCodec.run((zstd2) => resolve(zstd2)));
+        zstd = await zstdPromise;
       }
     }
     compressSync(input) {
+      getJSModule("zstd-codec", this.name);
       const simpleZstd = new zstd.Simple();
       const inputArray = new Uint8Array(input);
       return simpleZstd.compress(inputArray).buffer;
     }
     decompressSync(input) {
+      getJSModule("zstd-codec", this.name);
       const simpleZstd = new zstd.Simple();
       const inputArray = new Uint8Array(input);
       return simpleZstd.decompress(inputArray).buffer;
     }
+    async decompress(input, size) {
+      await this.preload();
+      const simpleZstd = new zstd.Streaming();
+      const inputArray = new Uint8Array(input);
+      const chunks = [];
+      for (let i = 0; i <= inputArray.length; i += CHUNK_SIZE) {
+        chunks.push(inputArray.subarray(i, i + CHUNK_SIZE));
+      }
+      const decompressResult = await simpleZstd.decompressChunks(chunks);
+      return decompressResult.buffer;
+    }
   };
 
   // src/lib/lzo-compression.ts
-  var lzo;
   var LZOCompression = class extends Compression {
+    name = "lzo";
+    extensions = [];
+    contentEncodings = [];
+    isSupported = false;
+    // !isBrowser;
+    options;
     /**
      * lzo is an injectable dependency due to big size
      * @param options
      */
     constructor(options) {
       super(options);
-      this.name = "lzo";
-      this.extensions = [];
-      this.contentEncodings = [];
-      this.isSupported = false;
       this.options = options;
-      lzo = lzo || this.options?.modules?.lzo;
-      if (!lzo) {
-        throw new Error(this.name);
-      }
+      registerJSModules(options?.modules);
     }
-    async preload() {
+    async preload(modules = {}) {
+      registerJSModules(modules);
     }
     async compress(input) {
       await this.preload();
+      const lzo = getJSModule("lzo", this.name);
       const inputBuffer = toBuffer2(input);
       return lzo.compress(inputBuffer).buffer;
     }
     async decompress(input) {
       try {
         await this.preload();
+        const lzo = getJSModule("lzo", this.name);
         const inputBuffer = toBuffer2(input);
         return lzo.decompress(inputBuffer).buffer;
       } catch (error) {
@@ -7881,12 +8524,12 @@ var __exports__ = (() => {
   };
 
   // src/compress-on-worker.ts
-  var VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
   var CompressionWorker = {
     id: "compression",
     name: "compression",
     module: "compression",
-    version: VERSION2,
+    version: VERSION3,
     options: {}
   };
   function compressOnWorker(data, options) {