@loaders.gl/textures 4.0.0-alpha.9 → 4.0.0-beta.2

package/dist/basis-worker-node.js

@@ -21408,7 +21408,7 @@ var require_cookie = __commonJS({
     var Store = require_store().Store;
     var MemoryCookieStore = require_memstore().MemoryCookieStore;
     var pathMatch = require_pathMatch().pathMatch;
-    var VERSION5 = require_version();
+    var VERSION3 = require_version();
     var punycode;
     try {
       punycode = require("punycode");
@@ -22225,7 +22225,7 @@ var require_cookie = __commonJS({
         type = null;
       }
       var serialized = {
-        version: "tough-cookie@" + VERSION5,
+        version: "tough-cookie@" + VERSION3,
         storeType: type,
         rejectPublicSuffixes: !!this.rejectPublicSuffixes,
         cookies: []
@@ -22377,7 +22377,7 @@ var require_cookie = __commonJS({
     CAN_BE_SYNC.forEach(function(method) {
       CookieJar.prototype[method + "Sync"] = syncWrap(method);
     });
-    exports2.version = VERSION5;
+    exports2.version = VERSION3;
     exports2.CookieJar = CookieJar;
     exports2.Cookie = Cookie;
     exports2.Store = Store;
@@ -45980,7 +45980,7 @@ var require_form_data = __commonJS({
     var http2 = require("http");
     var https2 = require("https");
     var parseUrl = require("url").parse;
-    var fs2 = require("fs");
+    var fs3 = require("fs");
     var mime = require_mime_types();
     var asynckit = require_asynckit();
     var populate = require_populate();
@@ -46044,7 +46044,7 @@ var require_form_data = __commonJS({
         if (value.end != void 0 && value.end != Infinity && value.start != void 0) {
           callback(null, value.end + 1 - (value.start ? value.start : 0));
         } else {
-          fs2.stat(value.path, function(err, stat) {
+          fs3.stat(value.path, function(err, stat) {
             var fileSize;
             if (err) {
               callback(err);
@@ -54151,7 +54151,7 @@ var require_promise = __commonJS({
 var require_har2 = __commonJS({
   "../../node_modules/request/lib/har.js"(exports2) {
     "use strict";
-    var fs2 = require("fs");
+    var fs3 = require("fs");
     var qs = require("querystring");
     var validate = require_promise();
     var extend = require_extend();
@@ -54285,7 +54285,7 @@ var require_har2 = __commonJS({
             return;
           }
           if (param.fileName && !param.value) {
-            attachment.value = fs2.createReadStream(param.fileName);
+            attachment.value = fs3.createReadStream(param.fileName);
           } else if (param.value) {
             attachment.value = param.value;
           }
@@ -56833,7 +56833,7 @@ var require_node_pixels = __commonJS({
     var pack = require_convert();
     var GifReader = require_omggif().GifReader;
     var Bitmap = require_node_bitmap();
-    var fs2 = require("fs");
+    var fs3 = require("fs");
     var request = require_request3();
     var mime = require_mime_types();
     var parseDataURI = require_parse_data_uri();
@@ -56985,7 +56985,7 @@ var require_node_pixels = __commonJS({
           doParse(type, body, cb);
         });
       } else {
-        fs2.readFile(url, function(err, data) {
+        fs3.readFile(url, function(err, data) {
           if (err) {
             cb(err);
             return;
@@ -62693,6 +62693,275 @@ function btoa(base642) {
   return Buffer.from(base642, "base64").toString("ascii");
 }
 
+// ../polyfills/src/node/images/encode-image.node.ts
+var import_save_pixels = __toModule(require_save_pixels());
+var import_ndarray = __toModule(require_ndarray());
+
+// ../polyfills/src/node/buffer/to-array-buffer.node.ts
+function bufferToArrayBuffer(buffer) {
+  if (Buffer.isBuffer(buffer)) {
+    const typedArray = new Uint8Array(buffer);
+    return typedArray.buffer;
+  }
+  return buffer;
+}
+
+// ../polyfills/src/node/images/encode-image.node.ts
+function encodeImageToStreamNode(image, options) {
+  const type = options.type ? options.type.replace("image/", "") : "jpeg";
+  const pixels = (0, import_ndarray.default)(image.data, [image.width, image.height, 4], [4, image.width * 4, 1], 0);
+  return (0, import_save_pixels.default)(pixels, type, options);
+}
+function encodeImageNode(image, options) {
+  const imageStream = encodeImageToStreamNode(image, options);
+  return new Promise((resolve) => {
+    const buffers = [];
+    imageStream.on("data", (buffer) => buffers.push(buffer));
+    imageStream.on("end", () => {
+      const buffer = Buffer.concat(buffers);
+      resolve(bufferToArrayBuffer(buffer));
+    });
+  });
+}
+
+// ../polyfills/src/node/images/parse-image.node.ts
+var import_get_pixels = __toModule(require_node_pixels());
+var NODE_FORMAT_SUPPORT = ["image/png", "image/jpeg", "image/gif"];
+async function parseImageNode(arrayBuffer, mimeType) {
+  if (!mimeType) {
+    throw new Error("MIMEType is required to parse image under Node.js");
+  }
+  const buffer = arrayBuffer instanceof Buffer ? arrayBuffer : Buffer.from(arrayBuffer);
+  const ndarray2 = await getPixelsAsync(buffer, mimeType);
+  return ndarray2;
+}
+function getPixelsAsync(buffer, mimeType) {
+  return new Promise((resolve) => (0, import_get_pixels.default)(buffer, mimeType, (err, ndarray2) => {
+    if (err) {
+      throw err;
+    }
+    const shape = [...ndarray2.shape];
+    const layers = ndarray2.shape.length === 4 ? ndarray2.shape.shift() : 1;
+    const data = ndarray2.data instanceof Buffer ? new Uint8Array(ndarray2.data) : ndarray2.data;
+    resolve({
+      shape,
+      data,
+      width: ndarray2.shape[0],
+      height: ndarray2.shape[1],
+      components: ndarray2.shape[2],
+      layers: layers ? [layers] : []
+    });
+  }));
+}
+
+// ../polyfills/src/node/file/readable-stream.ts
+var import_web_streams_polyfill = __toModule(require_polyfill());
+delete global.ReadableStream;
+var ReadableStreamPolyfill = class extends import_web_streams_polyfill.ReadableStream {
+};
+
+// ../polyfills/src/node/file/blob-stream-controller.ts
+var BlobStreamController = class {
+  constructor(chunks) {
+    this.isWorking = false;
+    this.isCancelled = false;
+    this.chunks = chunks;
+  }
+  start(controller) {
+    this.work(controller);
+  }
+  async work(controller) {
+    const { chunks } = this;
+    this.isWorking = true;
+    while (!this.isCancelled && (controller.desiredSize || 0) > 0) {
+      let next;
+      try {
+        next = chunks.next();
+      } catch (error) {
+        controller.error(error);
+        break;
+      }
+      if (next) {
+        if (!next.done && !this.isCancelled) {
+          controller.enqueue(next.value);
+        } else {
+          controller.close();
+        }
+      }
+    }
+    this.isWorking = false;
+  }
+  pull(controller) {
+    if (!this.isWorking) {
+      this.work(controller);
+    }
+  }
+  cancel() {
+    this.isCancelled = true;
+  }
+};
+
+// ../polyfills/src/node/file/blob-stream.ts
+var BlobStream = class extends ReadableStreamPolyfill {
+  constructor(chunks) {
+    super(new BlobStreamController(chunks.values()), { type: "bytes" });
+    this._chunks = chunks;
+  }
+  async *[Symbol.asyncIterator](_options) {
+    const reader = this.getReader();
+    yield* this._chunks;
+    reader.releaseLock();
+  }
+};
+
+// ../polyfills/src/node/file/blob.ts
+var BlobPolyfill = class {
+  constructor(init = [], options = {}) {
+    this.parts = [];
+    this.size = 0;
+    for (const part of init) {
+      if (typeof part === "string") {
+        const bytes = new TextEncoder().encode(part);
+        this.parts.push(bytes);
+        this.size += bytes.byteLength;
+      } else if (part instanceof BlobPolyfill) {
+        this.size += part.size;
+        this.parts.push(...part.parts);
+      } else if (part instanceof ArrayBuffer) {
+        this.parts.push(new Uint8Array(part));
+        this.size += part.byteLength;
+      } else if (part instanceof Uint8Array) {
+        this.parts.push(part);
+        this.size += part.byteLength;
+      } else if (ArrayBuffer.isView(part)) {
+        const { buffer, byteOffset, byteLength } = part;
+        this.parts.push(new Uint8Array(buffer, byteOffset, byteLength));
+        this.size += byteLength;
+      } else {
+        const bytes = new TextEncoder().encode(String(part));
+        this.parts.push(bytes);
+        this.size += bytes.byteLength;
+      }
+    }
+    this.type = readType(options.type);
+  }
+  slice(start = 0, end = this.size, type = "") {
+    const { size, parts } = this;
+    let offset = start < 0 ? Math.max(size + start, 0) : Math.min(start, size);
+    let limit = end < 0 ? Math.max(size + end, 0) : Math.min(end, size);
+    const span = Math.max(limit - offset, 0);
+    const blob = new BlobPolyfill([], { type });
+    if (span === 0) {
+      return blob;
+    }
+    let blobSize = 0;
+    const blobParts = [];
+    for (const part of parts) {
+      const { byteLength } = part;
+      if (offset > 0 && byteLength <= offset) {
+        offset -= byteLength;
+        limit -= byteLength;
+      } else {
+        const chunk = part.subarray(offset, Math.min(byteLength, limit));
+        blobParts.push(chunk);
+        blobSize += chunk.byteLength;
+        offset = 0;
+        if (blobSize >= span) {
+          break;
+        }
+      }
+    }
+    blob.parts = blobParts;
+    blob.size = blobSize;
+    return blob;
+  }
+  async arrayBuffer() {
+    return this._toArrayBuffer();
+  }
+  async text() {
+    const decoder = new TextDecoder();
+    let text = "";
+    for (const part of this.parts) {
+      text += decoder.decode(part);
+    }
+    return text;
+  }
+  stream() {
+    return new BlobStream(this.parts);
+  }
+  toString() {
+    return "[object Blob]";
+  }
+  get [Symbol.toStringTag]() {
+    return "Blob";
+  }
+  _toArrayBuffer() {
+    const buffer = new ArrayBuffer(this.size);
+    const bytes = new Uint8Array(buffer);
+    let offset = 0;
+    for (const part of this.parts) {
+      bytes.set(part, offset);
+      offset += part.byteLength;
+    }
+    return buffer;
+  }
+};
+function readType(input = "") {
+  const type = String(input).toLowerCase();
+  return /[^\u0020-\u007E]/.test(type) ? "" : type;
+}
+
+// ../polyfills/src/node/file/file.ts
+var FilePolyfill = class extends BlobPolyfill {
+  constructor(init, name, options = {}) {
+    super(init, options);
+    this.name = "";
+    this.webkitRelativePath = "";
+    this.name = String(name).replace(/\//g, ":");
+    this.lastModified = (options == null ? void 0 : options.lastModified) || Date.now();
+  }
+  get [Symbol.toStringTag]() {
+    return "File";
+  }
+};
+
+// ../polyfills/src/filesystems/node-filesystem.ts
+var import_fs = __toModule(require("fs"));
+var import_promises = __toModule(require("fs/promises"));
+var NodeFileSystem = class {
+  constructor(options) {
+    this.fetch = options._fetch;
+  }
+  async readdir(dirname = ".", options) {
+    return await import_promises.default.readdir(dirname, options);
+  }
+  async stat(path2, options) {
+    const info = await import_promises.default.stat(path2, options);
+    return { size: Number(info.size), isDirectory: () => false, info };
+  }
+  async fetch(path2, options) {
+    const fallbackFetch = options.fetch || this.fetch;
+    return fallbackFetch(path2, options);
+  }
+  async open(path2, flags, mode) {
+    return await import_promises.default.open(path2, flags);
+  }
+  async close(fd) {
+    import_fs.default.close(fd);
+  }
+  async fstat(fd) {
+    return await new Promise((resolve, reject) => import_fs.default.fstat(fd, (err, info) => err ? reject(err) : resolve(info)));
+  }
+  async read(fd, { buffer = null, offset = 0, length = buffer.byteLength, position = null }) {
+    let totalBytesRead = 0;
+    while (totalBytesRead < length) {
+      const { bytesRead } = await new Promise((resolve, reject) => import_fs.default.read(fd, buffer, offset + totalBytesRead, length - totalBytesRead, position + totalBytesRead, (err, bytesRead2, buffer2) => err ? reject(err) : resolve({ bytesRead: bytesRead2, buffer: buffer2 })));
+      totalBytesRead += bytesRead;
+    }
+    return { bytesRead: totalBytesRead, buffer };
+  }
+};
+
 // ../polyfills/src/node/fetch/headers.node.ts
 var Headers = class {
   constructor(headers) {
@@ -62939,48 +63208,12 @@ var Response = class {
 // ../polyfills/src/node/fetch/fetch.node.ts
 var import_http = __toModule(require("http"));
 var import_https = __toModule(require("https"));
-
-// ../polyfills/src/node/fetch/fetch-file.node.ts
-var import_fs = __toModule(require("fs"));
-async function fetchFileNode(url, options) {
-  const noqueryUrl = url.split("?")[0];
-  try {
-    const body = await new Promise((resolve, reject) => {
-      const stream = import_fs.default.createReadStream(noqueryUrl, { encoding: null });
-      stream.once("readable", () => resolve(stream));
-      stream.on("error", (error) => reject(error));
-    });
-    const status = 200;
-    const statusText = "OK";
-    const headers = getHeadersForFile(noqueryUrl);
-    return new Response(body, { headers, status, statusText, url });
-  } catch (error) {
-    const status = 400;
-    const statusText = error.message;
-    const headers = {};
-    return new Response(error.message, { headers, status, statusText, url });
-  }
-}
-function getHeadersForFile(noqueryUrl) {
-  const headers = {};
-  if (!headers["content-length"]) {
-    const stats = import_fs.default.statSync(noqueryUrl);
-    headers["content-length"] = stats.size;
-  }
-  if (noqueryUrl.endsWith(".gz")) {
-    noqueryUrl = noqueryUrl.slice(0, -3);
-    headers["content-encoding"] = "gzip";
-  }
-  return new Headers(headers);
-}
-
-// ../polyfills/src/node/fetch/fetch.node.ts
 var isDataURL = (url) => url.startsWith("data:");
 var isRequestURL = (url) => url.startsWith("http:") || url.startsWith("https:");
 async function fetchNode(url, options) {
   try {
-    if (!isRequestURL(url) && !isDataURL(url)) {
-      return await fetchFileNode(url, options);
+    if (globalThis.fetch !== fetchNode && (isRequestURL(url) || isDataURL(url))) {
+      return await fetch(url, options);
     }
     if (isDataURL(url)) {
       const { arrayBuffer, mimeType } = decodeDataUri(url);
@@ -63070,278 +63303,59 @@ function getContentLength(url) {
   return isDataURL(url) ? url.length - "data:".length : null;
 }
 
-// ../polyfills/src/node/images/encode-image.node.ts
-var import_save_pixels = __toModule(require_save_pixels());
-var import_ndarray = __toModule(require_ndarray());
-
-// ../polyfills/src/node/buffer/to-array-buffer.node.ts
-function bufferToArrayBuffer(buffer) {
-  if (Buffer.isBuffer(buffer)) {
-    const typedArray = new Uint8Array(buffer);
-    return typedArray.buffer;
-  }
-  return buffer;
-}
-
-// ../polyfills/src/node/images/encode-image.node.ts
-function encodeImageToStreamNode(image, options) {
-  const type = options.type ? options.type.replace("image/", "") : "jpeg";
-  const pixels = (0, import_ndarray.default)(image.data, [image.width, image.height, 4], [4, image.width * 4, 1], 0);
-  return (0, import_save_pixels.default)(pixels, type, options);
-}
-function encodeImageNode(image, options) {
-  const imageStream = encodeImageToStreamNode(image, options);
-  return new Promise((resolve) => {
-    const buffers = [];
-    imageStream.on("data", (buffer) => buffers.push(buffer));
-    imageStream.on("end", () => {
-      const buffer = Buffer.concat(buffers);
-      resolve(bufferToArrayBuffer(buffer));
-    });
-  });
-}
-
-// ../polyfills/src/node/images/parse-image.node.ts
-var import_get_pixels = __toModule(require_node_pixels());
-var NODE_FORMAT_SUPPORT = ["image/png", "image/jpeg", "image/gif"];
-async function parseImageNode(arrayBuffer, mimeType) {
-  if (!mimeType) {
-    throw new Error("MIMEType is required to parse image under Node.js");
-  }
-  const buffer = arrayBuffer instanceof Buffer ? arrayBuffer : Buffer.from(arrayBuffer);
-  const ndarray2 = await getPixelsAsync(buffer, mimeType);
-  return ndarray2;
-}
-function getPixelsAsync(buffer, mimeType) {
-  return new Promise((resolve) => (0, import_get_pixels.default)(buffer, mimeType, (err, ndarray2) => {
-    if (err) {
-      throw err;
-    }
-    const shape = [...ndarray2.shape];
-    const layers = ndarray2.shape.length === 4 ? ndarray2.shape.shift() : 1;
-    const data = ndarray2.data instanceof Buffer ? new Uint8Array(ndarray2.data) : ndarray2.data;
-    resolve({
-      shape,
-      data,
-      width: ndarray2.shape[0],
-      height: ndarray2.shape[1],
-      components: ndarray2.shape[2],
-      layers: layers ? [layers] : []
-    });
-  }));
-}
-
-// ../polyfills/src/node/file/readable-stream.ts
-var import_web_streams_polyfill = __toModule(require_polyfill());
-delete global.ReadableStream;
-var ReadableStreamPolyfill = class extends import_web_streams_polyfill.ReadableStream {
-};
-
-// ../polyfills/src/node/file/blob-stream-controller.ts
-var BlobStreamController = class {
-  constructor(chunks) {
-    this.isWorking = false;
-    this.isCancelled = false;
-    this.chunks = chunks;
-  }
-  start(controller) {
-    this.work(controller);
-  }
-  async work(controller) {
-    const { chunks } = this;
-    this.isWorking = true;
-    while (!this.isCancelled && (controller.desiredSize || 0) > 0) {
-      let next;
-      try {
-        next = chunks.next();
-      } catch (error) {
-        controller.error(error);
-        break;
-      }
-      if (next) {
-        if (!next.done && !this.isCancelled) {
-          controller.enqueue(next.value);
-        } else {
-          controller.close();
-        }
-      }
-    }
-    this.isWorking = false;
-  }
-  pull(controller) {
-    if (!this.isWorking) {
-      this.work(controller);
-    }
-  }
-  cancel() {
-    this.isCancelled = true;
-  }
-};
-
-// ../polyfills/src/node/file/blob-stream.ts
-var BlobStream = class extends ReadableStreamPolyfill {
-  constructor(chunks) {
-    super(new BlobStreamController(chunks.values()), { type: "bytes" });
-    this._chunks = chunks;
-  }
-  async *[Symbol.asyncIterator](_options) {
-    const reader = this.getReader();
-    yield* this._chunks;
-    reader.releaseLock();
-  }
-};
-
-// ../polyfills/src/node/file/blob.ts
-var BlobPolyfill = class {
-  constructor(init = [], options = {}) {
-    this.parts = [];
-    this.size = 0;
-    for (const part of init) {
-      if (typeof part === "string") {
-        const bytes = new TextEncoder().encode(part);
-        this.parts.push(bytes);
-        this.size += bytes.byteLength;
-      } else if (part instanceof BlobPolyfill) {
-        this.size += part.size;
-        this.parts.push(...part.parts);
-      } else if (part instanceof ArrayBuffer) {
-        this.parts.push(new Uint8Array(part));
-        this.size += part.byteLength;
-      } else if (part instanceof Uint8Array) {
-        this.parts.push(part);
-        this.size += part.byteLength;
-      } else if (ArrayBuffer.isView(part)) {
-        const { buffer, byteOffset, byteLength } = part;
-        this.parts.push(new Uint8Array(buffer, byteOffset, byteLength));
-        this.size += byteLength;
-      } else {
-        const bytes = new TextEncoder().encode(String(part));
-        this.parts.push(bytes);
-        this.size += bytes.byteLength;
-      }
-    }
-    this.type = readType(options.type);
-  }
-  slice(start = 0, end = this.size, type = "") {
-    const { size, parts } = this;
-    let offset = start < 0 ? Math.max(size + start, 0) : Math.min(start, size);
-    let limit = end < 0 ? Math.max(size + end, 0) : Math.min(end, size);
-    const span = Math.max(limit - offset, 0);
-    const blob = new BlobPolyfill([], { type });
-    if (span === 0) {
-      return blob;
-    }
-    let blobSize = 0;
-    const blobParts = [];
-    for (const part of parts) {
-      const { byteLength } = part;
-      if (offset > 0 && byteLength <= offset) {
-        offset -= byteLength;
-        limit -= byteLength;
-      } else {
-        const chunk = part.subarray(offset, Math.min(byteLength, limit));
-        blobParts.push(chunk);
-        blobSize += chunk.byteLength;
-        offset = 0;
-        if (blobSize >= span) {
-          break;
-        }
-      }
-    }
-    blob.parts = blobParts;
-    blob.size = blobSize;
-    return blob;
-  }
-  async arrayBuffer() {
-    return this._toArrayBuffer();
-  }
-  async text() {
-    const decoder = new TextDecoder();
-    let text = "";
-    for (const part of this.parts) {
-      text += decoder.decode(part);
-    }
-    return text;
-  }
-  stream() {
-    return new BlobStream(this.parts);
-  }
-  toString() {
-    return "[object Blob]";
-  }
-  get [Symbol.toStringTag]() {
-    return "Blob";
-  }
-  _toArrayBuffer() {
-    const buffer = new ArrayBuffer(this.size);
-    const bytes = new Uint8Array(buffer);
-    let offset = 0;
-    for (const part of this.parts) {
-      bytes.set(part, offset);
-      offset += part.byteLength;
-    }
-    return buffer;
-  }
-};
-function readType(input = "") {
-  const type = String(input).toLowerCase();
-  return /[^\u0020-\u007E]/.test(type) ? "" : type;
-}
-
-// ../polyfills/src/node/file/file.ts
-var FilePolyfill = class extends BlobPolyfill {
-  constructor(init, name, options = {}) {
-    super(init, options);
-    this.name = "";
-    this.webkitRelativePath = "";
-    this.name = String(name).replace(/\//g, ":");
-    this.lastModified = (options == null ? void 0 : options.lastModified) || Date.now();
-  }
-  get [Symbol.toStringTag]() {
-    return "File";
-  }
-};
-
 // ../polyfills/src/index.ts
-var installTextEncoder = !isBrowser || !("TextEncoder" in global_);
-if (installTextEncoder) {
-  global_["TextEncoder"] = TextEncoder2;
-}
-var installTextDecoder = !isBrowser || !("TextDecoder" in global_);
-if (installTextDecoder) {
-  global_["TextDecoder"] = TextDecoder2;
+if (isBrowser) {
+  console.error("loaders.gl: The @loaders.gl/polyfills should only be used in Node.js environments");
 }
-if (!isBrowser && !("atob" in global_) && atob) {
-  global_["atob"] = atob;
+if (!globalThis.TextEncoder) {
+  globalThis.TextEncoder = TextEncoder2;
 }
-if (!isBrowser && !("btoa" in global_) && btoa) {
-  global_["btoa"] = btoa;
+if (!globalThis.TextDecoder) {
+  globalThis.TextDecoder = TextDecoder2;
 }
-if (!isBrowser && !("Headers" in global_) && Headers) {
-  global_["Headers"] = Headers;
+if (!isBrowser && !("atob" in globalThis) && atob) {
+  globalThis["atob"] = atob;
 }
-if (!isBrowser && !("Response" in global_) && Response) {
-  global_["Response"] = Response;
+if (!isBrowser && !("btoa" in globalThis) && btoa) {
+  globalThis["btoa"] = btoa;
 }
-if (!isBrowser && !("fetch" in global_) && fetchNode) {
-  global_["fetch"] = fetchNode;
+globalThis.loaders = globalThis.loaders || {};
+globalThis.loaders.NodeFileSystem = NodeFileSystem;
+if (!isBrowser && !("_encodeImageNode" in globalThis) && encodeImageNode) {
+  globalThis["_encodeImageNode"] = encodeImageNode;
 }
-if (!isBrowser && !("_encodeImageNode" in global_) && encodeImageNode) {
-  global_["_encodeImageNode"] = encodeImageNode;
-}
-if (!isBrowser && !("_parseImageNode" in global_) && parseImageNode) {
-  global_["_parseImageNode"] = parseImageNode;
-  global_["_imageFormatsNode"] = NODE_FORMAT_SUPPORT;
+if (!isBrowser && !("_parseImageNode" in globalThis) && parseImageNode) {
+  globalThis["_parseImageNode"] = parseImageNode;
+  globalThis["_imageFormatsNode"] = NODE_FORMAT_SUPPORT;
 }
 if (!("allSettled" in Promise)) {
   Promise.allSettled = allSettled;
 }
+if (!isBrowser && !("Headers" in globalThis) && Headers) {
+  globalThis.Headers = Headers;
+}
+if (!isBrowser && !("Response" in globalThis) && Response) {
+  globalThis.Response = Response;
+}
+if (!isBrowser && !("fetch" in globalThis) && fetchNode) {
+  globalThis.fetch = fetchNode;
+}
 
 // ../worker-utils/src/lib/env-utils/version.ts
-var VERSION = true ? "4.0.0-alpha.9" : DEFAULT_VERSION;
-if (false) {
-  console.error("loaders.gl: The __VERSION__ variable is not injected using babel plugin. Latest unstable workers would be fetched from the CDN.");
+function getVersion() {
+  var _a;
+  if (!((_a = globalThis._loadersgl_) == null ? void 0 : _a.version)) {
+    globalThis._loadersgl_ = globalThis._loadersgl_ || {};
+    if (false) {
+      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 = "4.0.0-beta.2";
+    }
+  }
+  return globalThis._loadersgl_.version;
 }
+var VERSION = getVersion();
 
 // ../worker-utils/src/lib/env-utils/assert.ts
 function assert2(condition, message) {
@@ -63479,11 +63493,30 @@ function isKnownMessage(message) {
 // ../worker-utils/src/lib/node/require-utils.node.ts
 var require_utils_node_exports = {};
 __export(require_utils_node_exports, {
+  readFileAsArrayBuffer: () => readFileAsArrayBuffer,
+  readFileAsText: () => readFileAsText,
   requireFromFile: () => requireFromFile,
   requireFromString: () => requireFromString
 });
 var import_module = __toModule(require("module"));
 var import_path = __toModule(require("path"));
+var import_fs2 = __toModule(require("fs"));
+async function readFileAsArrayBuffer(filename) {
+  if (filename.startsWith("http")) {
+    const response = await fetch(filename);
+    return await response.arrayBuffer();
+  }
+  const buffer = import_fs2.default.readFileSync(filename);
+  return buffer.buffer;
+}
+async function readFileAsText(filename) {
+  if (filename.startsWith("http")) {
+    const response = await fetch(filename);
+    return await response.text();
+  }
+  const text = import_fs2.default.readFileSync(filename, "utf8");
+  return text;
+}
 async function requireFromFile(filename) {
   if (filename.startsWith("http")) {
     const response = await fetch(filename);
@@ -63516,40 +63549,38 @@ function requireFromString(code, filename = "", options) {
 }
 
 // ../worker-utils/src/lib/library-utils/library-utils.ts
-var LATEST = "beta";
-var VERSION2 = typeof VERSION !== "undefined" ? VERSION : LATEST;
 var loadLibraryPromises = {};
-async function loadLibrary(libraryUrl, moduleName = null, options = {}) {
+async function loadLibrary(libraryUrl, moduleName = null, options = {}, libraryName = null) {
   if (moduleName) {
-    libraryUrl = getLibraryUrl(libraryUrl, moduleName, options);
+    libraryUrl = getLibraryUrl(libraryUrl, moduleName, options, libraryName);
   }
   loadLibraryPromises[libraryUrl] = loadLibraryPromises[libraryUrl] || loadLibraryFromFile(libraryUrl);
   return await loadLibraryPromises[libraryUrl];
 }
-function getLibraryUrl(library, moduleName, options) {
-  if (library.startsWith("http")) {
+function getLibraryUrl(library, moduleName, options = {}, libraryName = null) {
+  if (!options.useLocalLibraries && library.startsWith("http")) {
     return library;
   }
+  libraryName = libraryName || library;
   const modules = options.modules || {};
-  if (modules[library]) {
-    return modules[library];
+  if (modules[libraryName]) {
+    return modules[libraryName];
   }
   if (!isBrowser2) {
-    return `modules/${moduleName}/dist/libs/${library}`;
+    return `modules/${moduleName}/dist/libs/${libraryName}`;
   }
   if (options.CDN) {
     assert2(options.CDN.startsWith("http"));
-    return `${options.CDN}/${moduleName}@${VERSION2}/dist/libs/${library}`;
+    return `${options.CDN}/${moduleName}@${VERSION}/dist/libs/${libraryName}`;
   }
   if (isWorker) {
-    return `../src/libs/${library}`;
+    return `../src/libs/${libraryName}`;
   }
-  return `modules/${moduleName}/src/libs/${library}`;
+  return `modules/${moduleName}/src/libs/${libraryName}`;
 }
 async function loadLibraryFromFile(libraryUrl) {
   if (libraryUrl.endsWith("wasm")) {
-    const response2 = await fetch(libraryUrl);
-    return await response2.arrayBuffer();
+    return await loadAsArrayBuffer(libraryUrl);
   }
   if (!isBrowser2) {
     try {
@@ -63561,8 +63592,7 @@ async function loadLibraryFromFile(libraryUrl) {
   if (isWorker) {
     return importScripts(libraryUrl);
   }
-  const response = await fetch(libraryUrl);
-  const scriptSource = await response.text();
+  const scriptSource = await loadAsText(libraryUrl);
   return loadLibraryFromString(scriptSource, libraryUrl);
 }
 function loadLibraryFromString(scriptSource, id) {
@@ -63583,6 +63613,20 @@ function loadLibraryFromString(scriptSource, id) {
   document.body.appendChild(script);
   return null;
 }
+async function loadAsArrayBuffer(url) {
+  if (!readFileAsArrayBuffer || url.startsWith("http")) {
+    const response = await fetch(url);
+    return await response.arrayBuffer();
+  }
+  return await readFileAsArrayBuffer(url);
+}
+async function loadAsText(url) {
+  if (!readFileAsText || url.startsWith("http")) {
+    const response = await fetch(url);
+    return await response.text();
+  }
+  return await readFileAsText(url);
+}
 
 // ../loader-utils/src/lib/worker-loader-utils/create-loader-worker.ts
 var requestId = 0;
@@ -63600,7 +63644,7 @@ function createLoaderWorker(loader) {
             arrayBuffer: input,
             options,
             context: __spreadProps(__spreadValues({}, context), {
-              parse: parseOnMainThread
+              _parse: parseOnMainThread
             })
           });
           WorkerBody.postMessage("done", { result });
@@ -63613,7 +63657,7 @@ function createLoaderWorker(loader) {
     }
   };
 }
-function parseOnMainThread(arrayBuffer, options) {
+function parseOnMainThread(arrayBuffer, loader, options, context) {
   return new Promise((resolve, reject) => {
     const id = requestId++;
     const onMessage = (type, payload2) => {
@@ -63637,7 +63681,12 @@ function parseOnMainThread(arrayBuffer, options) {
     WorkerBody.postMessage("process", payload);
   });
 }
-async function parseData({ loader, arrayBuffer, options, context }) {
+async function parseData({
+  loader,
+  arrayBuffer,
+  options,
+  context
+}) {
   let data;
   let parser;
   if (loader.parseSync || loader.parse) {
@@ -63658,32 +63707,35 @@ async function parseData({ loader, arrayBuffer, options, context }) {
 }
 
 // src/lib/utils/version.ts
-var VERSION3 = true ? "4.0.0-alpha.9" : "beta";
+var VERSION2 = true ? "4.0.0-beta.2" : "beta";
 
 // src/lib/parsers/basis-module-loader.ts
-var VERSION4 = true ? "4.0.0-alpha.9" : "beta";
-var BASIS_CDN_ENCODER_WASM = `https://unpkg.com/@loaders.gl/textures@${VERSION4}/dist/libs/basis_encoder.wasm`;
-var BASIS_CDN_ENCODER_JS = `https://unpkg.com/@loaders.gl/textures@${VERSION4}/dist/libs/basis_encoder.js`;
+var BASIS_EXTERNAL_LIBRARIES = {
+  TRANSCODER: "basis_transcoder.js",
+  TRANSCODER_WASM: "basis_transcoder.wasm",
+  ENCODER: "basis_encoder.js",
+  ENCODER_WASM: "basis_encoder.wasm"
+};
 var loadBasisTranscoderPromise;
-async function loadBasisTrascoderModule(options) {
+async function loadBasisTranscoderModule(options) {
   const modules = options.modules || {};
   if (modules.basis) {
     return modules.basis;
   }
-  loadBasisTranscoderPromise = loadBasisTranscoderPromise || loadBasisTrascoder(options);
+  loadBasisTranscoderPromise = loadBasisTranscoderPromise || loadBasisTranscoder(options);
   return await loadBasisTranscoderPromise;
 }
-async function loadBasisTrascoder(options) {
+async function loadBasisTranscoder(options) {
   let BASIS = null;
   let wasmBinary = null;
   [BASIS, wasmBinary] = await Promise.all([
-    await loadLibrary("basis_transcoder.js", "textures", options),
-    await loadLibrary("basis_transcoder.wasm", "textures", options)
+    await loadLibrary(BASIS_EXTERNAL_LIBRARIES.TRANSCODER, "textures", options),
+    await loadLibrary(BASIS_EXTERNAL_LIBRARIES.TRANSCODER_WASM, "textures", options)
   ]);
   BASIS = BASIS || globalThis.BASIS;
-  return await initializeBasisTrascoderModule(BASIS, wasmBinary);
+  return await initializeBasisTranscoderModule(BASIS, wasmBinary);
 }
-function initializeBasisTrascoderModule(BasisModule, wasmBinary) {
+function initializeBasisTranscoderModule(BasisModule, wasmBinary) {
   const options = {};
   if (wasmBinary) {
     options.wasmBinary = wasmBinary;
@@ -63709,8 +63761,8 @@ async function loadBasisEncoder(options) {
   let BASIS_ENCODER = null;
   let wasmBinary = null;
   [BASIS_ENCODER, wasmBinary] = await Promise.all([
-    await loadLibrary(BASIS_CDN_ENCODER_JS, "textures", options),
-    await loadLibrary(BASIS_CDN_ENCODER_WASM, "textures", options)
+    await loadLibrary(BASIS_EXTERNAL_LIBRARIES.ENCODER, "textures", options),
+    await loadLibrary(BASIS_EXTERNAL_LIBRARIES.ENCODER_WASM, "textures", options)
   ]);
   BASIS_ENCODER = BASIS_ENCODER || globalThis.BASIS;
   return await initializeBasisEncoderModule(BASIS_ENCODER, wasmBinary);
@@ -63900,7 +63952,7 @@ async function parseBasis(data, options) {
       const fileConstructors = await loadBasisEncoderModule(options);
       return parseKTX2File(fileConstructors.KTX2File, data, options);
     }
-    const { BasisFile } = await loadBasisTrascoderModule(options);
+    const { BasisFile } = await loadBasisTranscoderModule(options);
     return parseBasisFile(BasisFile, data, options);
   }
   switch (options.basis.module) {
@@ -63915,7 +63967,7 @@ async function parseBasis(data, options) {
       }
     case "transcoder":
     default:
-      const { BasisFile } = await loadBasisTrascoderModule(options);
+      const { BasisFile } = await loadBasisTranscoderModule(options);
       return parseBasisFile(BasisFile, data, options);
   }
 }
@@ -64034,7 +64086,7 @@ var BasisWorkerLoader = {
   name: "Basis",
   id: "basis",
   module: "textures",
-  version: VERSION3,
+  version: VERSION2,
   worker: true,
   extensions: ["basis", "ktx2"],
   mimeTypes: ["application/octet-stream", "image/ktx2"],