@loaders.gl/splats 5.0.0-alpha.6 → 5.0.0-alpha.8

package/dist/index.cjs

@@ -81,1894 +81,2196 @@ var init_splats_format = __esm({
   }
 });
 
-// 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);
+// ../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 SH_C0;
-var init_splat_utils = __esm({
-  "dist/lib/splat-utils.js"() {
+var import_log, VERSION, version, log;
+var init_log = __esm({
+  "../loader-utils/src/lib/log-utils/log.ts"() {
     "use strict";
-    SH_C0 = 0.28209479177387814;
+    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
-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);
+// ../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;
   }
-  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
-  };
+});
+
+// ../loader-utils/src/lib/option-utils/merge-options.ts
+function mergeOptions(baseOptions, newOptions) {
+  return mergeOptionsRecursively(baseOptions || {}, newOptions);
 }
-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];
+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];
     }
-    addScalarColumn(columns, fields, schemaFields, `${prefix}_${component}`, componentValues, {
-      ...metadata,
-      "loaders_gl.gaussian_splats.component": String(component)
-    });
   }
+  return options;
 }
-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"
-    });
+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 addScalarColumn(columns, fields, schemaFields, name, values, metadata) {
-  addColumn(columns, fields, schemaFields, name, arrow.makeVector(values), "float32", metadata);
+function getJSModule(name, caller) {
+  var _a, _b;
+  const module2 = (_b = (_a = globalThis.loaders) == null ? void 0 : _a.modules) == null ? void 0 : _b[name];
+  if (!module2) {
+    throw new Error(`${caller}: ${name} library not installed`);
+  }
+  return module2;
 }
-function 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 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 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_js_module_utils = __esm({
+  "../loader-utils/src/lib/module-utils/js-module-utils.ts"() {
+    "use strict";
+  }
+});
+
+// ../loader-utils/src/lib/binary-utils/array-buffer-utils.ts
+function concatenateArrayBuffers(...sources) {
+  return concatenateArrayBuffersFromArray(sources);
 }
-function 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 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 [fdc0, fdc1, fdc2];
+  return result.buffer;
 }
-var arrow;
-var init_splats_arrow_table = __esm({
-  "dist/lib/splats-arrow-table.js"() {
+var init_array_buffer_utils = __esm({
+  "../loader-utils/src/lib/binary-utils/array-buffer-utils.ts"() {
     "use strict";
-    arrow = __toESM(require("apache-arrow"), 1);
-    init_splat_utils();
   }
 });
 
-// dist/lib/parse-splat.js
-function parseSPLAT(data) {
-  return makeGaussianSplatsArrowTable(parseSPLATToGaussianSplats(data));
+// ../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 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 copyToArrayBuffer(chunk) {
+  if (chunk instanceof ArrayBuffer) {
+    return chunk;
   }
-  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;
+  if (ArrayBuffer.isView(chunk)) {
+    const { buffer, byteOffset, byteLength } = chunk;
+    return copyFromBuffer(buffer, byteOffset, byteLength);
   }
-  return {
-    format: "splat",
-    splatCount,
-    positions,
-    scales,
-    rotations,
-    colors,
-    opacities,
-    loaderData: {
-      format: "splat",
-      splatCount,
-      rowByteLength: SPLAT_ROW_BYTE_LENGTH
-    }
-  };
+  return copyFromBuffer(chunk);
 }
-var SPLAT_ROW_BYTE_LENGTH;
-var init_parse_splat = __esm({
-  "dist/lib/parse-splat.js"() {
+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_splats_arrow_table();
-    init_splat_utils();
-    SPLAT_ROW_BYTE_LENGTH = 32;
+    init_array_buffer_utils();
   }
 });
 
-// dist/splat-loader.js
-var splat_loader_exports = {};
-__export(splat_loader_exports, {
-  SPLATLoaderWithParser: () => SPLATLoaderWithParser
-});
-var _SPLATLoaderPreload, SPLATLoaderMetadataWithoutPreload, SPLATLoaderWithParser;
-var init_splat_loader = __esm({
-  "dist/splat-loader.js"() {
+// ../loader-utils/src/lib/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;
+  });
+}
+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";
-    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;
+// ../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]);
+  });
+  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;
+    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 = authorization.credentials.filter(
+      ({ credential }) => typeof credential.token === "function" && credential.refreshStatusCodes.includes(response.status)
+    );
+    const shouldRetrySignature = signedRequest.credentials.some(
+      (credential) => {
+        var _a2;
+        return (_a2 = credential.refreshStatusCodes) == null ? void 0 : _a2.includes(response.status);
+      }
+    );
+    if (!refreshableCredentials.length && !shouldRetrySignature || !isReplayableRequest(requestOptions) || !isReplayableRequest(signedRequest.options))
+      return response;
+    if ((_b = requestOptions.signal) == null ? void 0 : _b.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 ((_c = response.body) == null ? void 0 : _c.cancel().catch(() => {
+    }));
+    if ((_d = requestOptions.signal) == null ? void 0 : _d.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
+    }
+  });
+  return authenticatedFetch;
 }
-var VERSION, SPLATLoader;
-var init_splat_loader_types = __esm({
-  "dist/splat-loader-types.js"() {
-    "use strict";
-    init_splats_format();
-    VERSION = true ? "5.0.0-alpha.6" : "latest";
-    SPLATLoader = {
-      dataType: null,
-      batchType: null,
-      ...SPLATFormat,
-      version: VERSION,
-      options: {
-        splats: {
-          shape: "arrow-table"
-        }
-      },
-      preload
-    };
+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);
   }
-});
-
-// dist/lib/parse-ksplat.js
-function parseKSPLAT(data) {
-  return makeGaussianSplatsArrowTable(parseKSPLATToGaussianSplats(data));
+  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
+  });
 }
-function parseKSPLATToGaussianSplats(data) {
-  if (data.byteLength < HEADER_BYTE_LENGTH) {
-    throw new Error(`KSPLATLoader: file must contain a ${HEADER_BYTE_LENGTH}-byte header.`);
+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;
   }
-  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++;
+  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);
   }
-  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
-      }))
-    }
-  };
+  if (signal == null ? void 0 : signal.aborted) throw createAbortError();
+  return { ...request, credentials: appliedCredentials };
 }
