@loaders.gl/splats 4.5.3 → 5.0.0-alpha.10

package/dist/index.cjs

@@ -5,6 +5,14 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+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)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -27,598 +35,2149 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// dist/index.js
-var dist_exports = {};
-__export(dist_exports, {
-  KSPLATFormat: () => KSPLATFormat,
-  KSPLATLoader: () => KSPLATLoaderWithParser,
-  RADFormat: () => RADFormat,
-  RADLoader: () => RADLoaderWithParser,
-  RADSource: () => RADSource,
-  RADSourceLoader: () => RADSourceLoader,
-  SPLATFormat: () => SPLATFormat,
-  SPLATLoader: () => SPLATLoaderWithParser,
-  SPZFormat: () => SPZFormat,
-  SPZLoader: () => SPZLoaderWithParser,
-  resolveRADChunkUrl: () => resolveRADChunkUrl
+// dist/splats-format.js
+var SPLATFormat, KSPLATFormat, SPZFormat, RADFormat;
+var init_splats_format = __esm({
+  "dist/splats-format.js"() {
+    "use strict";
+    SPLATFormat = {
+      name: "SPLAT",
+      id: "splat",
+      module: "splats",
+      format: "splat",
+      extensions: ["splat"],
+      mimeTypes: ["application/octet-stream"],
+      binary: true
+    };
+    KSPLATFormat = {
+      name: "KSPLAT",
+      id: "ksplat",
+      module: "splats",
+      format: "ksplat",
+      extensions: ["ksplat"],
+      mimeTypes: ["application/octet-stream"],
+      binary: true
+    };
+    SPZFormat = {
+      name: "SPZ",
+      id: "spz",
+      module: "splats",
+      format: "spz",
+      extensions: ["spz"],
+      mimeTypes: ["application/octet-stream"],
+      binary: true,
+      tests: [new Uint8Array([78, 71, 83, 80]).buffer]
+    };
+    RADFormat = {
+      name: "RAD",
+      id: "rad",
+      module: "splats",
+      format: "rad",
+      extensions: ["rad"],
+      mimeTypes: ["application/octet-stream"],
+      binary: true,
+      tests: [new Uint8Array([82, 65, 68, 48]).buffer]
+    };
+  }
 });
-module.exports = __toCommonJS(dist_exports);
 
-// dist/splats-format.js
-var SPLATFormat = {
-  name: "SPLAT",
-  id: "splat",
-  module: "splats",
-  extensions: ["splat"],
-  mimeTypes: ["application/octet-stream"],
-  binary: true
-};
-var KSPLATFormat = {
-  name: "KSPLAT",
-  id: "ksplat",
-  module: "splats",
-  extensions: ["ksplat"],
-  mimeTypes: ["application/octet-stream"],
-  binary: true
-};
-var SPZFormat = {
-  name: "SPZ",
-  id: "spz",
-  module: "splats",
-  extensions: ["spz"],
-  mimeTypes: ["application/octet-stream"],
-  binary: true,
-  tests: [new Uint8Array([78, 71, 83, 80]).buffer]
-};
-var RADFormat = {
-  name: "RAD",
-  id: "rad",
-  module: "splats",
-  extensions: ["rad"],
-  mimeTypes: ["application/octet-stream"],
-  binary: true,
-  tests: [new Uint8Array([82, 65, 68, 48]).buffer]
-};
+// ../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();
+  }
+});
 
-// dist/lib/splats-arrow-table.js
-var arrow = __toESM(require("apache-arrow"), 1);
+// ../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;
+  }
+});
 
-// dist/lib/splat-utils.js
-var SH_C0 = 0.28209479177387814;
-function convertColorByteToSphericalHarmonicDc(colorByte) {
-  return (colorByte / 255 - 0.5) / SH_C0;
+// ../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, z2) {
-  const length = Math.hypot(w, x, y, z2);
-  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, z2 / 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);
+}
+function copyToArrayBuffer(chunk) {
+  if (chunk instanceof ArrayBuffer) {
+    return chunk;
+  }
+  if (ArrayBuffer.isView(chunk)) {
+    const { buffer, byteOffset, byteLength } = chunk;
+    return copyFromBuffer(buffer, byteOffset, byteLength);
+  }
+  return copyFromBuffer(chunk);
 }
+function copyFromBuffer(buffer, byteOffset = 0, byteLength = buffer.byteLength - byteOffset) {
+  const view = new Uint8Array(buffer, byteOffset, byteLength);
+  const copy = new Uint8Array(view.length);
+  copy.set(view);
+  return copy.buffer;
+}
+var init_async_iteration = __esm({
+  "../loader-utils/src/lib/iterators/async-iteration.ts"() {
+    "use strict";
+    init_array_buffer_utils();
+  }
+});
 
-// 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"
+// ../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, "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"
+}
+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]);
   });
-  addScalarColumn(columns, fields, schemaFields, "opacity", splats.opacities, {
-    "loaders_gl.gaussian_splats.semantic": "opacity",
-    "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, "scale", splats.scales, 3, {
-    "loaders_gl.gaussian_splats.semantic": "scale",
-    "loaders_gl.gaussian_splats.encoding": "linear"
+  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
   });
-  addVectorComponents(columns, fields, schemaFields, "rot", splats.rotations, 4, {
-    "loaders_gl.gaussian_splats.semantic": "rotation",
-    "loaders_gl.gaussian_splats.encoding": "quaternion"
+}
+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 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.");
+    }
+    if (!resolvedOrigin || url.pathname && url.pathname !== "/" || url.search || url.hash) {
+      throw new Error("Invalid request authentication origin.");
+    }
+    return resolvedOrigin;
   });
