@loaders.gl/splats 5.0.0-alpha.1 → 5.0.0-alpha.3

package/dist/index.cjs

@@ -5,8 +5,13 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
 };
 var __export = (target, all) => {
   for (var name in all)
@@ -83,12 +88,12 @@ function convertColorByteToSphericalHarmonicDc(colorByte) {
 function convertAlphaByteToLinearOpacity(alphaByte) {
   return Math.min(Math.max(alphaByte / 255, 0), 1);
 }
-function normalizeQuaternion(w, x, y, z) {
-  const length = Math.hypot(w, x, y, z);
+function normalizeQuaternion(w, x, y, z2) {
+  const length = Math.hypot(w, x, y, z2);
   if (!Number.isFinite(length) || length <= Number.EPSILON) {
     return [1, 0, 0, 0];
   }
-  return [w / length, x / length, y / length, z / length];
+  return [w / length, x / length, y / length, z2 / length];
 }
 function decodeQuaternionByte(byte) {
   return (byte - 128) / 128;
@@ -270,11 +275,11 @@ function parseSPLATToGaussianSplats(data) {
     colors[positionOffset + 1] = dataView.getUint8(byteOffset + 25);
     colors[positionOffset + 2] = dataView.getUint8(byteOffset + 26);
     opacities[splatIndex] = convertAlphaByteToLinearOpacity(dataView.getUint8(byteOffset + 27));
-    const [w, x, y, z] = normalizeQuaternion(decodeQuaternionByte(dataView.getUint8(byteOffset + 28)), decodeQuaternionByte(dataView.getUint8(byteOffset + 29)), decodeQuaternionByte(dataView.getUint8(byteOffset + 30)), decodeQuaternionByte(dataView.getUint8(byteOffset + 31)));
+    const [w, x, y, z2] = normalizeQuaternion(decodeQuaternionByte(dataView.getUint8(byteOffset + 28)), decodeQuaternionByte(dataView.getUint8(byteOffset + 29)), decodeQuaternionByte(dataView.getUint8(byteOffset + 30)), decodeQuaternionByte(dataView.getUint8(byteOffset + 31)));
     rotations[rotationOffset + 0] = w;
     rotations[rotationOffset + 1] = x;
     rotations[rotationOffset + 2] = y;
-    rotations[rotationOffset + 3] = z;
+    rotations[rotationOffset + 3] = z2;
   }
   return {
     format: "splat",
@@ -331,7 +336,7 @@ var init_splat_loader_types = __esm({
   "dist/splat-loader-types.js"() {
     "use strict";
     init_splats_format();
-    VERSION = true ? "5.0.0-alpha.1" : "latest";
+    VERSION = true ? "5.0.0-alpha.3" : "latest";
     SPLATLoader = {
       dataType: null,
       batchType: null,
@@ -407,11 +412,11 @@ function decodeKSPLATSplat(data, header, section, localSplatIndex, outputSplatIn
   scales[positionOffset + 0] = readCompressedFloat(data, splatBase + layout.scaleOffsetBytes, 0, header.compressionLevel);
   scales[positionOffset + 1] = readCompressedFloat(data, splatBase + layout.scaleOffsetBytes, 1, header.compressionLevel);
   scales[positionOffset + 2] = readCompressedFloat(data, splatBase + layout.scaleOffsetBytes, 2, header.compressionLevel);
-  const [w, x, y, z] = normalizeQuaternion(readCompressedFloat(data, splatBase + layout.scaleOffsetBytes, 3, header.compressionLevel), readCompressedFloat(data, splatBase + layout.scaleOffsetBytes, 4, header.compressionLevel), readCompressedFloat(data, splatBase + layout.scaleOffsetBytes, 5, header.compressionLevel), readCompressedFloat(data, splatBase + layout.scaleOffsetBytes, 6, header.compressionLevel));
+  const [w, x, y, z2] = normalizeQuaternion(readCompressedFloat(data, splatBase + layout.scaleOffsetBytes, 3, header.compressionLevel), readCompressedFloat(data, splatBase + layout.scaleOffsetBytes, 4, header.compressionLevel), readCompressedFloat(data, splatBase + layout.scaleOffsetBytes, 5, header.compressionLevel), readCompressedFloat(data, splatBase + layout.scaleOffsetBytes, 6, header.compressionLevel));
   rotations[rotationOffset + 0] = w;
   rotations[rotationOffset + 1] = x;
   rotations[rotationOffset + 2] = y;
-  rotations[rotationOffset + 3] = z;
+  rotations[rotationOffset + 3] = z2;
   const colorBase = splatBase + layout.colorOffsetBytes;
   const colorView = new Uint8Array(data, colorBase, 4);
   colors[positionOffset + 0] = colorView[0];
@@ -656,7 +661,7 @@ var init_ksplat_loader_types = __esm({
   "dist/ksplat-loader-types.js"() {
     "use strict";
     init_splats_format();
-    VERSION2 = true ? "5.0.0-alpha.1" : "latest";
+    VERSION2 = true ? "5.0.0-alpha.3" : "latest";
     KSPLATLoader = {
       dataType: null,
       batchType: null,
@@ -672,6 +677,1093 @@ var init_ksplat_loader_types = __esm({
   }
 });
 
+// ../loader-utils/src/lib/log-utils/log.ts
+function createLog() {
+  const log2 = new import_log.Log({ id: "loaders.gl" });
+  globalThis.loaders ||= {};
+  globalThis.loaders.log = log2;
+  globalThis.loaders.version = version;
+  globalThis.probe ||= {};
+  globalThis.probe.loaders = log2;
+  return log2;
+}
+var import_log, VERSION3, version, log;
+var init_log = __esm({
+  "../loader-utils/src/lib/log-utils/log.ts"() {
+    "use strict";
+    import_log = require("@probe.gl/log");
+    VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+    version = VERSION3[0] >= "0" && VERSION3[0] <= "9" ? `v${VERSION3}` : "";
+    log = createLog();
+  }
+});
+
+// ../loader-utils/src/lib/javascript-utils/is-type.ts
+var isObject, isPureObject, isSharedArrayBuffer;
+var init_is_type = __esm({
+  "../loader-utils/src/lib/javascript-utils/is-type.ts"() {
+    "use strict";
+    isObject = (value) => value !== null && typeof value === "object";
+    isPureObject = (value) => isObject(value) && value.constructor === {}.constructor;
+    isSharedArrayBuffer = (value) => typeof SharedArrayBuffer !== "undefined" && value instanceof SharedArrayBuffer;
+  }
+});
+
+// ../loader-utils/src/lib/option-utils/merge-options.ts
+function mergeOptions(baseOptions, newOptions) {
+  return mergeOptionsRecursively(baseOptions || {}, newOptions);
+}
+function mergeOptionsRecursively(baseOptions, newOptions, level = 0) {
+  if (level > 3) {
+    return newOptions;
+  }
+  const options = { ...baseOptions };
+  for (const [key, newValue] of Object.entries(newOptions)) {
+    if (isPureObject(newValue)) {
+      options[key] = mergeOptionsRecursively(
+        options[key] || {},
+        newOptions[key],
+        level + 1
+      );
+    } else {
+      options[key] = newOptions[key];
+    }
+  }
+  return options;
+}
+var init_merge_options = __esm({
+  "../loader-utils/src/lib/option-utils/merge-options.ts"() {
+    "use strict";
+    init_is_type();
+  }
+});
+
+// ../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 getJSModule(name, caller) {
+  var _a, _b;
+  const module2 = (_b = (_a = globalThis.loaders) == null ? void 0 : _a.modules) == null ? void 0 : _b[name];
+  if (!module2) {
+    throw new Error(`${caller}: ${name} library not installed`);
+  }
+  return module2;
+}
+function getJSModuleOrNull(name) {
+  var _a, _b;
+  const module2 = (_b = (_a = globalThis.loaders) == null ? void 0 : _a.modules) == null ? void 0 : _b[name];
+  return module2 || null;
+}
+var init_js_module_utils = __esm({
+  "../loader-utils/src/lib/module-utils/js-module-utils.ts"() {
+    "use strict";
+  }
+});
+
+// ../loader-utils/src/lib/binary-utils/array-buffer-utils.ts
+function concatenateArrayBuffers(...sources) {
+  return concatenateArrayBuffersFromArray(sources);
+}
+function concatenateArrayBuffersFromArray(sources) {
+  const sourceArrays = sources.map(
+    (source2) => source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2
+  );
+  const byteLength = sourceArrays.reduce((length, typedArray) => length + typedArray.byteLength, 0);
+  const result = new Uint8Array(byteLength);
+  let offset = 0;
+  for (const sourceArray of sourceArrays) {
+    result.set(sourceArray, offset);
+    offset += sourceArray.byteLength;
+  }
+  return result.buffer;
+}
+var init_array_buffer_utils = __esm({
+  "../loader-utils/src/lib/binary-utils/array-buffer-utils.ts"() {
+    "use strict";
+  }
+});
+
+// ../loader-utils/src/lib/iterators/async-iteration.ts
+async function concatenateArrayBuffersAsync(asyncIterator) {
+  const arrayBuffers = [];
+  for await (const chunk of asyncIterator) {
+    arrayBuffers.push(copyToArrayBuffer(chunk));
+  }
+  return concatenateArrayBuffers(...arrayBuffers);
+}
+function copyToArrayBuffer(chunk) {
+  if (chunk instanceof ArrayBuffer) {
+    return chunk;
+  }
+  if (ArrayBuffer.isView(chunk)) {
+    const { buffer, byteOffset, byteLength } = chunk;
+    return copyFromBuffer(buffer, byteOffset, byteLength);
+  }
+  return copyFromBuffer(chunk);
+}
+function copyFromBuffer(buffer, byteOffset = 0, byteLength = buffer.byteLength - byteOffset) {
+  const view = new Uint8Array(buffer, byteOffset, byteLength);
+  const copy = new Uint8Array(view.length);
+  copy.set(view);
+  return copy.buffer;
+}
+var init_async_iteration = __esm({
+  "../loader-utils/src/lib/iterators/async-iteration.ts"() {
+    "use strict";
+    init_array_buffer_utils();
+  }
+});
+
+// ../loader-utils/src/lib/request-utils/request-credentials.ts
+function createAuthenticatedFetch(options) {
+  const baseFetch = options.fetch || ((url, requestOptions) => fetch(url, requestOptions));
+  if (!options.credentials.length) return baseFetch;
+  const existingMetadata = baseFetch[AUTHENTICATED_FETCH];
+  if (existingMetadata === options.credentials) return baseFetch;
+  const authenticatedFetch = async (url, requestOptions = {}) => {
+    var _a, _b, _c;
+    const resolvedURL = parseHTTPURL(url);
+    if (!resolvedURL) return baseFetch(url, requestOptions);
+    const authorization = await authorizeRequest(resolvedURL, requestOptions, options.credentials);
+    const response = await baseFetch(authorization.url, authorization.options);
+    const refreshableCredentials = authorization.credentials.filter(
+      ({ credential }) => typeof credential.token === "function" && credential.refreshStatusCodes.includes(response.status)
+    );
+    if (!refreshableCredentials.length || !isReplayableRequest(requestOptions)) return response;
+    if ((_a = requestOptions.signal) == null ? void 0 : _a.aborted) throw createAbortError();
+    const refreshedTokens = /* @__PURE__ */ new Map();
+    await Promise.all(
+      refreshableCredentials.map(async ({ credential }) => {
+        const token = await refreshCredential(credential, url, response);
+        if (token) refreshedTokens.set(credential, token);
+      })
+    );
+    if (!refreshedTokens.size) return response;
+    await ((_b = response.body) == null ? void 0 : _b.cancel().catch(() => {
+    }));
+    if ((_c = requestOptions.signal) == null ? void 0 : _c.aborted) throw createAbortError();
+    const replayAuthorization = await authorizeRequest(
+      resolvedURL,
+      requestOptions,
+      options.credentials,
+      refreshedTokens,
+      authorization.credentials
+    );
+    return baseFetch(replayAuthorization.url, replayAuthorization.options);
+  };
+  Object.defineProperty(authenticatedFetch, AUTHENTICATED_FETCH, {
+    value: options.credentials
+  });
+  return authenticatedFetch;
+}
+async function authorizeRequest(sourceURL, requestOptions, credentials, tokenOverrides = /* @__PURE__ */ new Map(), previousCredentials = []) {
+  const url = new URL(sourceURL);
+  const headers = new Headers(requestOptions.headers);
+  const resolvedCredentials = [];
+  const previousTokens = new Map(
+    previousCredentials.map(({ credential, token }) => [credential, token])
+  );
+  for (const credential of credentials) {
+    if (!credential.origins.includes(url.origin)) continue;
+    const overrideToken = tokenOverrides.get(credential);
+    const previousToken = previousTokens.get(credential);
+    const ownsQueryParameter = credential.type === "query-parameter" && previousToken !== void 0;
+    const ownsHeader = credential.type === "header" && previousToken !== void 0;
+    if (credential.type === "query-parameter" && url.searchParams.has(credential.name) && !ownsQueryParameter || credential.type === "header" && headers.has(credential.name) && !ownsHeader) {
+      continue;
+    }
+    const token = overrideToken ?? previousToken ?? await resolveToken(credential.token, { url: sourceURL.toString(), reason: "request" });
+    if (!token) continue;
+    if (credential.type === "query-parameter") {
+      url.searchParams.set(credential.name, token);
+    } else {
+      headers.set(credential.name, `${credential.prefix || ""}${token}`);
+    }
+    resolvedCredentials.push({ credential, token });
+  }
+  return {
+    url: url.toString(),
+    options: { ...requestOptions, headers },
+    credentials: resolvedCredentials
+  };
+}
+async function refreshCredential(credential, url, response) {
+  const existingPromise = refreshPromises.get(credential);
+  if (existingPromise) return existingPromise;
+  const tokenProvider = credential.token;
+  const promise = Promise.resolve(
+    tokenProvider({
+      url,
+      reason: "refresh",
+      response: { status: response.status, headers: response.headers }
+    })
+  ).finally(() => refreshPromises.delete(credential));
+  refreshPromises.set(credential, promise);
+  return promise;
+}
+async function resolveToken(token, context) {
+  return typeof token === "function" ? token(context) : token;
+}
+function parseHTTPURL(url) {
+  try {
+    const parsedURL = new URL(url);
+    return ["http:", "https:"].includes(parsedURL.protocol) ? parsedURL : null;
+  } catch {
+    return null;
+  }
+}
+function isReplayableRequest(options) {
+  const method = (options.method || "GET").toUpperCase();
+  if (!["GET", "HEAD", "OPTIONS", "PUT", "DELETE"].includes(method)) return false;
+  return !(options.body && typeof ReadableStream !== "undefined" && options.body instanceof ReadableStream);
+}
+function createAbortError() {
+  return new DOMException("The operation was aborted.", "AbortError");
+}
+var AUTHENTICATED_FETCH, refreshPromises;
+var init_request_credentials = __esm({
+  "../loader-utils/src/lib/request-utils/request-credentials.ts"() {
+    "use strict";
+    AUTHENTICATED_FETCH = /* @__PURE__ */ Symbol("loaders.gl.authenticated-fetch");
+    refreshPromises = /* @__PURE__ */ new WeakMap();
+  }
+});
+
+// ../loader-utils/src/lib/path-utils/file-aliases.ts
+function resolvePath(filename) {
+  for (const alias in fileAliases) {
+    if (filename.startsWith(alias)) {
+      const replacement = fileAliases[alias];
+      filename = filename.replace(alias, replacement);
+    }
+  }
+  if (!filename.startsWith("http://") && !filename.startsWith("https://")) {
+    filename = `${pathPrefix}${filename}`;
+  }
+  return filename;
+}
+var pathPrefix, fileAliases;
+var init_file_aliases = __esm({
+  "../loader-utils/src/lib/path-utils/file-aliases.ts"() {
+    "use strict";
+    pathPrefix = "";
+    fileAliases = {};
+  }
+});
+
+// ../loader-utils/src/lib/binary-utils/memory-conversion-utils.ts
+function ensureArrayBuffer(bufferSource) {
+  if (bufferSource instanceof ArrayBuffer) {
+    return bufferSource;
+  }
+  if (isSharedArrayBuffer(bufferSource)) {
+    return copyToArrayBuffer2(bufferSource);
+  }
+  const { buffer, byteOffset, byteLength } = bufferSource;
+  if (buffer instanceof ArrayBuffer && byteOffset === 0 && byteLength === buffer.byteLength) {
+    return buffer;
+  }
+  return copyToArrayBuffer2(buffer, byteOffset, byteLength);
+}
+function copyToArrayBuffer2(buffer, byteOffset = 0, byteLength = buffer.byteLength - byteOffset) {
+  const view = new Uint8Array(buffer, byteOffset, byteLength);
+  const copy = new Uint8Array(view.length);
+  copy.set(view);
+  return copy.buffer;
+}
+var init_memory_conversion_utils = __esm({
+  "../loader-utils/src/lib/binary-utils/memory-conversion-utils.ts"() {
+    "use strict";
+    init_is_type();
+  }
+});
+
+// ../loader-utils/src/lib/sources/data-source.ts
+function getFetchFunction(options) {
+  var _a, _b;
+  const fetchOption = (options == null ? void 0 : options.fetch) ?? ((_a = options == null ? void 0 : options.core) == null ? void 0 : _a.fetch);
+  let fetchFunction;
+  if (typeof fetchOption === "function") {
+    fetchFunction = (url, fetchOptions) => fetchOption(url, fetchOptions);
+  } else if (fetchOption) {
+    fetchFunction = (url, requestOptions) => fetch(url, mergeFetchOptions(fetchOption, requestOptions));
+  } else {
+    fetchFunction = (url, requestOptions) => fetch(url, requestOptions);
+  }
+  return createAuthenticatedFetch({
+    fetch: fetchFunction,
+    credentials: ((_b = options == null ? void 0 : options.core) == null ? void 0 : _b.credentials) || []
+  });
+}
+function mergeFetchOptions(fetchOptions, requestOptions) {
+  const mergedOptions = { ...fetchOptions, ...requestOptions };
+  if (fetchOptions.headers || (requestOptions == null ? void 0 : requestOptions.headers)) {
+    mergedOptions.headers = mergeHeaders(fetchOptions.headers, requestOptions == null ? void 0 : requestOptions.headers);
+  }
+  return mergedOptions;
+}
+function mergeHeaders(defaultHeaders, requestHeaders) {
+  const headers = new Headers(defaultHeaders);
+  if (requestHeaders) {
+    new Headers(requestHeaders).forEach((value, key) => headers.set(key, value));
+  }
+  return headers;
+}
+function normalizeDirectLoaderOptions(options) {
+  const loadOptions = { ...options };
+  if (options == null ? void 0 : options.core) {
+    loadOptions.core = { ...options.core };
+  }
+  const topLevelBaseUri = typeof loadOptions.baseUri === "string" ? loadOptions.baseUri : void 0;
+  const topLevelBaseUrl = typeof loadOptions.baseUrl === "string" ? loadOptions.baseUrl : void 0;
+  if (topLevelBaseUri !== void 0 || topLevelBaseUrl !== void 0) {
+    loadOptions.core ||= {};
+    if (loadOptions.core.baseUrl === void 0) {
+      loadOptions.core.baseUrl = topLevelBaseUrl ?? topLevelBaseUri;
+    }
+    delete loadOptions.baseUri;
+    delete loadOptions.baseUrl;
+  }
+  return loadOptions;
+}
+function normalizeError(error, message) {
+  if (error instanceof Error) {
+    return error;
+  }
+  if (typeof error === "string") {
+    return new Error(error);
+  }
+  return new Error(message);
+}
+function unavailableCoreApiMethod(methodName) {
+  return () => {
+    throw new Error(
+      `CoreAPI.${methodName} is unavailable. Use @loaders.gl/core.createDataSource().`
+    );
+  };
+}
+var UNAVAILABLE_CORE_API, DataSource;
+var init_data_source = __esm({
+  "../loader-utils/src/lib/sources/data-source.ts"() {
+    "use strict";
+    init_merge_options();
+    init_file_aliases();
+    init_log();
+    init_request_credentials();
+    UNAVAILABLE_CORE_API = {
+      fetchFile: unavailableCoreApiMethod("fetchFile"),
+      parse: unavailableCoreApiMethod("parse"),
+      parseFile: unavailableCoreApiMethod("parseFile"),
+      parseSync: unavailableCoreApiMethod("parseSync"),
+      parseInBatches: unavailableCoreApiMethod("parseInBatches"),
+      load: unavailableCoreApiMethod("load"),
+      loadInBatches: unavailableCoreApiMethod("loadInBatches")
+    };
+    DataSource = class _DataSource {
+      static defaultOptions = {
+        core: {
+          type: "auto",
+          attributions: [],
+          loadOptions: {},
+          loaders: [],
+          onError: void 0
+        }
+      };
+      optionsType;
+      options;
+      data;
+      url;
+      /** The actual load options, if calling a loaders.gl loader */
+      loadOptions;
+      /** A resolved fetch function extracted from loadOptions prop */
+      fetch;
+      /** Shared source-level runtime hooks, when supplied by the source factory. */
+      coreApi;
+      /** Whether a real CoreAPI instance was injected by the integration layer. */
+      hasCoreApi;
+      _needsRefresh = true;
+      constructor(data, options, defaultOptions, coreApi) {
+        var _a;
+        if (defaultOptions) {
+          this.options = mergeOptions({ ...defaultOptions, core: _DataSource.defaultOptions }, options);
+        } else {
+          this.options = { ...options };
+        }
+        this.data = data;
+        this.url = typeof data === "string" ? resolvePath(data) : "";
+        const loadOptions = normalizeDirectLoaderOptions((_a = this.options.core) == null ? void 0 : _a.loadOptions);
+        this.loadOptions = loadOptions;
+        const fetch2 = getFetchFunction(loadOptions);
+        this.coreApi = coreApi || UNAVAILABLE_CORE_API;
+        this.hasCoreApi = Boolean(coreApi);
+        this.fetch = fetch2;
+      }
+      setProps(options) {
+        this.options = Object.assign(this.options, options);
+        this.setNeedsRefresh();
+      }
+      /** Mark this data source as needing a refresh (redraw) */
+      setNeedsRefresh() {
+        this._needsRefresh = true;
+      }
+      /**
+       * Does this data source need refreshing?
+       * @note The specifics of the refresh mechanism depends on type of data source
+       */
+      getNeedsRefresh(clear = true) {
+        const needsRefresh = this._needsRefresh;
+        if (clear) {
+          this._needsRefresh = false;
+        }
+        return needsRefresh;
+      }
+      /** Reports a source-level failure through the configured callback or the shared logger. */
+      reportError(error, message) {
+        var _a;
+        const normalizedError = normalizeError(error, message);
+        const callback = (_a = this.options.core) == null ? void 0 : _a.onError;
+        if (callback) {
+          callback(normalizedError, this);
+        } else {
+          log.warn(`${this.constructor.name}: ${normalizedError.message}`)();
+        }
+        return normalizedError;
+      }
+    };
+  }
+});
+
+// ../loader-utils/src/index.ts
+var init_src = __esm({
+  "../loader-utils/src/index.ts"() {
+    "use strict";
+    init_js_module_utils();
+    init_js_module_utils();
+    init_async_iteration();
+    init_memory_conversion_utils();
+    init_data_source();
+  }
+});
+
+// ../compression/src/lib/compression.ts
+var CompressionTransform, Compressor, Decompressor, Compression;
+var init_compression = __esm({
+  "../compression/src/lib/compression.ts"() {
+    "use strict";
+    init_src();
+    CompressionTransform = class {
+      /** Preloads any dynamic libraries. May enable sync functions */
+      async preload(modules = {}) {
+        registerJSModules(modules);
+        return void 0;
+      }
+      // HELPERS
+      concatenate(asyncIterator) {
+        return concatenateArrayBuffersAsync(asyncIterator);
+      }
+      improveError(error) {
+        if (!error.message.includes(this.name)) {
+          error.message = `${this.name} ${error.message}`;
+        }
+        return error;
+      }
+    };
+    Compressor = class extends CompressionTransform {
+      constructor(options) {
+        super();
+        this.compressBatches = this.compressBatches.bind(this);
+      }
+      /** Asynchronously compresses data. */
+      async compress(input) {
+        await this.preload();
+        return this.compressSync(input);
+      }
+      /** Synchronously compresses data. */
+      compressSync(input) {
+        throw new Error(`${this.name}: sync compression not supported`);
+      }
+      /** Compresses batches. */
+      async *compressBatches(asyncIterator) {
+        const input = await this.concatenate(asyncIterator);
+        yield this.compress(input);
+      }
+    };
+    Decompressor = class extends CompressionTransform {
+      constructor(options) {
+        super();
+        this.decompressBatches = this.decompressBatches.bind(this);
+      }
+      /** Asynchronously decompresses data. */
+      async decompress(input, size) {
+        await this.preload();
+        return this.decompressSync(input, size);
+      }
+      /** Synchronously decompresses data. */
+      decompressSync(input, size) {
+        throw new Error(`${this.name}: sync decompression not supported`);
+      }
+      /** Decompresses batches. */
+      async *decompressBatches(asyncIterator) {
+        const input = await this.concatenate(asyncIterator);
+        yield this.decompress(input);
+      }
+    };
+    Compression = class extends Compressor {
+      constructor(options) {
+        super(options);
+        this.decompressBatches = this.decompressBatches.bind(this);
+      }
+      /** Asynchronously decompresses data. */
+      async decompress(input, size) {
+        await this.preload();
+        return this.decompressSync(input, size);
+      }
+      /** Synchronously decompresses data. */
+      decompressSync(input, size) {
+        throw new Error(`${this.name}: sync decompression not supported`);
+      }
+      /** Decompresses batches. */
+      async *decompressBatches(asyncIterator) {
+        const input = await this.concatenate(asyncIterator);
+        yield this.decompress(input);
+      }
+    };
+  }
+});
+
+// ../compression/src/lib/compression-stream.ts
+async function compressWithNativeCompressionStream(input, format) {
+  const outputBatches = compressBatchesWithNativeCompressionStream([input], format);
+  return outputBatches ? await concatenateBatches(outputBatches) : null;
+}
+function compressBatchesWithNativeCompressionStream(inputBatches, format) {
+  const compressionStream = createNativeCompressionStream(format);
+  return compressionStream ? transformBatches(inputBatches, compressionStream) : null;
+}
+function createNativeCompressionStream(format) {
+  if (typeof globalThis.CompressionStream === "undefined") {
+    return null;
+  }
+  try {
+    const CompressionStreamConstructor = globalThis.CompressionStream;
+    return new CompressionStreamConstructor(format);
+  } catch (error) {
+    if (error instanceof TypeError || (error == null ? void 0 : error.name) === "TypeError") {
+      return null;
+    }
+    throw error;
+  }
+}
+async function* transformBatches(inputBatches, compressionStream) {
+  const writer = compressionStream.writable.getWriter();
+  const reader = compressionStream.readable.getReader();
+  const writePromise = writeBatches(inputBatches, writer);
+  writePromise.catch(() => {
+  });
+  let outputCompleted = false;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        outputCompleted = true;
+        break;
+      }
+      yield new Uint8Array(value).buffer;
+    }
+    await writePromise;
+  } finally {
+    if (!outputCompleted) {
+      await reader.cancel().catch(() => {
+      });
+      await writer.abort().catch(() => {
+      });
+      await writePromise.catch(() => {
+      });
+    }
+    reader.releaseLock();
+  }
+}
+async function writeBatches(inputBatches, writer) {
+  try {
+    for await (const inputBatch of inputBatches) {
+      await writer.write(new Uint8Array(inputBatch));
+    }
+    await writer.close();
+  } catch (error) {
+    await writer.abort(error).catch(() => {
+    });
+    throw error;
+  }
+}
+async function concatenateBatches(batches) {
+  const output = [];
+  let byteLength = 0;
+  for await (const batch of batches) {
+    const bytes = new Uint8Array(batch);
+    output.push(bytes);
+    byteLength += bytes.byteLength;
+  }
+  const result = new Uint8Array(byteLength);
+  let offset = 0;
+  for (const batch of output) {
+    result.set(batch, offset);
+    offset += batch.byteLength;
+  }
+  return result.buffer;
+}
+var init_compression_stream = __esm({
+  "../compression/src/lib/compression-stream.ts"() {
+    "use strict";
+  }
+});
+
+// ../compression/src/lib/decompression-stream.ts
+async function decompressWithNativeDecompressionStream(input, format) {
+  const outputBatches = decompressBatchesWithNativeDecompressionStream([input], format);
+  return outputBatches ? await concatenateNativeDecompressionBatches(outputBatches) : null;
+}
+function decompressBatchesWithNativeDecompressionStream(inputBatches, format) {
+  const decompressionStream = createNativeDecompressionStream(format);
+  return decompressionStream ? transformBatchesWithNativeDecompressionStream(inputBatches, decompressionStream) : null;
+}
+function isNativeDecompressionSupported(format) {
+  return Boolean(createNativeDecompressionStream(format));
+}
+function createNativeDecompressionStream(format) {
+  var _a, _b;
+  if (typeof globalThis.DecompressionStream === "undefined") {
+    return null;
+  }
+  if (((_b = (_a = globalThis.process) == null ? void 0 : _a.release) == null ? void 0 : _b.name) === "node" && typeof globalThis.Buffer === "undefined") {
+    return null;
+  }
+  try {
+    const DecompressionStreamConstructor = globalThis.DecompressionStream;
+    return new DecompressionStreamConstructor(format);
+  } catch (error) {
+    if (error instanceof TypeError || (error == null ? void 0 : error.name) === "TypeError") {
+      return null;
+    }
+    throw error;
+  }
+}
+async function* transformBatchesWithNativeDecompressionStream(inputBatches, decompressionStream) {
+  const writer = decompressionStream.writable.getWriter();
+  const reader = decompressionStream.readable.getReader();
+  const writePromise = writeBatchesToNativeDecompressionStream(inputBatches, writer);
+  writePromise.catch(() => {
+  });
+  let outputCompleted = false;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        outputCompleted = true;
+        break;
+      }
+      yield copyExactArrayBuffer(value);
+    }
+    await writePromise;
+  } finally {
+    if (!outputCompleted) {
+      await reader.cancel().catch(() => {
+      });
+      await writer.abort().catch(() => {
+      });
+      await writePromise.catch(() => {
+      });
+    }
+    reader.releaseLock();
+  }
+}
+async function concatenateNativeDecompressionBatches(outputBatches) {
+  const batches = [];
+  let byteLength = 0;
+  for await (const outputBatch of outputBatches) {
+    const bytes = new Uint8Array(outputBatch);
+    batches.push(bytes);
+    byteLength += bytes.byteLength;
+  }
+  const output = new Uint8Array(byteLength);
+  let byteOffset = 0;
+  for (const batch of batches) {
+    output.set(batch, byteOffset);
+    byteOffset += batch.byteLength;
+  }
+  return output.buffer;
+}
+function copyExactArrayBuffer(value) {
+  return new Uint8Array(value).buffer;
+}
+async function writeBatchesToNativeDecompressionStream(inputBatches, writer) {
+  try {
+    for await (const inputBatch of inputBatches) {
+      await writer.write(new Uint8Array(inputBatch));
+    }
+    await writer.close();
+  } catch (error) {
+    await writer.abort(error).catch(() => {
+    });
+    throw error;
+  }
+}
+var init_decompression_stream = __esm({
+  "../compression/src/lib/decompression-stream.ts"() {
+    "use strict";
+  }
+});
+
+// ../compression/src/lib/native-decompressor.ts
+var native_decompressor_exports = {};
+__export(native_decompressor_exports, {
+  NativeDecompressor: () => NativeDecompressor
+});
+var NativeDecompressor;
+var init_native_decompressor = __esm({
+  "../compression/src/lib/native-decompressor.ts"() {
+    "use strict";
+    init_compression();
+    init_decompression_stream();
+    NativeDecompressor = class extends Decompressor {
+      name;
+      extensions;
+      contentEncodings;
+      isSupported = true;
+      /** Runtime stream format used for every operation. */
+      format;
+      constructor(metadata, format, options = {}) {
+        super(options);
+        this.name = metadata.name;
+        this.extensions = [...metadata.extensions];
+        this.contentEncodings = [...metadata.contentEncodings];
+        this.format = format;
+      }
+      /** Decompresses one buffer with the runtime-provided stream. */
+      async decompress(input) {
+        const output = await decompressWithNativeDecompressionStream(input, this.format);
+        if (!output) throw new Error(`${this.name}: built-in decompression is no longer available`);
+        return output;
+      }
+      /** Decompresses batches incrementally with the runtime-provided stream. */
+      async *decompressBatches(inputBatches) {
+        const output = decompressBatchesWithNativeDecompressionStream(inputBatches, this.format);
+        if (!output) throw new Error(`${this.name}: built-in decompression is no longer available`);
+        yield* output;
+      }
+    };
+  }
+});
+
+// ../compression/src/lib/lazy-compression.ts
+function mergeModules(options, modules) {
+  return { ...options, modules: { ...options.modules, ...modules } };
+}
+var LazyDecompressor;
+var init_lazy_compression = __esm({
+  "../compression/src/lib/lazy-compression.ts"() {
+    "use strict";
+    init_compression();
+    init_decompression_stream();
+    LazyDecompressor = class extends Decompressor {
+      name;
+      extensions;
+      contentEncodings;
+      isSupported = true;
+      /** Constructor options retained until a concrete implementation is selected. */
+      options;
+      /** Built-in stream format to probe, or null when the format has no built-in path. */
+      nativeFormat;
+      /** Returns whether built-in selection remains eligible for the merged preload options. */
+      shouldUseNative;
+      /** Dynamically imports the balanced fallback constructor. */
+      loadFallback;
+      /** Selected concrete implementation after preload completes. */
+      implementation = null;
+      /** Shared in-flight selection used by concurrent asynchronous calls. */
+      implementationPromise = null;
+      constructor(metadata, loadFallback, options = {}, nativeFormat = null, shouldUseNative = () => true) {
+        super(options);
+        this.name = metadata.name;
+        this.extensions = [...metadata.extensions];
+        this.contentEncodings = [...metadata.contentEncodings];
+        this.options = options;
+        this.nativeFormat = nativeFormat;
+        this.shouldUseNative = shouldUseNative;
+        this.loadFallback = loadFallback;
+      }
+      /** Selects and returns the built-in or dynamically imported fallback decompressor. */
+      async preload(modules = {}) {
+        if (this.implementation) return this.implementation;
+        const options = mergeModules(this.options, modules);
+        this.implementationPromise ||= this.loadImplementation(options);
+        try {
+          this.implementation = await this.implementationPromise;
+          return this.implementation;
+        } catch (error) {
+          this.implementationPromise = null;
+          throw error;
+        }
+      }
+      /** Loads the selected concrete decompressor. */
+      async loadImplementation(options) {
+        if (options.useNative !== false && this.nativeFormat && this.shouldUseNative(options) && isNativeDecompressionSupported(this.nativeFormat)) {
+          const { NativeDecompressor: NativeDecompressor2 } = await Promise.resolve().then(() => (init_native_decompressor(), native_decompressor_exports));
+          return new NativeDecompressor2(this, this.nativeFormat, options);
+        }
+        const Decompressor2 = await this.loadFallback();
+        const implementation = new Decompressor2({ ...options, useNative: false });
+        await implementation.preload(options.modules);
+        return implementation;
+      }
+      /** Decompresses after lazily selecting the default implementation. */
+      async decompress(input, size) {
+        return (await this.preload()).decompress(input, size);
+      }
+      /** Decompresses synchronously after an implementation has been preloaded. */
+      decompressSync(input, size) {
+        if (!this.implementation) {
+          throw new Error(`${this.name}: call preload() before decompressSync()`);
+        }
+        return this.implementation.decompressSync(input, size);
+      }
+      /** Decompresses batches after lazily selecting the default implementation. */
+      async *decompressBatches(inputBatches) {
+        yield* (await this.preload()).decompressBatches(inputBatches);
+      }
+    };
+  }
+});
+
+// ../compression/src/zstd-decompressor-fzstd.ts
+var import_fzstd, ZstdFzstdDecompressor;
+var init_zstd_decompressor_fzstd = __esm({
+  "../compression/src/zstd-decompressor-fzstd.ts"() {
+    "use strict";
+    init_compression();
+    import_fzstd = require("fzstd");
+    ZstdFzstdDecompressor = class extends Decompressor {
+      name = "zstd";
+      extensions = ["zst"];
+      contentEncodings = ["zstd"];
+      isSupported = true;
+      constructor(options = {}) {
+        super(options);
+      }
+      /** Decompresses one Zstandard frame synchronously. */
+      decompressSync(input) {
+        return (0, import_fzstd.decompress)(new Uint8Array(input)).slice().buffer;
+      }
+    };
+  }
+});
+
+// ../compression/src/zstd-fallback.ts
+var zstd_fallback_exports = {};
+__export(zstd_fallback_exports, {
+  decompressZstd: () => decompressZstd
+});
+function decompressZstd(input) {
+  return (0, import_fzstd2.decompress)(input);
+}
+var import_fzstd2;
+var init_zstd_fallback = __esm({
+  "../compression/src/zstd-fallback.ts"() {
+    "use strict";
+    import_fzstd2 = require("fzstd");
+  }
+});
+
+// ../compression/src/lib/zstd-compression.ts
+var zstd_compression_exports = {};
+__export(zstd_compression_exports, {
+  ZstdCompression: () => ZstdCompression
+});
+var CHUNK_SIZE, zstdPromise, zstd, ZstdCompression;
+var init_zstd_compression = __esm({
+  "../compression/src/lib/zstd-compression.ts"() {
+    "use strict";
+    init_compression();
+    init_src();
+    init_compression_stream();
+    init_decompression_stream();
+    CHUNK_SIZE = 1e6;
+    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.options = options;
+        registerJSModules(options == null ? void 0 : options.modules);
+      }
+      async preload(modules = {}) {
+        registerJSModules(modules);
+        const ZstdCodec = getJSModuleOrNull("zstd-codec");
+        if (!zstdPromise && ZstdCodec) {
+          zstdPromise = new Promise((resolve) => ZstdCodec.run((zstd2) => resolve(zstd2)));
+        }
+        if (zstdPromise) {
+          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;
+      }
+      async compress(input) {
+        var _a;
+        if (this.options.useNative !== false && ((_a = this.options.zstd) == null ? void 0 : _a.useNative) !== false) {
+          const nativeOutput = await compressWithNativeCompressionStream(input, "zstd");
+          if (nativeOutput) return nativeOutput;
+        }
+        await this.preload();
+        return this.compressSync(input);
+      }
+      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) {
+        var _a;
+        if (!getJSModuleOrNull("zstd-codec") && this.options.useNative !== false && ((_a = this.options.zstd) == null ? void 0 : _a.useNative) !== false) {
+          const nativeOutput = await decompressWithNativeDecompressionStream(input, "zstd");
+          if (nativeOutput) return nativeOutput;
+        }
+        await this.preload();
+        const inputArray = new Uint8Array(input);
+        if (!zstd) {
+          const { decompressZstd: decompressZstd2 } = await Promise.resolve().then(() => (init_zstd_fallback(), zstd_fallback_exports));
+          return ensureArrayBuffer(decompressZstd2(inputArray));
+        }
+        const simpleZstd = new zstd.Streaming();
+        const chunks = [];
+        for (let i = 0; i <= inputArray.length; i += CHUNK_SIZE) {
+          const chunkView = inputArray.subarray(i, i + CHUNK_SIZE);
+          const chunkArrayBuffer = ensureArrayBuffer(chunkView);
+          chunks.push(new Uint8Array(chunkArrayBuffer));
+        }
+        const decompressResult = await simpleZstd.decompressChunks(chunks);
+        return decompressResult.buffer;
+      }
+    };
+  }
+});
+
+// ../compression/src/zstd-decompressor.ts
+var zstd_decompressor_exports = {};
+__export(zstd_decompressor_exports, {
+  ZstdDecompressor: () => ZstdDecompressor
+});
+var ZstdDecompressor;
+var init_zstd_decompressor = __esm({
+  "../compression/src/zstd-decompressor.ts"() {
+    "use strict";
+    init_zstd_decompressor_fzstd();
+    init_decompression_stream();
+    init_src();
+    ZstdDecompressor = class extends ZstdFzstdDecompressor {
+      options;
+      compatibility = null;
+      constructor(options = {}) {
+        super(options);
+        this.options = options;
+        registerJSModules(options.modules);
+      }
+      /** Preloads an injected zstd-codec implementation when supplied. */
+      async preload(modules = {}) {
+        registerJSModules(modules);
+        if (getJSModuleOrNull("zstd-codec")) {
+          const { ZstdCompression: ZstdCompression2 } = await Promise.resolve().then(() => (init_zstd_compression(), zstd_compression_exports));
+          this.compatibility ||= new ZstdCompression2(this.options);
+          await this.compatibility.preload(modules);
+        }
+      }
+      /** Decompresses with the built-in stream when available, then falls back to fzstd. */
+      async decompress(input) {
+        if (this.options.useNative !== false) {
+          const output = await decompressWithNativeDecompressionStream(input, "zstd");
+          if (output) return output;
+        }
+        if (getJSModuleOrNull("zstd-codec")) {
+          await this.preload(this.options.modules);
+        }
+        return this.decompressSync(input);
+      }
+      /** Decompresses with a preloaded zstd-codec implementation or compact fzstd. */
+      decompressSync(input) {
+        if (this.compatibility) {
+          return this.compatibility.decompressSync(input);
+        }
+        if (getJSModuleOrNull("zstd-codec")) {
+          throw new Error("zstd: call preload() before synchronous decompression with zstd-codec");
+        }
+        return super.decompressSync(input);
+      }
+      /** Decompresses batches with a built-in stream or compact fzstd fallback. */
+      async *decompressBatches(inputBatches) {
+        if (this.options.useNative !== false) {
+          const output = decompressBatchesWithNativeDecompressionStream(inputBatches, "zstd");
+          if (output) {
+            yield* output;
+            return;
+          }
+        }
+        if (getJSModuleOrNull("zstd-codec")) {
+          yield this.decompress(await this.concatenate(inputBatches));
+          return;
+        }
+        yield* super.decompressBatches(inputBatches);
+      }
+    };
+  }
+});
+
+// ../compression/src/default-codecs.ts
+var ZSTD, ZstdDecompressor2;
+var init_default_codecs = __esm({
+  "../compression/src/default-codecs.ts"() {
+    "use strict";
+    init_lazy_compression();
+    init_src();
+    ZSTD = { name: "zstd", extensions: ["zst"], contentEncodings: ["zstd"] };
+    ZstdDecompressor2 = class extends LazyDecompressor {
+      constructor(options = {}) {
+        super(
+          ZSTD,
+          async () => (await Promise.resolve().then(() => (init_zstd_decompressor(), zstd_decompressor_exports))).ZstdDecompressor,
+          options,
+          "zstd",
+          (preloadOptions) => {
+            var _a;
+            return !((_a = preloadOptions.modules) == null ? void 0 : _a["zstd-codec"]) && !getJSModuleOrNull("zstd-codec");
+          }
+        );
+      }
+    };
+  }
+});
+
+// ../compression/src/index.ts
+var init_src2 = __esm({
+  "../compression/src/index.ts"() {
+    "use strict";
+    init_default_codecs();
+  }
+});
+
 // dist/lib/parse-spz.js
 async function parseSPZ(data, options) {
   return makeGaussianSplatsArrowTable(await parseSPZToGaussianSplats(data, options));
@@ -680,8 +1772,8 @@ async function parseSPZToGaussianSplats(data, options) {
   const header = parseSPZHeader(data);
   const streamInfos = parseSPZStreamInfos(data, header, getSPZStreamByteLengths(header));
   const compressedStreams = streamInfos.map((streamInfo) => data.slice(streamInfo.compressedOffset, streamInfo.compressedOffset + streamInfo.compressedSize));
-  const compression = new import_compression.ZstdCompression({ modules: options == null ? void 0 : options.modules });
-  const streams = await Promise.all(compressedStreams.map((compressedStream, streamIndex) => compression.decompress(compressedStream, streamInfos[streamIndex].uncompressedSize)));
+  const decompressor = new ZstdDecompressor2({ modules: options == null ? void 0 : options.modules });
+  const streams = await Promise.all(compressedStreams.map((compressedStream, streamIndex) => decompressor.decompress(compressedStream, streamInfos[streamIndex].uncompressedSize)));
   validateSPZStreamLengths(streams, streamInfos);
   return decodeSPZStreams(header, streams, data);
 }
@@ -827,12 +1919,12 @@ function decodeSPZRotations(rotationStream, rotations) {
     const byteOffset = splatIndex * 4;
     const component = rotationStream[byteOffset] | rotationStream[byteOffset + 1] << 8 | rotationStream[byteOffset + 2] << 16 | rotationStream[byteOffset + 3] << 24;
     const xyzw = decodeSPZQuaternion(component >>> 0);
-    const [w, x, y, z] = normalizeQuaternion(xyzw[3], xyzw[0], xyzw[1], xyzw[2]);
+    const [w, x, y, z2] = normalizeQuaternion(xyzw[3], xyzw[0], xyzw[1], xyzw[2]);
     const rotationOffset = splatIndex * 4;
     rotations[rotationOffset + 0] = w;
     rotations[rotationOffset + 1] = x;
     rotations[rotationOffset + 2] = y;
-    rotations[rotationOffset + 3] = z;
+    rotations[rotationOffset + 3] = z2;
   }
 }
 function decodeSPZQuaternion(component) {
@@ -898,11 +1990,11 @@ function getSPZExtensionBytes(data, header) {
   const extensionByteLength = getSPZExtensionByteLength(header);
   return extensionByteLength ? new Uint8Array(data.slice(SPZ_HEADER_BYTE_LENGTH, header.tocByteOffset)) : void 0;
 }
-var import_compression, SPZ_HEADER_BYTE_LENGTH, SPZ_MAGIC, SPZ_VERSION, SPZ_EXTENSION_FLAG, SPZ_COLOR_SCALE, SPZ_ROTATION_COMPONENT_SCALE, SPZ_ROTATION_COMPONENT_MASK;
+var SPZ_HEADER_BYTE_LENGTH, SPZ_MAGIC, SPZ_VERSION, SPZ_EXTENSION_FLAG, SPZ_COLOR_SCALE, SPZ_ROTATION_COMPONENT_SCALE, SPZ_ROTATION_COMPONENT_MASK;
 var init_parse_spz = __esm({
   "dist/lib/parse-spz.js"() {
     "use strict";
-    import_compression = require("@loaders.gl/compression");
+    init_src2();
     init_splats_arrow_table();
     init_splat_utils();
     SPZ_HEADER_BYTE_LENGTH = 32;
@@ -939,17 +2031,17 @@ async function preload3() {
   const { SPZLoaderWithParser: SPZLoaderWithParser2 } = await Promise.resolve().then(() => (init_spz_loader(), spz_loader_exports));
   return SPZLoaderWithParser2;
 }
-var VERSION3, SPZLoader;
+var VERSION4, SPZLoader;
 var init_spz_loader_types = __esm({
   "dist/spz-loader-types.js"() {
     "use strict";
     init_splats_format();
-    VERSION3 = true ? "5.0.0-alpha.1" : "latest";
+    VERSION4 = true ? "5.0.0-alpha.3" : "latest";
     SPZLoader = {
       dataType: null,
       batchType: null,
       ...SPZFormat,
-      version: VERSION3,
+      version: VERSION4,
       options: {
         splats: {
           shape: "arrow-table"
@@ -960,6 +2052,65 @@ var init_spz_loader_types = __esm({
   }
 });
 
+// dist/rad-zod-schema.js
+var import_zod, nonNegativeSafeIntegerSchema, RADSplatEncodingSchema, RADChunkRangeSchema, RADMetadataJSONSchema, RADChunkPropertySchema, RADChunkMetadataJSONSchema;
+var init_rad_zod_schema = __esm({
+  "dist/rad-zod-schema.js"() {
+    "use strict";
+    import_zod = require("zod");
+    nonNegativeSafeIntegerSchema = import_zod.z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+    RADSplatEncodingSchema = import_zod.z.object({
+      rgbMin: import_zod.z.number().finite().optional(),
+      rgbMax: import_zod.z.number().finite().optional(),
+      lnScaleMin: import_zod.z.number().finite().optional(),
+      lnScaleMax: import_zod.z.number().finite().optional(),
+      sh1Max: import_zod.z.number().finite().optional(),
+      sh2Max: import_zod.z.number().finite().optional(),
+      sh3Max: import_zod.z.number().finite().optional(),
+      lodOpacity: import_zod.z.boolean().optional()
+    }).passthrough();
+    RADChunkRangeSchema = import_zod.z.object({
+      offset: nonNegativeSafeIntegerSchema,
+      bytes: nonNegativeSafeIntegerSchema,
+      base: nonNegativeSafeIntegerSchema.optional(),
+      count: nonNegativeSafeIntegerSchema.optional(),
+      filename: import_zod.z.string().optional()
+    }).passthrough();
+    RADMetadataJSONSchema = import_zod.z.object({
+      version: import_zod.z.literal(1),
+      type: import_zod.z.literal("gsplat"),
+      count: nonNegativeSafeIntegerSchema,
+      maxSh: nonNegativeSafeIntegerSchema.optional(),
+      lodTree: import_zod.z.boolean().optional(),
+      chunkSize: nonNegativeSafeIntegerSchema.optional(),
+      allChunkBytes: nonNegativeSafeIntegerSchema.optional(),
+      chunks: import_zod.z.array(RADChunkRangeSchema),
+      splatEncoding: RADSplatEncodingSchema.optional(),
+      shCodeCount: nonNegativeSafeIntegerSchema.optional(),
+      comment: import_zod.z.string().optional()
+    }).passthrough();
+    RADChunkPropertySchema = import_zod.z.object({
+      offset: nonNegativeSafeIntegerSchema,
+      bytes: nonNegativeSafeIntegerSchema,
+      property: import_zod.z.string(),
+      encoding: import_zod.z.string(),
+      compression: import_zod.z.string().optional(),
+      min: import_zod.z.number().finite().optional(),
+      max: import_zod.z.number().finite().optional()
+    }).passthrough();
+    RADChunkMetadataJSONSchema = import_zod.z.object({
+      version: import_zod.z.literal(1),
+      base: nonNegativeSafeIntegerSchema,
+      count: nonNegativeSafeIntegerSchema,
+      payloadBytes: nonNegativeSafeIntegerSchema,
+      maxSh: nonNegativeSafeIntegerSchema.optional(),
+      lodTree: import_zod.z.boolean().optional(),
+      splatEncoding: RADSplatEncodingSchema.optional(),
+      properties: import_zod.z.array(RADChunkPropertySchema)
+    }).passthrough();
+  }
+});
+
 // dist/lib/parse-rad.js
 function parseRADHeader(data) {
   const metadata = tryParseRADHeader(data);
@@ -983,7 +2134,7 @@ function tryParseRADHeader(data) {
   if (bytes.byteLength < headerJsonEnd) {
     return null;
   }
-  const rawMetadata = parseJSONRecord(bytes.subarray(RAD_HEADER_BYTE_LENGTH, headerJsonEnd), "RADLoader: failed to parse RAD metadata JSON.");
+  const rawMetadata = RADMetadataJSONSchema.parse(parseJSON(bytes.subarray(RAD_HEADER_BYTE_LENGTH, headerJsonEnd), "RADLoader: failed to parse RAD metadata JSON."));
   return normalizeRADMetadata(rawMetadata, headerJsonByteLength);
 }
 function parseRADChunkHeader(data) {
@@ -1003,7 +2154,7 @@ function parseRADChunkHeader(data) {
   if (bytes.byteLength < payloadByteOffset) {
     throw new Error("RADLoader: RADC chunk must contain a complete metadata header.");
   }
-  const rawMetadata = parseJSONRecord(bytes.subarray(RAD_HEADER_BYTE_LENGTH, headerJsonEnd), "RADLoader: failed to parse RADC metadata JSON.");
+  const rawMetadata = RADChunkMetadataJSONSchema.parse(parseJSON(bytes.subarray(RAD_HEADER_BYTE_LENGTH, headerJsonEnd), "RADLoader: failed to parse RADC metadata JSON."));
   const payloadBytes = readSafeUint642(dataView, payloadByteLengthOffset, "RADC payload byte length");
   return normalizeRADChunkMetadata(rawMetadata, headerJsonByteLength, payloadByteOffset, payloadBytes);
 }
@@ -1011,157 +2162,31 @@ function roundUpToEight(byteLength) {
   return byteLength + 7 & ~7;
 }
 function normalizeRADMetadata(rawMetadata, headerJsonByteLength) {
-  const version = requireSafeInteger(rawMetadata.version, "RAD version");
-  if (version !== 1) {
-    throw new Error(`RADLoader: version ${version} is not supported.`);
-  }
-  const type = requireString(rawMetadata.type, "RAD type");
-  if (type !== "gsplat") {
-    throw new Error(`RADLoader: RAD type ${type} is not supported.`);
-  }
-  const chunks = requireArray(rawMetadata.chunks, "RAD chunks").map((chunk, chunkIndex) => normalizeRADChunkRange(chunk, chunkIndex));
-  const metadata = {
-    version,
-    type,
-    count: requireSafeInteger(rawMetadata.count, "RAD count"),
-    maxSh: optionalSafeInteger(rawMetadata.maxSh, "RAD maxSh"),
-    lodTree: optionalBoolean(rawMetadata.lodTree, "RAD lodTree"),
-    chunkSize: optionalSafeInteger(rawMetadata.chunkSize, "RAD chunkSize"),
-    allChunkBytes: optionalSafeInteger(rawMetadata.allChunkBytes, "RAD allChunkBytes"),
-    chunks,
-    splatEncoding: optionalSplatEncoding(rawMetadata.splatEncoding, "RAD splatEncoding"),
-    shCodeCount: optionalSafeInteger(rawMetadata.shCodeCount, "RAD shCodeCount"),
-    comment: optionalString(rawMetadata.comment, "RAD comment"),
+  return {
+    ...rawMetadata,
     headerJsonByteLength,
     chunksByteOffset: RAD_HEADER_BYTE_LENGTH + roundUpToEight(headerJsonByteLength)
   };
-  return metadata;
-}
-function normalizeRADChunkRange(rawChunk, chunkIndex) {
-  const chunk = requireRecord(rawChunk, `RAD chunk ${chunkIndex}`);
-  return {
-    offset: requireSafeInteger(chunk.offset, `RAD chunk ${chunkIndex} offset`),
-    bytes: requireSafeInteger(chunk.bytes, `RAD chunk ${chunkIndex} bytes`),
-    base: optionalSafeInteger(chunk.base, `RAD chunk ${chunkIndex} base`),
-    count: optionalSafeInteger(chunk.count, `RAD chunk ${chunkIndex} count`),
-    filename: optionalString(chunk.filename, `RAD chunk ${chunkIndex} filename`)
-  };
 }
 function normalizeRADChunkMetadata(rawMetadata, headerJsonByteLength, payloadByteOffset, payloadBytes) {
-  const version = requireSafeInteger(rawMetadata.version, "RADC version");
-  if (version !== 1) {
-    throw new Error(`RADLoader: RADC version ${version} is not supported.`);
-  }
-  const metadataPayloadBytes = requireSafeInteger(rawMetadata.payloadBytes, "RADC payloadBytes");
-  if (metadataPayloadBytes !== payloadBytes) {
+  if (rawMetadata.payloadBytes !== payloadBytes) {
     throw new Error("RADLoader: RADC metadata payload byte length does not match binary header.");
   }
   return {
-    version,
-    base: requireSafeInteger(rawMetadata.base, "RADC base"),
-    count: requireSafeInteger(rawMetadata.count, "RADC count"),
+    ...rawMetadata,
     payloadBytes,
-    maxSh: optionalSafeInteger(rawMetadata.maxSh, "RADC maxSh"),
-    lodTree: optionalBoolean(rawMetadata.lodTree, "RADC lodTree"),
-    splatEncoding: optionalSplatEncoding(rawMetadata.splatEncoding, "RADC splatEncoding"),
-    properties: requireArray(rawMetadata.properties, "RADC properties").map((property, index) => normalizeRADChunkProperty(property, index)),
     headerJsonByteLength,
     payloadByteOffset,
     chunkByteLength: payloadByteOffset + payloadBytes
   };
 }
-function normalizeRADChunkProperty(rawProperty, propertyIndex) {
-  const property = requireRecord(rawProperty, `RADC property ${propertyIndex}`);
-  return {
-    offset: requireSafeInteger(property.offset, `RADC property ${propertyIndex} offset`),
-    bytes: requireSafeInteger(property.bytes, `RADC property ${propertyIndex} bytes`),
-    property: requireString(property.property, `RADC property ${propertyIndex} name`),
-    encoding: requireString(property.encoding, `RADC property ${propertyIndex} encoding`),
-    compression: optionalString(property.compression, `RADC property ${propertyIndex} compression`),
-    min: optionalFiniteNumber(property.min, `RADC property ${propertyIndex} min`),
-    max: optionalFiniteNumber(property.max, `RADC property ${propertyIndex} max`)
-  };
-}
-function optionalSplatEncoding(value, fieldName) {
-  if (value === void 0) {
-    return void 0;
-  }
-  const encoding = requireRecord(value, fieldName);
-  return {
-    rgbMin: optionalFiniteNumber(encoding.rgbMin, `${fieldName}.rgbMin`),
-    rgbMax: optionalFiniteNumber(encoding.rgbMax, `${fieldName}.rgbMax`),
-    lnScaleMin: optionalFiniteNumber(encoding.lnScaleMin, `${fieldName}.lnScaleMin`),
-    lnScaleMax: optionalFiniteNumber(encoding.lnScaleMax, `${fieldName}.lnScaleMax`),
-    sh1Max: optionalFiniteNumber(encoding.sh1Max, `${fieldName}.sh1Max`),
-    sh2Max: optionalFiniteNumber(encoding.sh2Max, `${fieldName}.sh2Max`),
-    sh3Max: optionalFiniteNumber(encoding.sh3Max, `${fieldName}.sh3Max`),
-    lodOpacity: optionalBoolean(encoding.lodOpacity, `${fieldName}.lodOpacity`)
-  };
-}
-function parseJSONRecord(bytes, message) {
+function parseJSON(bytes, message) {
   try {
-    return requireRecord(JSON.parse(TEXT_DECODER.decode(bytes)), message);
-  } catch (error) {
-    if (error instanceof Error && error.message.startsWith("RADLoader:")) {
-      throw error;
-    }
+    return JSON.parse(TEXT_DECODER.decode(bytes));
+  } catch {
     throw new Error(message);
   }
 }
-function requireRecord(value, fieldName) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    throw new Error(`RADLoader: ${fieldName} must be an object.`);
-  }
-  return value;
-}
-function requireArray(value, fieldName) {
-  if (!Array.isArray(value)) {
-    throw new Error(`RADLoader: ${fieldName} must be an array.`);
-  }
-  return value;
-}
-function requireString(value, fieldName) {
-  if (typeof value !== "string") {
-    throw new Error(`RADLoader: ${fieldName} must be a string.`);
-  }
-  return value;
-}
-function optionalString(value, fieldName) {
-  if (value === void 0) {
-    return void 0;
-  }
-  return requireString(value, fieldName);
-}
-function optionalBoolean(value, fieldName) {
-  if (value === void 0) {
-    return void 0;
-  }
-  if (typeof value !== "boolean") {
-    throw new Error(`RADLoader: ${fieldName} must be a boolean.`);
-  }
-  return value;
-}
-function requireSafeInteger(value, fieldName) {
-  if (!Number.isSafeInteger(value) || Number(value) < 0) {
-    throw new Error(`RADLoader: ${fieldName} must be a non-negative safe integer.`);
-  }
-  return Number(value);
-}
-function optionalSafeInteger(value, fieldName) {
-  if (value === void 0) {
-    return void 0;
-  }
-  return requireSafeInteger(value, fieldName);
-}
-function optionalFiniteNumber(value, fieldName) {
-  if (value === void 0) {
-    return void 0;
-  }
-  if (typeof value !== "number" || !Number.isFinite(value)) {
-    throw new Error(`RADLoader: ${fieldName} must be a finite number.`);
-  }
-  return value;
-}
 function readSafeUint642(dataView, byteOffset, fieldName) {
   const value = dataView.getBigUint64(byteOffset, true);
   if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
@@ -1176,6 +2201,7 @@ var RAD_MAGIC, RAD_CHUNK_MAGIC, RAD_HEADER_BYTE_LENGTH, RAD_CHUNK_PAYLOAD_LENGTH
 var init_parse_rad = __esm({
   "dist/lib/parse-rad.js"() {
     "use strict";
+    init_rad_zod_schema();
     RAD_MAGIC = 809779538;
     RAD_CHUNK_MAGIC = 1128546642;
     RAD_HEADER_BYTE_LENGTH = 8;
@@ -1184,6 +2210,94 @@ var init_parse_rad = __esm({
   }
 });
 
+// ../compression/src/lib/fflate-stream.ts
+async function* transformFflateBatches(processor, inputBatches) {
+  const chunks = [];
+  processor.ondata = (data) => {
+    chunks.push(data.slice().buffer);
+  };
+  for await (const batch of inputBatches) {
+    processor.push(new Uint8Array(batch), false);
+    yield* chunks.splice(0);
+  }
+  processor.push(new Uint8Array(0), true);
+  yield* chunks;
+}
+var init_fflate_stream = __esm({
+  "../compression/src/lib/fflate-stream.ts"() {
+    "use strict";
+  }
+});
+
+// ../compression/src/deflate-decompressor-fflate.ts
+var import_fflate, DeflateFflateDecompressor;
+var init_deflate_decompressor_fflate = __esm({
+  "../compression/src/deflate-decompressor-fflate.ts"() {
+    "use strict";
+    import_fflate = require("fflate");
+    init_compression();
+    init_fflate_stream();
+    DeflateFflateDecompressor = class extends Decompressor {
+      name = "deflate";
+      extensions = [];
+      contentEncodings = ["deflate"];
+      isSupported = true;
+      options;
+      constructor(options = {}) {
+        super(options);
+        this.options = options;
+      }
+      /** Decompresses one zlib-wrapped DEFLATE payload synchronously. */
+      decompressSync(input) {
+        const bytes = new Uint8Array(input);
+        const output = this.options.raw ? (0, import_fflate.inflateSync)(bytes) : (0, import_fflate.unzlibSync)(bytes);
+        return output.slice().buffer;
+      }
+      /** Decompresses DEFLATE batches incrementally. */
+      async *decompressBatches(inputBatches) {
+        const processor = this.options.raw ? new import_fflate.Inflate() : new import_fflate.Unzlib();
+        yield* transformFflateBatches(processor, inputBatches);
+      }
+    };
+  }
+});
+
+// ../compression/src/deflate-decompressor.ts
+var DeflateDecompressor2;
+var init_deflate_decompressor = __esm({
+  "../compression/src/deflate-decompressor.ts"() {
+    "use strict";
+    init_deflate_decompressor_fflate();
+    init_decompression_stream();
+    DeflateDecompressor2 = class extends DeflateFflateDecompressor {
+      constructor(options = {}) {
+        super(options);
+      }
+      /** Decompresses with the built-in stream when available, then falls back to fflate. */
+      async decompress(input) {
+        if (this.options.useNative !== false) {
+          const format = this.options.raw ? "deflate-raw" : "deflate";
+          const output = await decompressWithNativeDecompressionStream(input, format);
+          if (output) return output;
+        }
+        return this.decompressSync(input);
+      }
+      /** Decompresses batches with a built-in or fflate stream. */
+      async *decompressBatches(inputBatches) {
+        if (this.options.useNative !== false) {
+          const format = this.options.raw ? "deflate-raw" : "deflate";
+          const output = decompressBatchesWithNativeDecompressionStream(inputBatches, format);
+          if (output) {
+            yield* output;
+            return;
+          }
+        }
+        yield* super.decompressBatches(inputBatches);
+      }
+    };
+  }
+});
+
 // dist/lib/parse-rad-chunk.js
 function parseRADChunk(data, options) {
   return makeGaussianSplatsArrowTable(parseRADChunkToGaussianSplats(data, options));
@@ -1281,9 +2395,9 @@ function decodeRADRotations(bytes, metadata, splatCount) {
         const rotationOffset = splatIndex * 4;
         const x = xyz[xyzOffset + 0];
         const y = xyz[xyzOffset + 1];
-        const z = xyz[xyzOffset + 2];
-        const w = Math.sqrt(Math.max(0, 1 - x * x - y * y - z * z));
-        const normalized = normalizeQuaternion(w, x, y, z);
+        const z2 = xyz[xyzOffset + 2];
+        const w = Math.sqrt(Math.max(0, 1 - x * x - y * y - z2 * z2));
+        const normalized = normalizeQuaternion(w, x, y, z2);
         rotations.set(normalized, rotationOffset);
       }
       return rotations;
@@ -1392,7 +2506,7 @@ function getRADPropertyBytes(bytes, metadata, property) {
   return decompressRADProperty(propertyBytes, property.property);
 }
 function decompressRADProperty(bytes, propertyName) {
-  const arrayBuffer = copyToArrayBuffer(bytes);
+  const arrayBuffer = copyToArrayBuffer3(bytes);
   try {
     return new Uint8Array(RAD_PROPERTY_DEFLATE.decompressSync(arrayBuffer));
   } catch {
@@ -1517,8 +2631,8 @@ function decodeRADOct88R8Rotations(bytes, count) {
   const rotations = new Float32Array(count * 4);
   for (let splatIndex = 0; splatIndex < count; splatIndex++) {
     const byteOffset = splatIndex * 3;
-    const [x, y, z, w] = decodeQuatOct888(bytes[byteOffset], bytes[byteOffset + 1], bytes[byteOffset + 2]);
-    rotations.set(normalizeQuaternion(w, x, y, z), splatIndex * 4);
+    const [x, y, z2, w] = decodeQuatOct888(bytes[byteOffset], bytes[byteOffset + 1], bytes[byteOffset + 2]);
+    rotations.set(normalizeQuaternion(w, x, y, z2), splatIndex * 4);
   }
   return rotations;
 }
@@ -1549,14 +2663,14 @@ function decodeScale8(scale, min, max) {
 function decodeQuatOct888(u, v, r) {
   let x = u / 255 * 2 - 1;
   let y = v / 255 * 2 - 1;
-  const z = 1 - Math.abs(x) - Math.abs(y);
-  const t = Math.max(-z, 0);
+  const z2 = 1 - Math.abs(x) - Math.abs(y);
+  const t = Math.max(-z2, 0);
   x = x >= 0 ? x - t : x + t;
   y = y >= 0 ? y - t : y + t;
-  const length = Math.hypot(x, y, z);
+  const length = Math.hypot(x, y, z2);
   const axisX = length > Number.EPSILON ? x / length : 1;
   const axisY = length > Number.EPSILON ? y / length : 0;
-  const axisZ = length > Number.EPSILON ? z / length : 0;
+  const axisZ = length > Number.EPSILON ? z2 / length : 0;
   const halfTheta = r / 255 * 0.5 * Math.PI;
   const sinHalfTheta = Math.sin(halfTheta);
   return [axisX * sinHalfTheta, axisY * sinHalfTheta, axisZ * sinHalfTheta, Math.cos(halfTheta)];
@@ -1634,7 +2748,7 @@ function getSplatEncodingMaximum(splatEncoding, propertyName) {
 function normalizeColorByte2(value) {
   return Math.round(Math.min(Math.max(value, 0), 1) * 255);
 }
-function copyToArrayBuffer(bytes) {
+function copyToArrayBuffer3(bytes) {
   const copy = new Uint8Array(bytes.byteLength);
   copy.set(bytes);
   return copy.buffer;
@@ -1642,16 +2756,16 @@ function copyToArrayBuffer(bytes) {
 function getUint8Array2(data) {
   return data instanceof ArrayBuffer ? new Uint8Array(data) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
 }
-var import_compression2, RAD_PROPERTY_DEFLATE, RAD_PROPERTY_RAW_DEFLATE;
+var RAD_PROPERTY_DEFLATE, RAD_PROPERTY_RAW_DEFLATE;
 var init_parse_rad_chunk = __esm({
   "dist/lib/parse-rad-chunk.js"() {
     "use strict";
-    import_compression2 = require("@loaders.gl/compression");
+    init_deflate_decompressor();
     init_parse_rad();
     init_splats_arrow_table();
     init_splat_utils();
-    RAD_PROPERTY_DEFLATE = new import_compression2.DeflateCompression();
-    RAD_PROPERTY_RAW_DEFLATE = new import_compression2.DeflateCompression({ raw: true });
+    RAD_PROPERTY_DEFLATE = new DeflateDecompressor2({ useNative: false });
+    RAD_PROPERTY_RAW_DEFLATE = new DeflateDecompressor2({ raw: true, useNative: false });
   }
 });
 
@@ -1687,17 +2801,17 @@ async function preload4() {
   const { RADLoaderWithParser: RADLoaderWithParser2 } = await Promise.resolve().then(() => (init_rad_loader(), rad_loader_exports));
   return RADLoaderWithParser2;
 }
-var VERSION4, RADLoader;
+var VERSION5, RADLoader;
 var init_rad_loader_types = __esm({
   "dist/rad-loader-types.js"() {
     "use strict";
     init_splats_format();
-    VERSION4 = true ? "5.0.0-alpha.1" : "latest";
+    VERSION5 = true ? "5.0.0-alpha.3" : "latest";
     RADLoader = {
       dataType: null,
       batchType: null,
       ...RADFormat,
-      version: VERSION4,
+      version: VERSION5,
       options: {},
       preload: preload4
     };
@@ -1705,8 +2819,8 @@ var init_rad_loader_types = __esm({
 });
 
 // dist/index.js
-var dist_exports = {};
-__export(dist_exports, {
+var index_exports = {};
+__export(index_exports, {
   KSPLATFormat: () => KSPLATFormat,
   KSPLATLoader: () => KSPLATLoader,
   RADFormat: () => RADFormat,
@@ -1719,7 +2833,7 @@ __export(dist_exports, {
   SPZLoader: () => SPZLoader,
   resolveRADChunkUrl: () => resolveRADChunkUrl
 });
-module.exports = __toCommonJS(dist_exports);
+module.exports = __toCommonJS(index_exports);
 init_splats_format();
 init_splat_loader_types();
 init_ksplat_loader_types();
@@ -1727,20 +2841,20 @@ init_spz_loader_types();
 init_rad_loader_types();
 
 // dist/rad-source-loader.js
-var import_loader_utils = require("@loaders.gl/loader-utils");
+init_src();
 init_splats_format();
 init_parse_rad();
 init_parse_rad_chunk();
 init_splats_arrow_table();
 var DEFAULT_RAD_HEADER_BYTE_LENGTHS = [64 * 1024, 256 * 1024, 1024 * 1024];
 var DEFAULT_RAD_MAX_CONCURRENT_CHUNK_REQUESTS = 4;
-var VERSION5 = true ? "5.0.0-alpha.1" : "latest";
+var VERSION6 = true ? "5.0.0-alpha.3" : "latest";
 var RADSourceLoader = {
   dataType: null,
   batchType: null,
   ...RADFormat,
   name: "RADSourceLoader",
-  version: VERSION5,
+  version: VERSION6,
   type: "rad",
   fromUrl: true,
   fromBlob: true,
@@ -1761,7 +2875,7 @@ var RADSourceLoader = {
   testURL: (url) => /\.rad(?:$|[?#])/i.test(url),
   createDataSource: (data, options, coreApi) => new RADSource(data, options, coreApi)
 };
-var RADSource = class extends import_loader_utils.DataSource {
+var RADSource = class extends DataSource {
   /** Shared metadata promise exposed for source-style integrations. */
   metadata;
   /** Lazily initialized RAD header promise. */