-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 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 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}.`);
+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;
+  });
+}
+async function authorizeRequest(sourceURL, requestOptions, credentials, tokenOverrides = /* @__PURE__ */ new Map(), previousCredentials = []) {
+  const url = new URL(sourceURL);
+  const headers = new Headers(requestOptions.headers);
+  const resolvedCredentials = [];
+  const previousTokens = new Map(
+    previousCredentials.map(({ credential, token }) => [credential, token])
+  );
+  for (const credential of credentials) {
+    if (!credential.origins.includes(url.origin)) continue;
+    const overrideToken = tokenOverrides.get(credential);
+    const previousToken = previousTokens.get(credential);
+    const ownsQueryParameter = credential.type === "query-parameter" && previousToken !== void 0;
+    const ownsHeader = credential.type === "header" && previousToken !== void 0;
+    if (credential.type === "query-parameter" && url.searchParams.has(credential.name) && !ownsQueryParameter || credential.type === "header" && headers.has(credential.name) && !ownsHeader) {
+      continue;
+    }
+    const token = overrideToken ?? previousToken ?? await resolveToken(credential.token, { url: sourceURL.toString(), reason: "request" });
+    if (!token) continue;
+    if (credential.type === "query-parameter") {
+      url.searchParams.set(credential.name, token);
+    } else {
+      headers.set(credential.name, `${credential.prefix || ""}${token}`);
+    }
+    resolvedCredentials.push({ credential, token });
   }
   return {
-    versionMajor: dataView.getUint8(0),
-    versionMinor: dataView.getUint8(1),
-    maxSectionCount: dataView.getUint32(4, true),
-    sectionCount: dataView.getUint32(8, true),
-    maxSplatCount: dataView.getUint32(12, true),
-    splatCount: dataView.getUint32(16, true),
-    compressionLevel,
-    minSphericalHarmonicsCoeff: dataView.getFloat32(36, true) || -DEFAULT_SH_8BIT_COMPRESSION_HALF_RANGE,
-    maxSphericalHarmonicsCoeff: dataView.getFloat32(40, true) || DEFAULT_SH_8BIT_COMPRESSION_HALF_RANGE
-  };
-}
-function checkKSPLATVersion(header) {
-  if (header.versionMajor === CURRENT_MAJOR_VERSION ? header.versionMinor >= CURRENT_MINOR_VERSION : header.versionMajor > CURRENT_MAJOR_VERSION) {
-    return;
-  }
-  throw new Error(`KSPLATLoader: version ${header.versionMajor}.${header.versionMinor} is not supported.`);
-}
-function parseKSPLATSections(data, header) {
-  if (data.byteLength < HEADER_BYTE_LENGTH + header.maxSectionCount * SECTION_HEADER_BYTE_LENGTH) {
-    throw new Error("KSPLATLoader: file does not contain all section headers.");
-  }
-  const sections = [];
-  let sectionBase = HEADER_BYTE_LENGTH + header.maxSectionCount * SECTION_HEADER_BYTE_LENGTH;
-  let splatCountOffset = 0;
-  for (let sectionIndex = 0; sectionIndex < header.maxSectionCount; sectionIndex++) {
-    const sectionHeaderBase = HEADER_BYTE_LENGTH + sectionIndex * SECTION_HEADER_BYTE_LENGTH;
-    const dataView = new DataView(data, sectionHeaderBase, SECTION_HEADER_BYTE_LENGTH);
-    const splatCount = dataView.getUint32(0, true);
-    const maxSplatCount = dataView.getUint32(4, true);
-    const bucketSize = dataView.getUint32(8, true);
-    const bucketCount = dataView.getUint32(12, true);
-    const bucketBlockSize = dataView.getFloat32(16, true);
-    const bucketStorageSizeBytes = dataView.getUint16(20, true);
-    const compressionScaleRange = dataView.getUint32(24, true) || COMPRESSION_LAYOUTS[header.compressionLevel].scaleRange;
-    const fullBucketCount = dataView.getUint32(32, true);
-    const partiallyFilledBucketCount = dataView.getUint32(36, true);
-    const sphericalHarmonicsDegree = dataView.getUint16(40, true);
-    const bytesPerSplat = getBytesPerSplat(header.compressionLevel, sphericalHarmonicsDegree);
-    const bucketsMetaDataSizeBytes = partiallyFilledBucketCount * 4;
-    const bucketsStorageSizeBytes = bucketStorageSizeBytes * bucketCount + bucketsMetaDataSizeBytes;
-    const storageSizeBytes = bytesPerSplat * maxSplatCount + bucketsStorageSizeBytes;
-    sections.push({
-      bytesPerSplat,
-      splatCountOffset,
-      splatCount: splatCount || maxSplatCount,
-      maxSplatCount,
-      bucketSize,
-      bucketCount,
-      bucketStorageSizeBytes,
-      bucketsStorageSizeBytes,
-      compressionScaleRange,
-      compressionScaleFactor: bucketBlockSize / 2 / compressionScaleRange,
-      base: sectionBase,
-      bucketsBase: sectionBase + bucketsMetaDataSizeBytes,
-      dataBase: sectionBase + bucketsStorageSizeBytes,
-      fullBucketCount,
-      partiallyFilledBucketCount,
-      sphericalHarmonicsDegree
-    });
-    sectionBase += storageSizeBytes;
-    splatCountOffset += maxSplatCount;
-  }
-  return sections;
+    url: url.toString(),
+    options: { ...requestOptions, headers },
+    credentials: resolvedCredentials
+  };
 }
-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;
+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;
 }
-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);
+async function resolveToken(token, context) {
+  return typeof token === "function" ? token(context) : token;
 }
-function getBucketCenter(data, section, localSplatIndex) {
-  if (!section.bucketCount) {
-    return [0, 0, 0];
+function parseHTTPURL(url) {
+  try {
+    const parsedURL = new URL(url);
+    return ["http:", "https:"].includes(parsedURL.protocol) ? parsedURL : null;
+  } catch {
+    return null;
   }
-  const bucketIndex = getBucketIndex(data, section, localSplatIndex);
-  const bucketBase = section.bucketsBase + bucketIndex * section.bucketStorageSizeBytes;
-  const dataView = new DataView(data, bucketBase, 12);
-  return [dataView.getFloat32(0, true), dataView.getFloat32(4, true), dataView.getFloat32(8, true)];
 }
-function getBucketIndex(data, section, localSplatIndex) {
-  const maxSplatIndexInFullBuckets = section.fullBucketCount * section.bucketSize;
-  if (localSplatIndex < maxSplatIndexInFullBuckets) {
-    return Math.floor(localSplatIndex / section.bucketSize);
+function 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();
   }
-  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;
+});
+
+// ../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);
     }
-    bucketSplatIndex += bucketLength;
-    bucketIndex++;
   }
-  return Math.max(bucketIndex - 1, 0);
-}
-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);
+  if (!filename.startsWith("http://") && !filename.startsWith("https://")) {
+    filename = `${pathPrefix}${filename}`;
   }
+  return filename;
 }
-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);
+var pathPrefix, fileAliases;
+var init_file_aliases = __esm({
+  "../loader-utils/src/lib/path-utils/file-aliases.ts"() {
+    "use strict";
+    pathPrefix = "";
+    fileAliases = {};
   }
-  if (compressionLevel === 1 || !sphericalHarmonic) {
-    return decodeFloat16(dataView.getUint16(byteOffset + component * 2, true));
+});
+
+// ../loader-utils/src/lib/binary-utils/memory-conversion-utils.ts
+function ensureArrayBuffer(bufferSource) {
+  if (bufferSource instanceof ArrayBuffer) {
+    return bufferSource;
   }
-  const value = dataView.getUint8(byteOffset + component);
-  return value / 255 * (sphericalHarmonicRangeMax - sphericalHarmonicRangeMin) + sphericalHarmonicRangeMin;
+  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 getBytesPerSplat(compressionLevel, sphericalHarmonicsDegree) {
-  const layout = COMPRESSION_LAYOUTS[compressionLevel];
-  return layout.bytesPerCenter + layout.bytesPerScale + layout.bytesPerRotation + layout.bytesPerColor + layout.bytesPerSphericalHarmonicsComponent * getSphericalHarmonicsComponentCount(sphericalHarmonicsDegree);
+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 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}.`);
+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 getActiveSectionCount(header) {
-  return header.sectionCount || header.maxSectionCount;
-}
-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 getSourceLoaderOptions(options) {
+  var _a;
+  if (options.loadOptions !== void 0 || ((_a = options.core) == null ? void 0 : _a.loadOptions) !== void 0) {
+    throw new Error(
+      "Source loadOptions and core.loadOptions were removed. Use core and root loader namespaces directly."
+    );
+  }
+  const loadOptions = { ...options };
+  if (options == null ? void 0 : options.core) {
+    loadOptions.core = { ...options.core };
+    const parserCore = loadOptions.core;
+    for (const key of ["type", "attributions", "loaders", "onError", "loadOptions"]) {
+      delete parserCore[key];
+    }
+    if (Object.keys(parserCore).length === 0) {
+      delete loadOptions.core;
+    }
+  }
+  const topLevelBaseUri = typeof loadOptions.baseUri === "string" ? loadOptions.baseUri : void 0;
+  const topLevelBaseUrl = typeof loadOptions.baseUrl === "string" ? loadOptions.baseUrl : void 0;
+  if (topLevelBaseUri !== void 0 || topLevelBaseUrl !== void 0) {
+    loadOptions.core ||= {};
+    if (loadOptions.core.baseUrl === void 0) {
+      loadOptions.core.baseUrl = topLevelBaseUrl ?? topLevelBaseUri;
+    }
+    delete loadOptions.baseUri;
+    delete loadOptions.baseUrl;
+  }
+  return loadOptions;
 }
-function 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 normalizeError(error, message) {
+  if (error instanceof Error) {
+    return error;
+  }
+  if (typeof error === "string") {
+    return new Error(error);
   }
+  return new Error(message);
 }
-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"() {
+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_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
+    init_merge_options();
+    init_file_aliases();
+    init_log();
+    init_request_credentials();
+    init_authentication();
+    UNAVAILABLE_CORE_API = {
+      fetchFile: unavailableCoreApiMethod("fetchFile"),
+      parse: unavailableCoreApiMethod("parse"),
+      parseFile: unavailableCoreApiMethod("parseFile"),
+      parseSync: unavailableCoreApiMethod("parseSync"),
+      parseInBatches: unavailableCoreApiMethod("parseInBatches"),
+      load: unavailableCoreApiMethod("load"),
+      loadInBatches: unavailableCoreApiMethod("loadInBatches")
+    };
+    DataSource = class _DataSource {
+      static defaultOptions = {
+        core: {
+          type: "auto",
+          attributions: [],
+          loaders: [],
+          onError: void 0
+        }
+      };
+      optionsType;
+      options;
+      data;
+      url;
+      /** Shared parser options derived from the source options, excluding source-only core controls. */
+      loadOptions;
+      /** A resolved fetch function extracted from the shared core options. */
+      fetch;
+      /** Shared source-level runtime hooks, when supplied by the source factory. */
+      coreApi;
+      /** Whether a real CoreAPI instance was injected by the integration layer. */
+      hasCoreApi;
+      _needsRefresh = true;
+      constructor(data, options, defaultOptions, coreApi) {
+        this.options = mergeOptions(
+          mergeOptions(_DataSource.defaultOptions, defaultOptions || {}),
+          options
+        );
+        this.data = data;
+        this.url = typeof data === "string" ? resolvePath(data) : "";
+        const loadOptions = resolveAuthenticationOptions(getSourceLoaderOptions(this.options));
+        this.loadOptions = loadOptions;
+        const fetch2 = getFetchFunction(loadOptions);
+        this.coreApi = coreApi || UNAVAILABLE_CORE_API;
+        this.hasCoreApi = Boolean(coreApi);
+        this.fetch = fetch2;
+      }
+      setProps(options) {
+        const mergedOptions = mergeOptions(this.options, options);
+        const loadOptions = resolveAuthenticationOptions(getSourceLoaderOptions(mergedOptions));
+        this.options = mergedOptions;
+        this.loadOptions = loadOptions;
+        this.fetch = getFetchFunction(loadOptions);
+        this.setNeedsRefresh();
+      }
+      /** Mark this data source as needing a refresh (redraw) */
+      setNeedsRefresh() {
+        this._needsRefresh = true;
+      }
+      /**
+       * Does this data source need refreshing?
+       * @note The specifics of the refresh mechanism depends on type of data source
+       */
+      getNeedsRefresh(clear = true) {
+        const needsRefresh = this._needsRefresh;
+        if (clear) {
+          this._needsRefresh = false;
+        }
+        return needsRefresh;
+      }
+      /** Reports a source-level failure through the configured callback or the shared logger. */
+      reportError(error, message) {
+        var _a;
+        const normalizedError = normalizeError(error, message);
+        const callback = (_a = this.options.core) == null ? void 0 : _a.onError;
+        if (callback) {
+          callback(normalizedError, this);
+        } else {
+          log.warn(`${this.constructor.name}: ${normalizedError.message}`)();
+        }
+        return normalizedError;
       }
     };
   }
 });
 
-// dist/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"() {
+// ../loader-utils/src/index.ts
+var init_src = __esm({
+  "../loader-utils/src/index.ts"() {
     "use strict";
-    init_parse_ksplat();
-    init_ksplat_loader_types();
-    ({ preload: _KSPLATLoaderPreload, ...KSPLATLoaderMetadataWithoutPreload } = KSPLATLoader);
-    KSPLATLoaderWithParser = {
-      ...KSPLATLoaderMetadataWithoutPreload,
-      parse: async (arrayBuffer) => parseKSPLAT(arrayBuffer),
-      parseSync: (arrayBuffer) => parseKSPLAT(arrayBuffer)
-    };
+    init_js_module_utils();
+    init_js_module_utils();
+    init_async_iteration();
+    init_memory_conversion_utils();
+    init_data_source();
   }
 });
 