-  if (splats.sphericalHarmonics && splats.sphericalHarmonicsComponentCount) {
-    addSphericalHarmonicRestColumns(columns, fields, schemaFields, splats.sphericalHarmonics, splats.sphericalHarmonicsComponentCount);
+}
+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 });
   }
-  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
+    url: url.toString(),
+    options: { ...requestOptions, headers },
+    credentials: resolvedCredentials
   };
 }
-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)
-    });
+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 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 isReplayableRequest(options) {
+  const method = (options.method || "GET").toUpperCase();
+  if (!["GET", "HEAD", "OPTIONS", "PUT", "DELETE"].includes(method)) return false;
+  return !(options.body && typeof ReadableStream !== "undefined" && options.body instanceof ReadableStream);
+}
+function createAbortError() {
+  return new DOMException("The operation was aborted.", "AbortError");
+}
+var AUTHENTICATED_FETCH, refreshPromises;
+var init_request_credentials = __esm({
+  "../loader-utils/src/lib/request-utils/request-credentials.ts"() {
+    "use strict";
+    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);
     }
-    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 (!filename.startsWith("http://") && !filename.startsWith("https://")) {
+    filename = `${pathPrefix}${filename}`;
+  }
+  return filename;
 }
-function addScalarColumn(columns, fields, schemaFields, name, values, metadata) {
-  addColumn(columns, fields, schemaFields, name, arrow.makeVector(values), "float32", metadata);
+var pathPrefix, fileAliases;
+var init_file_aliases = __esm({
+  "../loader-utils/src/lib/path-utils/file-aliases.ts"() {
+    "use strict";
+    pathPrefix = "";
+    fileAliases = {};
+  }
+});
+
+// ../loader-utils/src/lib/binary-utils/memory-conversion-utils.ts
+function ensureArrayBuffer(bufferSource) {
+  if (bufferSource instanceof ArrayBuffer) {
+    return bufferSource;
+  }
+  if (isSharedArrayBuffer(bufferSource)) {
+    return copyToArrayBuffer2(bufferSource);
+  }
+  const { buffer, byteOffset, byteLength } = bufferSource;
+  if (buffer instanceof ArrayBuffer && byteOffset === 0 && byteLength === buffer.byteLength) {
+    return buffer;
+  }
+  return copyToArrayBuffer2(buffer, byteOffset, byteLength);
 }
-function 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 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;
 }
-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]);
+var init_memory_conversion_utils = __esm({
+  "../loader-utils/src/lib/binary-utils/memory-conversion-utils.ts"() {
+    "use strict";
+    init_is_type();
+  }
+});
+
+// ../loader-utils/src/lib/sources/data-source.ts
+function getFetchFunction(options) {
+  return getAuthenticatedFetch(options);
 }
-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]);
+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;
     }
   }
-  return [fdc0, fdc1, fdc2];
+  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;
 }
