@loaders.gl/splats 5.0.0-alpha.1

package/dist/index.cjs

@@ -0,0 +1,2046 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// dist/splats-format.js
+var SPLATFormat, KSPLATFormat, SPZFormat, RADFormat;
+var init_splats_format = __esm({
+  "dist/splats-format.js"() {
+    "use strict";
+    SPLATFormat = {
+      name: "SPLAT",
+      id: "splat",
+      module: "splats",
+      format: "splat",
+      extensions: ["splat"],
+      mimeTypes: ["application/octet-stream"],
+      binary: true
+    };
+    KSPLATFormat = {
+      name: "KSPLAT",
+      id: "ksplat",
+      module: "splats",
+      format: "ksplat",
+      extensions: ["ksplat"],
+      mimeTypes: ["application/octet-stream"],
+      binary: true
+    };
+    SPZFormat = {
+      name: "SPZ",
+      id: "spz",
+      module: "splats",
+      format: "spz",
+      extensions: ["spz"],
+      mimeTypes: ["application/octet-stream"],
+      binary: true,
+      tests: [new Uint8Array([78, 71, 83, 80]).buffer]
+    };
+    RADFormat = {
+      name: "RAD",
+      id: "rad",
+      module: "splats",
+      format: "rad",
+      extensions: ["rad"],
+      mimeTypes: ["application/octet-stream"],
+      binary: true,
+      tests: [new Uint8Array([82, 65, 68, 48]).buffer]
+    };
+  }
+});
+
+// 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, z) {
+  const length = Math.hypot(w, x, y, z);
+  if (!Number.isFinite(length) || length <= Number.EPSILON) {
+    return [1, 0, 0, 0];
+  }
+  return [w / length, x / length, y / length, z / length];
+}
+function decodeQuaternionByte(byte) {
+  return (byte - 128) / 128;
+}
+function decodeFloat16(value) {
+  const sign = value & 32768 ? -1 : 1;
+  const exponent = value >> 10 & 31;
+  const fraction = value & 1023;
+  if (exponent === 0) {
+    return sign * Math.pow(2, -14) * (fraction / 1024);
+  }
+  if (exponent === 31) {
+    return fraction ? Number.NaN : sign * Number.POSITIVE_INFINITY;
+  }
+  return sign * Math.pow(2, exponent - 15) * (1 + fraction / 1024);
+}
+var SH_C0;
+var init_splat_utils = __esm({
+  "dist/lib/splat-utils.js"() {
+    "use strict";
+    SH_C0 = 0.28209479177387814;
+  }
+});
+
+// dist/lib/splats-arrow-table.js
+function makeGaussianSplatsArrowTable(splats) {
+  const columns = {};
+  const fields = [];
+  const schemaFields = [];
+  addColumn(columns, fields, schemaFields, "POSITION", makeFixedSizeListVector(splats.positions, 3), {
+    type: "fixed-size-list",
+    listSize: 3,
+    children: [{ name: "value", type: "float32" }]
+  });
+  const colorCoefficients = getColorCoefficients(splats);
+  addScalarColumn(columns, fields, schemaFields, "f_dc_0", colorCoefficients[0], {
+    "loaders_gl.gaussian_splats.semantic": "spherical_harmonic_dc",
+    "loaders_gl.gaussian_splats.component": "0",
+    "loaders_gl.gaussian_splats.encoding": "coefficient"
+  });
+  addScalarColumn(columns, fields, schemaFields, "f_dc_1", colorCoefficients[1], {
+    "loaders_gl.gaussian_splats.semantic": "spherical_harmonic_dc",
+    "loaders_gl.gaussian_splats.component": "1",
+    "loaders_gl.gaussian_splats.encoding": "coefficient"
+  });
+  addScalarColumn(columns, fields, schemaFields, "f_dc_2", colorCoefficients[2], {
+    "loaders_gl.gaussian_splats.semantic": "spherical_harmonic_dc",
+    "loaders_gl.gaussian_splats.component": "2",
+    "loaders_gl.gaussian_splats.encoding": "coefficient"
+  });
+  addScalarColumn(columns, fields, schemaFields, "opacity", splats.opacities, {
+    "loaders_gl.gaussian_splats.semantic": "opacity",
+    "loaders_gl.gaussian_splats.encoding": "linear"
+  });
+  addVectorComponents(columns, fields, schemaFields, "scale", splats.scales, 3, {
+    "loaders_gl.gaussian_splats.semantic": "scale",
+    "loaders_gl.gaussian_splats.encoding": "linear"
+  });
+  addVectorComponents(columns, fields, schemaFields, "rot", splats.rotations, 4, {
+    "loaders_gl.gaussian_splats.semantic": "rotation",
+    "loaders_gl.gaussian_splats.encoding": "quaternion"
+  });
+  if (splats.sphericalHarmonics && splats.sphericalHarmonicsComponentCount) {
+    addSphericalHarmonicRestColumns(columns, fields, schemaFields, splats.sphericalHarmonics, splats.sphericalHarmonicsComponentCount);
+  }
+  const metadata = /* @__PURE__ */ new Map([
+    ["loaders_gl.semantic_type", "gaussian-splats"],
+    ["loaders_gl.gaussian_splats.version", "1"],
+    ["loaders_gl.gaussian_splats.source_format", splats.format],
+    ["topology", "point-list"],
+    ["mode", "0"]
+  ]);
+  const arrowSchema = new arrow.Schema(fields, metadata);
+  const schema = {
+    fields: schemaFields,
+    metadata: Object.fromEntries(metadata)
+  };
+  return {
+    shape: "arrow-table",
+    schema,
+    data: new arrow.Table(arrowSchema, columns),
+    topology: "point-list",
+    loaderData: splats.loaderData
+  };
+}
+function addVectorComponents(columns, fields, schemaFields, prefix, values, size, metadata) {
+  for (let component = 0; component < size; component++) {
+    const componentValues = new Float32Array(values.length / size);
+    for (let rowIndex = 0; rowIndex < componentValues.length; rowIndex++) {
+      componentValues[rowIndex] = values[rowIndex * size + component];
+    }
+    addScalarColumn(columns, fields, schemaFields, `${prefix}_${component}`, componentValues, {
+      ...metadata,
+      "loaders_gl.gaussian_splats.component": String(component)
+    });
+  }
+}
+function addSphericalHarmonicRestColumns(columns, fields, schemaFields, sphericalHarmonics, componentCount) {
+  for (let component = 0; component < componentCount; component++) {
+    const componentValues = new Float32Array(sphericalHarmonics.length / componentCount);
+    for (let rowIndex = 0; rowIndex < componentValues.length; rowIndex++) {
+      componentValues[rowIndex] = sphericalHarmonics[rowIndex * componentCount + component];
+    }
+    addScalarColumn(columns, fields, schemaFields, `f_rest_${component}`, componentValues, {
+      "loaders_gl.gaussian_splats.semantic": "spherical_harmonic_rest",
+      "loaders_gl.gaussian_splats.component": String(component),
+      "loaders_gl.gaussian_splats.encoding": "coefficient"
+    });
+  }
+}
+function addScalarColumn(columns, fields, schemaFields, name, values, metadata) {
+  addColumn(columns, fields, schemaFields, name, arrow.makeVector(values), "float32", metadata);
+}
+function addColumn(columns, fields, schemaFields, name, column, schemaType, metadata = {}) {
+  columns[name] = column;
+  fields.push(new arrow.Field(name, column.type, false, new Map(Object.entries(metadata))));
+  schemaFields.push({ name, type: schemaType, nullable: false, metadata });
+}
+function makeFixedSizeListVector(value, size) {
+  const values = arrow.makeVector(value);
+  const child = values.data[0];
+  const type = new arrow.FixedSizeList(size, new arrow.Field("value", child.type, false));
+  const data = new arrow.Data(type, 0, value.length / size, 0, {}, [child]);
+  return new arrow.Vector([data]);
+}
+function getColorCoefficients(splats) {
+  const rowCount = splats.splatCount;
+  const fdc0 = new Float32Array(rowCount);
+  const fdc1 = new Float32Array(rowCount);
+  const fdc2 = new Float32Array(rowCount);
+  for (let rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+    if (splats.sphericalHarmonicDcs) {
+      fdc0[rowIndex] = splats.sphericalHarmonicDcs[rowIndex * 3 + 0];
+      fdc1[rowIndex] = splats.sphericalHarmonicDcs[rowIndex * 3 + 1];
+      fdc2[rowIndex] = splats.sphericalHarmonicDcs[rowIndex * 3 + 2];
+    } else {
+      fdc0[rowIndex] = convertColorByteToSphericalHarmonicDc(splats.colors[rowIndex * 3 + 0]);
+      fdc1[rowIndex] = convertColorByteToSphericalHarmonicDc(splats.colors[rowIndex * 3 + 1]);
+      fdc2[rowIndex] = convertColorByteToSphericalHarmonicDc(splats.colors[rowIndex * 3 + 2]);
+    }
+  }
+  return [fdc0, fdc1, fdc2];
+}
+var arrow;
+var init_splats_arrow_table = __esm({
+  "dist/lib/splats-arrow-table.js"() {
+    "use strict";
+    arrow = __toESM(require("apache-arrow"), 1);
+    init_splat_utils();
+  }
+});
+
+// dist/lib/parse-splat.js
+function parseSPLAT(data) {
+  return makeGaussianSplatsArrowTable(parseSPLATToGaussianSplats(data));
+}
+function parseSPLATToGaussianSplats(data) {
+  if (data.byteLength % SPLAT_ROW_BYTE_LENGTH !== 0) {
+    throw new Error(`SPLATLoader: byte length must be a multiple of ${SPLAT_ROW_BYTE_LENGTH}.`);
+  }
+  const splatCount = data.byteLength / SPLAT_ROW_BYTE_LENGTH;
+  const dataView = new DataView(data);
+  const positions = new Float32Array(splatCount * 3);
+  const scales = new Float32Array(splatCount * 3);
+  const rotations = new Float32Array(splatCount * 4);
+  const colors = new Uint8Array(splatCount * 3);
+  const opacities = new Float32Array(splatCount);
+  for (let splatIndex = 0; splatIndex < splatCount; splatIndex++) {
+    const byteOffset = splatIndex * SPLAT_ROW_BYTE_LENGTH;
+    const positionOffset = splatIndex * 3;
+    const rotationOffset = splatIndex * 4;
+    positions[positionOffset + 0] = dataView.getFloat32(byteOffset + 0, true);
+    positions[positionOffset + 1] = dataView.getFloat32(byteOffset + 4, true);
+    positions[positionOffset + 2] = dataView.getFloat32(byteOffset + 8, true);
+    scales[positionOffset + 0] = dataView.getFloat32(byteOffset + 12, true);
+    scales[positionOffset + 1] = dataView.getFloat32(byteOffset + 16, true);
+    scales[positionOffset + 2] = dataView.getFloat32(byteOffset + 20, true);
+    colors[positionOffset + 0] = dataView.getUint8(byteOffset + 24);
+    colors[positionOffset + 1] = dataView.getUint8(byteOffset + 25);
+    colors[positionOffset + 2] = dataView.getUint8(byteOffset + 26);
+    opacities[splatIndex] = convertAlphaByteToLinearOpacity(dataView.getUint8(byteOffset + 27));
+    const [w, x, y, z] = normalizeQuaternion(decodeQuaternionByte(dataView.getUint8(byteOffset + 28)), decodeQuaternionByte(dataView.getUint8(byteOffset + 29)), decodeQuaternionByte(dataView.getUint8(byteOffset + 30)), decodeQuaternionByte(dataView.getUint8(byteOffset + 31)));
+    rotations[rotationOffset + 0] = w;
+    rotations[rotationOffset + 1] = x;
+    rotations[rotationOffset + 2] = y;
+    rotations[rotationOffset + 3] = z;
+  }
+  return {
+    format: "splat",
+    splatCount,
+    positions,
+    scales,
+    rotations,
+    colors,
+    opacities,
+    loaderData: {
+      format: "splat",
+      splatCount,
+      rowByteLength: SPLAT_ROW_BYTE_LENGTH
+    }
+  };
+}
+var SPLAT_ROW_BYTE_LENGTH;
+var init_parse_splat = __esm({
+  "dist/lib/parse-splat.js"() {
+    "use strict";
+    init_splats_arrow_table();
+    init_splat_utils();
+    SPLAT_ROW_BYTE_LENGTH = 32;
+  }
+});
+
+// dist/splat-loader.js
+var splat_loader_exports = {};
+__export(splat_loader_exports, {
+  SPLATLoaderWithParser: () => SPLATLoaderWithParser
+});
+var _SPLATLoaderPreload, SPLATLoaderMetadataWithoutPreload, SPLATLoaderWithParser;
+var init_splat_loader = __esm({
+  "dist/splat-loader.js"() {
+    "use strict";
+    init_parse_splat();
+    init_splat_loader_types();
+    ({ preload: _SPLATLoaderPreload, ...SPLATLoaderMetadataWithoutPreload } = SPLATLoader);
+    SPLATLoaderWithParser = {
+      ...SPLATLoaderMetadataWithoutPreload,
+      parse: async (arrayBuffer) => parseSPLAT(arrayBuffer),
+      parseSync: (arrayBuffer) => parseSPLAT(arrayBuffer)
+    };
+  }
+});
+
+// dist/splat-loader-types.js
+async function preload() {
+  const { SPLATLoaderWithParser: SPLATLoaderWithParser2 } = await Promise.resolve().then(() => (init_splat_loader(), splat_loader_exports));
+  return SPLATLoaderWithParser2;
+}
+var VERSION, SPLATLoader;
+var init_splat_loader_types = __esm({
+  "dist/splat-loader-types.js"() {
+    "use strict";
+    init_splats_format();
+    VERSION = true ? "5.0.0-alpha.1" : "latest";
+    SPLATLoader = {
+      dataType: null,
+      batchType: null,
+      ...SPLATFormat,
+      version: VERSION,
+      options: {
+        splats: {
+          shape: "arrow-table"
+        }
+      },
+      preload
+    };
+  }
+});
+
+// dist/lib/parse-ksplat.js
+function parseKSPLAT(data) {
+  return makeGaussianSplatsArrowTable(parseKSPLATToGaussianSplats(data));
+}
+function parseKSPLATToGaussianSplats(data) {
+  if (data.byteLength < HEADER_BYTE_LENGTH) {
+    throw new Error(`KSPLATLoader: file must contain a ${HEADER_BYTE_LENGTH}-byte header.`);
+  }
+  const header = parseKSPLATHeader(data);
+  checkKSPLATVersion(header);
+  const sections = parseKSPLATSections(data, header);
+  const splatCount = getTotalSplatCount(header, sections);
+  const sphericalHarmonicsComponentCount = Math.max(0, ...sections.slice(0, getActiveSectionCount(header)).map((section) => 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 {
+    format: "ksplat",
+    splatCount,
+    positions,
+    scales,
+    rotations,
+    colors,
+    opacities,
+    sphericalHarmonics,
+    sphericalHarmonicsComponentCount,
+    loaderData: {
+      format: "ksplat",
+      ...header,
+      sections: sections.slice(0, getActiveSectionCount(header)).map((section) => ({
+        splatCount: section.splatCount,
+        maxSplatCount: section.maxSplatCount,
+        sphericalHarmonicsDegree: section.sphericalHarmonicsDegree
+      }))
+    }
+  };
+}
+function decodeKSPLATSplat(data, header, section, localSplatIndex, outputSplatIndex, positions, scales, rotations, colors, opacities, sphericalHarmonics, sphericalHarmonicsComponentCount) {
+  const layout = COMPRESSION_LAYOUTS[header.compressionLevel];
+  const splatBase = section.dataBase + section.bytesPerSplat * localSplatIndex;
+  const positionOffset = outputSplatIndex * 3;
+  const rotationOffset = outputSplatIndex * 4;
+  const bucketCenter = getBucketCenter(data, section, localSplatIndex);
+  positions[positionOffset + 0] = decodeKSPLATCenterComponent(data, splatBase, 0, header, section, bucketCenter[0]);
+  positions[positionOffset + 1] = decodeKSPLATCenterComponent(data, splatBase, 1, header, section, bucketCenter[1]);
+  positions[positionOffset + 2] = decodeKSPLATCenterComponent(data, splatBase, 2, header, section, bucketCenter[2]);
+  scales[positionOffset + 0] = readCompressedFloat(data, splatBase + layout.scaleOffsetBytes, 0, header.compressionLevel);
+  scales[positionOffset + 1] = readCompressedFloat(data, splatBase + layout.scaleOffsetBytes, 1, header.compressionLevel);
+  scales[positionOffset + 2] = readCompressedFloat(data, splatBase + layout.scaleOffsetBytes, 2, header.compressionLevel);
+  const [w, x, y, z] = normalizeQuaternion(readCompressedFloat(data, splatBase + layout.scaleOffsetBytes, 3, header.compressionLevel), readCompressedFloat(data, splatBase + layout.scaleOffsetBytes, 4, header.compressionLevel), readCompressedFloat(data, splatBase + layout.scaleOffsetBytes, 5, header.compressionLevel), readCompressedFloat(data, splatBase + layout.scaleOffsetBytes, 6, header.compressionLevel));
+  rotations[rotationOffset + 0] = w;
+  rotations[rotationOffset + 1] = x;
+  rotations[rotationOffset + 2] = y;
+  rotations[rotationOffset + 3] = z;
+  const colorBase = splatBase + layout.colorOffsetBytes;
+  const colorView = new Uint8Array(data, colorBase, 4);
+  colors[positionOffset + 0] = colorView[0];
+  colors[positionOffset + 1] = colorView[1];
+  colors[positionOffset + 2] = colorView[2];
+  opacities[outputSplatIndex] = convertAlphaByteToLinearOpacity(colorView[3]);
+  if (sphericalHarmonics && sphericalHarmonicsComponentCount) {
+    decodeSphericalHarmonics(data, splatBase + layout.sphericalHarmonicsOffsetBytes, header, section, outputSplatIndex, sphericalHarmonics, sphericalHarmonicsComponentCount);
+  }
+}
+function parseKSPLATHeader(data) {
+  const dataView = new DataView(data, 0, HEADER_BYTE_LENGTH);
+  const compressionLevel = dataView.getUint16(20, true);
+  if (compressionLevel !== 0 && compressionLevel !== 1 && compressionLevel !== 2) {
+    throw new Error(`KSPLATLoader: unsupported compression level ${compressionLevel}.`);
+  }
+  return {
+    versionMajor: dataView.getUint8(0),
+    versionMinor: dataView.getUint8(1),
+    maxSectionCount: dataView.getUint32(4, true),
+    sectionCount: dataView.getUint32(8, true),
+    maxSplatCount: dataView.getUint32(12, true),
+    splatCount: dataView.getUint32(16, true),
+    compressionLevel,
+    minSphericalHarmonicsCoeff: dataView.getFloat32(36, true) || -DEFAULT_SH_8BIT_COMPRESSION_HALF_RANGE,
+    maxSphericalHarmonicsCoeff: dataView.getFloat32(40, true) || DEFAULT_SH_8BIT_COMPRESSION_HALF_RANGE
+  };
+}
+function checkKSPLATVersion(header) {
+  if (header.versionMajor === CURRENT_MAJOR_VERSION ? header.versionMinor >= CURRENT_MINOR_VERSION : header.versionMajor > CURRENT_MAJOR_VERSION) {
+    return;
+  }
+  throw new Error(`KSPLATLoader: version ${header.versionMajor}.${header.versionMinor} is not supported.`);
+}
+function parseKSPLATSections(data, header) {
+  if (data.byteLength < HEADER_BYTE_LENGTH + header.maxSectionCount * SECTION_HEADER_BYTE_LENGTH) {
+    throw new Error("KSPLATLoader: file does not contain all section headers.");
+  }
+  const sections = [];
+  let sectionBase = HEADER_BYTE_LENGTH + header.maxSectionCount * SECTION_HEADER_BYTE_LENGTH;
+  let splatCountOffset = 0;
+  for (let sectionIndex = 0; sectionIndex < header.maxSectionCount; sectionIndex++) {
+    const sectionHeaderBase = HEADER_BYTE_LENGTH + sectionIndex * SECTION_HEADER_BYTE_LENGTH;
+    const dataView = new DataView(data, sectionHeaderBase, SECTION_HEADER_BYTE_LENGTH);
+    const splatCount = dataView.getUint32(0, true);
+    const maxSplatCount = dataView.getUint32(4, true);
+    const bucketSize = dataView.getUint32(8, true);
+    const bucketCount = dataView.getUint32(12, true);
+    const bucketBlockSize = dataView.getFloat32(16, true);
+    const bucketStorageSizeBytes = dataView.getUint16(20, true);
+    const compressionScaleRange = dataView.getUint32(24, true) || COMPRESSION_LAYOUTS[header.compressionLevel].scaleRange;
+    const fullBucketCount = dataView.getUint32(32, true);
+    const partiallyFilledBucketCount = dataView.getUint32(36, true);
+    const sphericalHarmonicsDegree = dataView.getUint16(40, true);
+    const bytesPerSplat = getBytesPerSplat(header.compressionLevel, sphericalHarmonicsDegree);
+    const bucketsMetaDataSizeBytes = partiallyFilledBucketCount * 4;
+    const bucketsStorageSizeBytes = bucketStorageSizeBytes * bucketCount + bucketsMetaDataSizeBytes;
+    const storageSizeBytes = bytesPerSplat * maxSplatCount + bucketsStorageSizeBytes;
+    sections.push({
+      bytesPerSplat,
+      splatCountOffset,
+      splatCount: splatCount || maxSplatCount,
+      maxSplatCount,
+      bucketSize,
+      bucketCount,
+      bucketStorageSizeBytes,
+      bucketsStorageSizeBytes,
+      compressionScaleRange,
+      compressionScaleFactor: bucketBlockSize / 2 / compressionScaleRange,
+      base: sectionBase,
+      bucketsBase: sectionBase + bucketsMetaDataSizeBytes,
+      dataBase: sectionBase + bucketsStorageSizeBytes,
+      fullBucketCount,
+      partiallyFilledBucketCount,
+      sphericalHarmonicsDegree
+    });
+    sectionBase += storageSizeBytes;
+    splatCountOffset += maxSplatCount;
+  }
+  return sections;
+}
+function decodeKSPLATCenterComponent(data, splatBase, component, header, section, bucketCenter) {
+  const value = readCompressedCenterValue(data, splatBase, component, header.compressionLevel);
+  return header.compressionLevel >= 1 ? (value - section.compressionScaleRange) * section.compressionScaleFactor + bucketCenter : value;
+}
+function readCompressedCenterValue(data, byteOffset, component, compressionLevel) {
+  const dataView = new DataView(data);
+  return compressionLevel === 0 ? dataView.getFloat32(byteOffset + component * 4, true) : dataView.getUint16(byteOffset + component * 2, true);
+}
+function 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 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++;
+  }
+  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);
+  }
+}
+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);
+  }
+  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 getBytesPerSplat(compressionLevel, sphericalHarmonicsDegree) {
+  const layout = COMPRESSION_LAYOUTS[compressionLevel];
+  return layout.bytesPerCenter + layout.bytesPerScale + layout.bytesPerRotation + layout.bytesPerColor + layout.bytesPerSphericalHarmonicsComponent * getSphericalHarmonicsComponentCount(sphericalHarmonicsDegree);
+}
+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}.`);
+  }
+}
+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 validateSectionBounds(data, section) {
+  const requiredByteLength = section.dataBase + section.bytesPerSplat * section.splatCount;
+  if (requiredByteLength > data.byteLength) {
+    throw new Error("KSPLATLoader: section data extends beyond the file length.");
+  }
+}
+var CURRENT_MAJOR_VERSION, CURRENT_MINOR_VERSION, HEADER_BYTE_LENGTH, SECTION_HEADER_BYTE_LENGTH, DEFAULT_SH_8BIT_COMPRESSION_RANGE, DEFAULT_SH_8BIT_COMPRESSION_HALF_RANGE, COMPRESSION_LAYOUTS;
+var init_parse_ksplat = __esm({
+  "dist/lib/parse-ksplat.js"() {
+    "use strict";
+    init_splats_arrow_table();
+    init_splat_utils();
+    CURRENT_MAJOR_VERSION = 0;
+    CURRENT_MINOR_VERSION = 1;
+    HEADER_BYTE_LENGTH = 4096;
+    SECTION_HEADER_BYTE_LENGTH = 1024;
+    DEFAULT_SH_8BIT_COMPRESSION_RANGE = 3;
+    DEFAULT_SH_8BIT_COMPRESSION_HALF_RANGE = DEFAULT_SH_8BIT_COMPRESSION_RANGE / 2;
+    COMPRESSION_LAYOUTS = {
+      0: {
+        bytesPerCenter: 12,
+        bytesPerScale: 12,
+        bytesPerRotation: 16,
+        bytesPerColor: 4,
+        scaleOffsetBytes: 12,
+        colorOffsetBytes: 40,
+        sphericalHarmonicsOffsetBytes: 44,
+        scaleRange: 1,
+        bytesPerSphericalHarmonicsComponent: 4
+      },
+      1: {
+        bytesPerCenter: 6,
+        bytesPerScale: 6,
+        bytesPerRotation: 8,
+        bytesPerColor: 4,
+        scaleOffsetBytes: 6,
+        colorOffsetBytes: 20,
+        sphericalHarmonicsOffsetBytes: 24,
+        scaleRange: 32767,
+        bytesPerSphericalHarmonicsComponent: 2
+      },
+      2: {
+        bytesPerCenter: 6,
+        bytesPerScale: 6,
+        bytesPerRotation: 8,
+        bytesPerColor: 4,
+        scaleOffsetBytes: 6,
+        colorOffsetBytes: 20,
+        sphericalHarmonicsOffsetBytes: 24,
+        scaleRange: 32767,
+        bytesPerSphericalHarmonicsComponent: 1
+      }
+    };
+  }
+});
+
+// dist/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 VERSION2, KSPLATLoader;
+var init_ksplat_loader_types = __esm({
+  "dist/ksplat-loader-types.js"() {
+    "use strict";
+    init_splats_format();
+    VERSION2 = true ? "5.0.0-alpha.1" : "latest";
+    KSPLATLoader = {
+      dataType: null,
+      batchType: null,
+      ...KSPLATFormat,
+      version: VERSION2,
+      options: {
+        splats: {
+          shape: "arrow-table"
+        }
+      },
+      preload: preload2
+    };
+  }
+});
+
+// dist/lib/parse-spz.js
+async function parseSPZ(data, options) {
+  return makeGaussianSplatsArrowTable(await parseSPZToGaussianSplats(data, options));
+}
+async function parseSPZToGaussianSplats(data, options) {
+  const header = parseSPZHeader(data);
+  const streamInfos = parseSPZStreamInfos(data, header, getSPZStreamByteLengths(header));
+  const compressedStreams = streamInfos.map((streamInfo) => data.slice(streamInfo.compressedOffset, streamInfo.compressedOffset + streamInfo.compressedSize));
+  const compression = new import_compression.ZstdCompression({ modules: options == null ? void 0 : options.modules });
+  const streams = await Promise.all(compressedStreams.map((compressedStream, streamIndex) => compression.decompress(compressedStream, streamInfos[streamIndex].uncompressedSize)));
+  validateSPZStreamLengths(streams, streamInfos);
+  return decodeSPZStreams(header, streams, data);
+}
+function parseSPZHeader(data) {
+  if (data.byteLength < SPZ_HEADER_BYTE_LENGTH) {
+    throw new Error(`SPZLoader: file must contain a ${SPZ_HEADER_BYTE_LENGTH}-byte header.`);
+  }
+  const dataView = new DataView(data);
+  const header = {
+    magic: dataView.getUint32(0, true),
+    version: dataView.getUint32(4, true),
+    numPoints: dataView.getUint32(8, true),
+    shDegree: dataView.getUint8(12),
+    fractionalBits: dataView.getUint8(13),
+    flags: dataView.getUint8(14),
+    numStreams: dataView.getUint8(15),
+    tocByteOffset: dataView.getUint32(16, true)
+  };
+  if (header.magic !== SPZ_MAGIC) {
+    throw new Error("SPZLoader: NGSP magic header not found.");
+  }
+  if (header.version !== SPZ_VERSION) {
+    throw new Error(`SPZLoader: version ${header.version} is not supported.`);
+  }
+  if (header.shDegree > 4) {
+    throw new Error(`SPZLoader: spherical harmonics degree ${header.shDegree} is not supported.`);
+  }
+  if (header.tocByteOffset < SPZ_HEADER_BYTE_LENGTH || header.tocByteOffset > data.byteLength) {
+    throw new Error("SPZLoader: invalid table of contents byte offset.");
+  }
+  return header;
+}
+function parseSPZStreamInfos(data, header, expectedUncompressedSizes) {
+  if (header.numStreams !== expectedUncompressedSizes.length) {
+    throw new Error(`SPZLoader: expected ${expectedUncompressedSizes.length} streams, found ${header.numStreams}.`);
+  }
+  const tocByteLength = header.numStreams * 16;
+  const tocEnd = header.tocByteOffset + tocByteLength;
+  if (tocEnd > data.byteLength) {
+    throw new Error("SPZLoader: table of contents exceeds file byte length.");
+  }
+  const dataView = new DataView(data);
+  let compressedOffset = tocEnd;
+  const streamInfos = [];
+  for (let streamIndex = 0; streamIndex < header.numStreams; streamIndex++) {
+    const tocOffset = header.tocByteOffset + streamIndex * 16;
+    const compressedSize = readSafeUint64(dataView, tocOffset);
+    const uncompressedSize = readSafeUint64(dataView, tocOffset + 8);
+    const expectedUncompressedSize = expectedUncompressedSizes[streamIndex];
+    if (uncompressedSize !== expectedUncompressedSize) {
+      throw new Error(`SPZLoader: stream ${streamIndex} has ${uncompressedSize} uncompressed bytes, expected ${expectedUncompressedSize}.`);
+    }
+    if (compressedOffset + compressedSize > data.byteLength) {
+      throw new Error(`SPZLoader: stream ${streamIndex} exceeds file byte length.`);
+    }
+    streamInfos.push({ compressedSize, uncompressedSize, compressedOffset });
+    compressedOffset += compressedSize;
+  }
+  if (compressedOffset !== data.byteLength) {
+    throw new Error("SPZLoader: compressed stream byte lengths do not match file byte length.");
+  }
+  return streamInfos;
+}
+function readSafeUint64(dataView, byteOffset) {
+  const value = dataView.getBigUint64(byteOffset, true);
+  if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw new Error("SPZLoader: stream byte length exceeds Number.MAX_SAFE_INTEGER.");
+  }
+  return Number(value);
+}
+function getSPZStreamByteLengths(header) {
+  return [
+    header.numPoints * 9,
+    header.numPoints,
+    header.numPoints * 3,
+    header.numPoints * 3,
+    header.numPoints * 4,
+    header.numPoints * getSphericalHarmonicsComponentCount2(header.shDegree)
+  ].filter((byteLength) => byteLength > 0);
+}
+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 = 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);
+  }
+  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, z] = normalizeQuaternion(xyzw[3], xyzw[0], xyzw[1], xyzw[2]);
+    const rotationOffset = splatIndex * 4;
+    rotations[rotationOffset + 0] = w;
+    rotations[rotationOffset + 1] = x;
+    rotations[rotationOffset + 2] = y;
+    rotations[rotationOffset + 3] = z;
+  }
+}
+function decodeSPZQuaternion(component) {
+  const rotation = [0, 0, 0, 0];
+  const largestComponent = component >>> 30;
+  let remainingBits = component;
+  let sumSquares = 0;
+  for (let componentIndex = 3; componentIndex >= 0; componentIndex--) {
+    if (componentIndex !== largestComponent) {
+      const magnitude = remainingBits & SPZ_ROTATION_COMPONENT_MASK;
+      const isNegative = remainingBits >>> 9 & 1;
+      remainingBits >>>= 10;
+      let value = SPZ_ROTATION_COMPONENT_SCALE * magnitude / SPZ_ROTATION_COMPONENT_MASK;
+      if (isNegative) {
+        value = -value;
+      }
+      rotation[componentIndex] = value;
+      sumSquares += value * value;
+    }
+  }
+  rotation[largestComponent] = Math.sqrt(Math.max(0, 1 - sumSquares));
+  return rotation;
+}
+function decodeSPZColors(colorStream, colors, sphericalHarmonicDcs) {
+  for (let componentIndex = 0; componentIndex < colors.length; componentIndex++) {
+    sphericalHarmonicDcs[componentIndex] = (colorStream[componentIndex] / 255 - 0.5) / SPZ_COLOR_SCALE;
+    colors[componentIndex] = normalizeColorByte(sphericalHarmonicDcs[componentIndex]);
+  }
+}
+function decodeSPZOpacities(alphaStream, opacities) {
+  for (let splatIndex = 0; splatIndex < opacities.length; splatIndex++) {
+    opacities[splatIndex] = alphaStream[splatIndex] / 255;
+  }
+}
+function decodeSPZSphericalHarmonics(sphericalHarmonicsStream, sphericalHarmonics) {
+  for (let componentIndex = 0; componentIndex < sphericalHarmonics.length; componentIndex++) {
+    sphericalHarmonics[componentIndex] = (sphericalHarmonicsStream[componentIndex] - 128) / 128;
+  }
+}
+function normalizeColorByte(sphericalHarmonicDc) {
+  return Math.min(Math.max(Math.round((sphericalHarmonicDc * SPZ_COLOR_SCALE + 0.5) * 255), 0), 255);
+}
+function getSphericalHarmonicsComponentCount2(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 import_compression, SPZ_HEADER_BYTE_LENGTH, SPZ_MAGIC, SPZ_VERSION, SPZ_EXTENSION_FLAG, SPZ_COLOR_SCALE, SPZ_ROTATION_COMPONENT_SCALE, SPZ_ROTATION_COMPONENT_MASK;
+var init_parse_spz = __esm({
+  "dist/lib/parse-spz.js"() {
+    "use strict";
+    import_compression = require("@loaders.gl/compression");
+    init_splats_arrow_table();
+    init_splat_utils();
+    SPZ_HEADER_BYTE_LENGTH = 32;
+    SPZ_MAGIC = 1347635022;
+    SPZ_VERSION = 4;
+    SPZ_EXTENSION_FLAG = 2;
+    SPZ_COLOR_SCALE = 0.15;
+    SPZ_ROTATION_COMPONENT_SCALE = Math.SQRT1_2;
+    SPZ_ROTATION_COMPONENT_MASK = (1 << 9) - 1;
+  }
+});
+
+// dist/spz-loader.js
+var spz_loader_exports = {};
+__export(spz_loader_exports, {
+  SPZLoaderWithParser: () => SPZLoaderWithParser
+});
+var _SPZLoaderPreload, SPZLoaderMetadataWithoutPreload, SPZLoaderWithParser;
+var init_spz_loader = __esm({
+  "dist/spz-loader.js"() {
+    "use strict";
+    init_parse_spz();
+    init_spz_loader_types();
+    ({ preload: _SPZLoaderPreload, ...SPZLoaderMetadataWithoutPreload } = SPZLoader);
+    SPZLoaderWithParser = {
+      ...SPZLoaderMetadataWithoutPreload,
+      parse: async (arrayBuffer, options) => parseSPZ(arrayBuffer, options)
+    };
+  }
+});
+
+// dist/spz-loader-types.js
+async function preload3() {
+  const { SPZLoaderWithParser: SPZLoaderWithParser2 } = await Promise.resolve().then(() => (init_spz_loader(), spz_loader_exports));
+  return SPZLoaderWithParser2;
+}
+var VERSION3, SPZLoader;
+var init_spz_loader_types = __esm({
+  "dist/spz-loader-types.js"() {
+    "use strict";
+    init_splats_format();
+    VERSION3 = true ? "5.0.0-alpha.1" : "latest";
+    SPZLoader = {
+      dataType: null,
+      batchType: null,
+      ...SPZFormat,
+      version: VERSION3,
+      options: {
+        splats: {
+          shape: "arrow-table"
+        }
+      },
+      preload: preload3
+    };
+  }
+});
+
+// dist/lib/parse-rad.js
+function parseRADHeader(data) {
+  const metadata = tryParseRADHeader(data);
+  if (!metadata) {
+    throw new Error("RADLoader: file must contain a complete RAD metadata header.");
+  }
+  return metadata;
+}
+function tryParseRADHeader(data) {
+  const bytes = getUint8Array(data);
+  if (bytes.byteLength < RAD_HEADER_BYTE_LENGTH) {
+    return null;
+  }
+  const dataView = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const magic = dataView.getUint32(0, true);
+  if (magic !== RAD_MAGIC) {
+    throw new Error(`RADLoader: RAD0 magic header not found, received 0x${magic.toString(16)}.`);
+  }
+  const headerJsonByteLength = dataView.getUint32(4, true);
+  const headerJsonEnd = RAD_HEADER_BYTE_LENGTH + headerJsonByteLength;
+  if (bytes.byteLength < headerJsonEnd) {
+    return null;
+  }
+  const rawMetadata = parseJSONRecord(bytes.subarray(RAD_HEADER_BYTE_LENGTH, headerJsonEnd), "RADLoader: failed to parse RAD metadata JSON.");
+  return normalizeRADMetadata(rawMetadata, headerJsonByteLength);
+}
+function parseRADChunkHeader(data) {
+  const bytes = getUint8Array(data);
+  if (bytes.byteLength < RAD_HEADER_BYTE_LENGTH) {
+    throw new Error("RADLoader: RADC chunk must contain an 8-byte metadata header.");
+  }
+  const dataView = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const magic = dataView.getUint32(0, true);
+  if (magic !== RAD_CHUNK_MAGIC) {
+    throw new Error(`RADLoader: RADC magic header not found, received 0x${magic.toString(16)}.`);
+  }
+  const headerJsonByteLength = dataView.getUint32(4, true);
+  const headerJsonEnd = RAD_HEADER_BYTE_LENGTH + headerJsonByteLength;
+  const payloadByteLengthOffset = RAD_HEADER_BYTE_LENGTH + roundUpToEight(headerJsonByteLength);
+  const payloadByteOffset = payloadByteLengthOffset + RAD_CHUNK_PAYLOAD_LENGTH_BYTE_LENGTH;
+  if (bytes.byteLength < payloadByteOffset) {
+    throw new Error("RADLoader: RADC chunk must contain a complete metadata header.");
+  }
+  const rawMetadata = parseJSONRecord(bytes.subarray(RAD_HEADER_BYTE_LENGTH, headerJsonEnd), "RADLoader: failed to parse RADC metadata JSON.");
+  const payloadBytes = readSafeUint642(dataView, payloadByteLengthOffset, "RADC payload byte length");
+  return normalizeRADChunkMetadata(rawMetadata, headerJsonByteLength, payloadByteOffset, payloadBytes);
+}
+function roundUpToEight(byteLength) {
+  return byteLength + 7 & ~7;
+}
+function normalizeRADMetadata(rawMetadata, headerJsonByteLength) {
+  const version = requireSafeInteger(rawMetadata.version, "RAD version");
+  if (version !== 1) {
+    throw new Error(`RADLoader: version ${version} is not supported.`);
+  }
+  const type = requireString(rawMetadata.type, "RAD type");
+  if (type !== "gsplat") {
+    throw new Error(`RADLoader: RAD type ${type} is not supported.`);
+  }
+  const chunks = requireArray(rawMetadata.chunks, "RAD chunks").map((chunk, chunkIndex) => normalizeRADChunkRange(chunk, chunkIndex));
+  const metadata = {
+    version,
+    type,
+    count: requireSafeInteger(rawMetadata.count, "RAD count"),
+    maxSh: optionalSafeInteger(rawMetadata.maxSh, "RAD maxSh"),
+    lodTree: optionalBoolean(rawMetadata.lodTree, "RAD lodTree"),
+    chunkSize: optionalSafeInteger(rawMetadata.chunkSize, "RAD chunkSize"),
+    allChunkBytes: optionalSafeInteger(rawMetadata.allChunkBytes, "RAD allChunkBytes"),
+    chunks,
+    splatEncoding: optionalSplatEncoding(rawMetadata.splatEncoding, "RAD splatEncoding"),
+    shCodeCount: optionalSafeInteger(rawMetadata.shCodeCount, "RAD shCodeCount"),
+    comment: optionalString(rawMetadata.comment, "RAD comment"),
+    headerJsonByteLength,
+    chunksByteOffset: RAD_HEADER_BYTE_LENGTH + roundUpToEight(headerJsonByteLength)
+  };
+  return metadata;
+}
+function normalizeRADChunkRange(rawChunk, chunkIndex) {
+  const chunk = requireRecord(rawChunk, `RAD chunk ${chunkIndex}`);
+  return {
+    offset: requireSafeInteger(chunk.offset, `RAD chunk ${chunkIndex} offset`),
+    bytes: requireSafeInteger(chunk.bytes, `RAD chunk ${chunkIndex} bytes`),
+    base: optionalSafeInteger(chunk.base, `RAD chunk ${chunkIndex} base`),
+    count: optionalSafeInteger(chunk.count, `RAD chunk ${chunkIndex} count`),
+    filename: optionalString(chunk.filename, `RAD chunk ${chunkIndex} filename`)
+  };
+}
+function normalizeRADChunkMetadata(rawMetadata, headerJsonByteLength, payloadByteOffset, payloadBytes) {
+  const version = requireSafeInteger(rawMetadata.version, "RADC version");
+  if (version !== 1) {
+    throw new Error(`RADLoader: RADC version ${version} is not supported.`);
+  }
+  const metadataPayloadBytes = requireSafeInteger(rawMetadata.payloadBytes, "RADC payloadBytes");
+  if (metadataPayloadBytes !== payloadBytes) {
+    throw new Error("RADLoader: RADC metadata payload byte length does not match binary header.");
+  }
+  return {
+    version,
+    base: requireSafeInteger(rawMetadata.base, "RADC base"),
+    count: requireSafeInteger(rawMetadata.count, "RADC count"),
+    payloadBytes,
+    maxSh: optionalSafeInteger(rawMetadata.maxSh, "RADC maxSh"),
+    lodTree: optionalBoolean(rawMetadata.lodTree, "RADC lodTree"),
+    splatEncoding: optionalSplatEncoding(rawMetadata.splatEncoding, "RADC splatEncoding"),
+    properties: requireArray(rawMetadata.properties, "RADC properties").map((property, index) => normalizeRADChunkProperty(property, index)),
+    headerJsonByteLength,
+    payloadByteOffset,
+    chunkByteLength: payloadByteOffset + payloadBytes
+  };
+}
+function normalizeRADChunkProperty(rawProperty, propertyIndex) {
+  const property = requireRecord(rawProperty, `RADC property ${propertyIndex}`);
+  return {
+    offset: requireSafeInteger(property.offset, `RADC property ${propertyIndex} offset`),
+    bytes: requireSafeInteger(property.bytes, `RADC property ${propertyIndex} bytes`),
+    property: requireString(property.property, `RADC property ${propertyIndex} name`),
+    encoding: requireString(property.encoding, `RADC property ${propertyIndex} encoding`),
+    compression: optionalString(property.compression, `RADC property ${propertyIndex} compression`),
+    min: optionalFiniteNumber(property.min, `RADC property ${propertyIndex} min`),
+    max: optionalFiniteNumber(property.max, `RADC property ${propertyIndex} max`)
+  };
+}
+function optionalSplatEncoding(value, fieldName) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const encoding = requireRecord(value, fieldName);
+  return {
+    rgbMin: optionalFiniteNumber(encoding.rgbMin, `${fieldName}.rgbMin`),
+    rgbMax: optionalFiniteNumber(encoding.rgbMax, `${fieldName}.rgbMax`),
+    lnScaleMin: optionalFiniteNumber(encoding.lnScaleMin, `${fieldName}.lnScaleMin`),
+    lnScaleMax: optionalFiniteNumber(encoding.lnScaleMax, `${fieldName}.lnScaleMax`),
+    sh1Max: optionalFiniteNumber(encoding.sh1Max, `${fieldName}.sh1Max`),
+    sh2Max: optionalFiniteNumber(encoding.sh2Max, `${fieldName}.sh2Max`),
+    sh3Max: optionalFiniteNumber(encoding.sh3Max, `${fieldName}.sh3Max`),
+    lodOpacity: optionalBoolean(encoding.lodOpacity, `${fieldName}.lodOpacity`)
+  };
+}
+function parseJSONRecord(bytes, message) {
+  try {
+    return requireRecord(JSON.parse(TEXT_DECODER.decode(bytes)), message);
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith("RADLoader:")) {
+      throw error;
+    }
+    throw new Error(message);
+  }
+}
+function requireRecord(value, fieldName) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`RADLoader: ${fieldName} must be an object.`);
+  }
+  return value;
+}
+function requireArray(value, fieldName) {
+  if (!Array.isArray(value)) {
+    throw new Error(`RADLoader: ${fieldName} must be an array.`);
+  }
+  return value;
+}
+function requireString(value, fieldName) {
+  if (typeof value !== "string") {
+    throw new Error(`RADLoader: ${fieldName} must be a string.`);
+  }
+  return value;
+}
+function optionalString(value, fieldName) {
+  if (value === void 0) {
+    return void 0;
+  }
+  return requireString(value, fieldName);
+}
+function optionalBoolean(value, fieldName) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "boolean") {
+    throw new Error(`RADLoader: ${fieldName} must be a boolean.`);
+  }
+  return value;
+}
+function requireSafeInteger(value, fieldName) {
+  if (!Number.isSafeInteger(value) || Number(value) < 0) {
+    throw new Error(`RADLoader: ${fieldName} must be a non-negative safe integer.`);
+  }
+  return Number(value);
+}
+function optionalSafeInteger(value, fieldName) {
+  if (value === void 0) {
+    return void 0;
+  }
+  return requireSafeInteger(value, fieldName);
+}
+function optionalFiniteNumber(value, fieldName) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new Error(`RADLoader: ${fieldName} must be a finite number.`);
+  }
+  return value;
+}
+function readSafeUint642(dataView, byteOffset, fieldName) {
+  const value = dataView.getBigUint64(byteOffset, true);
+  if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw new Error(`RADLoader: ${fieldName} exceeds Number.MAX_SAFE_INTEGER.`);
+  }
+  return Number(value);
+}
+function getUint8Array(data) {
+  return data instanceof ArrayBuffer ? new Uint8Array(data) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+}
+var RAD_MAGIC, RAD_CHUNK_MAGIC, RAD_HEADER_BYTE_LENGTH, RAD_CHUNK_PAYLOAD_LENGTH_BYTE_LENGTH, TEXT_DECODER;
+var init_parse_rad = __esm({
+  "dist/lib/parse-rad.js"() {
+    "use strict";
+    RAD_MAGIC = 809779538;
+    RAD_CHUNK_MAGIC = 1128546642;
+    RAD_HEADER_BYTE_LENGTH = 8;
+    RAD_CHUNK_PAYLOAD_LENGTH_BYTE_LENGTH = 8;
+    TEXT_DECODER = new TextDecoder();
+  }
+});
+
+// dist/lib/parse-rad-chunk.js
+function parseRADChunk(data, options) {
+  return makeGaussianSplatsArrowTable(parseRADChunkToGaussianSplats(data, options));
+}
+function parseRADChunkToGaussianSplats(data, options) {
+  var _a, _b;
+  const bytes = getUint8Array2(data);
+  const metadata = getRADChunkDecodeMetadata(parseRADChunkHeader(bytes), options);
+  if (bytes.byteLength < metadata.chunkByteLength) {
+    throw new Error("RADLoader: RADC chunk payload is incomplete.");
+  }
+  const splatCount = metadata.count;
+  const positions = decodeRADFloatProperty(bytes, metadata, requireRADProperty(metadata, "center"), 3);
+  const opacities = decodeRADAlpha(bytes, metadata, splatCount);
+  const rgb = decodeRADRgb(bytes, metadata, splatCount);
+  const scales = decodeRADScales(bytes, metadata, splatCount);
+  const rotations = decodeRADRotations(bytes, metadata, splatCount);
+  const { colors, sphericalHarmonicDcs } = convertRgbToColorColumns(rgb);
+  const includeLoDTree = ((_a = options == null ? void 0 : options.radChunk) == null ? void 0 : _a.includeLoDTree) ?? true;
+  const childCounts = includeLoDTree ? decodeOptionalRADUint16(bytes, metadata, "child_count") : null;
+  const childStarts = includeLoDTree ? decodeOptionalRADUint32(bytes, metadata, "child_start") : null;
+  const includeSphericalHarmonics = ((_b = options == null ? void 0 : options.radChunk) == null ? void 0 : _b.includeSphericalHarmonics) ?? false;
+  const sphericalHarmonics = includeSphericalHarmonics ? decodeRADSphericalHarmonics(bytes, metadata) : null;
+  return {
+    format: "rad",
+    splatCount,
+    positions,
+    scales,
+    rotations,
+    colors,
+    sphericalHarmonicDcs,
+    opacities,
+    sphericalHarmonics: sphericalHarmonics == null ? void 0 : sphericalHarmonics.values,
+    sphericalHarmonicsComponentCount: sphericalHarmonics == null ? void 0 : sphericalHarmonics.componentCount,
+    loaderData: {
+      format: "rad",
+      base: metadata.base,
+      count: metadata.count,
+      maxSh: metadata.maxSh ?? 0,
+      lodTree: metadata.lodTree ?? false,
+      splatEncoding: metadata.splatEncoding,
+      childCounts: childCounts ?? void 0,
+      childStarts: childStarts ?? void 0
+    }
+  };
+}
+function decodeRADAlpha(bytes, metadata, splatCount) {
+  const property = findRADProperty(metadata, "alpha");
+  if (!property) {
+    return new Float32Array(splatCount).fill(1);
+  }
+  const opacities = decodeRADFloatProperty(bytes, metadata, property, 1);
+  for (let splatIndex = 0; splatIndex < opacities.length; splatIndex++) {
+    opacities[splatIndex] = decodeRADOpacity(opacities[splatIndex], metadata, property);
+  }
+  return opacities;
+}
+function decodeRADOpacity(opacity, metadata, property) {
+  var _a;
+  const normalizedOpacity = Math.max(opacity, 0);
+  if (!((_a = metadata.splatEncoding) == null ? void 0 : _a.lodOpacity) || property.encoding !== "r8" && property.encoding !== "r8_delta") {
+    return normalizedOpacity;
+  }
+  return normalizedOpacity * 2;
+}
+function decodeRADRgb(bytes, metadata, splatCount) {
+  const property = findRADProperty(metadata, "rgb");
+  if (!property) {
+    return new Float32Array(splatCount * 3).fill(1);
+  }
+  return decodeRADFloatProperty(bytes, metadata, property, 3);
+}
+function decodeRADScales(bytes, metadata, splatCount) {
+  const property = findRADProperty(metadata, "scales");
+  if (!property) {
+    return new Float32Array(splatCount * 3).fill(1);
+  }
+  return decodeRADFloatProperty(bytes, metadata, property, 3);
+}
+function decodeRADRotations(bytes, metadata, splatCount) {
+  const property = findRADProperty(metadata, "orientation");
+  if (!property) {
+    return makeIdentityRotations(splatCount);
+  }
+  const propertyBytes = getRADPropertyBytes(bytes, metadata, property);
+  switch (property.encoding) {
+    case "oct88r8":
+      return decodeRADOct88R8Rotations(propertyBytes, splatCount);
+    case "f32":
+    case "f16": {
+      const xyz = decodeRADFloatProperty(bytes, metadata, property, 3);
+      const rotations = new Float32Array(splatCount * 4);
+      for (let splatIndex = 0; splatIndex < splatCount; splatIndex++) {
+        const xyzOffset = splatIndex * 3;
+        const rotationOffset = splatIndex * 4;
+        const x = xyz[xyzOffset + 0];
+        const y = xyz[xyzOffset + 1];
+        const z = xyz[xyzOffset + 2];
+        const w = Math.sqrt(Math.max(0, 1 - x * x - y * y - z * z));
+        const normalized = normalizeQuaternion(w, x, y, z);
+        rotations.set(normalized, rotationOffset);
+      }
+      return rotations;
+    }
+    default:
+      throw new Error(`RADLoader: unsupported orientation encoding ${property.encoding}.`);
+  }
+}
+function decodeRADSphericalHarmonics(bytes, metadata) {
+  const shProperties = [
+    { property: findRADProperty(metadata, "sh1"), dimensions: 9 },
+    { property: findRADProperty(metadata, "sh2"), dimensions: 15 },
+    { property: findRADProperty(metadata, "sh3"), dimensions: 21 }
+  ].filter((entry) => entry.property !== void 0);
+  if (shProperties.length === 0) {
+    return null;
+  }
+  const decodedProperties = shProperties.map((entry) => ({
+    values: decodeRADFloatProperty(bytes, metadata, entry.property, entry.dimensions),
+    dimensions: entry.dimensions
+  }));
+  const componentCount = decodedProperties.reduce((total, entry) => total + entry.dimensions, 0);
+  const values = new Float32Array(metadata.count * componentCount);
+  for (let splatIndex = 0; splatIndex < metadata.count; splatIndex++) {
+    let outputOffset = splatIndex * componentCount;
+    for (const decodedProperty of decodedProperties) {
+      const inputOffset = splatIndex * decodedProperty.dimensions;
+      values.set(decodedProperty.values.subarray(inputOffset, inputOffset + decodedProperty.dimensions), outputOffset);
+      outputOffset += decodedProperty.dimensions;
+    }
+  }
+  return { values, componentCount };
+}
+function decodeRADFloatProperty(bytes, metadata, property, dimensions) {
+  const propertyBytes = getRADPropertyBytes(bytes, metadata, property);
+  switch (property.encoding) {
+    case "f32":
+      return decodePlanarFloat32(propertyBytes, dimensions, metadata.count);
+    case "f16":
+      return decodePlanarFloat16(propertyBytes, dimensions, metadata.count);
+    case "f32_lebytes":
+      return decodeLeBytesFloat32(propertyBytes, dimensions, metadata.count);
+    case "f16_lebytes":
+      return decodeLeBytesFloat16(propertyBytes, dimensions, metadata.count);
+    case "r8":
+      return decodeR8(propertyBytes, dimensions, metadata.count, getPropertyMin(metadata, property), getPropertyMax(metadata, property));
+    case "r8_delta":
+      return decodeR8Delta(propertyBytes, dimensions, metadata.count, getPropertyMin(metadata, property), getPropertyMax(metadata, property));
+    case "s8":
+      return decodeS8(propertyBytes, dimensions, metadata.count, getPropertyMax(metadata, property));
+    case "s8_delta":
+      return decodeS8Delta(propertyBytes, dimensions, metadata.count, getPropertyMax(metadata, property));
+    case "ln_0r8":
+      return decodeScaleR8(propertyBytes, dimensions, metadata.count, getPropertyMin(metadata, property), getPropertyMax(metadata, property));
+    case "ln_f16":
+      return decodeLogFloat16(propertyBytes, dimensions, metadata.count);
+    default:
+      throw new Error(`RADLoader: unsupported ${property.property} encoding ${property.encoding}.`);
+  }
+}
+function decodeOptionalRADUint16(bytes, metadata, propertyName) {
+  const property = findRADProperty(metadata, propertyName);
+  if (!property) {
+    return null;
+  }
+  if (property.encoding !== "u16") {
+    throw new Error(`RADLoader: unsupported ${propertyName} encoding ${property.encoding}.`);
+  }
+  const propertyBytes = getRADPropertyBytes(bytes, metadata, property);
+  const values = new Uint16Array(metadata.count);
+  for (let splatIndex = 0; splatIndex < metadata.count; splatIndex++) {
+    values[splatIndex] = propertyBytes[splatIndex * 2] | propertyBytes[splatIndex * 2 + 1] << 8;
+  }
+  return values;
+}
+function decodeOptionalRADUint32(bytes, metadata, propertyName) {
+  const property = findRADProperty(metadata, propertyName);
+  if (!property) {
+    return null;
+  }
+  if (property.encoding !== "u32") {
+    throw new Error(`RADLoader: unsupported ${propertyName} encoding ${property.encoding}.`);
+  }
+  const propertyBytes = getRADPropertyBytes(bytes, metadata, property);
+  const dataView = new DataView(propertyBytes.buffer, propertyBytes.byteOffset, propertyBytes.byteLength);
+  const values = new Uint32Array(metadata.count);
+  for (let splatIndex = 0; splatIndex < metadata.count; splatIndex++) {
+    values[splatIndex] = dataView.getUint32(splatIndex * 4, true);
+  }
+  return values;
+}
+function getRADPropertyBytes(bytes, metadata, property) {
+  const paddedByteLength = roundUpToEight(property.bytes);
+  const byteOffset = metadata.payloadByteOffset + property.offset;
+  const byteEnd = byteOffset + paddedByteLength;
+  if (byteEnd > bytes.byteLength || property.offset + paddedByteLength > metadata.payloadBytes) {
+    throw new Error(`RADLoader: property ${property.property} exceeds RADC payload byte length.`);
+  }
+  const propertyBytes = bytes.subarray(byteOffset, byteOffset + property.bytes);
+  if (!property.compression) {
+    return propertyBytes;
+  }
+  if (property.compression !== "gz") {
+    throw new Error(`RADLoader: unsupported property compression ${property.compression}.`);
+  }
+  return decompressRADProperty(propertyBytes, property.property);
+}
+function decompressRADProperty(bytes, propertyName) {
+  const arrayBuffer = copyToArrayBuffer(bytes);
+  try {
+    return new Uint8Array(RAD_PROPERTY_DEFLATE.decompressSync(arrayBuffer));
+  } catch {
+    try {
+      return new Uint8Array(RAD_PROPERTY_RAW_DEFLATE.decompressSync(arrayBuffer));
+    } catch {
+      throw new Error(`RADLoader: failed to decompress RADC property ${propertyName}.`);
+    }
+  }
+}
+function decodePlanarFloat32(bytes, dimensions, count) {
+  const dataView = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const values = new Float32Array(count * dimensions);
+  for (let rowIndex = 0; rowIndex < count; rowIndex++) {
+    for (let dimension = 0; dimension < dimensions; dimension++) {
+      values[rowIndex * dimensions + dimension] = dataView.getFloat32((dimension * count + rowIndex) * 4, true);
+    }
+  }
+  return values;
+}
+function decodePlanarFloat16(bytes, dimensions, count) {
+  const values = new Float32Array(count * dimensions);
+  for (let rowIndex = 0; rowIndex < count; rowIndex++) {
+    for (let dimension = 0; dimension < dimensions; dimension++) {
+      const byteOffset = (dimension * count + rowIndex) * 2;
+      values[rowIndex * dimensions + dimension] = decodeFloat16(bytes[byteOffset] | bytes[byteOffset + 1] << 8);
+    }
+  }
+  return values;
+}
+function decodeLeBytesFloat32(bytes, dimensions, count) {
+  const values = new Float32Array(count * dimensions);
+  const stride = count * dimensions;
+  const scratch = new Uint8Array(4);
+  const scratchView = new DataView(scratch.buffer);
+  for (let rowIndex = 0; rowIndex < count; rowIndex++) {
+    for (let dimension = 0; dimension < dimensions; dimension++) {
+      const byteOffset = dimension * count + rowIndex;
+      for (let byteIndex = 0; byteIndex < 4; byteIndex++) {
+        scratch[byteIndex] = bytes[byteOffset + stride * byteIndex];
+      }
+      values[rowIndex * dimensions + dimension] = scratchView.getFloat32(0, true);
+    }
+  }
+  return values;
+}
+function decodeLeBytesFloat16(bytes, dimensions, count) {
+  const values = new Float32Array(count * dimensions);
+  const stride = count * dimensions;
+  for (let rowIndex = 0; rowIndex < count; rowIndex++) {
+    for (let dimension = 0; dimension < dimensions; dimension++) {
+      const byteOffset = dimension * count + rowIndex;
+      values[rowIndex * dimensions + dimension] = decodeFloat16(bytes[byteOffset] | bytes[byteOffset + stride] << 8);
+    }
+  }
+  return values;
+}
+function decodeR8(bytes, dimensions, count, min, max) {
+  const values = new Float32Array(count * dimensions);
+  const range = max - min;
+  for (let rowIndex = 0; rowIndex < count; rowIndex++) {
+    for (let dimension = 0; dimension < dimensions; dimension++) {
+      values[rowIndex * dimensions + dimension] = bytes[dimension * count + rowIndex] / 255 * range + min;
+    }
+  }
+  return values;
+}
+function decodeR8Delta(bytes, dimensions, count, min, max) {
+  const values = new Float32Array(count * dimensions);
+  const range = max - min;
+  const last = new Uint8Array(dimensions);
+  for (let rowIndex = 0; rowIndex < count; rowIndex++) {
+    for (let dimension = 0; dimension < dimensions; dimension++) {
+      const byteOffset = dimension * count + rowIndex;
+      const value = last[dimension] + bytes[byteOffset] & 255;
+      last[dimension] = value;
+      values[rowIndex * dimensions + dimension] = value / 255 * range + min;
+    }
+  }
+  return values;
+}
+function decodeS8(bytes, dimensions, count, max) {
+  const values = new Float32Array(count * dimensions);
+  for (let rowIndex = 0; rowIndex < count; rowIndex++) {
+    for (let dimension = 0; dimension < dimensions; dimension++) {
+      const byte = bytes[dimension * count + rowIndex];
+      values[rowIndex * dimensions + dimension] = (byte << 24 >> 24) / 127 * max;
+    }
+  }
+  return values;
+}
+function decodeS8Delta(bytes, dimensions, count, max) {
+  const values = new Float32Array(count * dimensions);
+  const last = new Uint8Array(dimensions);
+  for (let rowIndex = 0; rowIndex < count; rowIndex++) {
+    for (let dimension = 0; dimension < dimensions; dimension++) {
+      const byteOffset = dimension * count + rowIndex;
+      const value = last[dimension] + bytes[byteOffset] & 255;
+      last[dimension] = value;
+      values[rowIndex * dimensions + dimension] = (value << 24 >> 24) / 127 * max;
+    }
+  }
+  return values;
+}
+function decodeScaleR8(bytes, dimensions, count, min, max) {
+  const values = new Float32Array(count * dimensions);
+  for (let rowIndex = 0; rowIndex < count; rowIndex++) {
+    for (let dimension = 0; dimension < dimensions; dimension++) {
+      values[rowIndex * dimensions + dimension] = decodeScale8(bytes[dimension * count + rowIndex], min, max);
+    }
+  }
+  return values;
+}
+function decodeLogFloat16(bytes, dimensions, count) {
+  const logValues = decodePlanarFloat16(bytes, dimensions, count);
+  for (let valueIndex = 0; valueIndex < logValues.length; valueIndex++) {
+    logValues[valueIndex] = Math.exp(logValues[valueIndex]);
+  }
+  return logValues;
+}
+function decodeRADOct88R8Rotations(bytes, count) {
+  const rotations = new Float32Array(count * 4);
+  for (let splatIndex = 0; splatIndex < count; splatIndex++) {
+    const byteOffset = splatIndex * 3;
+    const [x, y, z, w] = decodeQuatOct888(bytes[byteOffset], bytes[byteOffset + 1], bytes[byteOffset + 2]);
+    rotations.set(normalizeQuaternion(w, x, y, z), splatIndex * 4);
+  }
+  return rotations;
+}
+function convertRgbToColorColumns(rgb) {
+  const colors = new Uint8Array(rgb.length);
+  const sphericalHarmonicDcs = new Float32Array(rgb.length);
+  for (let componentIndex = 0; componentIndex < rgb.length; componentIndex++) {
+    const component = rgb[componentIndex];
+    colors[componentIndex] = normalizeColorByte2(component);
+    sphericalHarmonicDcs[componentIndex] = (component - 0.5) / SH_C0;
+  }
+  return { colors, sphericalHarmonicDcs };
+}
+function makeIdentityRotations(count) {
+  const rotations = new Float32Array(count * 4);
+  for (let splatIndex = 0; splatIndex < count; splatIndex++) {
+    rotations[splatIndex * 4] = 1;
+  }
+  return rotations;
+}
+function decodeScale8(scale, min, max) {
+  if (scale === 0) {
+    return 0;
+  }
+  const logScaleStep = (max - min) / 254;
+  return Math.exp(min + (scale - 1) * logScaleStep);
+}
+function decodeQuatOct888(u, v, r) {
+  let x = u / 255 * 2 - 1;
+  let y = v / 255 * 2 - 1;
+  const z = 1 - Math.abs(x) - Math.abs(y);
+  const t = Math.max(-z, 0);
+  x = x >= 0 ? x - t : x + t;
+  y = y >= 0 ? y - t : y + t;
+  const length = Math.hypot(x, y, z);
+  const axisX = length > Number.EPSILON ? x / length : 1;
+  const axisY = length > Number.EPSILON ? y / length : 0;
+  const axisZ = length > Number.EPSILON ? z / length : 0;
+  const halfTheta = r / 255 * 0.5 * Math.PI;
+  const sinHalfTheta = Math.sin(halfTheta);
+  return [axisX * sinHalfTheta, axisY * sinHalfTheta, axisZ * sinHalfTheta, Math.cos(halfTheta)];
+}
+function requireRADProperty(metadata, propertyName) {
+  const property = findRADProperty(metadata, propertyName);
+  if (!property) {
+    throw new Error(`RADLoader: RADC chunk is missing ${propertyName} property.`);
+  }
+  return property;
+}
+function findRADProperty(metadata, propertyName) {
+  return metadata.properties.find((property) => property.property === propertyName);
+}
+function getRADChunkDecodeMetadata(metadata, options) {
+  var _a;
+  const splatEncoding = (_a = options == null ? void 0 : options.radChunk) == null ? void 0 : _a.splatEncoding;
+  if (!splatEncoding) {
+    return metadata;
+  }
+  return {
+    ...metadata,
+    splatEncoding: {
+      ...splatEncoding,
+      ...metadata.splatEncoding
+    }
+  };
+}
+function getPropertyMin(metadata, property) {
+  if (property.min === void 0) {
+    const fallback = getSplatEncodingMinimum(metadata.splatEncoding, property.property);
+    if (fallback !== void 0) {
+      return fallback;
+    }
+    throw new Error(`RADLoader: RADC property ${property.property} is missing min.`);
+  }
+  return property.min;
+}
+function getPropertyMax(metadata, property) {
+  if (property.max === void 0) {
+    const fallback = getSplatEncodingMaximum(metadata.splatEncoding, property.property);
+    if (fallback !== void 0) {
+      return fallback;
+    }
+    throw new Error(`RADLoader: RADC property ${property.property} is missing max.`);
+  }
+  return property.max;
+}
+function getSplatEncodingMinimum(splatEncoding, propertyName) {
+  switch (propertyName) {
+    case "rgb":
+      return splatEncoding == null ? void 0 : splatEncoding.rgbMin;
+    case "scales":
+      return splatEncoding == null ? void 0 : splatEncoding.lnScaleMin;
+    default:
+      return void 0;
+  }
+}
+function getSplatEncodingMaximum(splatEncoding, propertyName) {
+  switch (propertyName) {
+    case "rgb":
+      return splatEncoding == null ? void 0 : splatEncoding.rgbMax;
+    case "scales":
+      return splatEncoding == null ? void 0 : splatEncoding.lnScaleMax;
+    case "sh1":
+      return splatEncoding == null ? void 0 : splatEncoding.sh1Max;
+    case "sh2":
+      return splatEncoding == null ? void 0 : splatEncoding.sh2Max;
+    case "sh3":
+      return splatEncoding == null ? void 0 : splatEncoding.sh3Max;
+    default:
+      return void 0;
+  }
+}
+function normalizeColorByte2(value) {
+  return Math.round(Math.min(Math.max(value, 0), 1) * 255);
+}
+function copyToArrayBuffer(bytes) {
+  const copy = new Uint8Array(bytes.byteLength);
+  copy.set(bytes);
+  return copy.buffer;
+}
+function getUint8Array2(data) {
+  return data instanceof ArrayBuffer ? new Uint8Array(data) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+}
+var import_compression2, RAD_PROPERTY_DEFLATE, RAD_PROPERTY_RAW_DEFLATE;
+var init_parse_rad_chunk = __esm({
+  "dist/lib/parse-rad-chunk.js"() {
+    "use strict";
+    import_compression2 = require("@loaders.gl/compression");
+    init_parse_rad();
+    init_splats_arrow_table();
+    init_splat_utils();
+    RAD_PROPERTY_DEFLATE = new import_compression2.DeflateCompression();
+    RAD_PROPERTY_RAW_DEFLATE = new import_compression2.DeflateCompression({ raw: true });
+  }
+});
+
+// dist/rad-loader.js
+var rad_loader_exports = {};
+__export(rad_loader_exports, {
+  RADLoaderWithParser: () => RADLoaderWithParser,
+  parseRADChunk: () => parseRADChunk,
+  parseRADChunkHeader: () => parseRADChunkHeader,
+  parseRADChunkToGaussianSplats: () => parseRADChunkToGaussianSplats,
+  parseRADHeader: () => parseRADHeader,
+  tryParseRADHeader: () => tryParseRADHeader
+});
+var _RADLoaderPreload, RADLoaderMetadataWithoutPreload, RADLoaderWithParser;
+var init_rad_loader = __esm({
+  "dist/rad-loader.js"() {
+    "use strict";
+    init_parse_rad();
+    init_rad_loader_types();
+    init_parse_rad();
+    init_parse_rad_chunk();
+    ({ preload: _RADLoaderPreload, ...RADLoaderMetadataWithoutPreload } = RADLoader);
+    RADLoaderWithParser = {
+      ...RADLoaderMetadataWithoutPreload,
+      parse: async (arrayBuffer) => parseRADHeader(arrayBuffer),
+      parseSync: (arrayBuffer) => parseRADHeader(arrayBuffer)
+    };
+  }
+});
+
+// dist/rad-loader-types.js
+async function preload4() {
+  const { RADLoaderWithParser: RADLoaderWithParser2 } = await Promise.resolve().then(() => (init_rad_loader(), rad_loader_exports));
+  return RADLoaderWithParser2;
+}
+var VERSION4, RADLoader;
+var init_rad_loader_types = __esm({
+  "dist/rad-loader-types.js"() {
+    "use strict";
+    init_splats_format();
+    VERSION4 = true ? "5.0.0-alpha.1" : "latest";
+    RADLoader = {
+      dataType: null,
+      batchType: null,
+      ...RADFormat,
+      version: VERSION4,
+      options: {},
+      preload: preload4
+    };
+  }
+});
+
+// dist/index.js
+var dist_exports = {};
+__export(dist_exports, {
+  KSPLATFormat: () => KSPLATFormat,
+  KSPLATLoader: () => KSPLATLoader,
+  RADFormat: () => RADFormat,
+  RADLoader: () => RADLoader,
+  RADSource: () => RADSource,
+  RADSourceLoader: () => RADSourceLoader,
+  SPLATFormat: () => SPLATFormat,
+  SPLATLoader: () => SPLATLoader,
+  SPZFormat: () => SPZFormat,
+  SPZLoader: () => SPZLoader,
+  resolveRADChunkUrl: () => resolveRADChunkUrl
+});
+module.exports = __toCommonJS(dist_exports);
+init_splats_format();
+init_splat_loader_types();
+init_ksplat_loader_types();
+init_spz_loader_types();
+init_rad_loader_types();
+
+// dist/rad-source-loader.js
+var import_loader_utils = require("@loaders.gl/loader-utils");
+init_splats_format();
+init_parse_rad();
+init_parse_rad_chunk();
+init_splats_arrow_table();
+var DEFAULT_RAD_HEADER_BYTE_LENGTHS = [64 * 1024, 256 * 1024, 1024 * 1024];
+var DEFAULT_RAD_MAX_CONCURRENT_CHUNK_REQUESTS = 4;
+var VERSION5 = true ? "5.0.0-alpha.1" : "latest";
+var RADSourceLoader = {
+  dataType: null,
+  batchType: null,
+  ...RADFormat,
+  name: "RADSourceLoader",
+  version: VERSION5,
+  type: "rad",
+  fromUrl: true,
+  fromBlob: true,
+  options: {
+    rad: {
+      headers: void 0,
+      withCredentials: false,
+      headerByteLengths: void 0
+    }
+  },
+  defaultOptions: {
+    rad: {
+      headers: void 0,
+      withCredentials: false,
+      headerByteLengths: void 0
+    }
+  },
+  testURL: (url) => /\.rad(?:$|[?#])/i.test(url),
+  createDataSource: (data, options, coreApi) => new RADSource(data, options, coreApi)
+};
+var RADSource = class extends import_loader_utils.DataSource {
+  /** Shared metadata promise exposed for source-style integrations. */
+  metadata;
+  /** Lazily initialized RAD header promise. */
+  _metadataPromise = null;
+  /** Lazily initialized per-chunk metadata promises. */
+  _chunkMetadataPromises = /* @__PURE__ */ new Map();
+  constructor(data, options, coreApi) {
+    super(data, options, RADSourceLoader.defaultOptions, coreApi);
+    this.metadata = this.getMetadata();
+  }
+  /** Ensures the RAD header metadata has been loaded. */
+  async initialize() {
+    await this.getMetadata();
+  }
+  /** Returns parsed Spark RAD top-level metadata. */
+  async getMetadata() {
+    if (!this._metadataPromise) {
+      this._metadataPromise = this._loadMetadata();
+    }
+    return await this._metadataPromise;
+  }
+  /** Returns the number of chunks declared by the RAD metadata. */
+  async getChunkCount() {
+    const metadata = await this.getMetadata();
+    return metadata.chunks.length;
+  }
+  /** Returns the URL used for a chunk, or `null` for Blob-backed inline chunks. */
+  async getChunkUrl(chunkIndex) {
+    const metadata = await this.getMetadata();
+    const chunk = this._getChunkRange(metadata, chunkIndex);
+    if (chunk.filename) {
+      return resolveRADChunkUrl(this.url, chunk.filename);
+    }
+    return typeof this.data === "string" ? this.url : null;
+  }
+  /** Fetches one raw RADC chunk by index. */
+  async getChunk(chunkIndex, options = {}) {
+    const metadata = await this.getMetadata();
+    const chunk = this._getChunkRange(metadata, chunkIndex);
+    if (chunk.filename) {
+      if (typeof this.data !== "string") {
+        throw new Error("RADSource: sidecar RADC chunks require a URL-backed RAD source.");
+      }
+      return await this._fetchArrayBuffer(resolveRADChunkUrl(this.url, chunk.filename), void 0, {
+        signal: options.signal
+      });
+    }
+    if (chunk.bytes === 0) {
+      return new ArrayBuffer(0);
+    }
+    const byteOffset = metadata.chunksByteOffset + chunk.offset;
+    if (typeof this.data !== "string") {
+      return await this.data.slice(byteOffset, byteOffset + chunk.bytes).arrayBuffer();
+    }
+    return await this._fetchArrayBuffer(this.url, { offset: byteOffset, bytes: chunk.bytes }, { signal: options.signal });
+  }
+  /** Fetches and parses metadata for one RADC chunk. */
+  async getChunkMetadata(chunkIndex, options = {}) {
+    let chunkMetadataPromise = this._chunkMetadataPromises.get(chunkIndex);
+    if (!chunkMetadataPromise) {
+      chunkMetadataPromise = this.getChunk(chunkIndex, options).then((chunk) => parseRADChunkHeader(chunk));
+      this._chunkMetadataPromises.set(chunkIndex, chunkMetadataPromise);
+    }
+    return await chunkMetadataPromise;
+  }
+  /** Fetches and decodes one RADC chunk into raw Gaussian splat arrays. */
+  async getChunkSplats(chunkIndex, options = {}) {
+    const metadata = await this.getMetadata();
+    return parseRADChunkToGaussianSplats(await this.getChunk(chunkIndex, options), this._getChunkDecodeOptions(metadata, options));
+  }
+  /** Fetches and decodes one RADC chunk into a Mesh Arrow table. */
+  async getChunkTable(chunkIndex, options = {}) {
+    const metadata = await this.getMetadata();
+    return parseRADChunk(await this.getChunk(chunkIndex, options), this._getChunkDecodeOptions(metadata, options));
+  }
+  /** Iterates decoded RADC chunks as Mesh Arrow tables. */
+  async *getChunkTables(options = {}) {
+    const metadata = await this.getMetadata();
+    const startChunkIndex = options.startChunkIndex ?? 0;
+    const maxChunks = options.maxChunks ?? Number.POSITIVE_INFINITY;
+    const maxSplats = options.maxSplats ?? Number.POSITIVE_INFINITY;
+    let chunkCount = 0;
+    let splatCount = 0;
+    if (options.pruneLoadedLoDParents) {
+      const chunkIndices = getRADChunkTableIteratorIndices(metadata, startChunkIndex, maxChunks, maxSplats);
+      const splatChunks = await this._getChunkSplatsConcurrently(chunkIndices, options);
+      let loadedGlobalSplatEnd = 0;
+      for (const splats of splatChunks) {
+        chunkCount++;
+        splatCount += splats.splatCount;
+        const base = getRADChunkSplatBase(splats);
+        loadedGlobalSplatEnd = Math.max(loadedGlobalSplatEnd, base + splats.splatCount);
+      }
+      for (const splats of splatChunks) {
+        yield makeGaussianSplatsArrowTable(pruneLoadedLoDParents(splats, loadedGlobalSplatEnd));
+      }
+      return;
+    }
+    for (let chunkIndex = startChunkIndex; chunkIndex < metadata.chunks.length && chunkCount < maxChunks && splatCount < maxSplats; chunkIndex++) {
+      const table = await this.getChunkTable(chunkIndex, options);
+      chunkCount++;
+      splatCount += table.data.numRows;
+      yield table;
+    }
+  }
+  /** Fetches and decodes RAD chunks with bounded concurrency while preserving chunk order. */
+  async _getChunkSplatsConcurrently(chunkIndices, options) {
+    const splatChunks = new Array(chunkIndices.length);
+    const maxConcurrentChunkRequests = getRADMaxConcurrentChunkRequests(options.maxConcurrentChunkRequests);
+    let nextResultIndex = 0;
+    async function loadNextChunk(source) {
+      while (nextResultIndex < chunkIndices.length) {
+        const resultIndex = nextResultIndex++;
+        const chunkIndex = chunkIndices[resultIndex];
+        splatChunks[resultIndex] = await source.getChunkSplats(chunkIndex, options);
+      }
+    }
+    const workerCount = Math.min(maxConcurrentChunkRequests, chunkIndices.length);
+    await Promise.all(Array.from({ length: workerCount }, () => loadNextChunk(this)));
+    return splatChunks;
+  }
+  /** Adds source-level RAD decode metadata to chunk decode options. */
+  _getChunkDecodeOptions(metadata, options) {
+    return {
+      ...options,
+      radChunk: {
+        splatEncoding: metadata.splatEncoding,
+        ...options.radChunk
+      }
+    };
+  }
+  /** Loads and parses the top-level RAD metadata. */
+  async _loadMetadata() {
+    var _a, _b;
+    const headerByteLengths = ((_b = (_a = this.options.rad) == null ? void 0 : _a.headerByteLengths) == null ? void 0 : _b.length) ? this.options.rad.headerByteLengths : DEFAULT_RAD_HEADER_BYTE_LENGTHS;
+    if (typeof this.data !== "string") {
+      const byteLength = Math.min(this.data.size, Math.max(...headerByteLengths));
+      const metadata = tryParseRADHeader(await this.data.slice(0, byteLength).arrayBuffer());
+      if (metadata) {
+        return metadata;
+      }
+      throw new Error("RADSource: Blob does not contain a complete RAD metadata header.");
+    }
+    for (const byteLength of headerByteLengths) {
+      const metadata = tryParseRADHeader(await this._fetchArrayBuffer(this.url, { offset: 0, bytes: byteLength }));
+      if (metadata) {
+        return metadata;
+      }
+    }
+    throw new Error("RADSource: failed to load a complete RAD metadata header.");
+  }
+  /** Returns a validated chunk table entry. */
+  _getChunkRange(metadata, chunkIndex) {
+    if (!Number.isInteger(chunkIndex) || chunkIndex < 0 || chunkIndex >= metadata.chunks.length) {
+      throw new Error(`RADSource: chunk index ${chunkIndex} is outside 0-${metadata.chunks.length - 1}.`);
+    }
+    return metadata.chunks[chunkIndex];
+  }
+  /** Fetches a full or ranged ArrayBuffer while tolerating non-206 range fallbacks. */
+  async _fetchArrayBuffer(url, range, options = {}) {
+    const response = await this._fetchResponse(url, this._getRequestInit(range, options));
+    if (!response.ok) {
+      throw new Error(`RADSource: failed to fetch ${url}: ${response.status} ${response.statusText}`);
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    if (range && response.status !== 206 && arrayBuffer.byteLength >= range.offset + range.bytes) {
+      return arrayBuffer.slice(range.offset, range.offset + range.bytes);
+    }
+    if (range && arrayBuffer.byteLength > range.bytes) {
+      return arrayBuffer.slice(0, range.bytes);
+    }
+    return arrayBuffer;
+  }
+  /** Fetches through custom source fetch hooks or the injected core fetchFile helper. */
+  async _fetchResponse(url, requestInit) {
+    if (this._hasCustomFetch()) {
+      return await this.fetch(url, requestInit);
+    }
+    return this.hasCoreApi ? await this.coreApi.fetchFile(url, requestInit) : await this.fetch(url, requestInit);
+  }
+  /** Returns true when source options supplied an explicit fetch override. */
+  _hasCustomFetch() {
+    var _a, _b, _c;
+    return Boolean(((_b = (_a = this.loadOptions) == null ? void 0 : _a.core) == null ? void 0 : _b.fetch) || ((_c = this.loadOptions) == null ? void 0 : _c.fetch));
+  }
+  /** Builds request options for RAD fetches. */
+  _getRequestInit(range, options = {}) {
+    var _a, _b;
+    const headers = new Headers((_a = this.options.rad) == null ? void 0 : _a.headers);
+    if (range && range.bytes > 0) {
+      headers.set("Range", `bytes=${range.offset}-${range.offset + range.bytes - 1}`);
+    }
+    return {
+      headers,
+      credentials: ((_b = this.options.rad) == null ? void 0 : _b.withCredentials) ? "include" : "same-origin",
+      signal: options.signal
+    };
+  }
+};
+function getRADChunkTableIteratorIndices(metadata, startChunkIndex, maxChunks, maxSplats) {
+  const chunkIndices = [];
+  let estimatedSplatCount = 0;
+  for (let chunkIndex = startChunkIndex; chunkIndex < metadata.chunks.length && chunkIndices.length < maxChunks && estimatedSplatCount < maxSplats; chunkIndex++) {
+    const chunk = metadata.chunks[chunkIndex];
+    chunkIndices.push(chunkIndex);
+    estimatedSplatCount += (chunk == null ? void 0 : chunk.count) ?? metadata.chunkSize ?? 0;
+  }
+  return chunkIndices;
+}
+function getRADMaxConcurrentChunkRequests(maxConcurrentChunkRequests) {
+  return Number.isFinite(maxConcurrentChunkRequests) && maxConcurrentChunkRequests > 0 ? Math.floor(maxConcurrentChunkRequests) : DEFAULT_RAD_MAX_CONCURRENT_CHUNK_REQUESTS;
+}
+function getRADChunkSplatBase(splats) {
+  var _a;
+  return typeof ((_a = splats.loaderData) == null ? void 0 : _a.base) === "number" ? splats.loaderData.base : 0;
+}
+function pruneLoadedLoDParents(splats, loadedGlobalSplatEnd) {
+  var _a, _b;
+  const childCounts = (_a = splats.loaderData) == null ? void 0 : _a.childCounts;
+  const childStarts = (_b = splats.loaderData) == null ? void 0 : _b.childStarts;
+  if (!(childCounts instanceof Uint16Array) || !(childStarts instanceof Uint32Array)) {
+    return splats;
+  }
+  const keepRows = new Uint32Array(splats.splatCount);
+  let keepCount = 0;
+  for (let rowIndex = 0; rowIndex < splats.splatCount; rowIndex++) {
+    const childCount = childCounts[rowIndex];
+    const childStart = childStarts[rowIndex];
+    if (childCount > 0 && childStart < loadedGlobalSplatEnd) {
+      continue;
+    }
+    keepRows[keepCount++] = rowIndex;
+  }
+  if (keepCount === splats.splatCount) {
+    return splats;
+  }
+  const keptRows = keepRows.subarray(0, keepCount);
+  const sphericalHarmonicsComponentCount = splats.sphericalHarmonicsComponentCount ?? 0;
+  return {
+    ...splats,
+    splatCount: keepCount,
+    positions: copyInterleavedRows(splats.positions, 3, keptRows),
+    scales: copyInterleavedRows(splats.scales, 3, keptRows),
+    rotations: copyInterleavedRows(splats.rotations, 4, keptRows),
+    colors: copyInterleavedRows(splats.colors, 3, keptRows),
+    sphericalHarmonicDcs: splats.sphericalHarmonicDcs ? copyInterleavedRows(splats.sphericalHarmonicDcs, 3, keptRows) : void 0,
+    opacities: copyInterleavedRows(splats.opacities, 1, keptRows),
+    sphericalHarmonics: splats.sphericalHarmonics && sphericalHarmonicsComponentCount ? copyInterleavedRows(splats.sphericalHarmonics, sphericalHarmonicsComponentCount, keptRows) : void 0,
+    loaderData: {
+      ...splats.loaderData,
+      count: keepCount,
+      childCounts: copyInterleavedRows(childCounts, 1, keptRows),
+      childStarts: copyInterleavedRows(childStarts, 1, keptRows)
+    }
+  };
+}
+function copyInterleavedRows(values, itemSize, rows) {
+  const copiedValues = new values.constructor(rows.length * itemSize);
+  for (let outputRowIndex = 0; outputRowIndex < rows.length; outputRowIndex++) {
+    const inputOffset = rows[outputRowIndex] * itemSize;
+    const outputOffset = outputRowIndex * itemSize;
+    copiedValues.set(values.subarray(inputOffset, inputOffset + itemSize), outputOffset);
+  }
+  return copiedValues;
+}
+function resolveRADChunkUrl(rootUrl, chunkFilename) {
+  if (/^[a-z][a-z0-9+.-]*:/i.test(chunkFilename) || chunkFilename.startsWith("/")) {
+    return chunkFilename;
+  }
+  if (!rootUrl) {
+    throw new Error("RADSource: cannot resolve a sidecar RADC chunk without a RAD URL.");
+  }
+  try {
+    return new URL(chunkFilename, rootUrl).toString();
+  } catch {
+    const [rootPath, suffix = ""] = rootUrl.split(/([?#].*)/, 2);
+    const lastSlashIndex = Math.max(rootPath.lastIndexOf("/"), rootPath.lastIndexOf("\\"));
+    const rootDirectory = lastSlashIndex >= 0 ? rootPath.slice(0, lastSlashIndex + 1) : "";
+    return `${rootDirectory}${chunkFilename}${suffix}`;
+  }
+}
+//# sourceMappingURL=index.cjs.map