-// dist/ksplat-loader-types.js
-async function preload2() {
-  const { KSPLATLoaderWithParser: KSPLATLoaderWithParser2 } = await Promise.resolve().then(() => (init_ksplat_loader(), ksplat_loader_exports));
-  return KSPLATLoaderWithParser2;
-}
-var VERSION2, KSPLATLoader;
-var init_ksplat_loader_types = __esm({
-  "dist/ksplat-loader-types.js"() {
+// ../compression/src/lib/compression.ts
+var CompressionTransform, Compressor, Decompressor, Compression;
+var init_compression = __esm({
+  "../compression/src/lib/compression.ts"() {
     "use strict";
-    init_splats_format();
-    VERSION2 = true ? "5.0.0-alpha.6" : "latest";
-    KSPLATLoader = {
-      dataType: null,
-      batchType: null,
-      ...KSPLATFormat,
-      version: VERSION2,
-      options: {
-        splats: {
-          shape: "arrow-table"
+    init_src();
+    CompressionTransform = class {
+      /** Preloads any dynamic libraries. May enable sync functions */
+      async preload(modules = {}) {
+        registerJSModules(modules);
+        return void 0;
+      }
+      // HELPERS
+      concatenate(asyncIterator) {
+        return concatenateArrayBuffersAsync(asyncIterator);
+      }
+      improveError(error) {
+        if (!error.message.includes(this.name)) {
+          error.message = `${this.name} ${error.message}`;
         }
-      },
-      preload: preload2
+        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);
+      }
     };
   }
 });
 
-// ../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;
+// ../compression/src/lib/compression-stream.ts
+async function compressWithNativeCompressionStream(input, format) {
+  const outputBatches = compressBatchesWithNativeCompressionStream([input], format);
+  return outputBatches ? await concatenateBatches(outputBatches) : null;
 }
-var import_log, VERSION3, version, log;
-var init_log = __esm({
-  "../loader-utils/src/lib/log-utils/log.ts"() {
-    "use strict";
-    import_log = require("@probe.gl/log");
-    VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
-    version = VERSION3[0] >= "0" && VERSION3[0] <= "9" ? `v${VERSION3}` : "";
-    log = createLog();
-  }
-});
-
-// ../loader-utils/src/lib/javascript-utils/is-type.ts
-var isObject, isPureObject, isSharedArrayBuffer;
-var init_is_type = __esm({
-  "../loader-utils/src/lib/javascript-utils/is-type.ts"() {
-    "use strict";
-    isObject = (value) => value !== null && typeof value === "object";
-    isPureObject = (value) => isObject(value) && value.constructor === {}.constructor;
-    isSharedArrayBuffer = (value) => typeof SharedArrayBuffer !== "undefined" && value instanceof SharedArrayBuffer;
-  }
-});
-
-// ../loader-utils/src/lib/option-utils/merge-options.ts
-function mergeOptions(baseOptions, newOptions) {
-  return mergeOptionsRecursively(baseOptions || {}, newOptions);
+function compressBatchesWithNativeCompressionStream(inputBatches, format) {
+  const compressionStream = createNativeCompressionStream(format);
+  return compressionStream ? transformBatches(inputBatches, compressionStream) : null;
 }
-function mergeOptionsRecursively(baseOptions, newOptions, level = 0) {
-  if (level > 3) {
-    return newOptions;
+function createNativeCompressionStream(format) {
+  if (typeof globalThis.CompressionStream === "undefined") {
+    return null;
   }
-  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];
+  try {
+    const CompressionStreamConstructor = globalThis.CompressionStream;
+    return new CompressionStreamConstructor(format);
+  } catch (error) {
+    if (error instanceof TypeError || (error == null ? void 0 : error.name) === "TypeError") {
+      return null;
     }
+    throw error;
   }
-  return options;
 }
-var init_merge_options = __esm({
-  "../loader-utils/src/lib/option-utils/merge-options.ts"() {
-    "use strict";
-    init_is_type();
+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();
   }
-});
-
-// ../loader-utils/src/lib/module-utils/js-module-utils.ts
-function registerJSModules(modules) {
-  globalThis.loaders ||= {};
-  globalThis.loaders.modules ||= {};
-  Object.assign(globalThis.loaders.modules, modules);
 }
-function getJSModule(name, caller) {
-  var _a, _b;
-  const module2 = (_b = (_a = globalThis.loaders) == null ? void 0 : _a.modules) == null ? void 0 : _b[name];
-  if (!module2) {
-    throw new Error(`${caller}: ${name} library not installed`);
+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 module2;
-}
-function getJSModuleOrNull(name) {
-  var _a, _b;
-  const module2 = (_b = (_a = globalThis.loaders) == null ? void 0 : _a.modules) == null ? void 0 : _b[name];
-  return module2 || null;
 }
-var init_js_module_utils = __esm({
-  "../loader-utils/src/lib/module-utils/js-module-utils.ts"() {
-    "use strict";
+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;
   }
-});
-
-// ../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;
+  for (const batch of output) {
+    result.set(batch, offset);
+    offset += batch.byteLength;
   }
   return result.buffer;
 }
-var init_array_buffer_utils = __esm({
-  "../loader-utils/src/lib/binary-utils/array-buffer-utils.ts"() {
+var init_compression_stream = __esm({
+  "../compression/src/lib/compression-stream.ts"() {
     "use strict";
   }
 });
 
-// ../loader-utils/src/lib/iterators/async-iteration.ts
-async function concatenateArrayBuffersAsync(asyncIterator) {
-  const arrayBuffers = [];
-  for await (const chunk of asyncIterator) {
-    arrayBuffers.push(copyToArrayBuffer(chunk));
+// ../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;
   }
-  return concatenateArrayBuffers(...arrayBuffers);
 }
-function copyToArrayBuffer(chunk) {
-  if (chunk instanceof ArrayBuffer) {
-    return chunk;
+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();
   }
-  if (ArrayBuffer.isView(chunk)) {
-    const { buffer, byteOffset, byteLength } = chunk;
-    return copyFromBuffer(buffer, byteOffset, byteLength);
+}
+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;
   }
-  return copyFromBuffer(chunk);
+  const output = new Uint8Array(byteLength);
+  let byteOffset = 0;
+  for (const batch of batches) {
+    output.set(batch, byteOffset);
+    byteOffset += batch.byteLength;
+  }
+  return output.buffer;
 }
-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;
+function copyExactArrayBuffer(value) {
+  return new Uint8Array(value).buffer;
 }
-var init_async_iteration = __esm({
-  "../loader-utils/src/lib/iterators/async-iteration.ts"() {
+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";
-    init_array_buffer_utils();
   }
 });
 
-// ../loader-utils/src/lib/request-utils/request-credentials.ts
-function createAuthenticatedFetch(options) {
-  const baseFetch = options.fetch || ((url, requestOptions) => fetch(url, requestOptions));
-  if (!options.credentials.length) return baseFetch;
-  const existingMetadata = baseFetch[AUTHENTICATED_FETCH];
-  if (existingMetadata === options.credentials) return baseFetch;
-  const authenticatedFetch = async (url, requestOptions = {}) => {
-    var _a, _b, _c;
-    const resolvedURL = parseHTTPURL(url);
-    if (!resolvedURL) return baseFetch(url, requestOptions);
-    const authorization = await authorizeRequest(resolvedURL, requestOptions, options.credentials);
-    const response = await baseFetch(authorization.url, authorization.options);
-    const refreshableCredentials = authorization.credentials.filter(
-      ({ credential }) => typeof credential.token === "function" && credential.refreshStatusCodes.includes(response.status)
-    );
-    if (!refreshableCredentials.length || !isReplayableRequest(requestOptions)) return response;
-    if ((_a = requestOptions.signal) == null ? void 0 : _a.aborted) throw createAbortError();
-    const refreshedTokens = /* @__PURE__ */ new Map();
-    await Promise.all(
-      refreshableCredentials.map(async ({ credential }) => {
-        const token = await refreshCredential(credential, url, response);
-        if (token) refreshedTokens.set(credential, token);
-      })
-    );
-    if (!refreshedTokens.size) return response;
-    await ((_b = response.body) == null ? void 0 : _b.cancel().catch(() => {
-    }));
-    if ((_c = requestOptions.signal) == null ? void 0 : _c.aborted) throw createAbortError();
-    const replayAuthorization = await authorizeRequest(
-      resolvedURL,
-      requestOptions,
-      options.credentials,
-      refreshedTokens,
-      authorization.credentials
-    );
-    return baseFetch(replayAuthorization.url, replayAuthorization.options);
-  };
-  Object.defineProperty(authenticatedFetch, AUTHENTICATED_FETCH, {
-    value: options.credentials
-  });
-  return authenticatedFetch;
-}
-async function authorizeRequest(sourceURL, requestOptions, credentials, tokenOverrides = /* @__PURE__ */ new Map(), previousCredentials = []) {
-  const url = new URL(sourceURL);
-  const headers = new Headers(requestOptions.headers);
-  const resolvedCredentials = [];
-  const previousTokens = new Map(
-    previousCredentials.map(({ credential, token }) => [credential, token])
-  );
-  for (const credential of credentials) {
-    if (!credential.origins.includes(url.origin)) continue;
-    const overrideToken = tokenOverrides.get(credential);
-    const previousToken = previousTokens.get(credential);
-    const ownsQueryParameter = credential.type === "query-parameter" && previousToken !== void 0;
-    const ownsHeader = credential.type === "header" && previousToken !== void 0;
-    if (credential.type === "query-parameter" && url.searchParams.has(credential.name) && !ownsQueryParameter || credential.type === "header" && headers.has(credential.name) && !ownsHeader) {
-      continue;
-    }
-    const token = overrideToken ?? previousToken ?? await resolveToken(credential.token, { url: sourceURL.toString(), reason: "request" });
-    if (!token) continue;
-    if (credential.type === "query-parameter") {
-      url.searchParams.set(credential.name, token);
-    } else {
-      headers.set(credential.name, `${credential.prefix || ""}${token}`);
-    }
-    resolvedCredentials.push({ credential, token });
-  }
-  return {
-    url: url.toString(),
-    options: { ...requestOptions, headers },
-    credentials: resolvedCredentials
-  };
-}
-async function refreshCredential(credential, url, response) {
-  const existingPromise = refreshPromises.get(credential);
-  if (existingPromise) return existingPromise;
-  const tokenProvider = credential.token;
-  const promise = Promise.resolve(
-    tokenProvider({
-      url,
-      reason: "refresh",
-      response: { status: response.status, headers: response.headers }
-    })
-  ).finally(() => refreshPromises.delete(credential));
-  refreshPromises.set(credential, promise);
-  return promise;
-}
-async function resolveToken(token, context) {
-  return typeof token === "function" ? token(context) : token;
-}
-function parseHTTPURL(url) {
-  try {
-    const parsedURL = new URL(url);
-    return ["http:", "https:"].includes(parsedURL.protocol) ? parsedURL : null;
-  } catch {
-    return null;
-  }
-}
-function isReplayableRequest(options) {
-  const method = (options.method || "GET").toUpperCase();
-  if (!["GET", "HEAD", "OPTIONS", "PUT", "DELETE"].includes(method)) return false;
-  return !(options.body && typeof ReadableStream !== "undefined" && options.body instanceof ReadableStream);
-}
-function createAbortError() {
-  return new DOMException("The operation was aborted.", "AbortError");
-}
-var AUTHENTICATED_FETCH, refreshPromises;
-var init_request_credentials = __esm({
-  "../loader-utils/src/lib/request-utils/request-credentials.ts"() {
+// ../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";
-    AUTHENTICATED_FETCH = /* @__PURE__ */ Symbol("loaders.gl.authenticated-fetch");
-    refreshPromises = /* @__PURE__ */ new WeakMap();
+    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;
+      }
+    };
   }
 });
 
-// ../loader-utils/src/lib/path-utils/file-aliases.ts
-function resolvePath(filename) {
-  for (const alias in fileAliases) {
-    if (filename.startsWith(alias)) {
-      const replacement = fileAliases[alias];
-      filename = filename.replace(alias, replacement);
-    }
-  }
-  if (!filename.startsWith("http://") && !filename.startsWith("https://")) {
-    filename = `${pathPrefix}${filename}`;
-  }
-  return filename;
+// ../compression/src/lib/lazy-compression.ts
+function mergeModules(options, modules) {
+  return { ...options, modules: { ...options.modules, ...modules } };
 }
-var pathPrefix, fileAliases;
-var init_file_aliases = __esm({
-  "../loader-utils/src/lib/path-utils/file-aliases.ts"() {
+var LazyDecompressor;
+var init_lazy_compression = __esm({
+  "../compression/src/lib/lazy-compression.ts"() {
     "use strict";
-    pathPrefix = "";
-    fileAliases = {};
+    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);
+      }
+    };
   }
 });
 
-// ../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;
+// ../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);
   }
-  return copyToArrayBuffer2(buffer, byteOffset, byteLength);
-}
-function copyToArrayBuffer2(buffer, byteOffset = 0, byteLength = buffer.byteLength - byteOffset) {
-  const view = new Uint8Array(buffer, byteOffset, byteLength);
-  const copy = new Uint8Array(view.length);
-  copy.set(view);
-  return copy.buffer;
+  processor.push(new Uint8Array(0), true);
+  yield* chunks;
 }
-var init_memory_conversion_utils = __esm({
-  "../loader-utils/src/lib/binary-utils/memory-conversion-utils.ts"() {
+var init_fflate_stream = __esm({
+  "../compression/src/lib/fflate-stream.ts"() {
     "use strict";
-    init_is_type();
   }
 });
 
-// ../loader-utils/src/lib/sources/data-source.ts
-function getFetchFunction(options) {
-  var _a, _b;
-  const fetchOption = (options == null ? void 0 : options.fetch) ?? ((_a = options == null ? void 0 : options.core) == null ? void 0 : _a.fetch);
-  let fetchFunction;
-  if (typeof fetchOption === "function") {
-    fetchFunction = (url, fetchOptions) => fetchOption(url, fetchOptions);
-  } else if (fetchOption) {
-    fetchFunction = (url, requestOptions) => fetch(url, mergeFetchOptions(fetchOption, requestOptions));
-  } else {
-    fetchFunction = (url, requestOptions) => fetch(url, requestOptions);
-  }
-  return createAuthenticatedFetch({
-    fetch: fetchFunction,
-    credentials: ((_b = options == null ? void 0 : options.core) == null ? void 0 : _b.credentials) || []
-  });
-}
-function mergeFetchOptions(fetchOptions, requestOptions) {
-  const mergedOptions = { ...fetchOptions, ...requestOptions };
-  if (fetchOptions.headers || (requestOptions == null ? void 0 : requestOptions.headers)) {
-    mergedOptions.headers = mergeHeaders(fetchOptions.headers, requestOptions == null ? void 0 : requestOptions.headers);
-  }
-  return mergedOptions;
-}
-function mergeHeaders(defaultHeaders, requestHeaders) {
-  const headers = new Headers(defaultHeaders);
-  if (requestHeaders) {
-    new Headers(requestHeaders).forEach((value, key) => headers.set(key, value));
+// ../compression/src/gzip-decompressor-fflate.ts
+var import_fflate, GZipFflateDecompressor;
+var init_gzip_decompressor_fflate = __esm({
+  "../compression/src/gzip-decompressor-fflate.ts"() {
+    "use strict";
+    import_fflate = require("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 (0, import_fflate.gunzipSync)(new Uint8Array(input)).slice().buffer;
+      }
+      /** Decompresses GZIP batches incrementally. */
+      async *decompressBatches(inputBatches) {
+        yield* transformFflateBatches(new import_fflate.Gunzip(), inputBatches);
+      }
+    };
   }
-  return headers;
-}
-function normalizeDirectLoaderOptions(options) {
-  const loadOptions = { ...options };
-  if (options == null ? void 0 : options.core) {
-    loadOptions.core = { ...options.core };
-  }
-  const topLevelBaseUri = typeof loadOptions.baseUri === "string" ? loadOptions.baseUri : void 0;
-  const topLevelBaseUrl = typeof loadOptions.baseUrl === "string" ? loadOptions.baseUrl : void 0;
-  if (topLevelBaseUri !== void 0 || topLevelBaseUrl !== void 0) {
-    loadOptions.core ||= {};
-    if (loadOptions.core.baseUrl === void 0) {
-      loadOptions.core.baseUrl = topLevelBaseUrl ?? topLevelBaseUri;
-    }
-    delete loadOptions.baseUri;
-    delete loadOptions.baseUrl;
-  }
-  return loadOptions;
-}
-function normalizeError(error, message) {
-  if (error instanceof Error) {
-    return error;
-  }
-  if (typeof error === "string") {
-    return new Error(error);
-  }
-  return new Error(message);
-}
-function unavailableCoreApiMethod(methodName) {
-  return () => {
-    throw new Error(
-      `CoreAPI.${methodName} is unavailable. Use @loaders.gl/core.createDataSource().`
-    );
-  };
-}
-var UNAVAILABLE_CORE_API, DataSource;
-var init_data_source = __esm({
-  "../loader-utils/src/lib/sources/data-source.ts"() {
+});
+
+// ../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_merge_options();
-    init_file_aliases();
-    init_log();
-    init_request_credentials();
-    UNAVAILABLE_CORE_API = {
-      fetchFile: unavailableCoreApiMethod("fetchFile"),
-      parse: unavailableCoreApiMethod("parse"),
-      parseFile: unavailableCoreApiMethod("parseFile"),
-      parseSync: unavailableCoreApiMethod("parseSync"),
-      parseInBatches: unavailableCoreApiMethod("parseInBatches"),
-      load: unavailableCoreApiMethod("load"),
-      loadInBatches: unavailableCoreApiMethod("loadInBatches")
-    };
-    DataSource = class _DataSource {
-      static defaultOptions = {
-        core: {
-          type: "auto",
-          attributions: [],
-          loadOptions: {},
-          loaders: [],
-          onError: void 0
-        }
-      };
-      optionsType;
+    init_gzip_decompressor_fflate();
+    init_decompression_stream();
+    GZipDecompressor = class extends GZipFflateDecompressor {
       options;
-      data;
-      url;
-      /** The actual load options, if calling a loaders.gl loader */
-      loadOptions;
-      /** A resolved fetch function extracted from loadOptions prop */
-      fetch;
-      /** Shared source-level runtime hooks, when supplied by the source factory. */
-      coreApi;
-      /** Whether a real CoreAPI instance was injected by the integration layer. */
-      hasCoreApi;
-      _needsRefresh = true;
-      constructor(data, options, defaultOptions, coreApi) {
-        var _a;
-        if (defaultOptions) {
-          this.options = mergeOptions({ ...defaultOptions, core: _DataSource.defaultOptions }, options);
-        } else {
-          this.options = { ...options };
-        }
-        this.data = data;
-        this.url = typeof data === "string" ? resolvePath(data) : "";
-        const loadOptions = normalizeDirectLoaderOptions((_a = this.options.core) == null ? void 0 : _a.loadOptions);
-        this.loadOptions = loadOptions;
-        const fetch2 = getFetchFunction(loadOptions);
-        this.coreApi = coreApi || UNAVAILABLE_CORE_API;
-        this.hasCoreApi = Boolean(coreApi);
-        this.fetch = fetch2;
-      }
-      setProps(options) {
-        this.options = Object.assign(this.options, options);
-        this.setNeedsRefresh();
-      }
-      /** Mark this data source as needing a refresh (redraw) */
-      setNeedsRefresh() {
-        this._needsRefresh = true;
+      constructor(options = {}) {
+        super(options);
+        this.options = options;
       }
-      /**
-       * 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;
+      /** 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 needsRefresh;
+        return this.decompressSync(input);
       }
-      /** 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}`)();
+      /** 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;
+          }
         }
-        return normalizedError;
+        yield* super.decompressBatches(inputBatches);
       }
     };
   }
 });
 
-// ../loader-utils/src/index.ts
-var init_src = __esm({
-  "../loader-utils/src/index.ts"() {
+// ../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_js_module_utils();
-    init_js_module_utils();
-    init_async_iteration();
-    init_memory_conversion_utils();
-    init_data_source();
+    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/lib/compression.ts
-var CompressionTransform, Compressor, Decompressor, Compression;
-var init_compression = __esm({
-  "../compression/src/lib/compression.ts"() {
+// ../compression/src/zstd-fallback.ts
+var zstd_fallback_exports = {};
+__export(zstd_fallback_exports, {
+  decompressZstd: () => decompressZstd
+});
+function decompressZstd(input) {
+  return (0, import_fzstd2.decompress)(input);
+}
+var import_fzstd2;
+var init_zstd_fallback = __esm({
+  "../compression/src/zstd-fallback.ts"() {
+    "use strict";
+    import_fzstd2 = require("fzstd");
+  }
+});
+
+// ../compression/src/lib/zstd-compression.ts
+var zstd_compression_exports = {};
+__export(zstd_compression_exports, {
+  ZstdCompression: () => ZstdCompression
+});
+var CHUNK_SIZE, zstdPromise, zstd, ZstdCompression;
+var init_zstd_compression = __esm({
+  "../compression/src/lib/zstd-compression.ts"() {
     "use strict";
+    init_compression();
     init_src();
-    CompressionTransform = class {
-      /** Preloads any dynamic libraries. May enable sync functions */
+    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);
-        return void 0;
-      }
-      // HELPERS
-      concatenate(asyncIterator) {
-        return concatenateArrayBuffersAsync(asyncIterator);
-      }
-      improveError(error) {
-        if (!error.message.includes(this.name)) {
-          error.message = `${this.name} ${error.message}`;
+        const ZstdCodec = getJSModuleOrNull("zstd-codec");
+        if (!zstdPromise && ZstdCodec) {
+          zstdPromise = new Promise((resolve) => ZstdCodec.run((zstd2) => resolve(zstd2)));
+        }
+        if (zstdPromise) {
+          zstd = await zstdPromise;
         }
-        return error;
       }
-    };
-    Compressor = class extends CompressionTransform {
-      constructor(options) {
-        super();
-        this.compressBatches = this.compressBatches.bind(this);
+      compressSync(input) {
+        getJSModule("zstd-codec", this.name);
+        const simpleZstd = new zstd.Simple();
+        const inputArray = new Uint8Array(input);
+        return simpleZstd.compress(inputArray).buffer;
       }
-      /** Asynchronously compresses data. */
       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);
       }
-      /** 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);
+      decompressSync(input) {
+        getJSModule("zstd-codec", this.name);
+        const simpleZstd = new zstd.Simple();
+        const inputArray = new Uint8Array(input);
+        return simpleZstd.decompress(inputArray).buffer;
       }
-      /** Asynchronously decompresses data. */
       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();
-        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);
+        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 = class extends Compressor {
-      constructor(options) {
+  }
+});
+
+// ../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.decompressBatches = this.decompressBatches.bind(this);
+        this.options = options;
+        registerJSModules(options.modules);
       }
-      /** Asynchronously decompresses data. */
-      async decompress(input, size) {
-        await this.preload();
-        return this.decompressSync(input, size);
+      /** 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);
+        }
       }
-      /** Synchronously decompresses data. */
-      decompressSync(input, size) {
-        throw new Error(`${this.name}: sync decompression not supported`);
+      /** 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 batches. */
-      async *decompressBatches(asyncIterator) {
-        const input = await this.concatenate(asyncIterator);
-        yield this.decompress(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/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;
+// ../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");
+          }
+        );
+      }
+    };
   }
-  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;
+});
+
+// ../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;
 }
-async function* transformBatches(inputBatches, compressionStream) {
-  const writer = compressionStream.writable.getWriter();
-  const reader = compressionStream.readable.getReader();
-  const writePromise = writeBatches(inputBatches, writer);
-  writePromise.catch(() => {
-  });
-  let outputCompleted = false;
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) {
-        outputCompleted = true;
-        break;
-      }
-      yield new Uint8Array(value).buffer;
-    }
-    await writePromise;
-  } finally {
-    if (!outputCompleted) {
-      await reader.cancel().catch(() => {
-      });
-      await writer.abort().catch(() => {
-      });
-      await writePromise.catch(() => {
-      });
-    }
-    reader.releaseLock();
-  }
+function convertAlphaByteToLinearOpacity(alphaByte) {
+  return Math.min(Math.max(alphaByte / 255, 0), 1);
 }
-async function writeBatches(inputBatches, writer) {
-  try {
-    for await (const inputBatch of inputBatches) {
-      await writer.write(new Uint8Array(inputBatch));
-    }
-    await writer.close();
-  } catch (error) {
-    await writer.abort(error).catch(() => {
-    });
-    throw error;
+function 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];
 }
-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;
+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);
   }
-  const result = new Uint8Array(byteLength);
-  let offset = 0;
-  for (const batch of output) {
-    result.set(batch, offset);
-    offset += batch.byteLength;
+  if (exponent === 31) {
+    return fraction ? Number.NaN : sign * Number.POSITIVE_INFINITY;
   }
-  return result.buffer;
+  return sign * Math.pow(2, exponent - 15) * (1 + fraction / 1024);
 }
-var init_compression_stream = __esm({
-  "../compression/src/lib/compression-stream.ts"() {
+var SH_C0;
+var init_splat_utils = __esm({
+  "dist/lib/splat-utils.js"() {
     "use strict";
+    SH_C0 = 0.28209479177387814;
   }
 });
 
-// ../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;
+// dist/lib/splats-arrow-table.js
+function makeGaussianSplatsArrowTable(splats) {
+  const columns = {};
+  const fields = [];
+  const schemaFields = [];
+  addColumn(columns, fields, schemaFields, "POSITION", makeFixedSizeListVector(splats.positions, 3), {
+    type: "fixed-size-list",
+    listSize: 3,
+    children: [{ name: "value", type: "float32" }]
+  });
+  const colorCoefficients = getColorCoefficients(splats);
+  addScalarColumn(columns, fields, schemaFields, "f_dc_0", colorCoefficients[0], {
+    "loaders_gl.gaussian_splats.semantic": "spherical_harmonic_dc",
+    "loaders_gl.gaussian_splats.component": "0",
+    "loaders_gl.gaussian_splats.encoding": "coefficient"
+  });
+  addScalarColumn(columns, fields, schemaFields, "f_dc_1", colorCoefficients[1], {
+    "loaders_gl.gaussian_splats.semantic": "spherical_harmonic_dc",
+    "loaders_gl.gaussian_splats.component": "1",
+    "loaders_gl.gaussian_splats.encoding": "coefficient"
+  });
+  addScalarColumn(columns, fields, schemaFields, "f_dc_2", colorCoefficients[2], {
+    "loaders_gl.gaussian_splats.semantic": "spherical_harmonic_dc",
+    "loaders_gl.gaussian_splats.component": "2",
+    "loaders_gl.gaussian_splats.encoding": "coefficient"
+  });
+  addScalarColumn(columns, fields, schemaFields, "opacity", splats.opacities, {
+    "loaders_gl.gaussian_splats.semantic": "opacity",
+    "loaders_gl.gaussian_splats.encoding": "linear"
+  });
+  addVectorComponents(columns, fields, schemaFields, "scale", splats.scales, 3, {
+    "loaders_gl.gaussian_splats.semantic": "scale",
+    "loaders_gl.gaussian_splats.encoding": "linear"
+  });
+  addVectorComponents(columns, fields, schemaFields, "rot", splats.rotations, 4, {
+    "loaders_gl.gaussian_splats.semantic": "rotation",
+    "loaders_gl.gaussian_splats.encoding": "quaternion"
+  });
+  if (splats.sphericalHarmonics && splats.sphericalHarmonicsComponentCount) {
+    addSphericalHarmonicRestColumns(columns, fields, schemaFields, splats.sphericalHarmonics, splats.sphericalHarmonicsComponentCount);
   }
+  const metadata = /* @__PURE__ */ new Map([
+    ["loaders_gl.semantic_type", "gaussian-splats"],
+    ["loaders_gl.gaussian_splats.version", "1"],
+    ["loaders_gl.gaussian_splats.source_format", splats.format],
+    ["topology", "point-list"],
+    ["mode", "0"]
+  ]);
+  const arrowSchema = new arrow.Schema(fields, metadata);
+  const schema = {
+    fields: schemaFields,
+    metadata: Object.fromEntries(metadata)
+  };
+  return {
+    shape: "arrow-table",
+    schema,
+    data: new arrow.Table(arrowSchema, columns),
+    topology: "point-list",
+    loaderData: splats.loaderData
+  };
 }
-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(() => {
-      });
+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];
     }
-    reader.releaseLock();
+    addScalarColumn(columns, fields, schemaFields, `${prefix}_${component}`, componentValues, {
+      ...metadata,
+      "loaders_gl.gaussian_splats.component": String(component)
+    });
   }
 }