-
-// dist/lib/parse-splat.js
-var SPLAT_ROW_BYTE_LENGTH = 32;
-function parseSPLAT(data) {
-  return makeGaussianSplatsArrowTable(parseSPLATToGaussianSplats(data));
+function normalizeError(error, message) {
+  if (error instanceof Error) {
+    return error;
+  }
+  if (typeof error === "string") {
+    return new Error(error);
+  }
+  return new Error(message);
 }
-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}.`);
+function unavailableCoreApiMethod(methodName) {
+  return () => {
+    throw new Error(
+      `CoreAPI.${methodName} is unavailable. Use @loaders.gl/core.createDataSource().`
+    );
+  };
+}
+var UNAVAILABLE_CORE_API, DataSource;
+var init_data_source = __esm({
+  "../loader-utils/src/lib/sources/data-source.ts"() {
+    "use strict";
+    init_merge_options();
+    init_file_aliases();
+    init_log();
+    init_request_credentials();
+    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;
+      }
+    };
   }
-  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;
+});
+
+// ../loader-utils/src/index.ts
+var init_src = __esm({
+  "../loader-utils/src/index.ts"() {
+    "use strict";
+    init_js_module_utils();
+    init_js_module_utils();
+    init_async_iteration();
+    init_memory_conversion_utils();
+    init_data_source();
   }
-  return {
-    format: "splat",
-    splatCount,
-    positions,
-    scales,
-    rotations,
-    colors,
-    opacities,
-    loaderData: {
-      format: "splat",
-      splatCount,
-      rowByteLength: SPLAT_ROW_BYTE_LENGTH
-    }
-  };
-}
+});
 
-// dist/splat-loader-types.js
-var VERSION = true ? "4.5.3" : "latest";
-var SPLATLoader = {
-  dataType: null,
-  batchType: null,
-  ...SPLATFormat,
-  version: VERSION,
-  options: {
-    splats: {
-      shape: "arrow-table"
-    }
+// ../compression/src/lib/compression.ts
+var CompressionTransform, Compressor, Decompressor, Compression;
+var init_compression = __esm({
+  "../compression/src/lib/compression.ts"() {
+    "use strict";
+    init_src();
+    CompressionTransform = class {
+      /** Preloads any dynamic libraries. May enable sync functions */
+      async preload(modules = {}) {
+        registerJSModules(modules);
+        return void 0;
+      }
+      // HELPERS
+      concatenate(asyncIterator) {
+        return concatenateArrayBuffersAsync(asyncIterator);
+      }
+      improveError(error) {
+        if (!error.message.includes(this.name)) {
+          error.message = `${this.name} ${error.message}`;
+        }
+        return error;
+      }
+    };
+    Compressor = class extends CompressionTransform {
+      constructor(options) {
+        super();
+        this.compressBatches = this.compressBatches.bind(this);
+      }
+      /** Asynchronously compresses data. */
+      async compress(input) {
+        await this.preload();
+        return this.compressSync(input);
+      }
+      /** Synchronously compresses data. */
+      compressSync(input) {
+        throw new Error(`${this.name}: sync compression not supported`);
+      }
+      /** Compresses batches. */
+      async *compressBatches(asyncIterator) {
+        const input = await this.concatenate(asyncIterator);
+        yield this.compress(input);
+      }
+    };
+    Decompressor = class extends CompressionTransform {
+      constructor(options) {
+        super();
+        this.decompressBatches = this.decompressBatches.bind(this);
+      }
+      /** Asynchronously decompresses data. */
+      async decompress(input, size) {
+        await this.preload();
+        return this.decompressSync(input, size);
+      }
+      /** Synchronously decompresses data. */
+      decompressSync(input, size) {
+        throw new Error(`${this.name}: sync decompression not supported`);
+      }
+      /** Decompresses batches. */
+      async *decompressBatches(asyncIterator) {
+        const input = await this.concatenate(asyncIterator);
+        yield this.decompress(input);
+      }
+    };
+    Compression = class extends Compressor {
+      constructor(options) {
+        super(options);
+        this.decompressBatches = this.decompressBatches.bind(this);
+      }
+      /** Asynchronously decompresses data. */
+      async decompress(input, size) {
+        await this.preload();
+        return this.decompressSync(input, size);
+      }
+      /** Synchronously decompresses data. */
+      decompressSync(input, size) {
+        throw new Error(`${this.name}: sync decompression not supported`);
+      }
+      /** Decompresses batches. */
+      async *decompressBatches(asyncIterator) {
+        const input = await this.concatenate(asyncIterator);
+        yield this.decompress(input);
+      }
+    };
   }
-};
+});
 
-// dist/splat-loader.js
-var SPLATLoaderWithParser = {
-  ...SPLATLoader,
-  parse: async (arrayBuffer) => parseSPLAT(arrayBuffer),
-  parseSync: (arrayBuffer) => parseSPLAT(arrayBuffer)
-};
+// ../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);
+      }
+    };
+  }
+});
 
-// dist/lib/parse-ksplat.js
-var CURRENT_MAJOR_VERSION = 0;
-var CURRENT_MINOR_VERSION = 1;
-var HEADER_BYTE_LENGTH = 4096;
-var SECTION_HEADER_BYTE_LENGTH = 1024;
-var DEFAULT_SH_8BIT_COMPRESSION_RANGE = 3;
-var DEFAULT_SH_8BIT_COMPRESSION_HALF_RANGE = DEFAULT_SH_8BIT_COMPRESSION_RANGE / 2;
-var 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
+// ../compression/src/lib/compression-stream.ts
+async function compressWithNativeCompressionStream(input, format) {
+  const outputBatches = compressBatchesWithNativeCompressionStream([input], format);
+  return outputBatches ? await concatenateBatches(outputBatches) : null;
+}
+function compressBatchesWithNativeCompressionStream(inputBatches, format) {
+  const compressionStream = createNativeCompressionStream(format);
+  return compressionStream ? transformBatches(inputBatches, compressionStream) : null;
+}
+function createNativeCompressionStream(format) {
+  if (typeof globalThis.CompressionStream === "undefined") {
+    return null;
+  }
+  try {
+    const CompressionStreamConstructor = globalThis.CompressionStream;
+    return new CompressionStreamConstructor(format);
+  } catch (error) {
+    if (error instanceof TypeError || (error == null ? void 0 : error.name) === "TypeError") {
+      return null;
+    }
+    throw error;
   }
-};
-function parseKSPLAT(data) {
-  return makeGaussianSplatsArrowTable(parseKSPLATToGaussianSplats(data));
 }
-function parseKSPLATToGaussianSplats(data) {
-  if (data.byteLength < HEADER_BYTE_LENGTH) {
-    throw new Error(`KSPLATLoader: file must contain a ${HEADER_BYTE_LENGTH}-byte header.`);
+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();
   }
-  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++;
+}
+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;
   }
-  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 concatenateBatches(batches) {
+  const output = [];
+  let byteLength = 0;
+  for await (const batch of batches) {
+    const bytes = new Uint8Array(batch);
+    output.push(bytes);
+    byteLength += bytes.byteLength;
+  }
+  const result = new Uint8Array(byteLength);
+  let offset = 0;
+  for (const batch of output) {
+    result.set(batch, offset);
+    offset += batch.byteLength;
+  }
+  return result.buffer;
+}
+var init_compression_stream = __esm({
+  "../compression/src/lib/compression-stream.ts"() {
+    "use strict";
+  }
+});
+
+// ../compression/src/lib/decompression-stream.ts
+async function decompressWithNativeDecompressionStream(input, format) {
+  const outputBatches = decompressBatchesWithNativeDecompressionStream([input], format);
+  return outputBatches ? await concatenateNativeDecompressionBatches(outputBatches) : null;
+}
+function decompressBatchesWithNativeDecompressionStream(inputBatches, format) {
+  const decompressionStream = createNativeDecompressionStream(format);
+  return decompressionStream ? transformBatchesWithNativeDecompressionStream(inputBatches, decompressionStream) : null;
+}
+function isNativeDecompressionSupported(format) {
+  return Boolean(createNativeDecompressionStream(format));
+}
+function createNativeDecompressionStream(format) {
+  var _a, _b;
+  if (typeof globalThis.DecompressionStream === "undefined") {
+    return null;
+  }
+  if (((_b = (_a = globalThis.process) == null ? void 0 : _a.release) == null ? void 0 : _b.name) === "node" && typeof globalThis.Buffer === "undefined") {
+    return null;
+  }
+  try {
+    const DecompressionStreamConstructor = globalThis.DecompressionStream;
+    return new DecompressionStreamConstructor(format);
+  } catch (error) {
+    if (error instanceof TypeError || (error == null ? void 0 : error.name) === "TypeError") {
+      return null;
+    }
+    throw error;
+  }
+}
+async function* transformBatchesWithNativeDecompressionStream(inputBatches, decompressionStream) {
+  const writer = decompressionStream.writable.getWriter();
+  const reader = decompressionStream.readable.getReader();
+  const writePromise = writeBatchesToNativeDecompressionStream(inputBatches, writer);
+  writePromise.catch(() => {
+  });
+  let outputCompleted = false;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        outputCompleted = true;
+        break;
+      }
+      yield copyExactArrayBuffer(value);
+    }
+    await writePromise;
+  } finally {
+    if (!outputCompleted) {
+      await reader.cancel().catch(() => {
+      });
+      await writer.abort().catch(() => {
+      });
+      await writePromise.catch(() => {
+      });
+    }
+    reader.releaseLock();
+  }
+}
+async function concatenateNativeDecompressionBatches(outputBatches) {
+  const batches = [];
+  let byteLength = 0;
+  for await (const outputBatch of outputBatches) {
+    const bytes = new Uint8Array(outputBatch);
+    batches.push(bytes);
+    byteLength += bytes.byteLength;
+  }
+  const output = new Uint8Array(byteLength);
+  let byteOffset = 0;
+  for (const batch of batches) {
+    output.set(batch, byteOffset);
+    byteOffset += batch.byteLength;
+  }
+  return output.buffer;
+}
+function copyExactArrayBuffer(value) {
+  return new Uint8Array(value).buffer;
+}
+async function writeBatchesToNativeDecompressionStream(inputBatches, writer) {
+  try {
+    for await (const inputBatch of inputBatches) {
+      await writer.write(new Uint8Array(inputBatch));
     }
+    await writer.close();
+  } catch (error) {
+    await writer.abort(error).catch(() => {
+    });
+    throw error;
+  }
+}
+var init_decompression_stream = __esm({
+  "../compression/src/lib/decompression-stream.ts"() {
+    "use strict";
+  }
+});
+
+// ../compression/src/lib/native-decompressor.ts
+var native_decompressor_exports = {};
+__export(native_decompressor_exports, {
+  NativeDecompressor: () => NativeDecompressor
+});
+var NativeDecompressor;
+var init_native_decompressor = __esm({
+  "../compression/src/lib/native-decompressor.ts"() {
+    "use strict";
+    init_compression();
+    init_decompression_stream();
+    NativeDecompressor = class extends Decompressor {
+      name;
+      extensions;
+      contentEncodings;
+      isSupported = true;
+      /** Runtime stream format used for every operation. */
+      format;
+      constructor(metadata, format, options = {}) {
+        super(options);
+        this.name = metadata.name;
+        this.extensions = [...metadata.extensions];
+        this.contentEncodings = [...metadata.contentEncodings];
+        this.format = format;
+      }
+      /** Decompresses one buffer with the runtime-provided stream. */
+      async decompress(input) {
+        const output = await decompressWithNativeDecompressionStream(input, this.format);
+        if (!output) throw new Error(`${this.name}: built-in decompression is no longer available`);
+        return output;
+      }
+      /** Decompresses batches incrementally with the runtime-provided stream. */
+      async *decompressBatches(inputBatches) {
+        const output = decompressBatchesWithNativeDecompressionStream(inputBatches, this.format);
+        if (!output) throw new Error(`${this.name}: built-in decompression is no longer available`);
+        yield* output;
+      }
+    };
+  }
+});
+
+// ../compression/src/lib/lazy-compression.ts
+function mergeModules(options, modules) {
+  return { ...options, modules: { ...options.modules, ...modules } };
+}
+var LazyDecompressor;
+var init_lazy_compression = __esm({
+  "../compression/src/lib/lazy-compression.ts"() {
+    "use strict";
+    init_compression();
+    init_decompression_stream();
+    LazyDecompressor = class extends Decompressor {
+      name;
+      extensions;
+      contentEncodings;
+      isSupported = true;
+      /** Constructor options retained until a concrete implementation is selected. */
+      options;
+      /** Built-in stream format to probe, or null when the format has no built-in path. */
+      nativeFormat;
+      /** Returns whether built-in selection remains eligible for the merged preload options. */
+      shouldUseNative;
+      /** Dynamically imports the balanced fallback constructor. */
+      loadFallback;
+      /** Selected concrete implementation after preload completes. */
+      implementation = null;
+      /** Shared in-flight selection used by concurrent asynchronous calls. */
+      implementationPromise = null;
+      constructor(metadata, loadFallback, options = {}, nativeFormat = null, shouldUseNative = () => true) {
+        super(options);
+        this.name = metadata.name;
+        this.extensions = [...metadata.extensions];
+        this.contentEncodings = [...metadata.contentEncodings];
+        this.options = options;
+        this.nativeFormat = nativeFormat;
+        this.shouldUseNative = shouldUseNative;
+        this.loadFallback = loadFallback;
+      }
+      /** Selects and returns the built-in or dynamically imported fallback decompressor. */
+      async preload(modules = {}) {
+        if (this.implementation) return this.implementation;
+        const options = mergeModules(this.options, modules);
+        this.implementationPromise ||= this.loadImplementation(options);
+        try {
+          this.implementation = await this.implementationPromise;
+          return this.implementation;
+        } catch (error) {
+          this.implementationPromise = null;
+          throw error;
+        }
+      }
+      /** Loads the selected concrete decompressor. */
+      async loadImplementation(options) {
+        if (options.useNative !== false && this.nativeFormat && this.shouldUseNative(options) && isNativeDecompressionSupported(this.nativeFormat)) {
+          const { NativeDecompressor: NativeDecompressor2 } = await Promise.resolve().then(() => (init_native_decompressor(), native_decompressor_exports));
+          return new NativeDecompressor2(this, this.nativeFormat, options);
+        }
+        const Decompressor2 = await this.loadFallback();
+        const implementation = new Decompressor2({ ...options, useNative: false });
+        await implementation.preload(options.modules);
+        return implementation;
+      }
+      /** Decompresses after lazily selecting the default implementation. */
+      async decompress(input, size) {
+        return (await this.preload()).decompress(input, size);
+      }
+      /** Decompresses synchronously after an implementation has been preloaded. */
+      decompressSync(input, size) {
+        if (!this.implementation) {
+          throw new Error(`${this.name}: call preload() before decompressSync()`);
+        }
+        return this.implementation.decompressSync(input, size);
+      }
+      /** Decompresses batches after lazily selecting the default implementation. */
+      async *decompressBatches(inputBatches) {
+        yield* (await this.preload()).decompressBatches(inputBatches);
+      }
+    };
+  }
+});
+
+// ../compression/src/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;
 }
-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);
+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);
 }
-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}.`);
+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 {
-    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
+    shape: "arrow-table",
+    schema,
+    data: new arrow.Table(arrowSchema, columns),
+    topology: "point-list",
+    loaderData: splats.loaderData
   };
 }
