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

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.2" : "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.2" : "latest";
     KSPLATLoader = {
       dataType: null,
       batchType: null,
@@ -672,6 +677,671 @@ var init_ksplat_loader_types = __esm({
   }
 });
 
+// ../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 createNativeDecompressionStream(format) {
+  var _a, _b;
+  if (typeof globalThis.DecompressionStream === "undefined") {
+    return null;
+  }
+  if (((_b = (_a = globalThis.process) == null ? void 0 : _a.versions) == null ? void 0 : _b.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/native-decompression.ts
+var init_native_decompression = __esm({
+  "../compression/src/native-decompression.ts"() {
+    "use strict";
+    init_decompression_stream();
+  }
+});
+
+// ../loader-utils/src/lib/env-utils/globals.ts
+var globals, self_, window_, global_, document_, isBrowser, matches, nodeVersion;
+var init_globals = __esm({
+  "../loader-utils/src/lib/env-utils/globals.ts"() {
+    "use strict";
+    globals = {
+      self: typeof self !== "undefined" && self,
+      window: typeof window !== "undefined" && window,
+      global: typeof global !== "undefined" && global,
+      document: typeof document !== "undefined" && document
+    };
+    self_ = globals.self || globals.window || globals.global || {};
+    window_ = globals.window || globals.self || globals.global || {};
+    global_ = globals.global || globals.self || globals.window || {};
+    document_ = globals.document || {};
+    isBrowser = // @ts-ignore process does not exist on browser
+    Boolean(typeof process !== "object" || String(process) !== "[object process]" || process.browser);
+    matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
+    nodeVersion = matches && parseFloat(matches[1]) || 0;
+  }
+});
+
+// ../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/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/node/buffer.browser.ts
+function toArrayBuffer(buffer) {
+  return buffer;
+}
+var init_buffer_browser = __esm({
+  "../loader-utils/src/lib/node/buffer.browser.ts"() {
+    "use strict";
+  }
+});
+
+// ../loader-utils/src/lib/binary-utils/memory-conversion-utils.ts
+function isBuffer(value) {
+  return value && typeof value === "object" && value.isBuffer;
+}
+function toArrayBuffer2(data) {
+  if (isBuffer(data)) {
+    return toArrayBuffer(data);
+  }
+  if (data instanceof ArrayBuffer) {
+    return data;
+  }
+  if (isSharedArrayBuffer(data)) {
+    return copyToArrayBuffer2(data);
+  }
+  if (ArrayBuffer.isView(data)) {
+    const buffer = data.buffer;
+    if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {
+      return buffer;
+    }
+    return buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+  }
+  if (typeof data === "string") {
+    const text = data;
+    const uint8Array = new TextEncoder().encode(text);
+    return uint8Array.buffer;
+  }
+  if (data && typeof data === "object" && data._toArrayBuffer) {
+    return data._toArrayBuffer();
+  }
+  throw new Error("toArrayBuffer");
+}
+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();
+    init_buffer_browser();
+  }
+});
+
+// ../loader-utils/src/lib/node/promisify.ts
+function promisify1(fn) {
+  return (args) => new Promise(
+    (resolve, reject) => fn(args, (error, callbackArgs) => error ? reject(error) : resolve(callbackArgs))
+  );
+}
+var init_promisify = __esm({
+  "../loader-utils/src/lib/node/promisify.ts"() {
+    "use strict";
+  }
+});
+
+// ../loader-utils/src/lib/sources/data-source.ts
+function getFetchFunction(options) {
+  var _a;
+  const fetchFunction = (_a = options == null ? void 0 : options.core) == null ? void 0 : _a.fetch;
+  if (fetchFunction && typeof fetchFunction === "function") {
+    return (url, fetchOptions2) => fetchFunction(url, fetchOptions2);
+  }
+  const fetchOptions = options == null ? void 0 : options.fetch;
+  if (fetchOptions && typeof fetchOptions !== "function") {
+    return (url, requestOptions) => fetch(url, mergeFetchOptions(fetchOptions, requestOptions));
+  }
+  return (url, requestOptions) => fetch(url, requestOptions);
+}
+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();
+    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_globals();
+    init_js_module_utils();
+    init_js_module_utils();
+    init_async_iteration();
+    init_memory_conversion_utils();
+    init_promisify();
+    init_data_source();
+  }
+});
+
+// ../compression/src/lib/compression.ts
+var Compression;
+var init_compression = __esm({
+  "../compression/src/lib/compression.ts"() {
+    "use strict";
+    init_src();
+    Compression = class {
+      constructor(options) {
+        this.compressBatches = this.compressBatches.bind(this);
+        this.decompressBatches = this.decompressBatches.bind(this);
+      }
+      /** Preloads any dynamic libraries. May enable sync functions */
+      async preload(modules = {}) {
+        registerJSModules(modules);
+        return;
+      }
+      /** Asynchronously compress data */
+      async compress(input) {
+        await this.preload();
+        return this.compressSync(input);
+      }
+      /** Asynchronously decompress data */
+      async decompress(input, size) {
+        await this.preload();
+        return this.decompressSync(input, size);
+      }
+      /** Synchronously compress data */
+      compressSync(input) {
+        throw new Error(`${this.name}: sync compression not supported`);
+      }
+      /** Synchronously compress data */
+      decompressSync(input, size) {
+        throw new Error(`${this.name}: sync decompression not supported`);
+      }
+      /** Compress batches */
+      async *compressBatches(asyncIterator) {
+        const input = await this.concatenate(asyncIterator);
+        yield this.compress(input);
+      }
+      /** Decompress batches */
+      async *decompressBatches(asyncIterator) {
+        const input = await this.concatenate(asyncIterator);
+        yield this.decompress(input);
+      }
+      // HELPERS
+      concatenate(asyncIterator) {
+        return concatenateArrayBuffersAsync(asyncIterator);
+      }
+      improveError(error) {
+        if (!error.message.includes(this.name)) {
+          error.message = `${this.name} ${error.message}`;
+        }
+        return error;
+      }
+    };
+  }
+});
+
+// ../compression/src/lib/zstd-compression.ts
+var CHUNK_SIZE, zstdPromise, zstd, ZstdCompression;
+var init_zstd_compression = __esm({
+  "../compression/src/lib/zstd-compression.ts"() {
+    "use strict";
+    init_compression();
+    init_src();
+    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;
+      }
+      decompressSync(input) {
+        getJSModule("zstd-codec", this.name);
+        const simpleZstd = new zstd.Simple();
+        const inputArray = new Uint8Array(input);
+        return simpleZstd.decompress(inputArray).buffer;
+      }
+      async decompress(input, size) {
+        await this.preload();
+        const inputArray = new Uint8Array(input);
+        if (!zstd) {
+          const { decompress } = await import("fzstd");
+          return ensureArrayBuffer(decompress(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-compression.ts
+var zstd_compression_exports = {};
+__export(zstd_compression_exports, {
+  ZstdCompression: () => ZstdCompression
+});
+var init_zstd_compression2 = __esm({
+  "../compression/src/zstd-compression.ts"() {
+    "use strict";
+    init_zstd_compression();
+  }
+});
+
 // dist/lib/parse-spz.js
 async function parseSPZ(data, options) {
   return makeGaussianSplatsArrowTable(await parseSPZToGaussianSplats(data, options));
@@ -680,11 +1350,30 @@ 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)));
+  registerJSModules(options == null ? void 0 : options.modules);
+  const useNativeDecompressionStream = !getJSModuleOrNull("zstd-codec");
+  let compressionPromise;
+  const streams = await Promise.all(compressedStreams.map((compressedStream, streamIndex) => decompressSPZStream(compressedStream, streamInfos[streamIndex].uncompressedSize, useNativeDecompressionStream, () => {
+    compressionPromise ||= createZstdCompression(options == null ? void 0 : options.modules);
+    return compressionPromise;
+  })));
   validateSPZStreamLengths(streams, streamInfos);
   return decodeSPZStreams(header, streams, data);
 }
+async function decompressSPZStream(compressedStream, uncompressedSize, useNativeDecompressionStream, getCompression) {
+  if (useNativeDecompressionStream) {
+    const nativeOutput = await decompressWithNativeDecompressionStream(compressedStream, "zstd");
+    if (nativeOutput) {
+      return nativeOutput;
+    }
+  }
+  const compression = await getCompression();
+  return await compression.decompress(compressedStream, uncompressedSize);
+}
+async function createZstdCompression(modules) {
+  const { ZstdCompression: ZstdCompression2 } = await Promise.resolve().then(() => (init_zstd_compression2(), zstd_compression_exports));
+  return new ZstdCompression2({ modules });
+}
 function parseSPZHeader(data) {
   if (data.byteLength < SPZ_HEADER_BYTE_LENGTH) {
     throw new Error(`SPZLoader: file must contain a ${SPZ_HEADER_BYTE_LENGTH}-byte header.`);
@@ -827,12 +1516,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 +1587,12 @@ 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_native_decompression();
+    init_src();
     init_splats_arrow_table();
     init_splat_utils();
     SPZ_HEADER_BYTE_LENGTH = 32;
@@ -939,17 +1629,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.2" : "latest";
     SPZLoader = {
       dataType: null,
       batchType: null,
       ...SPZFormat,
-      version: VERSION3,
+      version: VERSION4,
       options: {
         splats: {
           shape: "arrow-table"
@@ -960,6 +1650,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 +1732,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 +1752,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 +1760,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 +1799,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 +1808,144 @@ var init_parse_rad = __esm({
   }
 });
 
+// ../compression/src/lib/deflate-compression.ts
+var import_pako, import_zlib, DeflateCompression;
+var init_deflate_compression = __esm({
+  "../compression/src/lib/deflate-compression.ts"() {
+    "use strict";
+    init_compression();
+    init_src();
+    import_pako = __toESM(require("pako"), 1);
+    import_zlib = __toESM(require("zlib"), 1);
+    DeflateCompression = class extends Compression {
+      name = "deflate";
+      extensions = [];
+      contentEncodings = ["deflate"];
+      isSupported = true;
+      options;
+      _chunks = [];
+      constructor(options = {}) {
+        super(options);
+        this.options = options;
+      }
+      async compress(input) {
+        var _a, _b;
+        if (!isBrowser && ((_a = this.options.deflate) == null ? void 0 : _a.useZlib)) {
+          const buffer = ((_b = this.options.deflate) == null ? void 0 : _b.gzip) ? await promisify1(import_zlib.default.gzip)(input) : await promisify1(import_zlib.default.deflate)(input);
+          return toArrayBuffer2(buffer);
+        }
+        return this.compressSync(input);
+      }
+      async decompress(input) {
+        var _a, _b;
+        if (!isBrowser && ((_a = this.options.deflate) == null ? void 0 : _a.useZlib)) {
+          const buffer = ((_b = this.options.deflate) == null ? void 0 : _b.gzip) ? await promisify1(import_zlib.default.gunzip)(input) : await promisify1(import_zlib.default.inflate)(input);
+          return toArrayBuffer2(buffer);
+        }
+        return this.decompressSync(input);
+      }
+      compressSync(input) {
+        var _a, _b, _c, _d;
+        if (!isBrowser && ((_a = this.options.deflate) == null ? void 0 : _a.useZlib)) {
+          const buffer = ((_b = this.options.deflate) == null ? void 0 : _b.gzip) ? import_zlib.default.gzipSync(input) : import_zlib.default.deflateSync(input);
+          return toArrayBuffer2(buffer);
+        }
+        const pakoOptions = ((_c = this.options) == null ? void 0 : _c.deflate) || {};
+        const inputArray = new Uint8Array(input);
+        const deflate = ((_d = this.options) == null ? void 0 : _d.raw) ? import_pako.default.deflateRaw : import_pako.default.deflate;
+        return toArrayBuffer2(deflate(inputArray, pakoOptions).buffer);
+      }
+      decompressSync(input) {
+        var _a, _b, _c, _d;
+        if (!isBrowser && ((_a = this.options.deflate) == null ? void 0 : _a.useZlib)) {
+          const buffer = ((_b = this.options.deflate) == null ? void 0 : _b.gzip) ? import_zlib.default.gunzipSync(input) : import_zlib.default.inflateSync(input);
+          return toArrayBuffer2(buffer);
+        }
+        const pakoOptions = ((_c = this.options) == null ? void 0 : _c.deflate) || {};
+        const inputArray = new Uint8Array(input);
+        const inflate = ((_d = this.options) == null ? void 0 : _d.raw) ? import_pako.default.inflateRaw : import_pako.default.inflate;
+        return toArrayBuffer2(inflate(inputArray, pakoOptions).buffer);
+      }
+      async *compressBatches(asyncIterator) {
+        var _a;
+        const pakoOptions = ((_a = this.options) == null ? void 0 : _a.deflate) || {};
+        const pakoProcessor = new import_pako.default.Deflate(pakoOptions);
+        yield* this.transformBatches(pakoProcessor, asyncIterator);
+      }
+      async *decompressBatches(asyncIterator) {
+        var _a;
+        const pakoOptions = ((_a = this.options) == null ? void 0 : _a.deflate) || {};
+        const pakoProcessor = new import_pako.default.Inflate(pakoOptions);
+        yield* this.transformBatches(pakoProcessor, asyncIterator);
+      }
+      async *transformBatches(pakoProcessor, asyncIterator) {
+        pakoProcessor.onData = this._onData.bind(this);
+        pakoProcessor.onEnd = this._onEnd.bind(this);
+        for await (const chunk of asyncIterator) {
+          const uint8Array = new Uint8Array(chunk);
+          const ok2 = pakoProcessor.push(uint8Array, false);
+          if (!ok2) {
+            throw new Error(`${this._getError()}write`);
+          }
+          const chunks2 = this._getChunks();
+          yield* chunks2;
+        }
+        const emptyChunk = new Uint8Array(0);
+        const ok = pakoProcessor.push(emptyChunk, true);
+        if (!ok) {
+        }
+        const chunks = this._getChunks();
+        yield* chunks;
+      }
+      _onData(chunk) {
+        this._chunks.push(chunk);
+      }
+      _onEnd(status) {
+        if (status !== 0) {
+          throw new Error(this._getError(status) + this._chunks.length);
+        }
+      }
+      _getChunks() {
+        const chunks = this._chunks;
+        this._chunks = [];
+        return chunks;
+      }
+      // TODO - For some reason we don't get the error message from pako in _onEnd?
+      _getError(code = 0) {
+        const MESSAGES = {
+          /* Z_NEED_DICT       2  */
+          2: "need dictionary",
+          /* Z_STREAM_END      1  */
+          1: "stream end",
+          /* Z_OK              0  */
+          0: "",
+          /* Z_ERRNO         (-1) */
+          "-1": "file error",
+          /* Z_STREAM_ERROR  (-2) */
+          "-2": "stream error",
+          /* Z_DATA_ERROR    (-3) */
+          "-3": "data error",
+          /* Z_MEM_ERROR     (-4) */
+          "-4": "insufficient memory",
+          /* Z_BUF_ERROR     (-5) */
+          "-5": "buffer error",
+          /* Z_VERSION_ERROR (-6) */
+          "-6": "incompatible version"
+        };
+        return `${this.name}: ${MESSAGES[code]}`;
+      }
+    };
+  }
+});
+
+// ../compression/src/index.ts
+var init_src2 = __esm({
+  "../compression/src/index.ts"() {
+    "use strict";
+    init_deflate_compression();
+  }
+});
+
 // dist/lib/parse-rad-chunk.js
 function parseRADChunk(data, options) {
   return makeGaussianSplatsArrowTable(parseRADChunkToGaussianSplats(data, options));
@@ -1281,9 +2043,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 +2154,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 +2279,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 +2311,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 +2396,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 +2404,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_src2();
     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 DeflateCompression();
+    RAD_PROPERTY_RAW_DEFLATE = new DeflateCompression({ raw: true });
   }
 });
 
@@ -1687,17 +2449,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.2" : "latest";
     RADLoader = {
       dataType: null,
       batchType: null,
       ...RADFormat,
-      version: VERSION4,
+      version: VERSION5,
       options: {},
       preload: preload4
     };
@@ -1705,8 +2467,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 +2481,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 +2489,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.2" : "latest";
 var RADSourceLoader = {
   dataType: null,
   batchType: null,
   ...RADFormat,
   name: "RADSourceLoader",
-  version: VERSION5,
+  version: VERSION6,
   type: "rad",
   fromUrl: true,
   fromBlob: true,
@@ -1761,7 +2523,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. */