-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;
+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"
+    });
   }
-  return output.buffer;
 }
-function copyExactArrayBuffer(value) {
-  return new Uint8Array(value).buffer;
+function addScalarColumn(columns, fields, schemaFields, name, values, metadata) {
+  addColumn(columns, fields, schemaFields, name, arrow.makeVector(values), "float32", metadata);
 }
-async function writeBatchesToNativeDecompressionStream(inputBatches, writer) {
-  try {
-    for await (const inputBatch of inputBatches) {
-      await writer.write(new Uint8Array(inputBatch));
+function addColumn(columns, fields, schemaFields, name, column, schemaType, metadata = {}) {
+  columns[name] = column;
+  fields.push(new arrow.Field(name, column.type, false, new Map(Object.entries(metadata))));
+  schemaFields.push({ name, type: schemaType, nullable: false, metadata });
+}
+function makeFixedSizeListVector(value, size) {
+  const values = arrow.makeVector(value);
+  const child = values.data[0];
+  const type = new arrow.FixedSizeList(size, new arrow.Field("value", child.type, false));
+  const data = new arrow.Data(type, 0, value.length / size, 0, {}, [child]);
+  return new arrow.Vector([data]);
+}
+function getColorCoefficients(splats) {
+  const rowCount = splats.splatCount;
+  const fdc0 = new Float32Array(rowCount);
+  const fdc1 = new Float32Array(rowCount);
+  const fdc2 = new Float32Array(rowCount);
+  for (let rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+    if (splats.sphericalHarmonicDcs) {
+      fdc0[rowIndex] = splats.sphericalHarmonicDcs[rowIndex * 3 + 0];
+      fdc1[rowIndex] = splats.sphericalHarmonicDcs[rowIndex * 3 + 1];
+      fdc2[rowIndex] = splats.sphericalHarmonicDcs[rowIndex * 3 + 2];
+    } else {
+      fdc0[rowIndex] = convertColorByteToSphericalHarmonicDc(splats.colors[rowIndex * 3 + 0]);
+      fdc1[rowIndex] = convertColorByteToSphericalHarmonicDc(splats.colors[rowIndex * 3 + 1]);
+      fdc2[rowIndex] = convertColorByteToSphericalHarmonicDc(splats.colors[rowIndex * 3 + 2]);
     }
-    await writer.close();
-  } catch (error) {
-    await writer.abort(error).catch(() => {
-    });
-    throw error;
   }
+  return [fdc0, fdc1, fdc2];
 }
-var init_decompression_stream = __esm({
-  "../compression/src/lib/decompression-stream.ts"() {
+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();
   }
 });
 
-// ../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;
-      }
-    };
+// dist/lib/parse-spz.js
+async function parseSPZ(data, options) {
+  return makeGaussianSplatsArrowTable(await parseSPZToGaussianSplats(data, options));
+}
+async function parseSPZToGaussianSplats(data, options) {
+  var _a, _b, _c;
+  const version2 = detectSPZVersion(data);
+  if (version2 === 0) {
+    return await parseLegacySPZ(data, options);
   }
-});
-
-// ../compression/src/lib/lazy-compression.ts
-function mergeModules(options, modules) {
-  return { ...options, modules: { ...options.modules, ...modules } };
+  if (version2 !== SPZ_VERSION) {
+    throw new Error(`SPZLoader: version ${version2} is not supported.`);
+  }
+  const header = parseSPZHeader(data);
+  const streamInfos = parseSPZStreamInfos(data, header, getSPZStreamByteLengths(header));
+  const compressedStreams = streamInfos.map((streamInfo) => data.slice(streamInfo.compressedOffset, streamInfo.compressedOffset + streamInfo.compressedSize));
+  const decompressor = new ZstdDecompressor2({ modules: options == null ? void 0 : options.modules });
+  const streams = await Promise.all(compressedStreams.map((compressedStream, streamIndex) => decompressor.decompress(compressedStream, streamInfos[streamIndex].uncompressedSize)));
+  validateSPZStreamLengths(streams, streamInfos);
+  return applySPZCoordinateSystem(decodeSPZStreams(header, streams, data), ((_a = options == null ? void 0 : options.splats) == null ? void 0 : _a.sourceCoordinateSystem) ?? "RUB", ((_b = options == null ? void 0 : options.splats) == null ? void 0 : _b.targetCoordinateSystem) ?? ((_c = options == null ? void 0 : options.splats) == null ? void 0 : _c.sourceCoordinateSystem) ?? "RUB");
 }
-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);
+function detectSPZVersion(data) {
+  if (data.byteLength < 8) {
+    throw new Error("SPZLoader: file must contain at least an 8-byte header.");
+  }
+  const bytes = new Uint8Array(data);
+  if (bytes[0] === 31 && bytes[1] === 139) {
+    return 0;
+  }
+  if (data.byteLength < SPZ_HEADER_BYTE_LENGTH) {
+    throw new Error("SPZLoader: file must contain a 32-byte header.");
+  }
+  return new DataView(data).getUint32(4, true);
+}
+async function parseLegacySPZ(data, options) {
+  var _a, _b, _c;
+  const decompressed = await new GZipDecompressor2({
+    modules: options == null ? void 0 : options.modules,
+    useNative: true
+  }).decompress(data);
+  if (decompressed.byteLength < 16) {
+    throw new Error("SPZLoader: legacy payload must contain a 16-byte header.");
+  }
+  const dataView = new DataView(decompressed);
+  const header = {
+    magic: dataView.getUint32(0, true),
+    version: dataView.getUint32(4, true),
+    numPoints: dataView.getUint32(8, true),
+    shDegree: dataView.getUint8(12),
+    fractionalBits: dataView.getUint8(13),
+    flags: dataView.getUint8(14)
+  };
+  if (header.magic !== SPZ_MAGIC) {
+    throw new Error("SPZLoader: NGSP magic header not found.");
+  }
+  if (header.version !== 2 && header.version !== 3) {
+    throw new Error(`SPZLoader: version ${header.version} is not supported.`);
+  }
+  if (dataView.getUint8(15) !== 0) {
+    throw new Error("SPZLoader: legacy header reserved byte must be zero.");
+  }
+  if (header.shDegree > 3) {
+    throw new Error(`SPZLoader: spherical harmonics degree ${header.shDegree} is not supported.`);
+  }
+  const count = header.numPoints;
+  const shComponentCount = getSphericalHarmonicsComponentCount(header.shDegree);
+  const positionByteLength = count * 9;
+  const alphaByteLength = count;
+  const colorByteLength = count * 3;
+  const scaleByteLength = count * 3;
+  const rotationByteLength = count * (header.version === 2 ? 3 : 4);
+  const shByteLength = count * shComponentCount;
+  const payloadByteLength = positionByteLength + alphaByteLength + colorByteLength + scaleByteLength + rotationByteLength + shByteLength;
+  if (decompressed.byteLength - 16 !== payloadByteLength) {
+    throw new Error(`SPZLoader: legacy payload has ${decompressed.byteLength - 16} bytes, expected ${payloadByteLength}.`);
+  }
+  let offset = 16;
+  const positions = new Float32Array(count * 3);
+  const opacities = new Float32Array(count);
+  const colors = new Uint8Array(count * 3);
+  const scales = new Float32Array(count * 3);
+  const rotations = new Float32Array(count * 4);
+  const sphericalHarmonicDcs = new Float32Array(count * 3);
+  const sphericalHarmonics = shComponentCount ? new Float32Array(count * shComponentCount) : void 0;
+  decodeSPZPositions(new Uint8Array(decompressed, offset, positionByteLength), positions, header.fractionalBits);
+  offset += positionByteLength;
+  decodeSPZOpacities(new Uint8Array(decompressed, offset, alphaByteLength), opacities);
+  offset += alphaByteLength;
+  decodeSPZColors(new Uint8Array(decompressed, offset, colorByteLength), colors, sphericalHarmonicDcs);
+  offset += colorByteLength;
+  decodeSPZScales(new Uint8Array(decompressed, offset, scaleByteLength), scales);
+  offset += scaleByteLength;
+  if (header.version === 2) {
+    decodeLegacySPZRotations(new Uint8Array(decompressed, offset, rotationByteLength), rotations);
+  } else {
+    decodeSPZRotations(new Uint8Array(decompressed, offset, rotationByteLength), rotations);
+  }
+  offset += rotationByteLength;
+  if (sphericalHarmonics) {
+    decodeSPZSphericalHarmonics(new Uint8Array(decompressed, offset, shByteLength), sphericalHarmonics);
+  }
+  return applySPZCoordinateSystem({
+    format: "spz",
+    splatCount: count,
+    positions,
+    scales,
+    rotations,
+    colors,
+    sphericalHarmonicDcs,
+    opacities,
+    sphericalHarmonics,
+    sphericalHarmonicsComponentCount: shComponentCount || void 0,
+    loaderData: { ...header, legacy: true }
+  }, ((_a = options == null ? void 0 : options.splats) == null ? void 0 : _a.sourceCoordinateSystem) ?? "RUB", ((_b = options == null ? void 0 : options.splats) == null ? void 0 : _b.targetCoordinateSystem) ?? ((_c = options == null ? void 0 : options.splats) == null ? void 0 : _c.sourceCoordinateSystem) ?? "RUB");
+}
+function decodeLegacySPZRotations(rotationStream, rotations) {
+  for (let splatIndex = 0; splatIndex < rotations.length / 4; splatIndex++) {
+    const byteOffset = splatIndex * 3;
+    const x = signedByte(rotationStream[byteOffset]) / 127;
+    const y = signedByte(rotationStream[byteOffset + 1]) / 127;
+    const z2 = signedByte(rotationStream[byteOffset + 2]) / 127;
+    const w = Math.sqrt(Math.max(0, 1 - x * x - y * y - z2 * z2));
+    const normalized = normalizeQuaternion(w, x, y, z2);
+    rotations.set(normalized, splatIndex * 4);
+  }
+}
+function signedByte(value) {
+  return value > 127 ? value - 256 : value;
+}
+function applySPZCoordinateSystem(splats, source, target) {
+  if (source === target || source === "UNSPECIFIED" || target === "UNSPECIFIED") {
+    return splats;
+  }
+  if (source === "RUB" && target === "LUF") {
+    for (let index = 0; index < splats.positions.length; index += 3) {
+      splats.positions[index] = -splats.positions[index];
+      splats.positions[index + 2] = -splats.positions[index + 2];
+    }
+    for (let index = 0; index < splats.rotations.length; index += 4) {
+      splats.rotations[index + 1] = -splats.rotations[index + 1];
+      splats.rotations[index + 3] = -splats.rotations[index + 3];
+    }
+    return splats;
+  }
+  if (source === "LUF" && target === "RUB") {
+    return applySPZCoordinateSystem(splats, "RUB", "LUF");
+  }
+  throw new Error(`SPZLoader: coordinate conversion ${source} -> ${target} is not supported.`);
+}
+function parseSPZHeader(data) {
+  if (data.byteLength < SPZ_HEADER_BYTE_LENGTH) {
+    throw new Error(`SPZLoader: file must contain a ${SPZ_HEADER_BYTE_LENGTH}-byte header.`);
+  }
+  const dataView = new DataView(data);
+  const header = {
+    magic: dataView.getUint32(0, true),
+    version: dataView.getUint32(4, true),
+    numPoints: dataView.getUint32(8, true),
+    shDegree: dataView.getUint8(12),
+    fractionalBits: dataView.getUint8(13),
+    flags: dataView.getUint8(14),
+    numStreams: dataView.getUint8(15),
+    tocByteOffset: dataView.getUint32(16, true)
+  };
+  if (header.magic !== SPZ_MAGIC) {
+    throw new Error("SPZLoader: NGSP magic header not found.");
+  }
+  if (header.version !== SPZ_VERSION) {
+    throw new Error(`SPZLoader: version ${header.version} is not supported.`);
+  }
+  if (header.shDegree > 4) {
+    throw new Error(`SPZLoader: spherical harmonics degree ${header.shDegree} is not supported.`);
+  }
+  if (header.tocByteOffset < SPZ_HEADER_BYTE_LENGTH || header.tocByteOffset > data.byteLength) {
+    throw new Error("SPZLoader: invalid table of contents byte offset.");
+  }
+  return header;
+}
+function parseSPZStreamInfos(data, header, expectedUncompressedSizes) {
+  if (header.numStreams !== expectedUncompressedSizes.length) {
+    throw new Error(`SPZLoader: expected ${expectedUncompressedSizes.length} streams, found ${header.numStreams}.`);
+  }
+  const tocByteLength = header.numStreams * 16;
+  const tocEnd = header.tocByteOffset + tocByteLength;
+  if (tocEnd > data.byteLength) {
+    throw new Error("SPZLoader: table of contents exceeds file byte length.");
+  }
+  const dataView = new DataView(data);
+  let compressedOffset = tocEnd;
+  const streamInfos = [];
+  for (let streamIndex = 0; streamIndex < header.numStreams; streamIndex++) {
+    const tocOffset = header.tocByteOffset + streamIndex * 16;
+    const compressedSize = readSafeUint64(dataView, tocOffset);
+    const uncompressedSize = readSafeUint64(dataView, tocOffset + 8);
+    const expectedUncompressedSize = expectedUncompressedSizes[streamIndex];
+    if (uncompressedSize !== expectedUncompressedSize) {
+      throw new Error(`SPZLoader: stream ${streamIndex} has ${uncompressedSize} uncompressed bytes, expected ${expectedUncompressedSize}.`);
+    }
+    if (compressedOffset + compressedSize > data.byteLength) {
+      throw new Error(`SPZLoader: stream ${streamIndex} exceeds file byte length.`);
+    }
+    streamInfos.push({ compressedSize, uncompressedSize, compressedOffset });
+    compressedOffset += compressedSize;
+  }
+  if (compressedOffset !== data.byteLength) {
+    throw new Error("SPZLoader: compressed stream byte lengths do not match file byte length.");
+  }
+  return streamInfos;
+}
+function readSafeUint64(dataView, byteOffset) {
+  const value = dataView.getBigUint64(byteOffset, true);
+  if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw new Error("SPZLoader: stream byte length exceeds Number.MAX_SAFE_INTEGER.");
+  }
+  return Number(value);
+}
+function getSPZStreamByteLengths(header) {
+  return [
+    header.numPoints * 9,
+    header.numPoints,
+    header.numPoints * 3,
+    header.numPoints * 3,
+    header.numPoints * 4,
+    header.numPoints * getSphericalHarmonicsComponentCount(header.shDegree)
+  ].filter((byteLength) => byteLength > 0);
+}
+function validateSPZStreamLengths(streams, streamInfos) {
+  for (let streamIndex = 0; streamIndex < streams.length; streamIndex++) {
+    if (streams[streamIndex].byteLength !== streamInfos[streamIndex].uncompressedSize) {
+      throw new Error(`SPZLoader: decompressed stream ${streamIndex} has unexpected byte length.`);
+    }
+  }
+}
+function decodeSPZStreams(header, streams, sourceData) {
+  const splatCount = header.numPoints;
+  const positions = new Float32Array(splatCount * 3);
+  const scales = new Float32Array(splatCount * 3);
+  const rotations = new Float32Array(splatCount * 4);
+  const colors = new Uint8Array(splatCount * 3);
+  const sphericalHarmonicDcs = new Float32Array(splatCount * 3);
+  const opacities = new Float32Array(splatCount);
+  const sphericalHarmonicsComponentCount = getSphericalHarmonicsComponentCount(header.shDegree);
+  const sphericalHarmonics = sphericalHarmonicsComponentCount ? new Float32Array(splatCount * sphericalHarmonicsComponentCount) : void 0;
+  const [positionStream, alphaStream, colorStream, scaleStream, rotationStream, sphericalHarmonicsStream] = streams.map((stream) => new Uint8Array(stream));
+  decodeSPZPositions(positionStream, positions, header.fractionalBits);
+  decodeSPZScales(scaleStream, scales);
+  decodeSPZRotations(rotationStream, rotations);
+  decodeSPZColors(colorStream, colors, sphericalHarmonicDcs);
+  decodeSPZOpacities(alphaStream, opacities);
+  if (sphericalHarmonics && sphericalHarmonicsStream) {
+    decodeSPZSphericalHarmonics(sphericalHarmonicsStream, sphericalHarmonics);
+  }
+  return {
+    format: "spz",
+    splatCount,
+    positions,
+    scales,
+    rotations,
+    colors,
+    sphericalHarmonicDcs,
+    opacities,
+    sphericalHarmonics,
+    sphericalHarmonicsComponentCount,
+    loaderData: {
+      format: "spz",
+      ...header,
+      antialiased: Boolean(header.flags & 1),
+      extensionByteLength: getSPZExtensionByteLength(header),
+      extensionBytes: getSPZExtensionBytes(sourceData, header)
+    }
+  };
+}
+function 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;
+    }
   }