-function checkKSPLATVersion(header) {
-  if (header.versionMajor === CURRENT_MAJOR_VERSION ? header.versionMinor >= CURRENT_MINOR_VERSION : header.versionMajor > CURRENT_MAJOR_VERSION) {
-    return;
+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)
+    });
   }
-  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
+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"
     });
-    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 addScalarColumn(columns, fields, schemaFields, name, values, metadata) {
+  addColumn(columns, fields, schemaFields, name, arrow.makeVector(values), "float32", metadata);
 }
-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 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 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 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 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;
+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]);
     }
-    bucketSplatIndex += bucketLength;
-    bucketIndex++;
   }
-  return Math.max(bucketIndex - 1, 0);
+  return [fdc0, fdc1, fdc2];
 }
-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);
+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));
 }
-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);
+async function parseSPZToGaussianSplats(data, options) {
+  var _a, _b, _c;
+  const version2 = detectSPZVersion(data);
+  if (version2 === 0) {
+    return await parseLegacySPZ(data, options);
   }
-  if (compressionLevel === 1 || !sphericalHarmonic) {
-    return decodeFloat16(dataView.getUint16(byteOffset + component * 2, true));
+  if (version2 !== SPZ_VERSION) {
+    throw new Error(`SPZLoader: version ${version2} is not supported.`);
   }
-  const value = dataView.getUint8(byteOffset + component);
-  return value / 255 * (sphericalHarmonicRangeMax - sphericalHarmonicRangeMin) + sphericalHarmonicRangeMin;
+  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 getBytesPerSplat(compressionLevel, sphericalHarmonicsDegree) {
-  const layout = COMPRESSION_LAYOUTS[compressionLevel];
-  return layout.bytesPerCenter + layout.bytesPerScale + layout.bytesPerRotation + layout.bytesPerColor + layout.bytesPerSphericalHarmonicsComponent * getSphericalHarmonicsComponentCount(sphericalHarmonicsDegree);
+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);
 }
-function getSphericalHarmonicsComponentCount(sphericalHarmonicsDegree) {
-  switch (sphericalHarmonicsDegree) {
-    case 0:
-      return 0;
-    case 1:
-      return 9;
-    case 2:
-      return 24;
-    case 3:
-      return 45;
-    default:
-      throw new Error(`KSPLATLoader: unsupported spherical harmonics degree ${sphericalHarmonicsDegree}.`);
+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 getActiveSectionCount(header) {
-  return header.sectionCount || header.maxSectionCount;
+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 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 signedByte(value) {
+  return value > 127 ? value - 256 : value;
 }
-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.");
+function applySPZCoordinateSystem(splats, source, target) {
+  if (source === target || source === "UNSPECIFIED" || target === "UNSPECIFIED") {
+    return splats;
   }
-}
-
-// dist/ksplat-loader-types.js
-var VERSION2 = true ? "4.5.3" : "latest";
-var KSPLATLoader = {
-  dataType: null,
-  batchType: null,
-  ...KSPLATFormat,
-  version: VERSION2,
-  options: {
-    splats: {
-      shape: "arrow-table"
+  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;
   }
-};
-
-// dist/ksplat-loader.js
-var KSPLATLoaderWithParser = {
-  ...KSPLATLoader,
-  parse: async (arrayBuffer) => parseKSPLAT(arrayBuffer),
-  parseSync: (arrayBuffer) => parseKSPLAT(arrayBuffer)
-};
-
-// dist/lib/parse-spz.js
-var import_compression = require("@loaders.gl/compression");
-var SPZ_HEADER_BYTE_LENGTH = 32;
-var SPZ_MAGIC = 1347635022;
-var SPZ_VERSION = 4;
-var SPZ_EXTENSION_FLAG = 2;
-var SPZ_COLOR_SCALE = 0.15;
-var SPZ_ROTATION_COMPONENT_SCALE = Math.SQRT1_2;
-var SPZ_ROTATION_COMPONENT_MASK = (1 << 9) - 1;
-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);
+  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) {
@@ -694,7 +2253,7 @@ function getSPZStreamByteLengths(header) {
     header.numPoints * 3,
     header.numPoints * 3,
     header.numPoints * 4,
-    header.numPoints * getSphericalHarmonicsComponentCount2(header.shDegree)
+    header.numPoints * getSphericalHarmonicsComponentCount(header.shDegree)
   ].filter((byteLength) => byteLength > 0);
 }
 function validateSPZStreamLengths(streams, streamInfos) {
@@ -712,7 +2271,7 @@ function decodeSPZStreams(header, streams, sourceData) {
   const colors = new Uint8Array(splatCount * 3);
   const sphericalHarmonicDcs = new Float32Array(splatCount * 3);
   const opacities = new Float32Array(splatCount);
-  const sphericalHarmonicsComponentCount = getSphericalHarmonicsComponentCount2(header.shDegree);
+  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);
@@ -743,75 +2302,423 @@ function decodeSPZStreams(header, streams, sourceData) {
     }
   };
 }
-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 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 decodeSPZScales(scaleStream, scales) {
+  for (let componentIndex = 0; componentIndex < scales.length; componentIndex++) {
+    scales[componentIndex] = Math.exp(scaleStream[componentIndex] / 16 - 10);
+  }
+}
+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;
+  }
+}
+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;
+    }
+  }
+  rotation[largestComponent] = Math.sqrt(Math.max(0, 1 - sumSquares));
+  return rotation;
+}
+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 decodeSPZOpacities(alphaStream, opacities) {
+  for (let splatIndex = 0; splatIndex < opacities.length; splatIndex++) {
+    opacities[splatIndex] = alphaStream[splatIndex] / 255;
+  }
+}
+function decodeSPZSphericalHarmonics(sphericalHarmonicsStream, sphericalHarmonics) {
+  for (let componentIndex = 0; componentIndex < sphericalHarmonics.length; componentIndex++) {
+    sphericalHarmonics[componentIndex] = (sphericalHarmonicsStream[componentIndex] - 128) / 128;
+  }
+}
+function normalizeColorByte(sphericalHarmonicDc) {
+  return Math.min(Math.max(Math.round((sphericalHarmonicDc * SPZ_COLOR_SCALE + 0.5) * 255), 0), 255);
+}
+function getSphericalHarmonicsComponentCount(shDegree) {
+  switch (shDegree) {
+    case 0:
+      return 0;
+    case 1:
+      return 9;
+    case 2:
+      return 24;
+    case 3:
+      return 45;
+    case 4:
+      return 72;
+    default:
+      throw new Error(`SPZLoader: spherical harmonics degree ${shDegree} is not supported.`);
+  }
+}
+function getSPZExtensionByteLength(header) {
+  return header.flags & SPZ_EXTENSION_FLAG ? header.tocByteOffset - SPZ_HEADER_BYTE_LENGTH : 0;
+}
+function getSPZExtensionBytes(data, header) {
+  const extensionByteLength = getSPZExtensionByteLength(header);
+  return extensionByteLength ? new Uint8Array(data.slice(SPZ_HEADER_BYTE_LENGTH, header.tocByteOffset)) : void 0;
+}
+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 SPLAT_ROW_BYTE_LENGTH;
+var init_parse_splat = __esm({
+  "dist/lib/parse-splat.js"() {
+    "use strict";
+    init_splats_arrow_table();
+    init_splat_utils();
+    SPLAT_ROW_BYTE_LENGTH = 32;
+  }
+});
+
+// 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"() {
+    "use strict";
+    init_parse_splat();
+    init_splat_loader_types();
+    ({ preload: _SPLATLoaderPreload, ...SPLATLoaderMetadataWithoutPreload } = SPLATLoader);
+    SPLATLoaderWithParser = {
+      ...SPLATLoaderMetadataWithoutPreload,
+      parse: async (arrayBuffer) => parseSPLAT(arrayBuffer),
+      parseSync: (arrayBuffer) => parseSPLAT(arrayBuffer)
+    };
+  }
+});
+
+// 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, SPLATLoader;
+var init_splat_loader_types = __esm({
+  "dist/splat-loader-types.js"() {
+    "use strict";
+    init_splats_format();
+    VERSION2 = true ? "5.0.0-alpha.10" : "latest";
+    SPLATLoader = {
+      dataType: null,
+      batchType: null,
+      ...SPLATFormat,
+      version: VERSION2,
+      options: {
+        splats: {
+          shape: "arrow-table"
+        }
+      },
+      preload
+    };
+  }
+});
+
+// dist/lib/parse-ksplat.js
+function parseKSPLAT(data) {
+  return makeGaussianSplatsArrowTable(parseKSPLATToGaussianSplats(data));
+}
+function parseKSPLATToGaussianSplats(data) {
+  if (data.byteLength < HEADER_BYTE_LENGTH) {
+    throw new Error(`KSPLATLoader: file must contain a ${HEADER_BYTE_LENGTH}-byte header.`);
+  }
+  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 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++;
+    }
+  }
+  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
+      }))
+    }
+  };
+}
+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 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 decodeSPZScales(scaleStream, scales) {
-  for (let componentIndex = 0; componentIndex < scales.length; componentIndex++) {
-    scales[componentIndex] = Math.exp(scaleStream[componentIndex] / 16 - 10);
+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 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;
+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 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:
@@ -820,99 +2727,224 @@ 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;
+}
+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";
+    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
+      }
+    };
+  }
+});
 
