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

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, err2) => function __init() {
+  if (err2) throw err2[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err2 = [e], e;
+  }
 };
 var __export = (target, all) => {
   for (var name in all)
@@ -76,481 +81,2296 @@ var init_splats_format = __esm({
   }
 });
 
-// dist/lib/splat-utils.js
-function convertColorByteToSphericalHarmonicDc(colorByte) {
-  return (colorByte / 255 - 0.5) / SH_C0;
+// ../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, VERSION, version, log;
+var init_log = __esm({
+  "../loader-utils/src/lib/log-utils/log.ts"() {
+    "use strict";
+    import_log = require("@probe.gl/log");
+    VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+    version = VERSION[0] >= "0" && VERSION[0] <= "9" ? `v${VERSION}` : "";
+    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;
 }
-function convertAlphaByteToLinearOpacity(alphaByte) {
-  return Math.min(Math.max(alphaByte / 255, 0), 1);
+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 normalizeQuaternion(w, x, y, z) {
-  const length = Math.hypot(w, x, y, z);
-  if (!Number.isFinite(length) || length <= Number.EPSILON) {
-    return [1, 0, 0, 0];
+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 [w / length, x / length, y / length, z / length];
+  return module2;
 }
-function decodeQuaternionByte(byte) {
-  return (byte - 128) / 128;
+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;
 }
-function decodeFloat16(value) {
-  const sign = value & 32768 ? -1 : 1;
-  const exponent = value >> 10 & 31;
-  const fraction = value & 1023;
-  if (exponent === 0) {
-    return sign * Math.pow(2, -14) * (fraction / 1024);
+var init_js_module_utils = __esm({
+  "../loader-utils/src/lib/module-utils/js-module-utils.ts"() {
+    "use strict";
   }
-  if (exponent === 31) {
-    return fraction ? Number.NaN : sign * Number.POSITIVE_INFINITY;
+});
+
+// ../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";
   }
-  return sign * Math.pow(2, exponent - 15) * (1 + fraction / 1024);
+});
+
+// ../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);
 }
-var SH_C0;
-var init_splat_utils = __esm({
-  "dist/lib/splat-utils.js"() {
+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";
-    SH_C0 = 0.28209479177387814;
+    init_array_buffer_utils();
   }
 });
 
-// dist/lib/splats-arrow-table.js
-function makeGaussianSplatsArrowTable(splats) {
-  const columns = {};
-  const fields = [];
-  const schemaFields = [];
-  addColumn(columns, fields, schemaFields, "POSITION", makeFixedSizeListVector(splats.positions, 3), {
-    type: "fixed-size-list",
-    listSize: 3,
-    children: [{ name: "value", type: "float32" }]
-  });
-  const colorCoefficients = getColorCoefficients(splats);
-  addScalarColumn(columns, fields, schemaFields, "f_dc_0", colorCoefficients[0], {
-    "loaders_gl.gaussian_splats.semantic": "spherical_harmonic_dc",
-    "loaders_gl.gaussian_splats.component": "0",
-    "loaders_gl.gaussian_splats.encoding": "coefficient"
-  });
-  addScalarColumn(columns, fields, schemaFields, "f_dc_1", colorCoefficients[1], {
-    "loaders_gl.gaussian_splats.semantic": "spherical_harmonic_dc",
-    "loaders_gl.gaussian_splats.component": "1",
-    "loaders_gl.gaussian_splats.encoding": "coefficient"
-  });
-  addScalarColumn(columns, fields, schemaFields, "f_dc_2", colorCoefficients[2], {
-    "loaders_gl.gaussian_splats.semantic": "spherical_harmonic_dc",
-    "loaders_gl.gaussian_splats.component": "2",
-    "loaders_gl.gaussian_splats.encoding": "coefficient"
+// ../loader-utils/src/lib/request-utils/authentication.ts
+function resolveCredentials(credentials, authentications = []) {
+  if (credentials.every(isAuthentication)) return credentials;
+  return credentials.map((credential, index) => {
+    if (isAuthentication(credential)) return credential;
+    const AuthenticationClass = authentications.find(
+      (authentication2) => authentication2.type === (credential == null ? void 0 : credential.type)
+    );
+    if (!AuthenticationClass) {
+      throw new Error(`No authentication class registered for credential at index ${index}.`);
+    }
+    let authentication;
+    try {
+      authentication = new AuthenticationClass(credential);
+    } catch {
+      throw new Error(`Invalid authentication configuration at index ${index}.`);
+    }
+    if (!isAuthentication(authentication)) {
+      throw new Error(`Authentication class returned an invalid credential at index ${index}.`);
+    }
+    return authentication;
   });
-  addScalarColumn(columns, fields, schemaFields, "opacity", splats.opacities, {
-    "loaders_gl.gaussian_splats.semantic": "opacity",
-    "loaders_gl.gaussian_splats.encoding": "linear"
+}
+function resolveAuthenticationOptions(options) {
+  var _a, _b;
+  if (!((_b = (_a = options.core) == null ? void 0 : _a.credentials) == null ? void 0 : _b.length)) return options;
+  const credentials = resolveCredentials(options.core.credentials, options.core.authentications);
+  if (credentials === options.core.credentials) return options;
+  return { ...options, core: { ...options.core, credentials } };
+}
+function isAuthentication(credential) {
+  if (!credential || typeof credential !== "object") return false;
+  if (typeof credential.id !== "string" || !Array.isArray(credential.origins)) return false;
+  if (credential.type === "request") return typeof credential.authenticate === "function";
+  return (credential.type === "header" || credential.type === "query-parameter") && typeof credential.name === "string" && (typeof credential.token === "string" || typeof credential.token === "function") && Array.isArray(credential.refreshStatusCodes);
+}
+var init_authentication = __esm({
+  "../loader-utils/src/lib/request-utils/authentication.ts"() {
+    "use strict";
+  }
+});
+
+// ../loader-utils/src/lib/request-utils/request-credentials.ts
+function createAuthenticatedFetch(options) {
+  const suppliedFetch = options.fetch || ((url, requestOptions) => fetch(url, requestOptions));
+  const existingMetadata = suppliedFetch[AUTHENTICATED_FETCH];
+  const credentialResolutions = new Map(existingMetadata == null ? void 0 : existingMetadata.credentialResolutions);
+  const resolvedCredentials = resolveCredentials(
+    options.credentials.map((credential) => credentialResolutions.get(credential) || credential),
+    options.authentications
+  );
+  options.credentials.forEach((credential, index) => {
+    credentialResolutions.set(credential, resolvedCredentials[index]);
   });
-  addVectorComponents(columns, fields, schemaFields, "scale", splats.scales, 3, {
-    "loaders_gl.gaussian_splats.semantic": "scale",
-    "loaders_gl.gaussian_splats.encoding": "linear"
+  if (!options.fetchOptions && (!resolvedCredentials.length || (existingMetadata == null ? void 0 : existingMetadata.credentials.length) === resolvedCredentials.length && resolvedCredentials.every(
+    (credential, index) => credential === existingMetadata.credentials[index]
+  )))
+    return suppliedFetch;
+  const baseFetch = (existingMetadata == null ? void 0 : existingMetadata.fetch) || suppliedFetch;
+  const credentials = existingMetadata ? [.../* @__PURE__ */ new Set([...resolvedCredentials, ...existingMetadata.credentials])] : resolvedCredentials;
+  const fetchOptions = mergeFetchOptions(
+    (existingMetadata == null ? void 0 : existingMetadata.fetchOptions) || {},
+    options.fetchOptions
+  );
+  const tokenCredentials = credentials.filter(
+    (credential) => credential.type !== "request"
+  );
+  const requestCredentials = credentials.filter(
+    (credential) => credential.type === "request"
+  );
+  for (const credential of requestCredentials) normalizeRequestOrigins(credential.origins);
+  const authenticatedFetch = async (url, requestOptions = {}) => {
+    var _a, _b, _c, _d, _e, _f, _g;
+    requestOptions = mergeFetchOptions(fetchOptions, requestOptions);
+    if ((_a = requestOptions.signal) == null ? void 0 : _a.aborted) throw createAbortError();
+    if (!credentials.length) return baseFetch(url, requestOptions);
+    const resolvedURL = parseHTTPURL(url);
+    const authorization = resolvedURL ? await authorizeRequest(resolvedURL, requestOptions, tokenCredentials) : { url, options: requestOptions, credentials: [] };
+    const signedRequest = await authenticateRequest(authorization, requestCredentials, "request");
+    const response = await baseFetch(signedRequest.url, signedRequest.options);
+    const refreshableCredentials = [];
+    for (const resolvedCredential of authorization.credentials) {
+      const { credential } = resolvedCredential;
+      if (typeof credential.token === "function" && (isReplayableRequest(requestOptions) || ((_b = credential.canReplayRequest) == null ? void 0 : _b.call(credential, url, requestOptions))) && (isReplayableRequest(signedRequest.options) || ((_c = credential.canReplayRequest) == null ? void 0 : _c.call(credential, signedRequest.url, signedRequest.options))) && (credential.refreshStatusCodes.includes(response.status) || await ((_d = credential.shouldRefresh) == null ? void 0 : _d.call(credential, response))))
+        refreshableCredentials.push(resolvedCredential);
+    }
+    const shouldRetrySignature = isReplayableRequest(requestOptions) && isReplayableRequest(signedRequest.options) && signedRequest.credentials.some(
+      (credential) => {
+        var _a2;
+        return (_a2 = credential.refreshStatusCodes) == null ? void 0 : _a2.includes(response.status);
+      }
+    );
+    if (!refreshableCredentials.length && !shouldRetrySignature) return response;
+    if ((_e = requestOptions.signal) == null ? void 0 : _e.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 && !shouldRetrySignature) return response;
+    await ((_f = response.body) == null ? void 0 : _f.cancel().catch(() => {
+    }));
+    if ((_g = requestOptions.signal) == null ? void 0 : _g.aborted) throw createAbortError();
+    const replayAuthorization = resolvedURL ? await authorizeRequest(
+      resolvedURL,
+      requestOptions,
+      tokenCredentials,
+      refreshedTokens,
+      authorization.credentials
+    ) : { url, options: requestOptions };
+    const replayRequest = await authenticateRequest(
+      replayAuthorization,
+      requestCredentials,
+      "retry",
+      response
+    );
+    return baseFetch(replayRequest.url, replayRequest.options);
+  };
+  Object.defineProperty(authenticatedFetch, AUTHENTICATED_FETCH, {
+    value: {
+      fetch: baseFetch,
+      credentials,
+      credentialResolutions,
+      fetchOptions
+    }
   });
-  addVectorComponents(columns, fields, schemaFields, "rot", splats.rotations, 4, {
-    "loaders_gl.gaussian_splats.semantic": "rotation",
-    "loaders_gl.gaussian_splats.encoding": "quaternion"
+  return authenticatedFetch;
+}
+function getAuthenticatedFetch(options = {}) {
+  var _a, _b, _c;
+  const fetchOption = options.fetch ?? ((_a = options.core) == null ? void 0 : _a.fetch);
+  let fetchFunction;
+  if (typeof fetchOption === "function") {
+    fetchFunction = fetchOption;
+  } else {
+    fetchFunction = (url, requestOptions) => fetch(url, requestOptions);
+  }
+  return createAuthenticatedFetch({
+    fetch: fetchFunction,
+    fetchOptions: typeof fetchOption === "object" && fetchOption ? fetchOption : void 0,
+    credentials: ((_b = options.core) == null ? void 0 : _b.credentials) || [],
+    authentications: (_c = options.core) == null ? void 0 : _c.authentications
   });
-  if (splats.sphericalHarmonics && splats.sphericalHarmonicsComponentCount) {
-    addSphericalHarmonicRestColumns(columns, fields, schemaFields, splats.sphericalHarmonics, splats.sphericalHarmonicsComponentCount);
-  }
-  const metadata = /* @__PURE__ */ new Map([
-    ["loaders_gl.semantic_type", "gaussian-splats"],
-    ["loaders_gl.gaussian_splats.version", "1"],
-    ["loaders_gl.gaussian_splats.source_format", splats.format],
-    ["topology", "point-list"],
-    ["mode", "0"]
-  ]);
-  const arrowSchema = new arrow.Schema(fields, metadata);
-  const schema = {
-    fields: schemaFields,
-    metadata: Object.fromEntries(metadata)
-  };
-  return {
-    shape: "arrow-table",
-    schema,
-    data: new arrow.Table(arrowSchema, columns),
-    topology: "point-list",
-    loaderData: splats.loaderData
-  };
 }
-function addVectorComponents(columns, fields, schemaFields, prefix, values, size, metadata) {
-  for (let component = 0; component < size; component++) {
-    const componentValues = new Float32Array(values.length / size);
-    for (let rowIndex = 0; rowIndex < componentValues.length; rowIndex++) {
-      componentValues[rowIndex] = values[rowIndex * size + component];
-    }
-    addScalarColumn(columns, fields, schemaFields, `${prefix}_${component}`, componentValues, {
-      ...metadata,
-      "loaders_gl.gaussian_splats.component": String(component)
+function mergeFetchOptions(defaultOptions, requestOptions) {
+  const mergedOptions = { ...defaultOptions, ...requestOptions };
+  if (defaultOptions.headers || (requestOptions == null ? void 0 : requestOptions.headers)) {
+    const headers = new Headers(defaultOptions.headers);
+    new Headers(requestOptions == null ? void 0 : requestOptions.headers).forEach((value, key) => headers.set(key, value));
+    mergedOptions.headers = headers;
+  }
+  return mergedOptions;
+}
+async function authenticateRequest(request, credentials, reason, response) {
+  const appliedCredentials = [];
+  const signal = request.options.signal;
+  for (const credential of credentials) {
+    const origin = getRequestOrigin(request.url);
+    if (!origin || !normalizeRequestOrigins(credential.origins).includes(origin)) continue;
+    if (signal == null ? void 0 : signal.aborted) throw createAbortError();
+    const authenticatedRequest = await credential.authenticate({
+      url: request.url,
+      options: { ...request.options, headers: new Headers(request.options.headers) },
+      reason,
+      response: response ? { status: response.status, headers: new Headers(response.headers) } : void 0
     });
+    if (!authenticatedRequest || typeof authenticatedRequest.url !== "string" || !authenticatedRequest.options || typeof authenticatedRequest.options !== "object") {
+      throw new Error("Authentication callback returned an invalid request.");
+    }
+    request = {
+      url: authenticatedRequest.url,
+      options: { ...authenticatedRequest.options, ...signal ? { signal } : {} }
+    };
+    appliedCredentials.push(credential);
   }
+  if (signal == null ? void 0 : signal.aborted) throw createAbortError();
+  return { ...request, credentials: appliedCredentials };
 }
-function addSphericalHarmonicRestColumns(columns, fields, schemaFields, sphericalHarmonics, componentCount) {
-  for (let component = 0; component < componentCount; component++) {
-    const componentValues = new Float32Array(sphericalHarmonics.length / componentCount);
-    for (let rowIndex = 0; rowIndex < componentValues.length; rowIndex++) {
-      componentValues[rowIndex] = sphericalHarmonics[rowIndex * componentCount + component];
+function getRequestOrigin(url) {
+  try {
+    const parsedURL = new URL(url);
+    if (!parsedURL.host || parsedURL.username || parsedURL.password) return null;
+    return parsedURL.origin !== "null" ? parsedURL.origin : `${parsedURL.protocol}//${parsedURL.host}`;
+  } catch {
+    return null;
+  }
+}
+function normalizeRequestOrigins(origins) {
+  if (!origins.length)
+    throw new Error("Request authentication requires at least one exact origin.");
+  return origins.map((origin) => {
+    const resolvedOrigin = getRequestOrigin(origin);
+    let url;
+    try {
+      url = new URL(origin);
+    } catch {
+      throw new Error("Invalid request authentication origin.");
     }
-    addScalarColumn(columns, fields, schemaFields, `f_rest_${component}`, componentValues, {
-      "loaders_gl.gaussian_splats.semantic": "spherical_harmonic_rest",
-      "loaders_gl.gaussian_splats.component": String(component),
-      "loaders_gl.gaussian_splats.encoding": "coefficient"
-    });
+    if (!resolvedOrigin || url.pathname && url.pathname !== "/" || url.search || url.hash) {
+      throw new Error("Invalid request authentication origin.");
+    }
+    return resolvedOrigin;
+  });
+}
+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
+  };
 }
-function addScalarColumn(columns, fields, schemaFields, name, values, metadata) {
-  addColumn(columns, fields, schemaFields, name, arrow.makeVector(values), "float32", metadata);
+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 addColumn(columns, fields, schemaFields, name, column, schemaType, metadata = {}) {
-  columns[name] = column;
-  fields.push(new arrow.Field(name, column.type, false, new Map(Object.entries(metadata))));
-  schemaFields.push({ name, type: schemaType, nullable: false, metadata });
+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 makeFixedSizeListVector(value, size) {
-  const values = arrow.makeVector(value);
-  const child = values.data[0];
-  const type = new arrow.FixedSizeList(size, new arrow.Field("value", child.type, false));
-  const data = new arrow.Data(type, 0, value.length / size, 0, {}, [child]);
-  return new arrow.Vector([data]);
+function createAbortError() {
+  return new DOMException("The operation was aborted.", "AbortError");
 }
-function getColorCoefficients(splats) {
-  const rowCount = splats.splatCount;
-  const fdc0 = new Float32Array(rowCount);
-  const fdc1 = new Float32Array(rowCount);
-  const fdc2 = new Float32Array(rowCount);
-  for (let rowIndex = 0; rowIndex < rowCount; rowIndex++) {
-    if (splats.sphericalHarmonicDcs) {
-      fdc0[rowIndex] = splats.sphericalHarmonicDcs[rowIndex * 3 + 0];
-      fdc1[rowIndex] = splats.sphericalHarmonicDcs[rowIndex * 3 + 1];
-      fdc2[rowIndex] = splats.sphericalHarmonicDcs[rowIndex * 3 + 2];
-    } else {
-      fdc0[rowIndex] = convertColorByteToSphericalHarmonicDc(splats.colors[rowIndex * 3 + 0]);
-      fdc1[rowIndex] = convertColorByteToSphericalHarmonicDc(splats.colors[rowIndex * 3 + 1]);
-      fdc2[rowIndex] = convertColorByteToSphericalHarmonicDc(splats.colors[rowIndex * 3 + 2]);
+var AUTHENTICATED_FETCH, refreshPromises;
+var init_request_credentials = __esm({
+  "../loader-utils/src/lib/request-utils/request-credentials.ts"() {
+    "use strict";
+    init_authentication();
+    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);
     }
   }
-  return [fdc0, fdc1, fdc2];
+  if (!filename.startsWith("http://") && !filename.startsWith("https://")) {
+    filename = `${pathPrefix}${filename}`;
+  }
+  return filename;
 }
-var arrow;
-var init_splats_arrow_table = __esm({
-  "dist/lib/splats-arrow-table.js"() {
+var pathPrefix, fileAliases;
+var init_file_aliases = __esm({
+  "../loader-utils/src/lib/path-utils/file-aliases.ts"() {
     "use strict";
-    arrow = __toESM(require("apache-arrow"), 1);
-    init_splat_utils();
+    pathPrefix = "";
+    fileAliases = {};
   }
 });
 
-// dist/lib/parse-splat.js
-function parseSPLAT(data) {
-  return makeGaussianSplatsArrowTable(parseSPLATToGaussianSplats(data));
-}
-function parseSPLATToGaussianSplats(data) {
-  if (data.byteLength % SPLAT_ROW_BYTE_LENGTH !== 0) {
-    throw new Error(`SPLATLoader: byte length must be a multiple of ${SPLAT_ROW_BYTE_LENGTH}.`);
+// ../loader-utils/src/lib/binary-utils/memory-conversion-utils.ts
+function ensureArrayBuffer(bufferSource) {
+  if (bufferSource instanceof ArrayBuffer) {
+    return bufferSource;
   }
-  const splatCount = data.byteLength / SPLAT_ROW_BYTE_LENGTH;
-  const dataView = new DataView(data);
-  const positions = new Float32Array(splatCount * 3);
-  const scales = new Float32Array(splatCount * 3);
-  const rotations = new Float32Array(splatCount * 4);
-  const colors = new Uint8Array(splatCount * 3);
-  const opacities = new Float32Array(splatCount);
-  for (let splatIndex = 0; splatIndex < splatCount; splatIndex++) {
-    const byteOffset = splatIndex * SPLAT_ROW_BYTE_LENGTH;
-    const positionOffset = splatIndex * 3;
-    const rotationOffset = splatIndex * 4;
-    positions[positionOffset + 0] = dataView.getFloat32(byteOffset + 0, true);
-    positions[positionOffset + 1] = dataView.getFloat32(byteOffset + 4, true);
-    positions[positionOffset + 2] = dataView.getFloat32(byteOffset + 8, true);
-    scales[positionOffset + 0] = dataView.getFloat32(byteOffset + 12, true);
-    scales[positionOffset + 1] = dataView.getFloat32(byteOffset + 16, true);
-    scales[positionOffset + 2] = dataView.getFloat32(byteOffset + 20, true);
-    colors[positionOffset + 0] = dataView.getUint8(byteOffset + 24);
-    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)));
-    rotations[rotationOffset + 0] = w;
-    rotations[rotationOffset + 1] = x;
-    rotations[rotationOffset + 2] = y;
-    rotations[rotationOffset + 3] = z;
+  if (isSharedArrayBuffer(bufferSource)) {
+    return copyToArrayBuffer2(bufferSource);
   }
-  return {
-    format: "splat",
-    splatCount,
-    positions,
-    scales,
-    rotations,
-    colors,
-    opacities,
-    loaderData: {
-      format: "splat",
-      splatCount,
-      rowByteLength: SPLAT_ROW_BYTE_LENGTH
-    }
-  };
+  const { buffer, byteOffset, byteLength } = bufferSource;
+  if (buffer instanceof ArrayBuffer && byteOffset === 0 && byteLength === buffer.byteLength) {
+    return buffer;
+  }
+  return copyToArrayBuffer2(buffer, byteOffset, byteLength);
 }
-var SPLAT_ROW_BYTE_LENGTH;
-var init_parse_splat = __esm({
-  "dist/lib/parse-splat.js"() {
+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_splats_arrow_table();
-    init_splat_utils();
-    SPLAT_ROW_BYTE_LENGTH = 32;
+    init_is_type();
   }
 });
 
-// dist/splat-loader.js
-var splat_loader_exports = {};
-__export(splat_loader_exports, {
-  SPLATLoaderWithParser: () => SPLATLoaderWithParser
-});
-var _SPLATLoaderPreload, SPLATLoaderMetadataWithoutPreload, SPLATLoaderWithParser;
-var init_splat_loader = __esm({
-  "dist/splat-loader.js"() {
+// ../loader-utils/src/lib/sources/data-source.ts
+function getFetchFunction(options) {
+  return getAuthenticatedFetch(options);
+}
+function getSourceLoaderOptions(options) {
+  var _a;
+  if (options.loadOptions !== void 0 || ((_a = options.core) == null ? void 0 : _a.loadOptions) !== void 0) {
+    throw new Error(
+      "Source loadOptions and core.loadOptions were removed. Use core and root loader namespaces directly."
+    );
+  }
+  const loadOptions = { ...options };
+  if (options == null ? void 0 : options.core) {
+    loadOptions.core = { ...options.core };
+    const parserCore = loadOptions.core;
+    for (const key of ["type", "attributions", "loaders", "onError", "loadOptions"]) {
+      delete parserCore[key];
+    }
+    if (Object.keys(parserCore).length === 0) {
+      delete loadOptions.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_parse_splat();
-    init_splat_loader_types();
-    ({ preload: _SPLATLoaderPreload, ...SPLATLoaderMetadataWithoutPreload } = SPLATLoader);
-    SPLATLoaderWithParser = {
-      ...SPLATLoaderMetadataWithoutPreload,
-      parse: async (arrayBuffer) => parseSPLAT(arrayBuffer),
-      parseSync: (arrayBuffer) => parseSPLAT(arrayBuffer)
+    init_merge_options();
+    init_file_aliases();
+    init_log();
+    init_request_credentials();
+    init_authentication();
+    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: [],
+          loaders: [],
+          onError: void 0
+        }
+      };
+      optionsType;
+      options;
+      data;
+      url;
+      /** Shared parser options derived from the source options, excluding source-only core controls. */
+      loadOptions;
+      /** A resolved fetch function extracted from the shared core options. */
+      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) {
+        this.options = mergeOptions(
+          mergeOptions(_DataSource.defaultOptions, defaultOptions || {}),
+          options
+        );
+        this.data = data;
+        this.url = typeof data === "string" ? resolvePath(data) : "";
+        const loadOptions = resolveAuthenticationOptions(getSourceLoaderOptions(this.options));
+        this.loadOptions = loadOptions;
+        const fetch2 = getFetchFunction(loadOptions);
+        this.coreApi = coreApi || UNAVAILABLE_CORE_API;
+        this.hasCoreApi = Boolean(coreApi);
+        this.fetch = fetch2;
+      }
+      setProps(options) {
+        const mergedOptions = mergeOptions(this.options, options);
+        const loadOptions = resolveAuthenticationOptions(getSourceLoaderOptions(mergedOptions));
+        this.options = mergedOptions;
+        this.loadOptions = loadOptions;
+        this.fetch = getFetchFunction(loadOptions);
+        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;
+      }
     };
   }
 });
 
-// dist/splat-loader-types.js
-async function preload() {
-  const { SPLATLoaderWithParser: SPLATLoaderWithParser2 } = await Promise.resolve().then(() => (init_splat_loader(), splat_loader_exports));
-  return SPLATLoaderWithParser2;
-}
-var VERSION, SPLATLoader;
-var init_splat_loader_types = __esm({
-  "dist/splat-loader-types.js"() {
+// ../loader-utils/src/index.ts
+var init_src = __esm({
+  "../loader-utils/src/index.ts"() {
     "use strict";
-    init_splats_format();
-    VERSION = true ? "5.0.0-alpha.1" : "latest";
-    SPLATLoader = {
-      dataType: null,
-      batchType: null,
-      ...SPLATFormat,
-      version: VERSION,
-      options: {
-        splats: {
-          shape: "arrow-table"
+    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}`;
         }
-      },
-      preload
+        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);
+      }
     };
   }
 });
 
-// dist/lib/parse-ksplat.js
-function parseKSPLAT(data) {
-  return makeGaussianSplatsArrowTable(parseKSPLATToGaussianSplats(data));
+// ../compression/src/lib/compression-stream.ts
+async function compressWithNativeCompressionStream(input, format) {
+  const outputBatches = compressBatchesWithNativeCompressionStream([input], format);
+  return outputBatches ? await concatenateBatches(outputBatches) : null;
 }
-function parseKSPLATToGaussianSplats(data) {
-  if (data.byteLength < HEADER_BYTE_LENGTH) {
-    throw new Error(`KSPLATLoader: file must contain a ${HEADER_BYTE_LENGTH}-byte header.`);
+function compressBatchesWithNativeCompressionStream(inputBatches, format) {
+  const compressionStream = createNativeCompressionStream(format);
+  return compressionStream ? transformBatches(inputBatches, compressionStream) : null;
+}
+function createNativeCompressionStream(format) {
+  if (typeof globalThis.CompressionStream === "undefined") {
+    return null;
   }
-  const header = parseKSPLATHeader(data);
-  checkKSPLATVersion(header);
-  const sections = parseKSPLATSections(data, header);
-  const splatCount = getTotalSplatCount(header, sections);
-  const sphericalHarmonicsComponentCount = Math.max(0, ...sections.slice(0, getActiveSectionCount(header)).map((section) => getSphericalHarmonicsComponentCount(section.sphericalHarmonicsDegree)));
-  const positions = new Float32Array(splatCount * 3);
-  const scales = new Float32Array(splatCount * 3);
-  const rotations = new Float32Array(splatCount * 4);
-  const colors = new Uint8Array(splatCount * 3);
-  const opacities = new Float32Array(splatCount);
-  const sphericalHarmonics = sphericalHarmonicsComponentCount ? new Float32Array(splatCount * sphericalHarmonicsComponentCount) : void 0;
-  let outputSplatIndex = 0;
-  for (const section of sections.slice(0, getActiveSectionCount(header))) {
-    validateSectionBounds(data, section);
-    for (let localSplatIndex = 0; localSplatIndex < section.splatCount && outputSplatIndex < splatCount; localSplatIndex++) {
-      decodeKSPLATSplat(data, header, section, localSplatIndex, outputSplatIndex, positions, scales, rotations, colors, opacities, sphericalHarmonics, sphericalHarmonicsComponentCount);
-      outputSplatIndex++;
+  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;
   }
-  return {
-    format: "ksplat",
-    splatCount,
-    positions,
-    scales,
-    rotations,
-    colors,
-    opacities,
-    sphericalHarmonics,
-    sphericalHarmonicsComponentCount,
-    loaderData: {
-      format: "ksplat",
-      ...header,
-      sections: sections.slice(0, getActiveSectionCount(header)).map((section) => ({
-        splatCount: section.splatCount,
-        maxSplatCount: section.maxSplatCount,
-        sphericalHarmonicsDegree: section.sphericalHarmonicsDegree
-      }))
+}
+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();
+  }
 }
-function decodeKSPLATSplat(data, header, section, localSplatIndex, outputSplatIndex, positions, scales, rotations, colors, opacities, sphericalHarmonics, sphericalHarmonicsComponentCount) {
-  const layout = COMPRESSION_LAYOUTS[header.compressionLevel];
-  const splatBase = section.dataBase + section.bytesPerSplat * localSplatIndex;
-  const positionOffset = outputSplatIndex * 3;
-  const rotationOffset = outputSplatIndex * 4;
-  const bucketCenter = getBucketCenter(data, section, localSplatIndex);
-  positions[positionOffset + 0] = decodeKSPLATCenterComponent(data, splatBase, 0, header, section, bucketCenter[0]);
-  positions[positionOffset + 1] = decodeKSPLATCenterComponent(data, splatBase, 1, header, section, bucketCenter[1]);
-  positions[positionOffset + 2] = decodeKSPLATCenterComponent(data, splatBase, 2, header, section, bucketCenter[2]);
-  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));
-  rotations[rotationOffset + 0] = w;
-  rotations[rotationOffset + 1] = x;
-  rotations[rotationOffset + 2] = y;
-  rotations[rotationOffset + 3] = z;
-  const colorBase = splatBase + layout.colorOffsetBytes;
-  const colorView = new Uint8Array(data, colorBase, 4);
-  colors[positionOffset + 0] = colorView[0];
-  colors[positionOffset + 1] = colorView[1];
-  colors[positionOffset + 2] = colorView[2];
-  opacities[outputSplatIndex] = convertAlphaByteToLinearOpacity(colorView[3]);
-  if (sphericalHarmonics && sphericalHarmonicsComponentCount) {
-    decodeSphericalHarmonics(data, splatBase + layout.sphericalHarmonicsOffsetBytes, header, section, outputSplatIndex, sphericalHarmonics, sphericalHarmonicsComponentCount);
+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;
   }
 }
-function parseKSPLATHeader(data) {
-  const dataView = new DataView(data, 0, HEADER_BYTE_LENGTH);
-  const compressionLevel = dataView.getUint16(20, true);
-  if (compressionLevel !== 0 && compressionLevel !== 1 && compressionLevel !== 2) {
-    throw new Error(`KSPLATLoader: unsupported compression level ${compressionLevel}.`);
+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;
   }
-  return {
-    versionMajor: dataView.getUint8(0),
-    versionMinor: dataView.getUint8(1),
-    maxSectionCount: dataView.getUint32(4, true),
-    sectionCount: dataView.getUint32(8, true),
-    maxSplatCount: dataView.getUint32(12, true),
-    splatCount: dataView.getUint32(16, true),
-    compressionLevel,
-    minSphericalHarmonicsCoeff: dataView.getFloat32(36, true) || -DEFAULT_SH_8BIT_COMPRESSION_HALF_RANGE,
-    maxSphericalHarmonicsCoeff: dataView.getFloat32(40, true) || DEFAULT_SH_8BIT_COMPRESSION_HALF_RANGE
-  };
+  const result = new Uint8Array(byteLength);
+  let offset = 0;
+  for (const batch of output) {
+    result.set(batch, offset);
+    offset += batch.byteLength;
+  }
+  return result.buffer;
 }
-function checkKSPLATVersion(header) {
-  if (header.versionMajor === CURRENT_MAJOR_VERSION ? header.versionMinor >= CURRENT_MINOR_VERSION : header.versionMajor > CURRENT_MAJOR_VERSION) {
-    return;
+var init_compression_stream = __esm({
+  "../compression/src/lib/compression-stream.ts"() {
+    "use strict";
   }
-  throw new Error(`KSPLATLoader: version ${header.versionMajor}.${header.versionMinor} is not supported.`);
+});
+
+// ../compression/src/lib/decompression-stream.ts
+async function decompressWithNativeDecompressionStream(input, format) {
+  const outputBatches = decompressBatchesWithNativeDecompressionStream([input], format);
+  return outputBatches ? await concatenateNativeDecompressionBatches(outputBatches) : null;
 }
-function parseKSPLATSections(data, header) {
-  if (data.byteLength < HEADER_BYTE_LENGTH + header.maxSectionCount * SECTION_HEADER_BYTE_LENGTH) {
-    throw new Error("KSPLATLoader: file does not contain all section headers.");
+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;
   }
-  const sections = [];
-  let sectionBase = HEADER_BYTE_LENGTH + header.maxSectionCount * SECTION_HEADER_BYTE_LENGTH;
-  let splatCountOffset = 0;
-  for (let sectionIndex = 0; sectionIndex < header.maxSectionCount; sectionIndex++) {
-    const sectionHeaderBase = HEADER_BYTE_LENGTH + sectionIndex * SECTION_HEADER_BYTE_LENGTH;
-    const dataView = new DataView(data, sectionHeaderBase, SECTION_HEADER_BYTE_LENGTH);
-    const splatCount = dataView.getUint32(0, true);
-    const maxSplatCount = dataView.getUint32(4, true);
-    const bucketSize = dataView.getUint32(8, true);
-    const bucketCount = dataView.getUint32(12, true);
-    const bucketBlockSize = dataView.getFloat32(16, true);
-    const bucketStorageSizeBytes = dataView.getUint16(20, true);
-    const compressionScaleRange = dataView.getUint32(24, true) || COMPRESSION_LAYOUTS[header.compressionLevel].scaleRange;
-    const fullBucketCount = dataView.getUint32(32, true);
-    const partiallyFilledBucketCount = dataView.getUint32(36, true);
-    const sphericalHarmonicsDegree = dataView.getUint16(40, true);
-    const bytesPerSplat = getBytesPerSplat(header.compressionLevel, sphericalHarmonicsDegree);
-    const bucketsMetaDataSizeBytes = partiallyFilledBucketCount * 4;
-    const bucketsStorageSizeBytes = bucketStorageSizeBytes * bucketCount + bucketsMetaDataSizeBytes;
-    const storageSizeBytes = bytesPerSplat * maxSplatCount + bucketsStorageSizeBytes;
-    sections.push({
-      bytesPerSplat,
-      splatCountOffset,
-      splatCount: splatCount || maxSplatCount,
-      maxSplatCount,
-      bucketSize,
-      bucketCount,
-      bucketStorageSizeBytes,
-      bucketsStorageSizeBytes,
-      compressionScaleRange,
-      compressionScaleFactor: bucketBlockSize / 2 / compressionScaleRange,
-      base: sectionBase,
-      bucketsBase: sectionBase + bucketsMetaDataSizeBytes,
-      dataBase: sectionBase + bucketsStorageSizeBytes,
-      fullBucketCount,
-      partiallyFilledBucketCount,
-      sphericalHarmonicsDegree
+  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(() => {
     });
-    sectionBase += storageSizeBytes;
-    splatCountOffset += maxSplatCount;
+    throw error;
   }
-  return sections;
 }
-function decodeKSPLATCenterComponent(data, splatBase, component, header, section, bucketCenter) {
-  const value = readCompressedCenterValue(data, splatBase, component, header.compressionLevel);
-  return header.compressionLevel >= 1 ? (value - section.compressionScaleRange) * section.compressionScaleFactor + bucketCenter : value;
+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/lib/fflate/index.ts
+function inflateSync(data, out) {
+  return inflt(data, out);
+}
+function gunzipSync(data, out) {
+  return inflt(data.subarray(gzs(data), -8), out || new u8(gzl(data)));
+}
+function unzlibSync(data, out) {
+  return inflt((zlv(data), data.subarray(2, -4)), out);
+}
+var u8, u16, u32, fleb, fdeb, clim, freb, fl, revfl, fd, revfd, rev, hMap, flt, fdt, flrm, fdrm, max, bits, bits16, shft, slc, ec, err, inflt, gzs, gzl, zlv, Inflate, Gunzip, Unzlib;
+var init_fflate = __esm({
+  "../compression/src/lib/fflate/index.ts"() {
+    "use strict";
+    u8 = Uint8Array;
+    u16 = Uint16Array;
+    u32 = Uint32Array;
+    fleb = new u8([
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      1,
+      1,
+      1,
+      1,
+      2,
+      2,
+      2,
+      2,
+      3,
+      3,
+      3,
+      3,
+      4,
+      4,
+      4,
+      4,
+      5,
+      5,
+      5,
+      5,
+      0,
+      /* unused */
+      0,
+      0,
+      /* impossible */
+      0
+    ]);
+    fdeb = new u8([
+      0,
+      0,
+      0,
+      0,
+      1,
+      1,
+      2,
+      2,
+      3,
+      3,
+      4,
+      4,
+      5,
+      5,
+      6,
+      6,
+      7,
+      7,
+      8,
+      8,
+      9,
+      9,
+      10,
+      10,
+      11,
+      11,
+      12,
+      12,
+      13,
+      13,
+      /* unused */
+      0,
+      0
+    ]);
+    clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
+    freb = (eb, start) => {
+      const b = new u16(31);
+      for (let i = 0; i < 31; ++i) {
+        b[i] = start += 1 << eb[i - 1];
+      }
+      const r = new u32(b[30]);
+      for (let i = 1; i < 30; ++i) {
+        for (let j = b[i]; j < b[i + 1]; ++j) {
+          r[j] = j - b[i] << 5 | i;
+        }
+      }
+      return [b, r];
+    };
+    [fl, revfl] = freb(fleb, 2);
+    fl[28] = 258, revfl[258] = 28;
+    [fd, revfd] = freb(fdeb, 0);
+    rev = new u16(32768);
+    for (let i = 0; i < 32768; ++i) {
+      let x = (i & 43690) >>> 1 | (i & 21845) << 1;
+      x = (x & 52428) >>> 2 | (x & 13107) << 2;
+      x = (x & 61680) >>> 4 | (x & 3855) << 4;
+      rev[i] = ((x & 65280) >>> 8 | (x & 255) << 8) >>> 1;
+    }
+    hMap = (cd, mb, r) => {
+      const s = cd.length;
+      let i = 0;
+      const l = new u16(mb);
+      for (; i < s; ++i) {
+        if (cd[i]) ++l[cd[i] - 1];
+      }
+      const le = new u16(mb);
+      for (i = 0; i < mb; ++i) {
+        le[i] = le[i - 1] + l[i - 1] << 1;
+      }
+      let co;
+      if (r) {
+        co = new u16(1 << mb);
+        const rvb = 15 - mb;
+        for (i = 0; i < s; ++i) {
+          if (cd[i]) {
+            const sv = i << 4 | cd[i];
+            const r2 = mb - cd[i];
+            let v = le[cd[i] - 1]++ << r2;
+            for (const m = v | (1 << r2) - 1; v <= m; ++v) {
+              co[rev[v] >>> rvb] = sv;
+            }
+          }
+        }
+      } else {
+        co = new u16(s);
+        for (i = 0; i < s; ++i) {
+          if (cd[i]) {
+            co[i] = rev[le[cd[i] - 1]++] >>> 15 - cd[i];
+          }
+        }
+      }
+      return co;
+    };
+    flt = new u8(288);
+    for (let i = 0; i < 144; ++i) flt[i] = 8;
+    for (let i = 144; i < 256; ++i) flt[i] = 9;
+    for (let i = 256; i < 280; ++i) flt[i] = 7;
+    for (let i = 280; i < 288; ++i) flt[i] = 8;
+    fdt = new u8(32);
+    for (let i = 0; i < 32; ++i) fdt[i] = 5;
+    flrm = /* @__PURE__ */ hMap(flt, 9, 1);
+    fdrm = /* @__PURE__ */ hMap(fdt, 5, 1);
+    max = (a) => {
+      let m = a[0];
+      for (let i = 1; i < a.length; ++i) {
+        if (a[i] > m) m = a[i];
+      }
+      return m;
+    };
+    bits = (d, p, m) => {
+      const o = p / 8 | 0;
+      return (d[o] | d[o + 1] << 8) >> (p & 7) & m;
+    };
+    bits16 = (d, p) => {
+      const o = p / 8 | 0;
+      return (d[o] | d[o + 1] << 8 | d[o + 2] << 16) >> (p & 7);
+    };
+    shft = (p) => (p + 7) / 8 | 0;
+    slc = (v, s, e) => {
+      if (s == null || s < 0) s = 0;
+      if (e == null || e > v.length) e = v.length;
+      const n = new (v.BYTES_PER_ELEMENT == 2 ? u16 : v.BYTES_PER_ELEMENT == 4 ? u32 : u8)(e - s);
+      n.set(v.subarray(s, e));
+      return n;
+    };
+    ec = [
+      "unexpected EOF",
+      "invalid block type",
+      "invalid length/literal",
+      "invalid distance",
+      "stream finished",
+      "no stream handler",
+      ,
+      // determined by compression function
+      "no callback",
+      "invalid UTF-8 data",
+      "extra field too long",
+      "date not in range 1980-2099",
+      "filename too long",
+      "stream finishing",
+      "invalid zip data"
+      // determined by unknown compression method
+    ];
+    err = (ind, msg, nt) => {
+      const e = new Error(msg || ec[ind]);
+      e.code = ind;
+      if (Error.captureStackTrace) Error.captureStackTrace(e, err);
+      if (!nt) throw e;
+      return e;
+    };
+    inflt = (dat, buf, st) => {
+      const sl = dat.length;
+      if (!sl || st && st.f && !st.l) return buf || new u8(0);
+      const noBuf = !buf || st;
+      const noSt = !st || st.i;
+      if (!st) st = {};
+      if (!buf) buf = new u8(sl * 3);
+      const cbuf = (l) => {
+        let bl = buf.length;
+        if (l > bl) {
+          const nbuf = new u8(Math.max(bl * 2, l));
+          nbuf.set(buf);
+          buf = nbuf;
+        }
+      };
+      let final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;
+      const tbts = sl * 8;
+      do {
+        if (!lm) {
+          final = bits(dat, pos, 1);
+          const type = bits(dat, pos + 1, 3);
+          pos += 3;
+          if (!type) {
+            const s = shft(pos) + 4, l = dat[s - 4] | dat[s - 3] << 8, t = s + l;
+            if (t > sl) {
+              if (noSt) err(0);
+              break;
+            }
+            if (noBuf) cbuf(bt + l);
+            buf.set(dat.subarray(s, t), bt);
+            st.b = bt += l, st.p = pos = t * 8, st.f = final;
+            continue;
+          } else if (type == 1) lm = flrm, dm = fdrm, lbt = 9, dbt = 5;
+          else if (type == 2) {
+            const hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
+            const tl = hLit + bits(dat, pos + 5, 31) + 1;
+            pos += 14;
+            const ldt = new u8(tl);
+            const clt = new u8(19);
+            for (let i = 0; i < hcLen; ++i) {
+              clt[clim[i]] = bits(dat, pos + i * 3, 7);
+            }
+            pos += hcLen * 3;
+            const clb = max(clt), clbmsk = (1 << clb) - 1;
+            const clm = hMap(clt, clb, 1);
+            for (let i = 0; i < tl; ) {
+              const r = clm[bits(dat, pos, clbmsk)];
+              pos += r & 15;
+              const s = r >>> 4;
+              if (s < 16) {
+                ldt[i++] = s;
+              } else {
+                let c = 0, n = 0;
+                if (s == 16) n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i - 1];
+                else if (s == 17) n = 3 + bits(dat, pos, 7), pos += 3;
+                else if (s == 18) n = 11 + bits(dat, pos, 127), pos += 7;
+                while (n--) ldt[i++] = c;
+              }
+            }
+            const lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
+            lbt = max(lt);
+            dbt = max(dt);
+            lm = hMap(lt, lbt, 1);
+            dm = hMap(dt, dbt, 1);
+          } else err(1);
+          if (pos > tbts) {
+            if (noSt) err(0);
+            break;
+          }
+        }
+        if (noBuf) cbuf(bt + 131072);
+        const lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
+        let lpos = pos;
+        for (; ; lpos = pos) {
+          const c = lm[bits16(dat, pos) & lms], sym = c >>> 4;
+          pos += c & 15;
+          if (pos > tbts) {
+            if (noSt) err(0);
+            break;
+          }
+          if (!c) err(2);
+          if (sym < 256) buf[bt++] = sym;
+          else if (sym == 256) {
+            lpos = pos, lm = void 0;
+            break;
+          } else {
+            let add = sym - 254;
+            if (sym > 264) {
+              const i = sym - 257, b = fleb[i];
+              add = bits(dat, pos, (1 << b) - 1) + fl[i];
+              pos += b;
+            }
+            const d = dm[bits16(dat, pos) & dms], dsym = d >>> 4;
+            if (!d) err(3);
+            pos += d & 15;
+            let dt = fd[dsym];
+            if (dsym > 3) {
+              const b = fdeb[dsym];
+              dt += bits16(dat, pos) & (1 << b) - 1, pos += b;
+            }
+            if (pos > tbts) {
+              if (noSt) err(0);
+              break;
+            }
+            if (noBuf) cbuf(bt + 131072);
+            const end = bt + add;
+            for (; bt < end; bt += 4) {
+              buf[bt] = buf[bt - dt];
+              buf[bt + 1] = buf[bt + 1 - dt];
+              buf[bt + 2] = buf[bt + 2 - dt];
+              buf[bt + 3] = buf[bt + 3 - dt];
+            }
+            bt = end;
+          }
+        }
+        st.l = lm, st.p = lpos, st.b = bt, st.f = final;
+        if (lm) final = 1, st.m = lbt, st.d = dm, st.n = dbt;
+      } while (!final);
+      return bt == buf.length ? buf : slc(buf, 0, bt);
+    };
+    gzs = (d) => {
+      if (d[0] != 31 || d[1] != 139 || d[2] != 8) err(6, "invalid gzip data");
+      const flg = d[3];
+      let st = 10;
+      if (flg & 4) st += d[10] | (d[11] << 8) + 2;
+      for (let zs = (flg >> 3 & 1) + (flg >> 4 & 1); zs > 0; zs -= !d[st++]) ;
+      return st + (flg & 2);
+    };
+    gzl = (d) => {
+      const l = d.length;
+      return (d[l - 4] | d[l - 3] << 8 | d[l - 2] << 16 | d[l - 1] << 24) >>> 0;
+    };
+    zlv = (d) => {
+      if ((d[0] & 15) != 8 || d[0] >>> 4 > 7 || (d[0] << 8 | d[1]) % 31) err(6, "invalid zlib data");
+      if (d[1] & 32) err(6, "invalid zlib data: preset dictionaries not supported");
+    };
+    Inflate = class {
+      /**
+       * Creates an inflation stream
+       * @param cb The callback to call whenever data is inflated
+       */
+      constructor(cb) {
+        this.ondata = cb;
+      }
+      /** Persistent bit-reader and Huffman decoding state. */
+      s = {};
+      /** Compression options or retained output window for this stream. */
+      o;
+      /** Compressed bytes pending decoding. */
+      p = new u8(0);
+      /** Whether the stream has received its final chunk. */
+      d;
+      /**
+       * The handler to call whenever data is available
+       */
+      ondata;
+      /** Appends pending input after checking stream lifecycle. */
+      e(c) {
+        if (!this.ondata) err(5);
+        if (this.d) err(4);
+        const l = this.p.length;
+        const n = new u8(l + c.length);
+        n.set(this.p), n.set(c, l), this.p = n;
+      }
+      /** Decodes pending input and retains the sliding window. */
+      c(final) {
+        this.d = this.s.i = final || false;
+        const bts = this.s.b;
+        const dt = inflt(this.p, this.o, this.s);
+        this.ondata(slc(dt, bts, this.s.b), this.d);
+        this.o = slc(dt, this.s.b - 32768), this.s.b = this.o.length;
+        this.p = slc(this.p, this.s.p / 8 | 0), this.s.p &= 7;
+      }
+      /**
+       * Pushes a chunk to be inflated
+       * @param chunk The chunk to push
+       * @param final Whether this is the final chunk
+       */
+      push(chunk, final) {
+        this.e(chunk), this.c(final);
+      }
+    };
+    Gunzip = class extends Inflate {
+      /** Whether the stream header still needs to be emitted or consumed. */
+      v = 1;
+      /**
+       * Creates a GUNZIP stream
+       * @param cb The callback to call whenever data is inflated
+       */
+      constructor(cb) {
+        super(cb);
+      }
+      /**
+       * Pushes a chunk to be GUNZIPped
+       * @param chunk The chunk to push
+       * @param final Whether this is the last chunk
+       */
+      push(chunk, final) {
+        Inflate.prototype.e.call(this, chunk);
+        if (this.v) {
+          const s = this.p.length > 3 ? gzs(this.p) : 4;
+          if (s >= this.p.length && !final) return;
+          this.p = this.p.subarray(s), this.v = 0;
+        }
+        if (final) {
+          if (this.p.length < 8) err(6, "invalid gzip data");
+          this.p = this.p.subarray(0, -8);
+        }
+        Inflate.prototype.c.call(this, final);
+      }
+    };
+    Unzlib = class extends Inflate {
+      /** Whether the stream header still needs to be emitted or consumed. */
+      v = 1;
+      /**
+       * Creates a Zlib decompression stream
+       * @param cb The callback to call whenever data is inflated
+       */
+      constructor(cb) {
+        super(cb);
+      }
+      /**
+       * Pushes a chunk to be unzlibbed
+       * @param chunk The chunk to push
+       * @param final Whether this is the last chunk
+       */
+      push(chunk, final) {
+        Inflate.prototype.e.call(this, chunk);
+        if (this.v) {
+          if (this.p.length < 2 && !final) return;
+          this.p = this.p.subarray(2), this.v = 0;
+        }
+        if (final) {
+          if (this.p.length < 4) err(6, "invalid zlib data");
+          this.p = this.p.subarray(0, -4);
+        }
+        Inflate.prototype.c.call(this, final);
+      }
+    };
+  }
+});
+
+// ../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/gzip-decompressor-fflate.ts
+var GZipFflateDecompressor;
+var init_gzip_decompressor_fflate = __esm({
+  "../compression/src/gzip-decompressor-fflate.ts"() {
+    "use strict";
+    init_fflate();
+    init_compression();
+    init_fflate_stream();
+    GZipFflateDecompressor = class extends Decompressor {
+      name = "gzip";
+      extensions = ["gz", "gzip"];
+      contentEncodings = ["gzip", "x-gzip"];
+      isSupported = true;
+      constructor(options = {}) {
+        super(options);
+      }
+      /** Decompresses one GZIP payload synchronously. */
+      decompressSync(input) {
+        return gunzipSync(new Uint8Array(input)).slice().buffer;
+      }
+      /** Decompresses GZIP batches incrementally. */
+      async *decompressBatches(inputBatches) {
+        yield* transformFflateBatches(new Gunzip(), inputBatches);
+      }
+    };
+  }
+});
+
+// ../compression/src/gzip-decompressor.ts
+var gzip_decompressor_exports = {};
+__export(gzip_decompressor_exports, {
+  GZipDecompressor: () => GZipDecompressor
+});
+var GZipDecompressor;
+var init_gzip_decompressor = __esm({
+  "../compression/src/gzip-decompressor.ts"() {
+    "use strict";
+    init_gzip_decompressor_fflate();
+    init_decompression_stream();
+    GZipDecompressor = class extends GZipFflateDecompressor {
+      options;
+      constructor(options = {}) {
+        super(options);
+        this.options = options;
+      }
+      /** Decompresses with the built-in stream when available, then falls back to fflate. */
+      async decompress(input) {
+        if (this.options.useNative !== false) {
+          const output = await decompressWithNativeDecompressionStream(input, "gzip");
+          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 output = decompressBatchesWithNativeDecompressionStream(inputBatches, "gzip");
+          if (output) {
+            yield* output;
+            return;
+          }
+        }
+        yield* super.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 GZIP, ZSTD, GZipDecompressor2, ZstdDecompressor2;
+var init_default_codecs = __esm({
+  "../compression/src/default-codecs.ts"() {
+    "use strict";
+    init_lazy_compression();
+    init_src();
+    GZIP = { name: "gzip", extensions: ["gz"], contentEncodings: ["gzip"] };
+    ZSTD = { name: "zstd", extensions: ["zst"], contentEncodings: ["zstd"] };
+    GZipDecompressor2 = class extends LazyDecompressor {
+      constructor(options = {}) {
+        super(
+          GZIP,
+          async () => (await Promise.resolve().then(() => (init_gzip_decompressor(), gzip_decompressor_exports))).GZipDecompressor,
+          options,
+          "gzip"
+        );
+      }
+    };
+    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/splat-utils.js
+function convertColorByteToSphericalHarmonicDc(colorByte) {
+  return (colorByte / 255 - 0.5) / SH_C0;
+}
+function convertAlphaByteToLinearOpacity(alphaByte) {
+  return Math.min(Math.max(alphaByte / 255, 0), 1);
+}
+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, z2 / length];
+}
+function decodeQuaternionByte(byte) {
+  return (byte - 128) / 128;
+}
+function decodeFloat16(value) {
+  const sign = value & 32768 ? -1 : 1;
+  const exponent = value >> 10 & 31;
+  const fraction = value & 1023;
+  if (exponent === 0) {
+    return sign * Math.pow(2, -14) * (fraction / 1024);
+  }
+  if (exponent === 31) {
+    return fraction ? Number.NaN : sign * Number.POSITIVE_INFINITY;
+  }
+  return sign * Math.pow(2, exponent - 15) * (1 + fraction / 1024);
+}
+var SH_C0;
+var init_splat_utils = __esm({
+  "dist/lib/splat-utils.js"() {
+    "use strict";
+    SH_C0 = 0.28209479177387814;
+  }
+});
+
+// dist/lib/splats-arrow-table.js
+function makeGaussianSplatsArrowTable(splats) {
+  const columns = {};
+  const fields = [];
+  const schemaFields = [];
+  addColumn(columns, fields, schemaFields, "POSITION", makeFixedSizeListVector(splats.positions, 3), {
+    type: "fixed-size-list",
+    listSize: 3,
+    children: [{ name: "value", type: "float32" }]
+  });
+  const colorCoefficients = getColorCoefficients(splats);
+  addScalarColumn(columns, fields, schemaFields, "f_dc_0", colorCoefficients[0], {
+    "loaders_gl.gaussian_splats.semantic": "spherical_harmonic_dc",
+    "loaders_gl.gaussian_splats.component": "0",
+    "loaders_gl.gaussian_splats.encoding": "coefficient"
+  });
+  addScalarColumn(columns, fields, schemaFields, "f_dc_1", colorCoefficients[1], {
+    "loaders_gl.gaussian_splats.semantic": "spherical_harmonic_dc",
+    "loaders_gl.gaussian_splats.component": "1",
+    "loaders_gl.gaussian_splats.encoding": "coefficient"
+  });
+  addScalarColumn(columns, fields, schemaFields, "f_dc_2", colorCoefficients[2], {
+    "loaders_gl.gaussian_splats.semantic": "spherical_harmonic_dc",
+    "loaders_gl.gaussian_splats.component": "2",
+    "loaders_gl.gaussian_splats.encoding": "coefficient"
+  });
+  addScalarColumn(columns, fields, schemaFields, "opacity", splats.opacities, {
+    "loaders_gl.gaussian_splats.semantic": "opacity",
+    "loaders_gl.gaussian_splats.encoding": "linear"
+  });
+  addVectorComponents(columns, fields, schemaFields, "scale", splats.scales, 3, {
+    "loaders_gl.gaussian_splats.semantic": "scale",
+    "loaders_gl.gaussian_splats.encoding": "linear"
+  });
+  addVectorComponents(columns, fields, schemaFields, "rot", splats.rotations, 4, {
+    "loaders_gl.gaussian_splats.semantic": "rotation",
+    "loaders_gl.gaussian_splats.encoding": "quaternion"
+  });
+  if (splats.sphericalHarmonics && splats.sphericalHarmonicsComponentCount) {
+    addSphericalHarmonicRestColumns(columns, fields, schemaFields, splats.sphericalHarmonics, splats.sphericalHarmonicsComponentCount);
+  }
+  const metadata = /* @__PURE__ */ new Map([
+    ["loaders_gl.semantic_type", "gaussian-splats"],
+    ["loaders_gl.gaussian_splats.version", "1"],
+    ["loaders_gl.gaussian_splats.source_format", splats.format],
+    ["topology", "point-list"],
+    ["mode", "0"]
+  ]);
+  const arrowSchema = new arrow.Schema(fields, metadata);
+  const schema = {
+    fields: schemaFields,
+    metadata: Object.fromEntries(metadata)
+  };
+  return {
+    shape: "arrow-table",
+    schema,
+    data: new arrow.Table(arrowSchema, columns),
+    topology: "point-list",
+    loaderData: splats.loaderData
+  };
+}
+function addVectorComponents(columns, fields, schemaFields, prefix, values, size, metadata) {
+  for (let component = 0; component < size; component++) {
+    const componentValues = new Float32Array(values.length / size);
+    for (let rowIndex = 0; rowIndex < componentValues.length; rowIndex++) {
+      componentValues[rowIndex] = values[rowIndex * size + component];
+    }
+    addScalarColumn(columns, fields, schemaFields, `${prefix}_${component}`, componentValues, {
+      ...metadata,
+      "loaders_gl.gaussian_splats.component": String(component)
+    });
+  }
+}
+function addSphericalHarmonicRestColumns(columns, fields, schemaFields, sphericalHarmonics, componentCount) {
+  for (let component = 0; component < componentCount; component++) {
+    const componentValues = new Float32Array(sphericalHarmonics.length / componentCount);
+    for (let rowIndex = 0; rowIndex < componentValues.length; rowIndex++) {
+      componentValues[rowIndex] = sphericalHarmonics[rowIndex * componentCount + component];
+    }
+    addScalarColumn(columns, fields, schemaFields, `f_rest_${component}`, componentValues, {
+      "loaders_gl.gaussian_splats.semantic": "spherical_harmonic_rest",
+      "loaders_gl.gaussian_splats.component": String(component),
+      "loaders_gl.gaussian_splats.encoding": "coefficient"
+    });
+  }
+}
+function addScalarColumn(columns, fields, schemaFields, name, values, metadata) {
+  addColumn(columns, fields, schemaFields, name, arrow.makeVector(values), "float32", metadata);
+}
+function addColumn(columns, fields, schemaFields, name, column, schemaType, metadata = {}) {
+  columns[name] = column;
+  fields.push(new arrow.Field(name, column.type, false, new Map(Object.entries(metadata))));
+  schemaFields.push({ name, type: schemaType, nullable: false, metadata });
+}
+function makeFixedSizeListVector(value, size) {
+  const values = arrow.makeVector(value);
+  const child = values.data[0];
+  const type = new arrow.FixedSizeList(size, new arrow.Field("value", child.type, false));
+  const data = new arrow.Data(type, 0, value.length / size, 0, {}, [child]);
+  return new arrow.Vector([data]);
+}
+function getColorCoefficients(splats) {
+  const rowCount = splats.splatCount;
+  const fdc0 = new Float32Array(rowCount);
+  const fdc1 = new Float32Array(rowCount);
+  const fdc2 = new Float32Array(rowCount);
+  for (let rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+    if (splats.sphericalHarmonicDcs) {
+      fdc0[rowIndex] = splats.sphericalHarmonicDcs[rowIndex * 3 + 0];
+      fdc1[rowIndex] = splats.sphericalHarmonicDcs[rowIndex * 3 + 1];
+      fdc2[rowIndex] = splats.sphericalHarmonicDcs[rowIndex * 3 + 2];
+    } else {
+      fdc0[rowIndex] = convertColorByteToSphericalHarmonicDc(splats.colors[rowIndex * 3 + 0]);
+      fdc1[rowIndex] = convertColorByteToSphericalHarmonicDc(splats.colors[rowIndex * 3 + 1]);
+      fdc2[rowIndex] = convertColorByteToSphericalHarmonicDc(splats.colors[rowIndex * 3 + 2]);
+    }
+  }
+  return [fdc0, fdc1, fdc2];
+}
+var arrow;
+var init_splats_arrow_table = __esm({
+  "dist/lib/splats-arrow-table.js"() {
+    "use strict";
+    arrow = __toESM(require("apache-arrow"), 1);
+    init_splat_utils();
+  }
+});
+
+// dist/lib/parse-spz.js
+async function parseSPZ(data, options) {
+  return makeGaussianSplatsArrowTable(await parseSPZToGaussianSplats(data, options));
+}
+async function parseSPZToGaussianSplats(data, options) {
+  var _a, _b, _c;
+  const version2 = detectSPZVersion(data);
+  if (version2 === 0) {
+    return await parseLegacySPZ(data, options);
+  }
+  if (version2 !== SPZ_VERSION) {
+    throw new Error(`SPZLoader: version ${version2} is not supported.`);
+  }
+  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 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 applySPZCoordinateSystem(decodeSPZStreams(header, streams, data), ((_a = options == null ? void 0 : options.splats) == null ? void 0 : _a.sourceCoordinateSystem) ?? "RUB", ((_b = options == null ? void 0 : options.splats) == null ? void 0 : _b.targetCoordinateSystem) ?? ((_c = options == null ? void 0 : options.splats) == null ? void 0 : _c.sourceCoordinateSystem) ?? "RUB");
+}
+function detectSPZVersion(data) {
+  if (data.byteLength < 8) {
+    throw new Error("SPZLoader: file must contain at least an 8-byte header.");
+  }
+  const bytes = new Uint8Array(data);
+  if (bytes[0] === 31 && bytes[1] === 139) {
+    return 0;
+  }
+  if (data.byteLength < SPZ_HEADER_BYTE_LENGTH) {
+    throw new Error("SPZLoader: file must contain a 32-byte header.");
+  }
+  return new DataView(data).getUint32(4, true);
+}
+async function parseLegacySPZ(data, options) {
+  var _a, _b, _c;
+  const decompressed = await new GZipDecompressor2({
+    modules: options == null ? void 0 : options.modules,
+    useNative: true
+  }).decompress(data);
+  if (decompressed.byteLength < 16) {
+    throw new Error("SPZLoader: legacy payload must contain a 16-byte header.");
+  }
+  const dataView = new DataView(decompressed);
+  const header = {
+    magic: dataView.getUint32(0, true),
+    version: dataView.getUint32(4, true),
+    numPoints: dataView.getUint32(8, true),
+    shDegree: dataView.getUint8(12),
+    fractionalBits: dataView.getUint8(13),
+    flags: dataView.getUint8(14)
+  };
+  if (header.magic !== SPZ_MAGIC) {
+    throw new Error("SPZLoader: NGSP magic header not found.");
+  }
+  if (header.version !== 2 && header.version !== 3) {
+    throw new Error(`SPZLoader: version ${header.version} is not supported.`);
+  }
+  if (dataView.getUint8(15) !== 0) {
+    throw new Error("SPZLoader: legacy header reserved byte must be zero.");
+  }
+  if (header.shDegree > 3) {
+    throw new Error(`SPZLoader: spherical harmonics degree ${header.shDegree} is not supported.`);
+  }
+  const count = header.numPoints;
+  const shComponentCount = getSphericalHarmonicsComponentCount(header.shDegree);
+  const positionByteLength = count * 9;
+  const alphaByteLength = count;
+  const colorByteLength = count * 3;
+  const scaleByteLength = count * 3;
+  const rotationByteLength = count * (header.version === 2 ? 3 : 4);
+  const shByteLength = count * shComponentCount;
+  const payloadByteLength = positionByteLength + alphaByteLength + colorByteLength + scaleByteLength + rotationByteLength + shByteLength;
+  if (decompressed.byteLength - 16 !== payloadByteLength) {
+    throw new Error(`SPZLoader: legacy payload has ${decompressed.byteLength - 16} bytes, expected ${payloadByteLength}.`);
+  }
+  let offset = 16;
+  const positions = new Float32Array(count * 3);
+  const opacities = new Float32Array(count);
+  const colors = new Uint8Array(count * 3);
+  const scales = new Float32Array(count * 3);
+  const rotations = new Float32Array(count * 4);
+  const sphericalHarmonicDcs = new Float32Array(count * 3);
+  const sphericalHarmonics = shComponentCount ? new Float32Array(count * shComponentCount) : void 0;
+  decodeSPZPositions(new Uint8Array(decompressed, offset, positionByteLength), positions, header.fractionalBits);
+  offset += positionByteLength;
+  decodeSPZOpacities(new Uint8Array(decompressed, offset, alphaByteLength), opacities);
+  offset += alphaByteLength;
+  decodeSPZColors(new Uint8Array(decompressed, offset, colorByteLength), colors, sphericalHarmonicDcs);
+  offset += colorByteLength;
+  decodeSPZScales(new Uint8Array(decompressed, offset, scaleByteLength), scales);
+  offset += scaleByteLength;
+  if (header.version === 2) {
+    decodeLegacySPZRotations(new Uint8Array(decompressed, offset, rotationByteLength), rotations);
+  } else {
+    decodeSPZRotations(new Uint8Array(decompressed, offset, rotationByteLength), rotations);
+  }
+  offset += rotationByteLength;
+  if (sphericalHarmonics) {
+    decodeSPZSphericalHarmonics(new Uint8Array(decompressed, offset, shByteLength), sphericalHarmonics);
+  }
+  return applySPZCoordinateSystem({
+    format: "spz",
+    splatCount: count,
+    positions,
+    scales,
+    rotations,
+    colors,
+    sphericalHarmonicDcs,
+    opacities,
+    sphericalHarmonics,
+    sphericalHarmonicsComponentCount: shComponentCount || void 0,
+    loaderData: { ...header, legacy: true }
+  }, ((_a = options == null ? void 0 : options.splats) == null ? void 0 : _a.sourceCoordinateSystem) ?? "RUB", ((_b = options == null ? void 0 : options.splats) == null ? void 0 : _b.targetCoordinateSystem) ?? ((_c = options == null ? void 0 : options.splats) == null ? void 0 : _c.sourceCoordinateSystem) ?? "RUB");
+}
+function decodeLegacySPZRotations(rotationStream, rotations) {
+  for (let splatIndex = 0; splatIndex < rotations.length / 4; splatIndex++) {
+    const byteOffset = splatIndex * 3;
+    const x = signedByte(rotationStream[byteOffset]) / 127;
+    const y = signedByte(rotationStream[byteOffset + 1]) / 127;
+    const z2 = signedByte(rotationStream[byteOffset + 2]) / 127;
+    const w = Math.sqrt(Math.max(0, 1 - x * x - y * y - z2 * z2));
+    const normalized = normalizeQuaternion(w, x, y, z2);
+    rotations.set(normalized, splatIndex * 4);
+  }
+}
+function signedByte(value) {
+  return value > 127 ? value - 256 : value;
+}
+function applySPZCoordinateSystem(splats, source, target) {
+  if (source === target || source === "UNSPECIFIED" || target === "UNSPECIFIED") {
+    return splats;
+  }
+  if (source === "RUB" && target === "LUF") {
+    for (let index = 0; index < splats.positions.length; index += 3) {
+      splats.positions[index] = -splats.positions[index];
+      splats.positions[index + 2] = -splats.positions[index + 2];
+    }
+    for (let index = 0; index < splats.rotations.length; index += 4) {
+      splats.rotations[index + 1] = -splats.rotations[index + 1];
+      splats.rotations[index + 3] = -splats.rotations[index + 3];
+    }
+    return splats;
+  }
+  if (source === "LUF" && target === "RUB") {
+    return applySPZCoordinateSystem(splats, "RUB", "LUF");
+  }
+  throw new Error(`SPZLoader: coordinate conversion ${source} -> ${target} is not supported.`);
+}
+function parseSPZHeader(data) {
+  if (data.byteLength < SPZ_HEADER_BYTE_LENGTH) {
+    throw new Error(`SPZLoader: file must contain a ${SPZ_HEADER_BYTE_LENGTH}-byte header.`);
+  }
+  const dataView = new DataView(data);
+  const header = {
+    magic: dataView.getUint32(0, true),
+    version: dataView.getUint32(4, true),
+    numPoints: dataView.getUint32(8, true),
+    shDegree: dataView.getUint8(12),
+    fractionalBits: dataView.getUint8(13),
+    flags: dataView.getUint8(14),
+    numStreams: dataView.getUint8(15),
+    tocByteOffset: dataView.getUint32(16, true)
+  };
+  if (header.magic !== SPZ_MAGIC) {
+    throw new Error("SPZLoader: NGSP magic header not found.");
+  }
+  if (header.version !== SPZ_VERSION) {
+    throw new Error(`SPZLoader: version ${header.version} is not supported.`);
+  }
+  if (header.shDegree > 4) {
+    throw new Error(`SPZLoader: spherical harmonics degree ${header.shDegree} is not supported.`);
+  }
+  if (header.tocByteOffset < SPZ_HEADER_BYTE_LENGTH || header.tocByteOffset > data.byteLength) {
+    throw new Error("SPZLoader: invalid table of contents byte offset.");
+  }
+  return header;
+}
+function parseSPZStreamInfos(data, header, expectedUncompressedSizes) {
+  if (header.numStreams !== expectedUncompressedSizes.length) {
+    throw new Error(`SPZLoader: expected ${expectedUncompressedSizes.length} streams, found ${header.numStreams}.`);
+  }
+  const tocByteLength = header.numStreams * 16;
+  const tocEnd = header.tocByteOffset + tocByteLength;
+  if (tocEnd > data.byteLength) {
+    throw new Error("SPZLoader: table of contents exceeds file byte length.");
+  }
+  const dataView = new DataView(data);
+  let compressedOffset = tocEnd;
+  const streamInfos = [];
+  for (let streamIndex = 0; streamIndex < header.numStreams; streamIndex++) {
+    const tocOffset = header.tocByteOffset + streamIndex * 16;
+    const compressedSize = readSafeUint64(dataView, tocOffset);
+    const uncompressedSize = readSafeUint64(dataView, tocOffset + 8);
+    const expectedUncompressedSize = expectedUncompressedSizes[streamIndex];
+    if (uncompressedSize !== expectedUncompressedSize) {
+      throw new Error(`SPZLoader: stream ${streamIndex} has ${uncompressedSize} uncompressed bytes, expected ${expectedUncompressedSize}.`);
+    }
+    if (compressedOffset + compressedSize > data.byteLength) {
+      throw new Error(`SPZLoader: stream ${streamIndex} exceeds file byte length.`);
+    }
+    streamInfos.push({ compressedSize, uncompressedSize, compressedOffset });
+    compressedOffset += compressedSize;
+  }
+  if (compressedOffset !== data.byteLength) {
+    throw new Error("SPZLoader: compressed stream byte lengths do not match file byte length.");
+  }
+  return streamInfos;
+}
+function readSafeUint64(dataView, byteOffset) {
+  const value = dataView.getBigUint64(byteOffset, true);
+  if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw new Error("SPZLoader: stream byte length exceeds Number.MAX_SAFE_INTEGER.");
+  }
+  return Number(value);
+}
+function getSPZStreamByteLengths(header) {
+  return [
+    header.numPoints * 9,
+    header.numPoints,
+    header.numPoints * 3,
+    header.numPoints * 3,
+    header.numPoints * 4,
+    header.numPoints * getSphericalHarmonicsComponentCount(header.shDegree)
+  ].filter((byteLength) => byteLength > 0);
+}
+function validateSPZStreamLengths(streams, streamInfos) {
+  for (let streamIndex = 0; streamIndex < streams.length; streamIndex++) {
+    if (streams[streamIndex].byteLength !== streamInfos[streamIndex].uncompressedSize) {
+      throw new Error(`SPZLoader: decompressed stream ${streamIndex} has unexpected byte length.`);
+    }
+  }
+}
+function decodeSPZStreams(header, streams, sourceData) {
+  const splatCount = header.numPoints;
+  const positions = new Float32Array(splatCount * 3);
+  const scales = new Float32Array(splatCount * 3);
+  const rotations = new Float32Array(splatCount * 4);
+  const colors = new Uint8Array(splatCount * 3);
+  const sphericalHarmonicDcs = new Float32Array(splatCount * 3);
+  const opacities = new Float32Array(splatCount);
+  const sphericalHarmonicsComponentCount = getSphericalHarmonicsComponentCount(header.shDegree);
+  const sphericalHarmonics = sphericalHarmonicsComponentCount ? new Float32Array(splatCount * sphericalHarmonicsComponentCount) : void 0;
+  const [positionStream, alphaStream, colorStream, scaleStream, rotationStream, sphericalHarmonicsStream] = streams.map((stream) => new Uint8Array(stream));
+  decodeSPZPositions(positionStream, positions, header.fractionalBits);
+  decodeSPZScales(scaleStream, scales);
+  decodeSPZRotations(rotationStream, rotations);
+  decodeSPZColors(colorStream, colors, sphericalHarmonicDcs);
+  decodeSPZOpacities(alphaStream, opacities);
+  if (sphericalHarmonics && sphericalHarmonicsStream) {
+    decodeSPZSphericalHarmonics(sphericalHarmonicsStream, sphericalHarmonics);
+  }
+  return {
+    format: "spz",
+    splatCount,
+    positions,
+    scales,
+    rotations,
+    colors,
+    sphericalHarmonicDcs,
+    opacities,
+    sphericalHarmonics,
+    sphericalHarmonicsComponentCount,
+    loaderData: {
+      format: "spz",
+      ...header,
+      antialiased: Boolean(header.flags & 1),
+      extensionByteLength: getSPZExtensionByteLength(header),
+      extensionBytes: getSPZExtensionBytes(sourceData, header)
+    }
+  };
 }
-function readCompressedCenterValue(data, byteOffset, component, compressionLevel) {
-  const dataView = new DataView(data);
-  return compressionLevel === 0 ? dataView.getFloat32(byteOffset + component * 4, true) : dataView.getUint16(byteOffset + component * 2, true);
+function decodeSPZPositions(positionStream, positions, fractionalBits) {
+  const scale = 1 / 2 ** fractionalBits;
+  for (let componentIndex = 0; componentIndex < positions.length; componentIndex++) {
+    const byteOffset = componentIndex * 3;
+    let fixed32 = positionStream[byteOffset] | positionStream[byteOffset + 1] << 8 | positionStream[byteOffset + 2] << 16;
+    fixed32 |= fixed32 & 8388608 ? 4278190080 : 0;
+    positions[componentIndex] = fixed32 * scale;
+  }
 }
-function getBucketCenter(data, section, localSplatIndex) {
-  if (!section.bucketCount) {
-    return [0, 0, 0];
+function decodeSPZScales(scaleStream, scales) {
+  for (let componentIndex = 0; componentIndex < scales.length; componentIndex++) {
+    scales[componentIndex] = Math.exp(scaleStream[componentIndex] / 16 - 10);
   }
-  const bucketIndex = getBucketIndex(data, section, localSplatIndex);
-  const bucketBase = section.bucketsBase + bucketIndex * section.bucketStorageSizeBytes;
-  const dataView = new DataView(data, bucketBase, 12);
-  return [dataView.getFloat32(0, true), dataView.getFloat32(4, true), dataView.getFloat32(8, true)];
 }
-function getBucketIndex(data, section, localSplatIndex) {
-  const maxSplatIndexInFullBuckets = section.fullBucketCount * section.bucketSize;
-  if (localSplatIndex < maxSplatIndexInFullBuckets) {
-    return Math.floor(localSplatIndex / section.bucketSize);
+function decodeSPZRotations(rotationStream, rotations) {
+  for (let splatIndex = 0; splatIndex < rotations.length / 4; splatIndex++) {
+    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, 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] = z2;
   }
-  let bucketSplatIndex = maxSplatIndexInFullBuckets;
-  let bucketIndex = section.fullBucketCount;
-  for (let partiallyFilledBucketIndex = 0; partiallyFilledBucketIndex < section.partiallyFilledBucketCount; partiallyFilledBucketIndex++) {
-    const bucketLength = new DataView(data, section.base + partiallyFilledBucketIndex * 4, 4).getUint32(0, true);
-    if (localSplatIndex < bucketSplatIndex + bucketLength) {
-      return bucketIndex;
+}
+function decodeSPZQuaternion(component) {
+  const rotation = [0, 0, 0, 0];
+  const largestComponent = component >>> 30;
+  let remainingBits = component;
+  let sumSquares = 0;
+  for (let componentIndex = 3; componentIndex >= 0; componentIndex--) {
+    if (componentIndex !== largestComponent) {
+      const magnitude = remainingBits & SPZ_ROTATION_COMPONENT_MASK;
+      const isNegative = remainingBits >>> 9 & 1;
+      remainingBits >>>= 10;
+      let value = SPZ_ROTATION_COMPONENT_SCALE * magnitude / SPZ_ROTATION_COMPONENT_MASK;
+      if (isNegative) {
+        value = -value;
+      }
+      rotation[componentIndex] = value;
+      sumSquares += value * value;
     }
-    bucketSplatIndex += bucketLength;
-    bucketIndex++;
   }
-  return Math.max(bucketIndex - 1, 0);
+  rotation[largestComponent] = Math.sqrt(Math.max(0, 1 - sumSquares));
+  return rotation;
 }
-function decodeSphericalHarmonics(data, byteOffset, header, section, outputSplatIndex, output, outputComponentCount) {
-  const componentCount = getSphericalHarmonicsComponentCount(section.sphericalHarmonicsDegree);
-  const componentBase = outputSplatIndex * outputComponentCount;
-  for (let component = 0; component < componentCount; component++) {
-    output[componentBase + component] = readCompressedFloat(data, byteOffset, component, header.compressionLevel, true, header.minSphericalHarmonicsCoeff, header.maxSphericalHarmonicsCoeff);
+function decodeSPZColors(colorStream, colors, sphericalHarmonicDcs) {
+  for (let componentIndex = 0; componentIndex < colors.length; componentIndex++) {
+    sphericalHarmonicDcs[componentIndex] = (colorStream[componentIndex] / 255 - 0.5) / SPZ_COLOR_SCALE;
+    colors[componentIndex] = normalizeColorByte(sphericalHarmonicDcs[componentIndex]);
   }
 }
-function readCompressedFloat(data, byteOffset, component, compressionLevel, sphericalHarmonic = false, sphericalHarmonicRangeMin = 0, sphericalHarmonicRangeMax = 0) {
-  const dataView = new DataView(data);
-  if (compressionLevel === 0) {
-    return dataView.getFloat32(byteOffset + component * 4, true);
+function decodeSPZOpacities(alphaStream, opacities) {
+  for (let splatIndex = 0; splatIndex < opacities.length; splatIndex++) {
+    opacities[splatIndex] = alphaStream[splatIndex] / 255;
   }
-  if (compressionLevel === 1 || !sphericalHarmonic) {
-    return decodeFloat16(dataView.getUint16(byteOffset + component * 2, true));
+}
+function decodeSPZSphericalHarmonics(sphericalHarmonicsStream, sphericalHarmonics) {
+  for (let componentIndex = 0; componentIndex < sphericalHarmonics.length; componentIndex++) {
+    sphericalHarmonics[componentIndex] = (sphericalHarmonicsStream[componentIndex] - 128) / 128;
   }
-  const value = dataView.getUint8(byteOffset + component);
-  return value / 255 * (sphericalHarmonicRangeMax - sphericalHarmonicRangeMin) + sphericalHarmonicRangeMin;
 }
-function getBytesPerSplat(compressionLevel, sphericalHarmonicsDegree) {
-  const layout = COMPRESSION_LAYOUTS[compressionLevel];
-  return layout.bytesPerCenter + layout.bytesPerScale + layout.bytesPerRotation + layout.bytesPerColor + layout.bytesPerSphericalHarmonicsComponent * getSphericalHarmonicsComponentCount(sphericalHarmonicsDegree);
+function normalizeColorByte(sphericalHarmonicDc) {
+  return Math.min(Math.max(Math.round((sphericalHarmonicDc * SPZ_COLOR_SCALE + 0.5) * 255), 0), 255);
 }
-function getSphericalHarmonicsComponentCount(sphericalHarmonicsDegree) {
-  switch (sphericalHarmonicsDegree) {
+function getSphericalHarmonicsComponentCount(shDegree) {
+  switch (shDegree) {
     case 0:
       return 0;
     case 1:
@@ -559,324 +2379,346 @@ function getSphericalHarmonicsComponentCount(sphericalHarmonicsDegree) {
       return 24;
     case 3:
       return 45;
+    case 4:
+      return 72;
     default:
-      throw new Error(`KSPLATLoader: unsupported spherical harmonics degree ${sphericalHarmonicsDegree}.`);
+      throw new Error(`SPZLoader: spherical harmonics degree ${shDegree} is not supported.`);
   }
 }
-function getActiveSectionCount(header) {
-  return header.sectionCount || header.maxSectionCount;
+function getSPZExtensionByteLength(header) {
+  return header.flags & SPZ_EXTENSION_FLAG ? header.tocByteOffset - SPZ_HEADER_BYTE_LENGTH : 0;
 }
-function getTotalSplatCount(header, sections) {
-  const sectionSplatCount = sections.slice(0, getActiveSectionCount(header)).reduce((splatCount, section) => splatCount + section.splatCount, 0);
-  return header.splatCount ? Math.min(header.splatCount, sectionSplatCount || header.splatCount) : sectionSplatCount;
+function getSPZExtensionBytes(data, header) {
+  const extensionByteLength = getSPZExtensionByteLength(header);
+  return extensionByteLength ? new Uint8Array(data.slice(SPZ_HEADER_BYTE_LENGTH, header.tocByteOffset)) : void 0;
 }
-function validateSectionBounds(data, section) {
-  const requiredByteLength = section.dataBase + section.bytesPerSplat * section.splatCount;
-  if (requiredByteLength > data.byteLength) {
-    throw new Error("KSPLATLoader: section data extends beyond the file length.");
+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";
+    init_src2();
+    init_splats_arrow_table();
+    init_splat_utils();
+    SPZ_HEADER_BYTE_LENGTH = 32;
+    SPZ_MAGIC = 1347635022;
+    SPZ_VERSION = 4;
+    SPZ_EXTENSION_FLAG = 2;
+    SPZ_COLOR_SCALE = 0.15;
+    SPZ_ROTATION_COMPONENT_SCALE = Math.SQRT1_2;
+    SPZ_ROTATION_COMPONENT_MASK = (1 << 9) - 1;
+  }
+});
+
+// dist/lib/parse-splat.js
+function parseSPLAT(data) {
+  return makeGaussianSplatsArrowTable(parseSPLATToGaussianSplats(data));
+}
+function parseSPLATToGaussianSplats(data) {
+  if (data.byteLength % SPLAT_ROW_BYTE_LENGTH !== 0) {
+    throw new Error(`SPLATLoader: byte length must be a multiple of ${SPLAT_ROW_BYTE_LENGTH}.`);
+  }
+  const splatCount = data.byteLength / SPLAT_ROW_BYTE_LENGTH;
+  const dataView = new DataView(data);
+  const positions = new Float32Array(splatCount * 3);
+  const scales = new Float32Array(splatCount * 3);
+  const rotations = new Float32Array(splatCount * 4);
+  const colors = new Uint8Array(splatCount * 3);
+  const opacities = new Float32Array(splatCount);
+  for (let splatIndex = 0; splatIndex < splatCount; splatIndex++) {
+    const byteOffset = splatIndex * SPLAT_ROW_BYTE_LENGTH;
+    const positionOffset = splatIndex * 3;
+    const rotationOffset = splatIndex * 4;
+    positions[positionOffset + 0] = dataView.getFloat32(byteOffset + 0, true);
+    positions[positionOffset + 1] = dataView.getFloat32(byteOffset + 4, true);
+    positions[positionOffset + 2] = dataView.getFloat32(byteOffset + 8, true);
+    scales[positionOffset + 0] = dataView.getFloat32(byteOffset + 12, true);
+    scales[positionOffset + 1] = dataView.getFloat32(byteOffset + 16, true);
+    scales[positionOffset + 2] = dataView.getFloat32(byteOffset + 20, true);
+    colors[positionOffset + 0] = dataView.getUint8(byteOffset + 24);
+    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, 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] = z2;
   }
+  return {
+    format: "splat",
+    splatCount,
+    positions,
+    scales,
+    rotations,
+    colors,
+    opacities,
+    loaderData: {
+      format: "splat",
+      splatCount,
+      rowByteLength: SPLAT_ROW_BYTE_LENGTH
+    }
+  };
 }
-var CURRENT_MAJOR_VERSION, CURRENT_MINOR_VERSION, HEADER_BYTE_LENGTH, SECTION_HEADER_BYTE_LENGTH, DEFAULT_SH_8BIT_COMPRESSION_RANGE, DEFAULT_SH_8BIT_COMPRESSION_HALF_RANGE, COMPRESSION_LAYOUTS;
-var init_parse_ksplat = __esm({
-  "dist/lib/parse-ksplat.js"() {
+var SPLAT_ROW_BYTE_LENGTH;
+var init_parse_splat = __esm({
+  "dist/lib/parse-splat.js"() {
     "use strict";
     init_splats_arrow_table();
     init_splat_utils();
-    CURRENT_MAJOR_VERSION = 0;
-    CURRENT_MINOR_VERSION = 1;
-    HEADER_BYTE_LENGTH = 4096;
-    SECTION_HEADER_BYTE_LENGTH = 1024;
-    DEFAULT_SH_8BIT_COMPRESSION_RANGE = 3;
-    DEFAULT_SH_8BIT_COMPRESSION_HALF_RANGE = DEFAULT_SH_8BIT_COMPRESSION_RANGE / 2;
-    COMPRESSION_LAYOUTS = {
-      0: {
-        bytesPerCenter: 12,
-        bytesPerScale: 12,
-        bytesPerRotation: 16,
-        bytesPerColor: 4,
-        scaleOffsetBytes: 12,
-        colorOffsetBytes: 40,
-        sphericalHarmonicsOffsetBytes: 44,
-        scaleRange: 1,
-        bytesPerSphericalHarmonicsComponent: 4
-      },
-      1: {
-        bytesPerCenter: 6,
-        bytesPerScale: 6,
-        bytesPerRotation: 8,
-        bytesPerColor: 4,
-        scaleOffsetBytes: 6,
-        colorOffsetBytes: 20,
-        sphericalHarmonicsOffsetBytes: 24,
-        scaleRange: 32767,
-        bytesPerSphericalHarmonicsComponent: 2
-      },
-      2: {
-        bytesPerCenter: 6,
-        bytesPerScale: 6,
-        bytesPerRotation: 8,
-        bytesPerColor: 4,
-        scaleOffsetBytes: 6,
-        colorOffsetBytes: 20,
-        sphericalHarmonicsOffsetBytes: 24,
-        scaleRange: 32767,
-        bytesPerSphericalHarmonicsComponent: 1
-      }
-    };
+    SPLAT_ROW_BYTE_LENGTH = 32;
   }
 });
 
-// dist/ksplat-loader.js
-var ksplat_loader_exports = {};
-__export(ksplat_loader_exports, {
-  KSPLATLoaderWithParser: () => KSPLATLoaderWithParser
+// dist/splat-loader.js
+var splat_loader_exports = {};
+__export(splat_loader_exports, {
+  SPLATLoaderWithParser: () => SPLATLoaderWithParser
 });
-var _KSPLATLoaderPreload, KSPLATLoaderMetadataWithoutPreload, KSPLATLoaderWithParser;
-var init_ksplat_loader = __esm({
-  "dist/ksplat-loader.js"() {
+var _SPLATLoaderPreload, SPLATLoaderMetadataWithoutPreload, SPLATLoaderWithParser;
+var init_splat_loader = __esm({
+  "dist/splat-loader.js"() {
     "use strict";
-    init_parse_ksplat();
-    init_ksplat_loader_types();
-    ({ preload: _KSPLATLoaderPreload, ...KSPLATLoaderMetadataWithoutPreload } = KSPLATLoader);
-    KSPLATLoaderWithParser = {
-      ...KSPLATLoaderMetadataWithoutPreload,
-      parse: async (arrayBuffer) => parseKSPLAT(arrayBuffer),
-      parseSync: (arrayBuffer) => parseKSPLAT(arrayBuffer)
+    init_parse_splat();
+    init_splat_loader_types();
+    ({ preload: _SPLATLoaderPreload, ...SPLATLoaderMetadataWithoutPreload } = SPLATLoader);
+    SPLATLoaderWithParser = {
+      ...SPLATLoaderMetadataWithoutPreload,
+      parse: async (arrayBuffer) => parseSPLAT(arrayBuffer),
+      parseSync: (arrayBuffer) => parseSPLAT(arrayBuffer)
     };
   }
-});
-
-// dist/ksplat-loader-types.js
-async function preload2() {
-  const { KSPLATLoaderWithParser: KSPLATLoaderWithParser2 } = await Promise.resolve().then(() => (init_ksplat_loader(), ksplat_loader_exports));
-  return KSPLATLoaderWithParser2;
+});
+
+// dist/splat-loader-types.js
+async function preload() {
+  const { SPLATLoaderWithParser: SPLATLoaderWithParser2 } = await Promise.resolve().then(() => (init_splat_loader(), splat_loader_exports));
+  return SPLATLoaderWithParser2;
 }
-var VERSION2, KSPLATLoader;
-var init_ksplat_loader_types = __esm({
-  "dist/ksplat-loader-types.js"() {
+var VERSION2, SPLATLoader;
+var init_splat_loader_types = __esm({
+  "dist/splat-loader-types.js"() {
     "use strict";
     init_splats_format();
-    VERSION2 = true ? "5.0.0-alpha.1" : "latest";
-    KSPLATLoader = {
+    VERSION2 = true ? "5.0.0-alpha.11" : "latest";
+    SPLATLoader = {
       dataType: null,
       batchType: null,
-      ...KSPLATFormat,
+      ...SPLATFormat,
       version: VERSION2,
       options: {
         splats: {
           shape: "arrow-table"
         }
       },
-      preload: preload2
+      preload
     };
   }
 });
 
-// dist/lib/parse-spz.js
-async function parseSPZ(data, options) {
-  return makeGaussianSplatsArrowTable(await parseSPZToGaussianSplats(data, options));
-}
-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)));
-  validateSPZStreamLengths(streams, streamInfos);
-  return decodeSPZStreams(header, streams, data);
-}
-function parseSPZHeader(data) {
-  if (data.byteLength < SPZ_HEADER_BYTE_LENGTH) {
-    throw new Error(`SPZLoader: file must contain a ${SPZ_HEADER_BYTE_LENGTH}-byte header.`);
-  }
-  const dataView = new DataView(data);
-  const header = {
-    magic: dataView.getUint32(0, true),
-    version: dataView.getUint32(4, true),
-    numPoints: dataView.getUint32(8, true),
-    shDegree: dataView.getUint8(12),
-    fractionalBits: dataView.getUint8(13),
-    flags: dataView.getUint8(14),
-    numStreams: dataView.getUint8(15),
-    tocByteOffset: dataView.getUint32(16, true)
-  };
-  if (header.magic !== SPZ_MAGIC) {
-    throw new Error("SPZLoader: NGSP magic header not found.");
-  }
-  if (header.version !== SPZ_VERSION) {
-    throw new Error(`SPZLoader: version ${header.version} is not supported.`);
-  }
-  if (header.shDegree > 4) {
-    throw new Error(`SPZLoader: spherical harmonics degree ${header.shDegree} is not supported.`);
-  }
-  if (header.tocByteOffset < SPZ_HEADER_BYTE_LENGTH || header.tocByteOffset > data.byteLength) {
-    throw new Error("SPZLoader: invalid table of contents byte offset.");
-  }
-  return header;
-}
-function parseSPZStreamInfos(data, header, expectedUncompressedSizes) {
-  if (header.numStreams !== expectedUncompressedSizes.length) {
-    throw new Error(`SPZLoader: expected ${expectedUncompressedSizes.length} streams, found ${header.numStreams}.`);
-  }
-  const tocByteLength = header.numStreams * 16;
-  const tocEnd = header.tocByteOffset + tocByteLength;
-  if (tocEnd > data.byteLength) {
-    throw new Error("SPZLoader: table of contents exceeds file byte length.");
-  }
-  const dataView = new DataView(data);
-  let compressedOffset = tocEnd;
-  const streamInfos = [];
-  for (let streamIndex = 0; streamIndex < header.numStreams; streamIndex++) {
-    const tocOffset = header.tocByteOffset + streamIndex * 16;
-    const compressedSize = readSafeUint64(dataView, tocOffset);
-    const uncompressedSize = readSafeUint64(dataView, tocOffset + 8);
-    const expectedUncompressedSize = expectedUncompressedSizes[streamIndex];
-    if (uncompressedSize !== expectedUncompressedSize) {
-      throw new Error(`SPZLoader: stream ${streamIndex} has ${uncompressedSize} uncompressed bytes, expected ${expectedUncompressedSize}.`);
-    }
-    if (compressedOffset + compressedSize > data.byteLength) {
-      throw new Error(`SPZLoader: stream ${streamIndex} exceeds file byte length.`);
-    }
-    streamInfos.push({ compressedSize, uncompressedSize, compressedOffset });
-    compressedOffset += compressedSize;
-  }
-  if (compressedOffset !== data.byteLength) {
-    throw new Error("SPZLoader: compressed stream byte lengths do not match file byte length.");
-  }
-  return streamInfos;
-}
-function readSafeUint64(dataView, byteOffset) {
-  const value = dataView.getBigUint64(byteOffset, true);
-  if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
-    throw new Error("SPZLoader: stream byte length exceeds Number.MAX_SAFE_INTEGER.");
-  }
-  return Number(value);
-}
-function getSPZStreamByteLengths(header) {
-  return [
-    header.numPoints * 9,
-    header.numPoints,
-    header.numPoints * 3,
-    header.numPoints * 3,
-    header.numPoints * 4,
-    header.numPoints * getSphericalHarmonicsComponentCount2(header.shDegree)
-  ].filter((byteLength) => byteLength > 0);
+// dist/lib/parse-ksplat.js
+function parseKSPLAT(data) {
+  return makeGaussianSplatsArrowTable(parseKSPLATToGaussianSplats(data));
 }
-function validateSPZStreamLengths(streams, streamInfos) {
-  for (let streamIndex = 0; streamIndex < streams.length; streamIndex++) {
-    if (streams[streamIndex].byteLength !== streamInfos[streamIndex].uncompressedSize) {
-      throw new Error(`SPZLoader: decompressed stream ${streamIndex} has unexpected byte length.`);
-    }
+function parseKSPLATToGaussianSplats(data) {
+  if (data.byteLength < HEADER_BYTE_LENGTH) {
+    throw new Error(`KSPLATLoader: file must contain a ${HEADER_BYTE_LENGTH}-byte header.`);
   }
-}
-function decodeSPZStreams(header, streams, sourceData) {
-  const splatCount = header.numPoints;
+  const header = parseKSPLATHeader(data);
+  checkKSPLATVersion(header);
+  const sections = parseKSPLATSections(data, header);
+  const splatCount = getTotalSplatCount(header, sections);
+  const sphericalHarmonicsComponentCount = Math.max(0, ...sections.slice(0, getActiveSectionCount(header)).map((section) => getSphericalHarmonicsComponentCount2(section.sphericalHarmonicsDegree)));
   const positions = new Float32Array(splatCount * 3);
   const scales = new Float32Array(splatCount * 3);
   const rotations = new Float32Array(splatCount * 4);
   const colors = new Uint8Array(splatCount * 3);
-  const sphericalHarmonicDcs = new Float32Array(splatCount * 3);
   const opacities = new Float32Array(splatCount);
-  const sphericalHarmonicsComponentCount = getSphericalHarmonicsComponentCount2(header.shDegree);
   const sphericalHarmonics = sphericalHarmonicsComponentCount ? new Float32Array(splatCount * sphericalHarmonicsComponentCount) : void 0;
-  const [positionStream, alphaStream, colorStream, scaleStream, rotationStream, sphericalHarmonicsStream] = streams.map((stream) => new Uint8Array(stream));
-  decodeSPZPositions(positionStream, positions, header.fractionalBits);
-  decodeSPZScales(scaleStream, scales);
-  decodeSPZRotations(rotationStream, rotations);
-  decodeSPZColors(colorStream, colors, sphericalHarmonicDcs);
-  decodeSPZOpacities(alphaStream, opacities);
-  if (sphericalHarmonics && sphericalHarmonicsStream) {
-    decodeSPZSphericalHarmonics(sphericalHarmonicsStream, sphericalHarmonics);
+  let outputSplatIndex = 0;
+  for (const section of sections.slice(0, getActiveSectionCount(header))) {
+    validateSectionBounds(data, section);
+    for (let localSplatIndex = 0; localSplatIndex < section.splatCount && outputSplatIndex < splatCount; localSplatIndex++) {
+      decodeKSPLATSplat(data, header, section, localSplatIndex, outputSplatIndex, positions, scales, rotations, colors, opacities, sphericalHarmonics, sphericalHarmonicsComponentCount);
+      outputSplatIndex++;
+    }
   }
   return {
-    format: "spz",
+    format: "ksplat",
     splatCount,
     positions,
     scales,
     rotations,
     colors,
-    sphericalHarmonicDcs,
     opacities,
     sphericalHarmonics,
     sphericalHarmonicsComponentCount,
     loaderData: {
-      format: "spz",
+      format: "ksplat",
       ...header,
-      antialiased: Boolean(header.flags & 1),
-      extensionByteLength: getSPZExtensionByteLength(header),
-      extensionBytes: getSPZExtensionBytes(sourceData, header)
+      sections: sections.slice(0, getActiveSectionCount(header)).map((section) => ({
+        splatCount: section.splatCount,
+        maxSplatCount: section.maxSplatCount,
+        sphericalHarmonicsDegree: section.sphericalHarmonicsDegree
+      }))
     }
   };
 }
-function decodeSPZPositions(positionStream, positions, fractionalBits) {
-  const scale = 1 / 2 ** fractionalBits;
-  for (let componentIndex = 0; componentIndex < positions.length; componentIndex++) {
-    const byteOffset = componentIndex * 3;
-    let fixed32 = positionStream[byteOffset] | positionStream[byteOffset + 1] << 8 | positionStream[byteOffset + 2] << 16;
-    fixed32 |= fixed32 & 8388608 ? 4278190080 : 0;
-    positions[componentIndex] = fixed32 * scale;
+function decodeKSPLATSplat(data, header, section, localSplatIndex, outputSplatIndex, positions, scales, rotations, colors, opacities, sphericalHarmonics, sphericalHarmonicsComponentCount) {
+  const layout = COMPRESSION_LAYOUTS[header.compressionLevel];
+  const splatBase = section.dataBase + section.bytesPerSplat * localSplatIndex;
+  const positionOffset = outputSplatIndex * 3;
+  const rotationOffset = outputSplatIndex * 4;
+  const bucketCenter = getBucketCenter(data, section, localSplatIndex);
+  positions[positionOffset + 0] = decodeKSPLATCenterComponent(data, splatBase, 0, header, section, bucketCenter[0]);
+  positions[positionOffset + 1] = decodeKSPLATCenterComponent(data, splatBase, 1, header, section, bucketCenter[1]);
+  positions[positionOffset + 2] = decodeKSPLATCenterComponent(data, splatBase, 2, header, section, bucketCenter[2]);
+  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, 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] = z2;
+  const colorBase = splatBase + layout.colorOffsetBytes;
+  const colorView = new Uint8Array(data, colorBase, 4);
+  colors[positionOffset + 0] = colorView[0];
+  colors[positionOffset + 1] = colorView[1];
+  colors[positionOffset + 2] = colorView[2];
+  opacities[outputSplatIndex] = convertAlphaByteToLinearOpacity(colorView[3]);
+  if (sphericalHarmonics && sphericalHarmonicsComponentCount) {
+    decodeSphericalHarmonics(data, splatBase + layout.sphericalHarmonicsOffsetBytes, header, section, outputSplatIndex, sphericalHarmonics, sphericalHarmonicsComponentCount);
   }
 }
-function decodeSPZScales(scaleStream, scales) {
-  for (let componentIndex = 0; componentIndex < scales.length; componentIndex++) {
-    scales[componentIndex] = Math.exp(scaleStream[componentIndex] / 16 - 10);
+function parseKSPLATHeader(data) {
+  const dataView = new DataView(data, 0, HEADER_BYTE_LENGTH);
+  const compressionLevel = dataView.getUint16(20, true);
+  if (compressionLevel !== 0 && compressionLevel !== 1 && compressionLevel !== 2) {
+    throw new Error(`KSPLATLoader: unsupported compression level ${compressionLevel}.`);
+  }
+  return {
+    versionMajor: dataView.getUint8(0),
+    versionMinor: dataView.getUint8(1),
+    maxSectionCount: dataView.getUint32(4, true),
+    sectionCount: dataView.getUint32(8, true),
+    maxSplatCount: dataView.getUint32(12, true),
+    splatCount: dataView.getUint32(16, true),
+    compressionLevel,
+    minSphericalHarmonicsCoeff: dataView.getFloat32(36, true) || -DEFAULT_SH_8BIT_COMPRESSION_HALF_RANGE,
+    maxSphericalHarmonicsCoeff: dataView.getFloat32(40, true) || DEFAULT_SH_8BIT_COMPRESSION_HALF_RANGE
+  };
+}
+function checkKSPLATVersion(header) {
+  if (header.versionMajor === CURRENT_MAJOR_VERSION ? header.versionMinor >= CURRENT_MINOR_VERSION : header.versionMajor > CURRENT_MAJOR_VERSION) {
+    return;
+  }
+  throw new Error(`KSPLATLoader: version ${header.versionMajor}.${header.versionMinor} is not supported.`);
+}
+function parseKSPLATSections(data, header) {
+  if (data.byteLength < HEADER_BYTE_LENGTH + header.maxSectionCount * SECTION_HEADER_BYTE_LENGTH) {
+    throw new Error("KSPLATLoader: file does not contain all section headers.");
+  }
+  const sections = [];
+  let sectionBase = HEADER_BYTE_LENGTH + header.maxSectionCount * SECTION_HEADER_BYTE_LENGTH;
+  let splatCountOffset = 0;
+  for (let sectionIndex = 0; sectionIndex < header.maxSectionCount; sectionIndex++) {
+    const sectionHeaderBase = HEADER_BYTE_LENGTH + sectionIndex * SECTION_HEADER_BYTE_LENGTH;
+    const dataView = new DataView(data, sectionHeaderBase, SECTION_HEADER_BYTE_LENGTH);
+    const splatCount = dataView.getUint32(0, true);
+    const maxSplatCount = dataView.getUint32(4, true);
+    const bucketSize = dataView.getUint32(8, true);
+    const bucketCount = dataView.getUint32(12, true);
+    const bucketBlockSize = dataView.getFloat32(16, true);
+    const bucketStorageSizeBytes = dataView.getUint16(20, true);
+    const compressionScaleRange = dataView.getUint32(24, true) || COMPRESSION_LAYOUTS[header.compressionLevel].scaleRange;
+    const fullBucketCount = dataView.getUint32(32, true);
+    const partiallyFilledBucketCount = dataView.getUint32(36, true);
+    const sphericalHarmonicsDegree = dataView.getUint16(40, true);
+    const bytesPerSplat = getBytesPerSplat(header.compressionLevel, sphericalHarmonicsDegree);
+    const bucketsMetaDataSizeBytes = partiallyFilledBucketCount * 4;
+    const bucketsStorageSizeBytes = bucketStorageSizeBytes * bucketCount + bucketsMetaDataSizeBytes;
+    const storageSizeBytes = bytesPerSplat * maxSplatCount + bucketsStorageSizeBytes;
+    sections.push({
+      bytesPerSplat,
+      splatCountOffset,
+      splatCount: splatCount || maxSplatCount,
+      maxSplatCount,
+      bucketSize,
+      bucketCount,
+      bucketStorageSizeBytes,
+      bucketsStorageSizeBytes,
+      compressionScaleRange,
+      compressionScaleFactor: bucketBlockSize / 2 / compressionScaleRange,
+      base: sectionBase,
+      bucketsBase: sectionBase + bucketsMetaDataSizeBytes,
+      dataBase: sectionBase + bucketsStorageSizeBytes,
+      fullBucketCount,
+      partiallyFilledBucketCount,
+      sphericalHarmonicsDegree
+    });
+    sectionBase += storageSizeBytes;
+    splatCountOffset += maxSplatCount;
   }
+  return sections;
+}
+function decodeKSPLATCenterComponent(data, splatBase, component, header, section, bucketCenter) {
+  const value = readCompressedCenterValue(data, splatBase, component, header.compressionLevel);
+  return header.compressionLevel >= 1 ? (value - section.compressionScaleRange) * section.compressionScaleFactor + bucketCenter : value;
+}
+function readCompressedCenterValue(data, byteOffset, component, compressionLevel) {
+  const dataView = new DataView(data);
+  return compressionLevel === 0 ? dataView.getFloat32(byteOffset + component * 4, true) : dataView.getUint16(byteOffset + component * 2, true);
 }
-function decodeSPZRotations(rotationStream, rotations) {
-  for (let splatIndex = 0; splatIndex < rotations.length / 4; splatIndex++) {
-    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 rotationOffset = splatIndex * 4;
-    rotations[rotationOffset + 0] = w;
-    rotations[rotationOffset + 1] = x;
-    rotations[rotationOffset + 2] = y;
-    rotations[rotationOffset + 3] = z;
+function getBucketCenter(data, section, localSplatIndex) {
+  if (!section.bucketCount) {
+    return [0, 0, 0];
   }
+  const bucketIndex = getBucketIndex(data, section, localSplatIndex);
+  const bucketBase = section.bucketsBase + bucketIndex * section.bucketStorageSizeBytes;
+  const dataView = new DataView(data, bucketBase, 12);
+  return [dataView.getFloat32(0, true), dataView.getFloat32(4, true), dataView.getFloat32(8, true)];
 }
-function decodeSPZQuaternion(component) {
-  const rotation = [0, 0, 0, 0];
-  const largestComponent = component >>> 30;
-  let remainingBits = component;
-  let sumSquares = 0;
-  for (let componentIndex = 3; componentIndex >= 0; componentIndex--) {
-    if (componentIndex !== largestComponent) {
-      const magnitude = remainingBits & SPZ_ROTATION_COMPONENT_MASK;
-      const isNegative = remainingBits >>> 9 & 1;
-      remainingBits >>>= 10;
-      let value = SPZ_ROTATION_COMPONENT_SCALE * magnitude / SPZ_ROTATION_COMPONENT_MASK;
-      if (isNegative) {
-        value = -value;
-      }
-      rotation[componentIndex] = value;
-      sumSquares += value * value;
+function getBucketIndex(data, section, localSplatIndex) {
+  const maxSplatIndexInFullBuckets = section.fullBucketCount * section.bucketSize;
+  if (localSplatIndex < maxSplatIndexInFullBuckets) {
+    return Math.floor(localSplatIndex / section.bucketSize);
+  }
+  let bucketSplatIndex = maxSplatIndexInFullBuckets;
+  let bucketIndex = section.fullBucketCount;
+  for (let partiallyFilledBucketIndex = 0; partiallyFilledBucketIndex < section.partiallyFilledBucketCount; partiallyFilledBucketIndex++) {
+    const bucketLength = new DataView(data, section.base + partiallyFilledBucketIndex * 4, 4).getUint32(0, true);
+    if (localSplatIndex < bucketSplatIndex + bucketLength) {
+      return bucketIndex;
     }
+    bucketSplatIndex += bucketLength;
+    bucketIndex++;
   }
-  rotation[largestComponent] = Math.sqrt(Math.max(0, 1 - sumSquares));
-  return rotation;
+  return Math.max(bucketIndex - 1, 0);
 }
-function decodeSPZColors(colorStream, colors, sphericalHarmonicDcs) {
-  for (let componentIndex = 0; componentIndex < colors.length; componentIndex++) {
-    sphericalHarmonicDcs[componentIndex] = (colorStream[componentIndex] / 255 - 0.5) / SPZ_COLOR_SCALE;
-    colors[componentIndex] = normalizeColorByte(sphericalHarmonicDcs[componentIndex]);
+function decodeSphericalHarmonics(data, byteOffset, header, section, outputSplatIndex, output, outputComponentCount) {
+  const componentCount = getSphericalHarmonicsComponentCount2(section.sphericalHarmonicsDegree);
+  const componentBase = outputSplatIndex * outputComponentCount;
+  for (let component = 0; component < componentCount; component++) {
+    output[componentBase + component] = readCompressedFloat(data, byteOffset, component, header.compressionLevel, true, header.minSphericalHarmonicsCoeff, header.maxSphericalHarmonicsCoeff);
   }
 }
-function decodeSPZOpacities(alphaStream, opacities) {
-  for (let splatIndex = 0; splatIndex < opacities.length; splatIndex++) {
-    opacities[splatIndex] = alphaStream[splatIndex] / 255;
+function readCompressedFloat(data, byteOffset, component, compressionLevel, sphericalHarmonic = false, sphericalHarmonicRangeMin = 0, sphericalHarmonicRangeMax = 0) {
+  const dataView = new DataView(data);
+  if (compressionLevel === 0) {
+    return dataView.getFloat32(byteOffset + component * 4, true);
   }
-}
-function decodeSPZSphericalHarmonics(sphericalHarmonicsStream, sphericalHarmonics) {
-  for (let componentIndex = 0; componentIndex < sphericalHarmonics.length; componentIndex++) {
-    sphericalHarmonics[componentIndex] = (sphericalHarmonicsStream[componentIndex] - 128) / 128;
+  if (compressionLevel === 1 || !sphericalHarmonic) {
+    return decodeFloat16(dataView.getUint16(byteOffset + component * 2, true));
   }
+  const value = dataView.getUint8(byteOffset + component);
+  return value / 255 * (sphericalHarmonicRangeMax - sphericalHarmonicRangeMin) + sphericalHarmonicRangeMin;
 }
-function normalizeColorByte(sphericalHarmonicDc) {
-  return Math.min(Math.max(Math.round((sphericalHarmonicDc * SPZ_COLOR_SCALE + 0.5) * 255), 0), 255);
+function getBytesPerSplat(compressionLevel, sphericalHarmonicsDegree) {
+  const layout = COMPRESSION_LAYOUTS[compressionLevel];
+  return layout.bytesPerCenter + layout.bytesPerScale + layout.bytesPerRotation + layout.bytesPerColor + layout.bytesPerSphericalHarmonicsComponent * getSphericalHarmonicsComponentCount2(sphericalHarmonicsDegree);
 }
-function getSphericalHarmonicsComponentCount2(shDegree) {
-  switch (shDegree) {
+function getSphericalHarmonicsComponentCount2(sphericalHarmonicsDegree) {
+  switch (sphericalHarmonicsDegree) {
     case 0:
       return 0;
     case 1:
@@ -885,33 +2727,116 @@ function getSphericalHarmonicsComponentCount2(shDegree) {
       return 24;
     case 3:
       return 45;
-    case 4:
-      return 72;
     default:
-      throw new Error(`SPZLoader: spherical harmonics degree ${shDegree} is not supported.`);
+      throw new Error(`KSPLATLoader: unsupported spherical harmonics degree ${sphericalHarmonicsDegree}.`);
   }
 }
-function getSPZExtensionByteLength(header) {
-  return header.flags & SPZ_EXTENSION_FLAG ? header.tocByteOffset - SPZ_HEADER_BYTE_LENGTH : 0;
+function getActiveSectionCount(header) {
+  return header.sectionCount || header.maxSectionCount;
 }
-function getSPZExtensionBytes(data, header) {
-  const extensionByteLength = getSPZExtensionByteLength(header);
-  return extensionByteLength ? new Uint8Array(data.slice(SPZ_HEADER_BYTE_LENGTH, header.tocByteOffset)) : void 0;
+function getTotalSplatCount(header, sections) {
+  const sectionSplatCount = sections.slice(0, getActiveSectionCount(header)).reduce((splatCount, section) => splatCount + section.splatCount, 0);
+  return header.splatCount ? Math.min(header.splatCount, sectionSplatCount || header.splatCount) : sectionSplatCount;
 }
-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 init_parse_spz = __esm({
-  "dist/lib/parse-spz.js"() {
+function validateSectionBounds(data, section) {
+  const requiredByteLength = section.dataBase + section.bytesPerSplat * section.splatCount;
+  if (requiredByteLength > data.byteLength) {
+    throw new Error("KSPLATLoader: section data extends beyond the file length.");
+  }
+}
+var CURRENT_MAJOR_VERSION, CURRENT_MINOR_VERSION, HEADER_BYTE_LENGTH, SECTION_HEADER_BYTE_LENGTH, DEFAULT_SH_8BIT_COMPRESSION_RANGE, DEFAULT_SH_8BIT_COMPRESSION_HALF_RANGE, COMPRESSION_LAYOUTS;
+var init_parse_ksplat = __esm({
+  "dist/lib/parse-ksplat.js"() {
     "use strict";
-    import_compression = require("@loaders.gl/compression");
     init_splats_arrow_table();
     init_splat_utils();
-    SPZ_HEADER_BYTE_LENGTH = 32;
-    SPZ_MAGIC = 1347635022;
-    SPZ_VERSION = 4;
-    SPZ_EXTENSION_FLAG = 2;
-    SPZ_COLOR_SCALE = 0.15;
-    SPZ_ROTATION_COMPONENT_SCALE = Math.SQRT1_2;
-    SPZ_ROTATION_COMPONENT_MASK = (1 << 9) - 1;
+    CURRENT_MAJOR_VERSION = 0;
+    CURRENT_MINOR_VERSION = 1;
+    HEADER_BYTE_LENGTH = 4096;
+    SECTION_HEADER_BYTE_LENGTH = 1024;
+    DEFAULT_SH_8BIT_COMPRESSION_RANGE = 3;
+    DEFAULT_SH_8BIT_COMPRESSION_HALF_RANGE = DEFAULT_SH_8BIT_COMPRESSION_RANGE / 2;
+    COMPRESSION_LAYOUTS = {
+      0: {
+        bytesPerCenter: 12,
+        bytesPerScale: 12,
+        bytesPerRotation: 16,
+        bytesPerColor: 4,
+        scaleOffsetBytes: 12,
+        colorOffsetBytes: 40,
+        sphericalHarmonicsOffsetBytes: 44,
+        scaleRange: 1,
+        bytesPerSphericalHarmonicsComponent: 4
+      },
+      1: {
+        bytesPerCenter: 6,
+        bytesPerScale: 6,
+        bytesPerRotation: 8,
+        bytesPerColor: 4,
+        scaleOffsetBytes: 6,
+        colorOffsetBytes: 20,
+        sphericalHarmonicsOffsetBytes: 24,
+        scaleRange: 32767,
+        bytesPerSphericalHarmonicsComponent: 2
+      },
+      2: {
+        bytesPerCenter: 6,
+        bytesPerScale: 6,
+        bytesPerRotation: 8,
+        bytesPerColor: 4,
+        scaleOffsetBytes: 6,
+        colorOffsetBytes: 20,
+        sphericalHarmonicsOffsetBytes: 24,
+        scaleRange: 32767,
+        bytesPerSphericalHarmonicsComponent: 1
+      }
+    };
+  }
+});
+
+// dist/ksplat-loader.js
+var ksplat_loader_exports = {};
+__export(ksplat_loader_exports, {
+  KSPLATLoaderWithParser: () => KSPLATLoaderWithParser
+});
+var _KSPLATLoaderPreload, KSPLATLoaderMetadataWithoutPreload, KSPLATLoaderWithParser;
+var init_ksplat_loader = __esm({
+  "dist/ksplat-loader.js"() {
+    "use strict";
+    init_parse_ksplat();
+    init_ksplat_loader_types();
+    ({ preload: _KSPLATLoaderPreload, ...KSPLATLoaderMetadataWithoutPreload } = KSPLATLoader);
+    KSPLATLoaderWithParser = {
+      ...KSPLATLoaderMetadataWithoutPreload,
+      parse: async (arrayBuffer) => parseKSPLAT(arrayBuffer),
+      parseSync: (arrayBuffer) => parseKSPLAT(arrayBuffer)
+    };
+  }
+});
+
+// dist/ksplat-loader-types.js
+async function preload2() {
+  const { KSPLATLoaderWithParser: KSPLATLoaderWithParser2 } = await Promise.resolve().then(() => (init_ksplat_loader(), ksplat_loader_exports));
+  return KSPLATLoaderWithParser2;
+}
+var VERSION3, KSPLATLoader;
+var init_ksplat_loader_types = __esm({
+  "dist/ksplat-loader-types.js"() {
+    "use strict";
+    init_splats_format();
+    VERSION3 = true ? "5.0.0-alpha.11" : "latest";
+    KSPLATLoader = {
+      dataType: null,
+      batchType: null,
+      ...KSPLATFormat,
+      version: VERSION3,
+      options: {
+        splats: {
+          shape: "arrow-table"
+        }
+      },
+      preload: preload2
+    };
   }
 });
 
@@ -939,17 +2864,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.11" : "latest";
     SPZLoader = {
       dataType: null,
       batchType: null,
       ...SPZFormat,
-      version: VERSION3,
+      version: VERSION4,
       options: {
         splats: {
           shape: "arrow-table"
@@ -960,6 +2885,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 +2967,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 +2987,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 +2995,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 +3034,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 +3043,75 @@ var init_parse_rad = __esm({
   }
 });
 
+// ../compression/src/deflate-decompressor-fflate.ts
+var DeflateFflateDecompressor;
+var init_deflate_decompressor_fflate = __esm({
+  "../compression/src/deflate-decompressor-fflate.ts"() {
+    "use strict";
+    init_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 ? inflateSync(bytes) : unzlibSync(bytes);
+        return output.slice().buffer;
+      }
+      /** Decompresses DEFLATE batches incrementally. */
+      async *decompressBatches(inputBatches) {
+        const processor = this.options.raw ? new Inflate() : new 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 +3209,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 +3320,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 {
@@ -1450,9 +3378,9 @@ function decodeLeBytesFloat16(bytes, dimensions, count) {
   }
   return values;
 }
-function decodeR8(bytes, dimensions, count, min, max) {
+function decodeR8(bytes, dimensions, count, min, max2) {
   const values = new Float32Array(count * dimensions);
-  const range = max - min;
+  const range = max2 - min;
   for (let rowIndex = 0; rowIndex < count; rowIndex++) {
     for (let dimension = 0; dimension < dimensions; dimension++) {
       values[rowIndex * dimensions + dimension] = bytes[dimension * count + rowIndex] / 255 * range + min;
@@ -1460,9 +3388,9 @@ function decodeR8(bytes, dimensions, count, min, max) {
   }
   return values;
 }
-function decodeR8Delta(bytes, dimensions, count, min, max) {
+function decodeR8Delta(bytes, dimensions, count, min, max2) {
   const values = new Float32Array(count * dimensions);
-  const range = max - min;
+  const range = max2 - min;
   const last = new Uint8Array(dimensions);
   for (let rowIndex = 0; rowIndex < count; rowIndex++) {
     for (let dimension = 0; dimension < dimensions; dimension++) {
@@ -1474,17 +3402,17 @@ function decodeR8Delta(bytes, dimensions, count, min, max) {
   }
   return values;
 }
-function decodeS8(bytes, dimensions, count, max) {
+function decodeS8(bytes, dimensions, count, max2) {
   const values = new Float32Array(count * dimensions);
   for (let rowIndex = 0; rowIndex < count; rowIndex++) {
     for (let dimension = 0; dimension < dimensions; dimension++) {
       const byte = bytes[dimension * count + rowIndex];
-      values[rowIndex * dimensions + dimension] = (byte << 24 >> 24) / 127 * max;
+      values[rowIndex * dimensions + dimension] = (byte << 24 >> 24) / 127 * max2;
     }
   }
   return values;
 }
-function decodeS8Delta(bytes, dimensions, count, max) {
+function decodeS8Delta(bytes, dimensions, count, max2) {
   const values = new Float32Array(count * dimensions);
   const last = new Uint8Array(dimensions);
   for (let rowIndex = 0; rowIndex < count; rowIndex++) {
@@ -1492,16 +3420,16 @@ function decodeS8Delta(bytes, dimensions, count, max) {
       const byteOffset = dimension * count + rowIndex;
       const value = last[dimension] + bytes[byteOffset] & 255;
       last[dimension] = value;
-      values[rowIndex * dimensions + dimension] = (value << 24 >> 24) / 127 * max;
+      values[rowIndex * dimensions + dimension] = (value << 24 >> 24) / 127 * max2;
     }
   }
   return values;
 }
-function decodeScaleR8(bytes, dimensions, count, min, max) {
+function decodeScaleR8(bytes, dimensions, count, min, max2) {
   const values = new Float32Array(count * dimensions);
   for (let rowIndex = 0; rowIndex < count; rowIndex++) {
     for (let dimension = 0; dimension < dimensions; dimension++) {
-      values[rowIndex * dimensions + dimension] = decodeScale8(bytes[dimension * count + rowIndex], min, max);
+      values[rowIndex * dimensions + dimension] = decodeScale8(bytes[dimension * count + rowIndex], min, max2);
     }
   }
   return values;
@@ -1517,8 +3445,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;
 }
@@ -1539,24 +3467,24 @@ function makeIdentityRotations(count) {
   }
   return rotations;
 }
-function decodeScale8(scale, min, max) {
+function decodeScale8(scale, min, max2) {
   if (scale === 0) {
     return 0;
   }
-  const logScaleStep = (max - min) / 254;
+  const logScaleStep = (max2 - min) / 254;
   return Math.exp(min + (scale - 1) * logScaleStep);
 }
 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 +3562,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 +3570,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 +3615,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.11" : "latest";
     RADLoader = {
       dataType: null,
       batchType: null,
       ...RADFormat,
-      version: VERSION4,
+      version: VERSION5,
       options: {},
       preload: preload4
     };
@@ -1705,8 +3633,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,
@@ -1717,30 +3645,33 @@ __export(dist_exports, {
   SPLATLoader: () => SPLATLoader,
   SPZFormat: () => SPZFormat,
   SPZLoader: () => SPZLoader,
+  parseSPZ: () => parseSPZ,
+  parseSPZToGaussianSplats: () => parseSPZToGaussianSplats,
   resolveRADChunkUrl: () => resolveRADChunkUrl
 });
-module.exports = __toCommonJS(dist_exports);
+module.exports = __toCommonJS(index_exports);
 init_splats_format();
+init_parse_spz();
 init_splat_loader_types();
 init_ksplat_loader_types();
 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.11" : "latest";
 var RADSourceLoader = {
   dataType: null,
   batchType: null,
   ...RADFormat,
   name: "RADSourceLoader",
-  version: VERSION5,
+  version: VERSION6,
   type: "rad",
   fromUrl: true,
   fromBlob: true,
@@ -1761,7 +3692,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. */