-});
-
-// ../compression/src/zstd-decompressor-fzstd.ts
-var import_fzstd, ZstdFzstdDecompressor;
-var init_zstd_decompressor_fzstd = __esm({
-  "../compression/src/zstd-decompressor-fzstd.ts"() {
+  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_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;
-      }
-    };
+    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;
   }
 });
 
-// ../compression/src/zstd-fallback.ts
-var zstd_fallback_exports = {};
-__export(zstd_fallback_exports, {
-  decompressZstd: () => decompressZstd
-});
-function decompressZstd(input) {
-  return (0, import_fzstd2.decompress)(input);
+// dist/lib/parse-splat.js
+function parseSPLAT(data) {
+  return makeGaussianSplatsArrowTable(parseSPLATToGaussianSplats(data));
 }
-var import_fzstd2;
-var init_zstd_fallback = __esm({
-  "../compression/src/zstd-fallback.ts"() {
-    "use strict";
-    import_fzstd2 = require("fzstd");
+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}.`);
   }
-});
-
-// ../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;
-      }
-    };
+  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;
   }
-});
-
-// ../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"() {
+  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_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);
-      }
-    };
+    init_splats_arrow_table();
+    init_splat_utils();
+    SPLAT_ROW_BYTE_LENGTH = 32;
   }
 });
 
-// ../compression/src/default-codecs.ts
-var ZSTD, ZstdDecompressor2;
-var init_default_codecs = __esm({
-  "../compression/src/default-codecs.ts"() {
-    "use strict";
-    init_lazy_compression();
-    init_src();
-    ZSTD = { name: "zstd", extensions: ["zst"], contentEncodings: ["zstd"] };
-    ZstdDecompressor2 = class extends LazyDecompressor {
-      constructor(options = {}) {
-        super(
-          ZSTD,
-          async () => (await Promise.resolve().then(() => (init_zstd_decompressor(), zstd_decompressor_exports))).ZstdDecompressor,
-          options,
-          "zstd",
-          (preloadOptions) => {
-            var _a;
-            return !((_a = preloadOptions.modules) == null ? void 0 : _a["zstd-codec"]) && !getJSModuleOrNull("zstd-codec");
-          }
-        );
-      }
-    };
-  }
+// dist/splat-loader.js
+var splat_loader_exports = {};
+__export(splat_loader_exports, {
+  SPLATLoaderWithParser: () => SPLATLoaderWithParser
 });
-
-// ../compression/src/index.ts
-var init_src2 = __esm({
-  "../compression/src/index.ts"() {
+var _SPLATLoaderPreload, SPLATLoaderMetadataWithoutPreload, SPLATLoaderWithParser;
+var init_splat_loader = __esm({
+  "dist/splat-loader.js"() {
     "use strict";
-    init_default_codecs();
+    init_parse_splat();
+    init_splat_loader_types();
+    ({ preload: _SPLATLoaderPreload, ...SPLATLoaderMetadataWithoutPreload } = SPLATLoader);
+    SPLATLoaderWithParser = {
+      ...SPLATLoaderMetadataWithoutPreload,
+      parse: async (arrayBuffer) => parseSPLAT(arrayBuffer),
+      parseSync: (arrayBuffer) => parseSPLAT(arrayBuffer)
+    };
   }
 });
 
-// dist/lib/parse-spz.js
-async function parseSPZ(data, options) {
-  return makeGaussianSplatsArrowTable(await parseSPZToGaussianSplats(data, options));
-}
-async function parseSPZToGaussianSplats(data, options) {
-  const header = parseSPZHeader(data);
-  const streamInfos = parseSPZStreamInfos(data, header, getSPZStreamByteLengths(header));
-  const compressedStreams = streamInfos.map((streamInfo) => data.slice(streamInfo.compressedOffset, streamInfo.compressedOffset + streamInfo.compressedSize));
-  const decompressor = new ZstdDecompressor2({ modules: options == null ? void 0 : options.modules });
-  const streams = await Promise.all(compressedStreams.map((compressedStream, streamIndex) => decompressor.decompress(compressedStream, streamInfos[streamIndex].uncompressedSize)));
-  validateSPZStreamLengths(streams, streamInfos);
-  return decodeSPZStreams(header, streams, data);
+// dist/splat-loader-types.js
+async function preload() {
+  const { SPLATLoaderWithParser: SPLATLoaderWithParser2 } = await Promise.resolve().then(() => (init_splat_loader(), splat_loader_exports));
+  return SPLATLoaderWithParser2;
 }
-function parseSPZHeader(data) {
-  if (data.byteLength < SPZ_HEADER_BYTE_LENGTH) {
-    throw new Error(`SPZLoader: file must contain a ${SPZ_HEADER_BYTE_LENGTH}-byte header.`);
-  }
-  const dataView = new DataView(data);
-  const header = {
-    magic: dataView.getUint32(0, true),
-    version: dataView.getUint32(4, true),
-    numPoints: dataView.getUint32(8, true),
-    shDegree: dataView.getUint8(12),
-    fractionalBits: dataView.getUint8(13),
-    flags: dataView.getUint8(14),
-    numStreams: dataView.getUint8(15),
-    tocByteOffset: dataView.getUint32(16, true)
-  };
-  if (header.magic !== SPZ_MAGIC) {
-    throw new Error("SPZLoader: NGSP magic header not found.");
-  }
-  if (header.version !== SPZ_VERSION) {
-    throw new Error(`SPZLoader: version ${header.version} is not supported.`);
-  }
-  if (header.shDegree > 4) {
-    throw new Error(`SPZLoader: spherical harmonics degree ${header.shDegree} is not supported.`);
-  }
-  if (header.tocByteOffset < SPZ_HEADER_BYTE_LENGTH || header.tocByteOffset > data.byteLength) {
-    throw new Error("SPZLoader: invalid table of contents byte offset.");
+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.8" : "latest";
+    SPLATLoader = {
+      dataType: null,
+      batchType: null,
+      ...SPLATFormat,
+      version: VERSION2,
+      options: {
+        splats: {
+          shape: "arrow-table"
+        }
+      },
+      preload
+    };
   }
-  return header;
+});
+
+// dist/lib/parse-ksplat.js
+function parseKSPLAT(data) {
+  return makeGaussianSplatsArrowTable(parseKSPLATToGaussianSplats(data));
 }
-function parseSPZStreamInfos(data, header, expectedUncompressedSizes) {
-  if (header.numStreams !== expectedUncompressedSizes.length) {
-    throw new Error(`SPZLoader: expected ${expectedUncompressedSizes.length} streams, found ${header.numStreams}.`);
-  }
-  const tocByteLength = header.numStreams * 16;
-  const tocEnd = header.tocByteOffset + tocByteLength;
-  if (tocEnd > data.byteLength) {
-    throw new Error("SPZLoader: table of contents exceeds file byte length.");
+function parseKSPLATToGaussianSplats(data) {
+  if (data.byteLength < HEADER_BYTE_LENGTH) {
+    throw new Error(`KSPLATLoader: file must contain a ${HEADER_BYTE_LENGTH}-byte header.`);
   }
-  const dataView = new DataView(data);
-  let compressedOffset = tocEnd;
-  const streamInfos = [];
-  for (let streamIndex = 0; streamIndex < header.numStreams; streamIndex++) {
-    const tocOffset = header.tocByteOffset + streamIndex * 16;
-    const compressedSize = readSafeUint64(dataView, tocOffset);
-    const uncompressedSize = readSafeUint64(dataView, tocOffset + 8);
-    const expectedUncompressedSize = expectedUncompressedSizes[streamIndex];
-    if (uncompressedSize !== expectedUncompressedSize) {
-      throw new Error(`SPZLoader: stream ${streamIndex} has ${uncompressedSize} uncompressed bytes, expected ${expectedUncompressedSize}.`);
-    }
-    if (compressedOffset + compressedSize > data.byteLength) {
-      throw new Error(`SPZLoader: stream ${streamIndex} exceeds file byte length.`);
+  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++;
     }
-    streamInfos.push({ compressedSize, uncompressedSize, compressedOffset });
-    compressedOffset += compressedSize;
   }
-  if (compressedOffset !== data.byteLength) {
-    throw new Error("SPZLoader: compressed stream byte lengths do not match file byte length.");
-  }
-  return streamInfos;
+  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 readSafeUint64(dataView, byteOffset) {
-  const value = dataView.getBigUint64(byteOffset, true);
-  if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
-    throw new Error("SPZLoader: stream byte length exceeds Number.MAX_SAFE_INTEGER.");
+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);
   }
-  return Number(value);
 }
-function getSPZStreamByteLengths(header) {
-  return [
-    header.numPoints * 9,
-    header.numPoints,
-    header.numPoints * 3,
-    header.numPoints * 3,
-    header.numPoints * 4,
-    header.numPoints * getSphericalHarmonicsComponentCount2(header.shDegree)
-  ].filter((byteLength) => byteLength > 0);
+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 validateSPZStreamLengths(streams, streamInfos) {
-  for (let streamIndex = 0; streamIndex < streams.length; streamIndex++) {
-    if (streams[streamIndex].byteLength !== streamInfos[streamIndex].uncompressedSize) {
-      throw new Error(`SPZLoader: decompressed stream ${streamIndex} has unexpected byte length.`);
-    }
+function 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 decodeSPZStreams(header, streams, sourceData) {
-  const splatCount = header.numPoints;
-  const positions = new Float32Array(splatCount * 3);
-  const scales = new Float32Array(splatCount * 3);
-  const rotations = new Float32Array(splatCount * 4);
-  const colors = new Uint8Array(splatCount * 3);
-  const sphericalHarmonicDcs = new Float32Array(splatCount * 3);
-  const opacities = new Float32Array(splatCount);
-  const sphericalHarmonicsComponentCount = getSphericalHarmonicsComponentCount2(header.shDegree);
-  const sphericalHarmonics = sphericalHarmonicsComponentCount ? new Float32Array(splatCount * sphericalHarmonicsComponentCount) : void 0;
-  const [positionStream, alphaStream, colorStream, scaleStream, rotationStream, sphericalHarmonicsStream] = streams.map((stream) => new Uint8Array(stream));
-  decodeSPZPositions(positionStream, positions, header.fractionalBits);
-  decodeSPZScales(scaleStream, scales);
-  decodeSPZRotations(rotationStream, rotations);
-  decodeSPZColors(colorStream, colors, sphericalHarmonicDcs);
-  decodeSPZOpacities(alphaStream, opacities);
-  if (sphericalHarmonics && sphericalHarmonicsStream) {
-    decodeSPZSphericalHarmonics(sphericalHarmonicsStream, sphericalHarmonics);
+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 {
-    format: "spz",
-    splatCount,
-    positions,
-    scales,
-    rotations,
-    colors,
-    sphericalHarmonicDcs,
-    opacities,
-    sphericalHarmonics,
-    sphericalHarmonicsComponentCount,
-    loaderData: {
-      format: "spz",
-      ...header,
-      antialiased: Boolean(header.flags & 1),
-      extensionByteLength: getSPZExtensionByteLength(header),
-      extensionBytes: getSPZExtensionBytes(sourceData, header)
-    }
-  };
+  return sections;
 }
-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 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 decodeSPZScales(scaleStream, scales) {
-  for (let componentIndex = 0; componentIndex < scales.length; componentIndex++) {
-    scales[componentIndex] = Math.exp(scaleStream[componentIndex] / 16 - 10);
-  }
+function readCompressedCenterValue(data, byteOffset, component, compressionLevel) {
+  const dataView = new DataView(data);
+  return compressionLevel === 0 ? dataView.getFloat32(byteOffset + component * 4, true) : dataView.getUint16(byteOffset + component * 2, true);
 }
-function decodeSPZRotations(rotationStream, rotations) {
-  for (let splatIndex = 0; splatIndex < rotations.length / 4; splatIndex++) {
-    const byteOffset = splatIndex * 4;
-    const component = rotationStream[byteOffset] | rotationStream[byteOffset + 1] << 8 | rotationStream[byteOffset + 2] << 16 | rotationStream[byteOffset + 3] << 24;
-    const xyzw = decodeSPZQuaternion(component >>> 0);
-    const [w, x, y, 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 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:
@@ -1977,33 +2279,116 @@ function getSphericalHarmonicsComponentCount2(shDegree) {
       return 24;
     case 3:
       return 45;
-    case 4:
-      return 72;
     default:
-      throw new Error(`SPZLoader: spherical harmonics degree ${shDegree} is not supported.`);
+      throw new Error(`KSPLATLoader: unsupported spherical harmonics degree ${sphericalHarmonicsDegree}.`);
   }
 }
-function getSPZExtensionByteLength(header) {
-  return header.flags & SPZ_EXTENSION_FLAG ? header.tocByteOffset - SPZ_HEADER_BYTE_LENGTH : 0;
+function getActiveSectionCount(header) {
+  return header.sectionCount || header.maxSectionCount;
 }
-function getSPZExtensionBytes(data, header) {
-  const extensionByteLength = getSPZExtensionByteLength(header);
-  return extensionByteLength ? new Uint8Array(data.slice(SPZ_HEADER_BYTE_LENGTH, header.tocByteOffset)) : void 0;
+function getTotalSplatCount(header, sections) {
+  const sectionSplatCount = sections.slice(0, getActiveSectionCount(header)).reduce((splatCount, section) => splatCount + section.splatCount, 0);
+  return header.splatCount ? Math.min(header.splatCount, sectionSplatCount || header.splatCount) : sectionSplatCount;
 }
-var SPZ_HEADER_BYTE_LENGTH, SPZ_MAGIC, SPZ_VERSION, SPZ_EXTENSION_FLAG, SPZ_COLOR_SCALE, SPZ_ROTATION_COMPONENT_SCALE, SPZ_ROTATION_COMPONENT_MASK;
-var init_parse_spz = __esm({
-  "dist/lib/parse-spz.js"() {
+function validateSectionBounds(data, section) {
+  const requiredByteLength = section.dataBase + section.bytesPerSplat * section.splatCount;
+  if (requiredByteLength > data.byteLength) {
+    throw new Error("KSPLATLoader: section data extends beyond the file length.");
+  }
+}
+var CURRENT_MAJOR_VERSION, CURRENT_MINOR_VERSION, HEADER_BYTE_LENGTH, SECTION_HEADER_BYTE_LENGTH, DEFAULT_SH_8BIT_COMPRESSION_RANGE, DEFAULT_SH_8BIT_COMPRESSION_HALF_RANGE, COMPRESSION_LAYOUTS;
+var init_parse_ksplat = __esm({
+  "dist/lib/parse-ksplat.js"() {
     "use strict";
-    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;
+    CURRENT_MAJOR_VERSION = 0;
+    CURRENT_MINOR_VERSION = 1;
+    HEADER_BYTE_LENGTH = 4096;
+    SECTION_HEADER_BYTE_LENGTH = 1024;
+    DEFAULT_SH_8BIT_COMPRESSION_RANGE = 3;
+    DEFAULT_SH_8BIT_COMPRESSION_HALF_RANGE = DEFAULT_SH_8BIT_COMPRESSION_RANGE / 2;
+    COMPRESSION_LAYOUTS = {
+      0: {
+        bytesPerCenter: 12,
+        bytesPerScale: 12,
+        bytesPerRotation: 16,
+        bytesPerColor: 4,
+        scaleOffsetBytes: 12,
+        colorOffsetBytes: 40,
+        sphericalHarmonicsOffsetBytes: 44,
+        scaleRange: 1,
+        bytesPerSphericalHarmonicsComponent: 4
+      },
+      1: {
+        bytesPerCenter: 6,
+        bytesPerScale: 6,
+        bytesPerRotation: 8,
+        bytesPerColor: 4,
+        scaleOffsetBytes: 6,
+        colorOffsetBytes: 20,
+        sphericalHarmonicsOffsetBytes: 24,
+        scaleRange: 32767,
+        bytesPerSphericalHarmonicsComponent: 2
+      },
+      2: {
+        bytesPerCenter: 6,
+        bytesPerScale: 6,
+        bytesPerRotation: 8,
+        bytesPerColor: 4,
+        scaleOffsetBytes: 6,
+        colorOffsetBytes: 20,
+        sphericalHarmonicsOffsetBytes: 24,
+        scaleRange: 32767,
+        bytesPerSphericalHarmonicsComponent: 1
+      }
+    };
+  }
+});
+
+// dist/ksplat-loader.js
+var ksplat_loader_exports = {};
+__export(ksplat_loader_exports, {
+  KSPLATLoaderWithParser: () => KSPLATLoaderWithParser
+});
+var _KSPLATLoaderPreload, KSPLATLoaderMetadataWithoutPreload, KSPLATLoaderWithParser;
+var init_ksplat_loader = __esm({
+  "dist/ksplat-loader.js"() {
+    "use strict";
+    init_parse_ksplat();
+    init_ksplat_loader_types();
+    ({ preload: _KSPLATLoaderPreload, ...KSPLATLoaderMetadataWithoutPreload } = KSPLATLoader);
+    KSPLATLoaderWithParser = {
+      ...KSPLATLoaderMetadataWithoutPreload,
+      parse: async (arrayBuffer) => parseKSPLAT(arrayBuffer),
+      parseSync: (arrayBuffer) => parseKSPLAT(arrayBuffer)
+    };
+  }
+});
+
+// dist/ksplat-loader-types.js
+async function preload2() {
+  const { KSPLATLoaderWithParser: KSPLATLoaderWithParser2 } = await Promise.resolve().then(() => (init_ksplat_loader(), ksplat_loader_exports));
+  return KSPLATLoaderWithParser2;
+}
+var VERSION3, KSPLATLoader;
+var init_ksplat_loader_types = __esm({
+  "dist/ksplat-loader-types.js"() {
+    "use strict";
+    init_splats_format();
+    VERSION3 = true ? "5.0.0-alpha.8" : "latest";
+    KSPLATLoader = {
+      dataType: null,
+      batchType: null,
+      ...KSPLATFormat,
+      version: VERSION3,
+      options: {
+        splats: {
+          shape: "arrow-table"
+        }
+      },
+      preload: preload2
+    };
   }
 });
 
@@ -2036,7 +2421,7 @@ var init_spz_loader_types = __esm({
   "dist/spz-loader-types.js"() {
     "use strict";
     init_splats_format();
-    VERSION4 = true ? "5.0.0-alpha.6" : "latest";
+    VERSION4 = true ? "5.0.0-alpha.8" : "latest";
     SPZLoader = {
       dataType: null,
       batchType: null,
@@ -2210,31 +2595,12 @@ var init_parse_rad = __esm({
   }
 });
 
-// ../compression/src/lib/fflate-stream.ts
-async function* transformFflateBatches(processor, inputBatches) {
-  const chunks = [];
-  processor.ondata = (data) => {
-    chunks.push(data.slice().buffer);
-  };
-  for await (const batch of inputBatches) {
-    processor.push(new Uint8Array(batch), false);
-    yield* chunks.splice(0);
-  }
-  processor.push(new Uint8Array(0), true);
-  yield* chunks;
-}
-var init_fflate_stream = __esm({
-  "../compression/src/lib/fflate-stream.ts"() {
-    "use strict";
-  }
-});
-
 // ../compression/src/deflate-decompressor-fflate.ts
-var import_fflate, DeflateFflateDecompressor;
+var import_fflate2, DeflateFflateDecompressor;
 var init_deflate_decompressor_fflate = __esm({
   "../compression/src/deflate-decompressor-fflate.ts"() {
     "use strict";
-    import_fflate = require("fflate");
+    import_fflate2 = require("fflate");
     init_compression();
     init_fflate_stream();
     DeflateFflateDecompressor = class extends Decompressor {
@@ -2250,12 +2616,12 @@ var init_deflate_decompressor_fflate = __esm({
       /** Decompresses one zlib-wrapped DEFLATE payload synchronously. */
       decompressSync(input) {
         const bytes = new Uint8Array(input);
-        const output = this.options.raw ? (0, import_fflate.inflateSync)(bytes) : (0, import_fflate.unzlibSync)(bytes);
+        const output = this.options.raw ? (0, import_fflate2.inflateSync)(bytes) : (0, import_fflate2.unzlibSync)(bytes);
         return output.slice().buffer;
       }
       /** Decompresses DEFLATE batches incrementally. */
       async *decompressBatches(inputBatches) {
-        const processor = this.options.raw ? new import_fflate.Inflate() : new import_fflate.Unzlib();
+        const processor = this.options.raw ? new import_fflate2.Inflate() : new import_fflate2.Unzlib();
         yield* transformFflateBatches(processor, inputBatches);
       }
     };
@@ -2806,7 +3172,7 @@ var init_rad_loader_types = __esm({
   "dist/rad-loader-types.js"() {
     "use strict";
     init_splats_format();
-    VERSION5 = true ? "5.0.0-alpha.6" : "latest";
+    VERSION5 = true ? "5.0.0-alpha.8" : "latest";
     RADLoader = {
       dataType: null,
       batchType: null,
@@ -2831,10 +3197,13 @@ __export(index_exports, {
   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();
@@ -2848,7 +3217,7 @@ 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 VERSION6 = true ? "5.0.0-alpha.6" : "latest";
+var VERSION6 = true ? "5.0.0-alpha.8" : "latest";
 var RADSourceLoader = {
   dataType: null,
   batchType: null,