-// dist/spz-loader-types.js
-var VERSION3 = true ? "4.5.3" : "latest";
-var SPZLoader = {
-  dataType: null,
-  batchType: null,
-  ...SPZFormat,
-  version: VERSION3,
-  options: {
-    splats: {
-      shape: "arrow-table"
-    }
+// 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.10" : "latest";
+    KSPLATLoader = {
+      dataType: null,
+      batchType: null,
+      ...KSPLATFormat,
+      version: VERSION3,
+      options: {
+        splats: {
+          shape: "arrow-table"
+        }
+      },
+      preload: preload2
+    };
+  }
+});
 
 // dist/spz-loader.js
-var SPZLoaderWithParser = {
-  ...SPZLoader,
-  parse: async (arrayBuffer, options) => parseSPZ(arrayBuffer, options)
-};
+var spz_loader_exports = {};
+__export(spz_loader_exports, {
+  SPZLoaderWithParser: () => SPZLoaderWithParser
+});
+var _SPZLoaderPreload, SPZLoaderMetadataWithoutPreload, SPZLoaderWithParser;
+var init_spz_loader = __esm({
+  "dist/spz-loader.js"() {
+    "use strict";
+    init_parse_spz();
+    init_spz_loader_types();
+    ({ preload: _SPZLoaderPreload, ...SPZLoaderMetadataWithoutPreload } = SPZLoader);
+    SPZLoaderWithParser = {
+      ...SPZLoaderMetadataWithoutPreload,
+      parse: async (arrayBuffer, options) => parseSPZ(arrayBuffer, options)
+    };
+  }
+});
+
+// dist/spz-loader-types.js
+async function preload3() {
+  const { SPZLoaderWithParser: SPZLoaderWithParser2 } = await Promise.resolve().then(() => (init_spz_loader(), spz_loader_exports));
+  return SPZLoaderWithParser2;
+}
+var VERSION4, SPZLoader;
+var init_spz_loader_types = __esm({
+  "dist/spz-loader-types.js"() {
+    "use strict";
+    init_splats_format();
+    VERSION4 = true ? "5.0.0-alpha.10" : "latest";
+    SPZLoader = {
+      dataType: null,
+      batchType: null,
+      ...SPZFormat,
+      version: VERSION4,
+      options: {
+        splats: {
+          shape: "arrow-table"
+        }
+      },
+      preload: preload3
+    };
+  }
+});
 
 // dist/rad-zod-schema.js
-var import_zod = require("zod");
-var nonNegativeSafeIntegerSchema = import_zod.z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
-var 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();
-var RADChunkRangeSchema = import_zod.z.object({
-  offset: nonNegativeSafeIntegerSchema,
-  bytes: nonNegativeSafeIntegerSchema,
-  base: nonNegativeSafeIntegerSchema.optional(),
-  count: nonNegativeSafeIntegerSchema.optional(),
-  filename: import_zod.z.string().optional()
-}).passthrough();
-var 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();
-var 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();
-var 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();
+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
-var RAD_MAGIC = 809779538;
-var RAD_CHUNK_MAGIC = 1128546642;
-var RAD_HEADER_BYTE_LENGTH = 8;
-var RAD_CHUNK_PAYLOAD_LENGTH_BYTE_LENGTH = 8;
-var TEXT_DECODER = new TextDecoder();
 function parseRADHeader(data) {
   const metadata = tryParseRADHeader(data);
   if (!metadata) {
@@ -998,21 +3030,89 @@ function readSafeUint642(dataView, byteOffset, fieldName) {
 function getUint8Array(data) {
   return data instanceof ArrayBuffer ? new Uint8Array(data) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
 }
+var RAD_MAGIC, RAD_CHUNK_MAGIC, RAD_HEADER_BYTE_LENGTH, RAD_CHUNK_PAYLOAD_LENGTH_BYTE_LENGTH, TEXT_DECODER;
+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;
+    RAD_CHUNK_PAYLOAD_LENGTH_BYTE_LENGTH = 8;
+    TEXT_DECODER = new TextDecoder();
+  }
+});
 
-// dist/rad-loader-types.js
-var VERSION4 = true ? "4.5.3" : "latest";
-var RADLoader = {
-  dataType: null,
-  batchType: null,
-  ...RADFormat,
-  version: VERSION4,
-  options: {}
-};
+// ../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
-var import_compression2 = require("@loaders.gl/compression");
-var RAD_PROPERTY_DEFLATE = new import_compression2.DeflateCompression();
-var RAD_PROPERTY_RAW_DEFLATE = new import_compression2.DeflateCompression({ raw: true });
 function parseRADChunk(data, options) {
   return makeGaussianSplatsArrowTable(parseRADChunkToGaussianSplats(data, options));
 }
@@ -1220,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 {
@@ -1278,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;
@@ -1288,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++) {
@@ -1302,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++) {
@@ -1320,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;
@@ -1367,11 +3467,11 @@ 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) {
@@ -1462,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;
@@ -1470,25 +3570,108 @@ function copyToArrayBuffer(bytes) {
 function getUint8Array2(data) {
   return data instanceof ArrayBuffer ? new Uint8Array(data) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
 }
+var RAD_PROPERTY_DEFLATE, RAD_PROPERTY_RAW_DEFLATE;
+var init_parse_rad_chunk = __esm({
+  "dist/lib/parse-rad-chunk.js"() {
+    "use strict";
+    init_deflate_decompressor();
+    init_parse_rad();
+    init_splats_arrow_table();
+    init_splat_utils();
+    RAD_PROPERTY_DEFLATE = new DeflateDecompressor2({ useNative: false });
+    RAD_PROPERTY_RAW_DEFLATE = new DeflateDecompressor2({ raw: true, useNative: false });
+  }
+});
 
 // dist/rad-loader.js
-var RADLoaderWithParser = {
-  ...RADLoader,
-  parse: async (arrayBuffer) => parseRADHeader(arrayBuffer),
-  parseSync: (arrayBuffer) => parseRADHeader(arrayBuffer)
-};
+var rad_loader_exports = {};
+__export(rad_loader_exports, {
+  RADLoaderWithParser: () => RADLoaderWithParser,
+  parseRADChunk: () => parseRADChunk,
+  parseRADChunkHeader: () => parseRADChunkHeader,
+  parseRADChunkToGaussianSplats: () => parseRADChunkToGaussianSplats,
+  parseRADHeader: () => parseRADHeader,
+  tryParseRADHeader: () => tryParseRADHeader
+});
+var _RADLoaderPreload, RADLoaderMetadataWithoutPreload, RADLoaderWithParser;
+var init_rad_loader = __esm({
+  "dist/rad-loader.js"() {
+    "use strict";
+    init_parse_rad();
+    init_rad_loader_types();
+    init_parse_rad();
+    init_parse_rad_chunk();
+    ({ preload: _RADLoaderPreload, ...RADLoaderMetadataWithoutPreload } = RADLoader);
+    RADLoaderWithParser = {
+      ...RADLoaderMetadataWithoutPreload,
+      parse: async (arrayBuffer) => parseRADHeader(arrayBuffer),
+      parseSync: (arrayBuffer) => parseRADHeader(arrayBuffer)
+    };
+  }
+});
+
+// dist/rad-loader-types.js
+async function preload4() {
+  const { RADLoaderWithParser: RADLoaderWithParser2 } = await Promise.resolve().then(() => (init_rad_loader(), rad_loader_exports));
+  return RADLoaderWithParser2;
+}
+var VERSION5, RADLoader;
+var init_rad_loader_types = __esm({
+  "dist/rad-loader-types.js"() {
+    "use strict";
+    init_splats_format();
+    VERSION5 = true ? "5.0.0-alpha.10" : "latest";
+    RADLoader = {
+      dataType: null,
+      batchType: null,
+      ...RADFormat,
+      version: VERSION5,
+      options: {},
+      preload: preload4
+    };
+  }
+});
+
+// dist/index.js
+var index_exports = {};
+__export(index_exports, {
+  KSPLATFormat: () => KSPLATFormat,
+  KSPLATLoader: () => KSPLATLoader,
+  RADFormat: () => RADFormat,
+  RADLoader: () => RADLoader,
+  RADSource: () => RADSource,
+  RADSourceLoader: () => RADSourceLoader,
+  SPLATFormat: () => SPLATFormat,
+  SPLATLoader: () => SPLATLoader,
+  SPZFormat: () => SPZFormat,
+  SPZLoader: () => SPZLoader,
+  parseSPZ: () => parseSPZ,
+  parseSPZToGaussianSplats: () => parseSPZToGaussianSplats,
+  resolveRADChunkUrl: () => resolveRADChunkUrl
+});
+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 ? "4.5.3" : "latest";
+var VERSION6 = true ? "5.0.0-alpha.10" : "latest";
 var RADSourceLoader = {
   dataType: null,
   batchType: null,
   ...RADFormat,
   name: "RADSourceLoader",
-  version: VERSION5,
+  version: VERSION6,
   type: "rad",
   fromUrl: true,
   fromBlob: true,
@@ -1507,17 +3690,17 @@ var RADSourceLoader = {
     }
   },
   testURL: (url) => /\.rad(?:$|[?#])/i.test(url),
-  createDataSource: (data, options) => new RADSource(data, options)
+  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. */
   _metadataPromise = null;
   /** Lazily initialized per-chunk metadata promises. */
   _chunkMetadataPromises = /* @__PURE__ */ new Map();
-  constructor(data, options) {
-    super(data, options, RADSourceLoader.defaultOptions);
+  constructor(data, options, coreApi) {
+    super(data, options, RADSourceLoader.defaultOptions, coreApi);
     this.metadata = this.getMetadata();
   }
   /** Ensures the RAD header metadata has been loaded. */
@@ -1685,7 +3868,15 @@ var RADSource = class extends import_loader_utils.DataSource {
   }
   /** Fetches through custom source fetch hooks or the injected core fetchFile helper. */
   async _fetchResponse(url, requestInit) {
-    return await this.fetch(url, requestInit);
+    if (this._hasCustomFetch()) {
+      return await this.fetch(url, requestInit);
+    }
+    return this.hasCoreApi ? await this.coreApi.fetchFile(url, requestInit) : await this.fetch(url, requestInit);
+  }
+  /** Returns true when source options supplied an explicit fetch override. */
+  _hasCustomFetch() {
+    var _a, _b, _c;
+    return Boolean(((_b = (_a = this.loadOptions) == null ? void 0 : _a.core) == null ? void 0 : _b.fetch) || ((_c = this.loadOptions) == null ? void 0 : _c.fetch));
   }
   /** Builds request options for RAD fetches. */
   _getRequestInit(range, options = {}) {