@loaders.gl/services 5.0.0-alpha.5 → 5.0.0-alpha.6

package/dist/index.cjs

@@ -919,6 +919,78 @@ var init_convert_geometry_to_wkb = __esm({
   }
 });
 
+// ../gis/src/lib/geometry-converters/wkb/convert-geometry-to-wkt.ts
+function convertGeometryToWKT(geometry, options) {
+  const dimension = getWKTDimension(geometry, options);
+  if (geometry.type === "GeometryCollection" && !(options == null ? void 0 : options.dimension) && !(options == null ? void 0 : options.hasZ) && !(options == null ? void 0 : options.hasM) && hasMixedChildDimensions(geometry)) {
+    if (geometry.geometries.length === 0) return "GEOMETRYCOLLECTION EMPTY";
+    return `GEOMETRYCOLLECTION (${geometry.geometries.map((child) => convertGeometryToWKT(child)).join(", ")})`;
+  }
+  return (0, import_wkb.formatWKT)(normalizeGeometryDimension(geometry, dimension), dimension);
+}
+function normalizeGeometryDimension(geometry, dimension) {
+  if (geometry.type === "GeometryCollection") {
+    return {
+      type: "GeometryCollection",
+      geometries: geometry.geometries.map((child) => normalizeGeometryDimension(child, dimension))
+    };
+  }
+  return {
+    ...geometry,
+    coordinates: normalizeCoordinateNesting(geometry.coordinates, getDimensionSize(dimension))
+  };
+}
+function normalizeCoordinateNesting(value, dimensionSize) {
+  if (value.length === 0) return value;
+  if (typeof value[0] === "number") {
+    const coordinate = value.slice(0, dimensionSize);
+    while (coordinate.length < dimensionSize) coordinate.push(0);
+    return coordinate;
+  }
+  return value.map((child) => normalizeCoordinateNesting(child, dimensionSize));
+}
+function hasMixedChildDimensions(geometry) {
+  const dimensions = geometry.geometries.map((child) => getCoordinateDimension(child));
+  return dimensions.some((dimension) => dimension !== dimensions[0]);
+}
+function getWKTDimension(geometry, options) {
+  if (options == null ? void 0 : options.dimension) return options.dimension;
+  if ((options == null ? void 0 : options.hasZ) && (options == null ? void 0 : options.hasM)) return "xyzm";
+  if (options == null ? void 0 : options.hasZ) return "xyz";
+  if (options == null ? void 0 : options.hasM) return "xym";
+  const declaredDimension = geometry.__geoarrowDimension;
+  if (declaredDimension) return declaredDimension;
+  return getCoordinateDimension(geometry);
+}
+function getCoordinateDimension(geometry) {
+  const declaredDimension = geometry.__geoarrowDimension;
+  if (declaredDimension) return declaredDimension;
+  if (geometry.type === "GeometryCollection") {
+    const childDimensions = geometry.geometries.map(getCoordinateDimension);
+    return childDimensions.length > 0 && childDimensions.every((dimension) => dimension === childDimensions[0]) ? childDimensions[0] : "xy";
+  }
+  const coordinate = getFirstCoordinate(geometry);
+  return coordinate && coordinate.length >= 4 ? "xyzm" : coordinate && coordinate.length >= 3 ? "xyz" : "xy";
+}
+function getDimensionSize(dimension) {
+  return dimension === "xy" ? 2 : dimension === "xyzm" ? 4 : 3;
+}
+function getFirstCoordinate(geometry) {
+  if (geometry.type === "Point") return geometry.coordinates;
+  if (geometry.type === "GeometryCollection") return null;
+  const coordinates = geometry.coordinates;
+  let value = coordinates;
+  while (Array.isArray(value) && Array.isArray(value[0])) value = value[0];
+  return Array.isArray(value) ? value : null;
+}
+var import_wkb;
+var init_convert_geometry_to_wkt = __esm({
+  "../gis/src/lib/geometry-converters/wkb/convert-geometry-to-wkt.ts"() {
+    "use strict";
+    import_wkb = require("@math.gl/wkb");
+  }
+});
+
 // ../schema/src/metadata.ts
 function getMetadataValue(metadata, key) {
   return metadata instanceof Map ? metadata.get(key) || null : metadata[key] || null;
@@ -2073,32 +2145,956 @@ var init_src2 = __esm({
   }
 });
 
-// ../gis/src/lib/geoarrow/feature-collection-to-arrow.ts
-function convertFeaturesToWKBArrowTable(features) {
-  const propertyRows = features.map((feature) => normalizeProperties(feature.properties));
-  const propertySchema = getPropertySchema(propertyRows);
-  const schema = buildFeatureArrowSchema(propertySchema, features);
-  const arrowTableBuilder = new ArrowTableBuilder(schema);
-  for (let featureIndex = 0; featureIndex < features.length; featureIndex++) {
-    arrowTableBuilder.addObjectRow({
-      ...propertyRows[featureIndex],
-      [GEOMETRY_COLUMN_NAME]: encodeWKBGeometryValue(features[featureIndex].geometry)
+// ../gis/src/lib/geoarrow/geoarrow-builder.ts
+function makePrimitiveData(values) {
+  return arrow6.makeData({ type: new arrow6.Float64(), data: values });
+}
+function getBoxFieldNames(dimension) {
+  const minimumNames = dimension === "xy" ? ["xmin", "ymin"] : dimension === "xyz" ? ["xmin", "ymin", "zmin"] : dimension === "xym" ? ["xmin", "ymin", "mmin"] : ["xmin", "ymin", "zmin", "mmin"];
+  const maximumNames = dimension === "xy" ? ["xmax", "ymax"] : dimension === "xyz" ? ["xmax", "ymax", "zmax"] : dimension === "xym" ? ["xmax", "ymax", "mmax"] : ["xmax", "ymax", "zmax", "mmax"];
+  return [...minimumNames, ...maximumNames];
+}
+function getCoordinateSize2(dimension) {
+  return dimension === "xy" ? 2 : dimension === "xyzm" ? 4 : 3;
+}
+function makeCoordinateData(values, dimension, coordinateLayout) {
+  if (coordinateLayout === "separated") {
+    const coordinateBuffers = values;
+    const coordinateNames = getCoordinateNames(dimension);
+    return arrow6.makeData({
+      type: new arrow6.Struct(
+        coordinateNames.map((name) => new arrow6.Field(name, new arrow6.Float64(), false))
+      ),
+      children: coordinateNames.map((name) => makePrimitiveData(coordinateBuffers[name]))
     });
   }
+  return arrow6.makeData({
+    type: new arrow6.FixedSizeList(
+      getCoordinateSize2(dimension),
+      new arrow6.Field("xy", new arrow6.Float64(), false)
+    ),
+    child: makePrimitiveData(values)
+  });
+}
+function makeBoxData(values, dimension) {
+  const names = getBoxFieldNames(dimension);
+  const children = names.map((name, index) => {
+    if (values instanceof Float64Array) {
+      const boxSize = names.length;
+      return makePrimitiveData(
+        Float64Array.from(
+          { length: values.length / boxSize },
+          (_, rowIndex) => values[rowIndex * boxSize + index]
+        )
+      );
+    }
+    return makePrimitiveData(values[name]);
+  });
+  return arrow6.makeData({
+    type: new arrow6.Struct(names.map((name) => new arrow6.Field(name, new arrow6.Float64(), false))),
+    children
+  });
+}
+function makeListData(child, offsets, fieldName, offsetType) {
+  return arrow6.makeData({
+    type: offsetType === "int64" ? new arrow6.LargeList(new arrow6.Field(fieldName, child.type, false)) : new arrow6.List(new arrow6.Field(fieldName, child.type, false)),
+    valueOffsets: offsets,
+    child
+  });
+}
+function makeCoordinateBuffers(coordinateCount, dimension, coordinateLayout) {
+  if (coordinateLayout === "interleaved") {
+    return new Float64Array(coordinateCount * getCoordinateSize2(dimension));
+  }
+  const coordinateNames = getCoordinateNames(dimension);
+  const buffers = {
+    x: new Float64Array(coordinateCount),
+    y: new Float64Array(coordinateCount)
+  };
+  for (const name of coordinateNames.slice(2)) buffers[name] = new Float64Array(coordinateCount);
+  return buffers;
+}
+function makeBoxBuffers(boxCount, dimension, coordinateLayout) {
+  const names = getBoxFieldNames(dimension);
+  if (coordinateLayout === "interleaved") {
+    return new Float64Array(boxCount * names.length);
+  }
+  const buffers = {};
+  for (const name of names) {
+    buffers[name] = new Float64Array(boxCount);
+  }
+  return buffers;
+}
+function getBoxValues(dimension, xmin, ymin, xmax, ymax, zmin, zmax, mmin, mmax) {
+  switch (dimension) {
+    case "xy":
+      return [xmin, ymin, xmax, ymax];
+    case "xyz":
+      return [xmin, ymin, zmin ?? Number.NaN, xmax, ymax, zmax ?? Number.NaN];
+    case "xym":
+      return [xmin, ymin, mmin ?? Number.NaN, xmax, ymax, mmax ?? Number.NaN];
+    case "xyzm":
+      return [
+        xmin,
+        ymin,
+        zmin ?? Number.NaN,
+        mmin ?? Number.NaN,
+        xmax,
+        ymax,
+        zmax ?? Number.NaN,
+        mmax ?? Number.NaN
+      ];
+  }
+}
+function getCoordinateNames(dimension) {
+  switch (dimension) {
+    case "xy":
+      return ["x", "y"];
+    case "xyz":
+      return ["x", "y", "z"];
+    case "xym":
+      return ["x", "y", "m"];
+    case "xyzm":
+      return ["x", "y", "z", "m"];
+  }
+}
+function withNulls(data, geometryArray) {
+  return new arrow6.Data(
+    data.type,
+    0,
+    geometryArray.length,
+    geometryArray.nullCount,
+    [
+      data.valueOffsets,
+      data.values,
+      geometryArray.nullCount > 0 ? geometryArray.nullBitmap : void 0
+    ],
+    data.children
+  );
+}
+var arrow6, GeoArrowBuilder;
+var init_geoarrow_builder = __esm({
+  "../gis/src/lib/geoarrow/geoarrow-builder.ts"() {
+    "use strict";
+    arrow6 = __toESM(require("apache-arrow"), 1);
+    GeoArrowBuilder = class _GeoArrowBuilder {
+      /** GeoArrow extension encoding emitted by this builder. */
+      encoding;
+      /** Whether coordinate tuples include Z. */
+      hasZ;
+      /** Whether coordinate tuples include M. */
+      hasM;
+      /** Exact coordinate dimension emitted by this builder. */
+      dimension;
+      state;
+      /** Creates a GeoArrow builder in measure or write mode. */
+      constructor(options) {
+        this.encoding = options.encoding;
+        this.dimension = options.dimension || (options.hasZ && options.hasM ? "xyzm" : options.hasZ ? "xyz" : options.hasM ? "xym" : "xy");
+        this.hasZ = this.dimension === "xyz" || this.dimension === "xyzm";
+        this.hasM = this.dimension === "xym" || this.dimension === "xyzm";
+        const coordinateLayout = options.coordinateLayout || "interleaved";
+        const offsetType = options.offsetType || "int32";
+        this.state = {
+          mode: options.mode,
+          encoding: options.encoding,
+          coordinateSize: getCoordinateSize2(this.dimension),
+          coordinateLayout,
+          offsetType,
+          transform: options.transform,
+          length: 0,
+          nullCount: 0,
+          coordinateCount: 0,
+          geometryChildCount: 0,
+          partChildCount: 0,
+          geometryOffsetCount: 1,
+          partOffsetCount: 1,
+          ringOffsetCount: 1,
+          target: options.mode === "write" ? options.target : void 0
+        };
+        this.initializeOffsets();
+      }
+      /** Emits one null geometry row. */
+      writeNullGeometry() {
+        this.state.length++;
+        this.state.nullCount++;
+        if (this.encoding !== "geoarrow.point" && this.encoding !== "geoarrow.box") {
+          this.writeGeometryOffset();
+        }
+        if (this.encoding === "geoarrow.point") this.state.coordinateCount++;
+      }
+      /** Begins one top-level geometry. */
+      beginGeometry(_type, _count) {
+        this.setValid(this.state.length);
+        this.state.length++;
+      }
+      /** Begins one point geometry or nested point. */
+      beginPoint() {
+        if (this.encoding === "geoarrow.point") this.beginGeometry();
+      }
+      /** Begins one axis-aligned GeoArrow box row. */
+      beginBox() {
+        if (this.encoding !== "geoarrow.box") {
+          throw new Error(`Cannot write Box into ${this.encoding}`);
+        }
+        this.beginGeometry();
+      }
+      /** Writes one axis-aligned box in canonical minimum-then-maximum ordinate order. */
+      writeBox(xmin, ymin, xmax, ymax, zmin, zmax, mmin, mmax) {
+        if (this.encoding !== "geoarrow.box") {
+          throw new Error(`Cannot write Box into ${this.encoding}`);
+        }
+        const coordinateIndex = this.state.coordinateCount;
+        const values = getBoxValues(this.dimension, xmin, ymin, xmax, ymax, zmin, zmax, mmin, mmax);
+        if (this.state.mode === "write") {
+          this.writeBoxValues(this.getTarget().coordinates, coordinateIndex, values);
+        }
+        this.state.coordinateCount++;
+      }
+      /** Begins one line string geometry or nested line string. */
+      beginLineString(pointCount) {
+        if (this.encoding === "geoarrow.linestring") {
+          this.beginGeometry();
+          this.writeGeometryOffset(pointCount);
+          return;
+        }
+        if (this.encoding === "geoarrow.multilinestring") {
+          this.writePartOffset(pointCount);
+          return;
+        }
+        throw new Error(`Cannot write LineString into ${this.encoding}`);
+      }
+      /** Begins one polygon geometry or nested polygon. */
+      beginPolygon(ringCount) {
+        if (this.encoding === "geoarrow.polygon") {
+          this.beginGeometry();
+          this.writeGeometryOffset(ringCount);
+          return;
+        }
+        if (this.encoding === "geoarrow.multipolygon") {
+          this.writePartOffset(ringCount);
+          return;
+        }
+        throw new Error(`Cannot write Polygon into ${this.encoding}`);
+      }
+      /** Begins one polygon linear ring. */
+      beginLinearRing(pointCount) {
+        if (this.encoding === "geoarrow.polygon") {
+          this.writePartOffset(pointCount);
+          return;
+        }
+        if (this.encoding === "geoarrow.multipolygon") {
+          this.writeRingOffset(pointCount);
+          return;
+        }
+        throw new Error(`Cannot write LinearRing into ${this.encoding}`);
+      }
+      /** Begins one multipoint geometry. */
+      beginMultiPoint(pointCount) {
+        if (this.encoding !== "geoarrow.multipoint") {
+          throw new Error(`Cannot write MultiPoint into ${this.encoding}`);
+        }
+        this.beginGeometry();
+        this.writeGeometryOffset(pointCount);
+      }
+      /** Begins one multilinestring geometry. */
+      beginMultiLineString(lineCount) {
+        if (this.encoding !== "geoarrow.multilinestring") {
+          throw new Error(`Cannot write MultiLineString into ${this.encoding}`);
+        }
+        this.beginGeometry();
+        this.writeGeometryOffset(lineCount);
+      }
+      /** Begins one multipolygon geometry. */
+      beginMultiPolygon(polygonCount) {
+        if (this.encoding !== "geoarrow.multipolygon") {
+          throw new Error(`Cannot write MultiPolygon into ${this.encoding}`);
+        }
+        this.beginGeometry();
+        this.writeGeometryOffset(polygonCount);
+      }
+      /** Writes one coordinate tuple. The third ordinate is M for an XYM builder. */
+      writeCoordinate(x, y, z2, m) {
+        const coordinateIndex = this.state.coordinateCount;
+        if (this.state.mode === "write") {
+          const target = this.getTarget();
+          const coordinate = this.getCoordinateValuesForWrite(x, y, z2, m);
+          const transformedCoordinate = this.state.transform ? this.state.transform(coordinate) : coordinate;
+          this.writeCoordinateValues(
+            target.coordinates,
+            coordinateIndex,
+            transformedCoordinate,
+            coordinate
+          );
+        }
+        this.state.coordinateCount++;
+      }
+      /** Completes the current geometry array and returns its row count. */
+      finishGeometry() {
+        return this.state.length;
+      }
+      /** Returns current measured or written array metadata. */
+      getGeometryArray() {
+        return {
+          encoding: this.encoding,
+          coordinateSize: this.state.coordinateSize,
+          dimension: this.dimension,
+          coordinateLayout: this.state.coordinateLayout,
+          offsetType: this.state.offsetType,
+          length: this.state.length,
+          nullCount: this.state.nullCount,
+          nullBitmap: this.getNullBitmap(),
+          coordinates: this.getCoordinateValues(),
+          geometryOffsets: this.getGeometryOffsets(),
+          partOffsets: this.getPartOffsets(),
+          ringOffsets: this.getRingOffsets()
+        };
+      }
+      /** Measures geometry callbacks and returns allocated offsets. */
+      static measureGeometryArray(writers, options) {
+        const builder = new _GeoArrowBuilder({ mode: "measure", ...options });
+        for (const writer of writers) writer ? writer(builder) : builder.writeNullGeometry();
+        builder.finishGeometry();
+        return builder.getGeometryArray();
+      }
+      /** Writes geometry callbacks into a measured target. */
+      static writeGeometryArray(writers, measured, options) {
+        const builder = new _GeoArrowBuilder({ mode: "write", target: measured, ...options });
+        for (const writer of writers) writer ? writer(builder) : builder.writeNullGeometry();
+        builder.finishGeometry();
+        return builder.getGeometryArray();
+      }
+      /** Builds GeoArrow buffers from callbacks in two passes. */
+      static buildGeometryArray(writers, options) {
+        const measured = _GeoArrowBuilder.measureGeometryArray(writers, options);
+        return _GeoArrowBuilder.writeGeometryArray(writers, measured, options);
+      }
+      /** Wraps GeoArrow buffers in an Apache Arrow Data instance. */
+      static makeGeometryData(geometryArray) {
+        if (geometryArray.encoding === "geoarrow.box") {
+          return withNulls(
+            makeBoxData(geometryArray.coordinates, geometryArray.dimension),
+            geometryArray
+          );
+        }
+        const coordinateData = makeCoordinateData(
+          geometryArray.coordinates,
+          geometryArray.dimension,
+          geometryArray.coordinateLayout
+        );
+        let data = coordinateData;
+        switch (geometryArray.encoding) {
+          case "geoarrow.point":
+            return withNulls(data, geometryArray);
+          case "geoarrow.linestring":
+          case "geoarrow.multipoint":
+            data = makeListData(
+              coordinateData,
+              geometryArray.geometryOffsets,
+              "vertices",
+              geometryArray.offsetType
+            );
+            return withNulls(data, geometryArray);
+          case "geoarrow.polygon":
+          case "geoarrow.multilinestring":
+            data = makeListData(
+              coordinateData,
+              geometryArray.partOffsets,
+              "vertices",
+              geometryArray.offsetType
+            );
+            data = makeListData(
+              data,
+              geometryArray.geometryOffsets,
+              "rings",
+              geometryArray.offsetType
+            );
+            return withNulls(data, geometryArray);
+          case "geoarrow.multipolygon":
+            data = makeListData(
+              coordinateData,
+              geometryArray.ringOffsets,
+              "vertices",
+              geometryArray.offsetType
+            );
+            data = makeListData(data, geometryArray.partOffsets, "rings", geometryArray.offsetType);
+            data = makeListData(
+              data,
+              geometryArray.geometryOffsets,
+              "polygons",
+              geometryArray.offsetType
+            );
+            return withNulls(data, geometryArray);
+          default:
+            throw new Error(`Unsupported GeoArrow encoding ${geometryArray.encoding}`);
+        }
+      }
+      initializeOffsets() {
+        if (this.state.mode !== "measure") return;
+        const target = {
+          nullBitmap: new Uint8Array(0),
+          coordinates: makeCoordinateBuffers(0, this.dimension, this.state.coordinateLayout)
+        };
+        if (this.encoding !== "geoarrow.point" && this.encoding !== "geoarrow.box") {
+          target.geometryOffsets = this.makeOffsets(1);
+        }
+        if (this.encoding === "geoarrow.polygon" || this.encoding === "geoarrow.multilinestring" || this.encoding === "geoarrow.multipolygon") {
+          target.partOffsets = this.makeOffsets(1);
+        }
+        if (this.encoding === "geoarrow.multipolygon") target.ringOffsets = this.makeOffsets(1);
+        this.state.target = target;
+      }
+      getCoordinateValuesForWrite(x, y, z2, m) {
+        if (this.dimension === "xy") return [x, y];
+        if (this.dimension === "xyz") return [x, y, z2 ?? Number.NaN];
+        if (this.dimension === "xym") return [x, y, m ?? z2 ?? Number.NaN];
+        return [x, y, z2 ?? Number.NaN, m ?? Number.NaN];
+      }
+      writeGeometryOffset(childCount = 0) {
+        if (this.encoding === "geoarrow.point") return;
+        this.state.geometryChildCount += childCount;
+        this.appendOffset("geometryOffsets", this.state.geometryChildCount);
+      }
+      writePartOffset(childCount = 0) {
+        this.state.partChildCount += childCount;
+        this.appendOffset("partOffsets", this.state.partChildCount);
+      }
+      writeRingOffset(childCount = 0) {
+        this.appendOffset("ringOffsets", this.state.coordinateCount + childCount);
+      }
+      appendOffset(name, value) {
+        const target = this.getTarget();
+        const offsets = target[name];
+        if (!offsets) return;
+        if (this.state.mode === "measure") {
+          this.incrementOffsetCount(name);
+          return;
+        }
+        const index = this.getOffsetCount(name);
+        if (index >= offsets.length) throw new Error(`GeoArrowBuilder target ${name} overflow`);
+        offsets[index] = offsets instanceof BigInt64Array ? BigInt(value) : value;
+        this.incrementOffsetCount(name);
+      }
+      getOffsetCount(name) {
+        switch (name) {
+          case "geometryOffsets":
+            return this.state.geometryOffsetCount;
+          case "partOffsets":
+            return this.state.partOffsetCount;
+          case "ringOffsets":
+            return this.state.ringOffsetCount;
+          default:
+            throw new Error(`Unexpected offset buffer ${name}`);
+        }
+      }
+      incrementOffsetCount(name) {
+        switch (name) {
+          case "geometryOffsets":
+            this.state.geometryOffsetCount++;
+            return;
+          case "partOffsets":
+            this.state.partOffsetCount++;
+            return;
+          case "ringOffsets":
+            this.state.ringOffsetCount++;
+            return;
+          default:
+            throw new Error(`Unexpected offset buffer ${name}`);
+        }
+      }
+      setValid(rowIndex) {
+        if (this.state.mode !== "write") return;
+        const bitmap = this.getTarget().nullBitmap;
+        bitmap[rowIndex >> 3] |= 1 << (rowIndex & 7);
+      }
+      getTarget() {
+        if (!this.state.target) throw new Error("GeoArrowBuilder target is not initialized");
+        return this.state.target;
+      }
+      getNullBitmap() {
+        return this.state.mode === "measure" ? new Uint8Array(Math.ceil(this.state.length / 8)) : this.getTarget().nullBitmap;
+      }
+      getCoordinateValues() {
+        return this.state.mode === "measure" ? this.encoding === "geoarrow.box" ? makeBoxBuffers(this.state.coordinateCount, this.dimension, this.state.coordinateLayout) : makeCoordinateBuffers(
+          this.state.coordinateCount,
+          this.dimension,
+          this.state.coordinateLayout
+        ) : this.getTarget().coordinates;
+      }
+      getGeometryOffsets() {
+        return this.state.mode === "measure" && this.encoding !== "geoarrow.point" && this.encoding !== "geoarrow.box" ? this.makeOffsets(this.state.geometryOffsetCount) : this.getTarget().geometryOffsets;
+      }
+      getPartOffsets() {
+        return this.state.mode === "measure" && (this.encoding === "geoarrow.polygon" || this.encoding === "geoarrow.multilinestring" || this.encoding === "geoarrow.multipolygon") ? this.makeOffsets(this.state.partOffsetCount) : this.getTarget().partOffsets;
+      }
+      getRingOffsets() {
+        return this.state.mode === "measure" && this.encoding === "geoarrow.multipolygon" ? this.makeOffsets(this.state.ringOffsetCount) : this.getTarget().ringOffsets;
+      }
+      makeOffsets(length) {
+        return this.state.offsetType === "int64" ? new BigInt64Array(length) : new Int32Array(length);
+      }
+      writeCoordinateValues(coordinates, coordinateIndex, transformedCoordinate, originalCoordinate) {
+        if (coordinates instanceof Float64Array) {
+          if (coordinateIndex >= coordinates.length / this.state.coordinateSize) {
+            throw new Error("GeoArrowBuilder target coordinate buffer overflow");
+          }
+          const valueOffset = coordinateIndex * this.state.coordinateSize;
+          for (let dimensionIndex = 0; dimensionIndex < this.state.coordinateSize; dimensionIndex++) {
+            coordinates[valueOffset + dimensionIndex] = transformedCoordinate[dimensionIndex] ?? originalCoordinate[dimensionIndex] ?? Number.NaN;
+          }
+          return;
+        }
+        const coordinateNames = getCoordinateNames(this.dimension);
+        for (let dimensionIndex = 0; dimensionIndex < coordinateNames.length; dimensionIndex++) {
+          const coordinateValues = coordinates[coordinateNames[dimensionIndex]];
+          if (!coordinateValues || coordinateIndex >= coordinateValues.length) {
+            throw new Error("GeoArrowBuilder target coordinate buffer overflow");
+          }
+          coordinateValues[coordinateIndex] = transformedCoordinate[dimensionIndex] ?? originalCoordinate[dimensionIndex] ?? Number.NaN;
+        }
+      }
+      writeBoxValues(coordinates, coordinateIndex, values) {
+        if (coordinates instanceof Float64Array) {
+          const valueOffset = coordinateIndex * values.length;
+          if (valueOffset + values.length > coordinates.length) {
+            throw new Error("GeoArrowBuilder target box buffer overflow");
+          }
+          coordinates.set(values, valueOffset);
+          return;
+        }
+        const boxCoordinates = coordinates;
+        const names = getBoxFieldNames(this.dimension);
+        for (let index = 0; index < names.length; index++) {
+          const valuesBuffer = boxCoordinates[names[index]];
+          if (!(valuesBuffer instanceof Float64Array) || coordinateIndex >= valuesBuffer.length) {
+            throw new Error("GeoArrowBuilder target box buffer overflow");
+          }
+          valuesBuffer[coordinateIndex] = values[index];
+        }
+      }
+    };
+  }
+});
+
+// ../gis/src/lib/table-converters/convert-geojson-to-geoarrow.ts
+function convertFeaturesToGeoArrowTable(features, options) {
+  const preference = resolveGeoArrowEncodingPreference(options);
+  if (preference === "geoarrow.geometry" || preference === "optimized") {
+    return convertFeaturesToNativeGeoArrowTable(features, options, preference);
+  }
+  const rows = makeGeoArrowFeatureRows(features, options);
+  const schema = makeGeoArrowFeatureSchema(features, options);
+  const arrowTableBuilder = new ArrowTableBuilder(schema);
+  for (const row of rows) {
+    arrowTableBuilder.addObjectRow(row);
+  }
   return arrowTableBuilder.finishTable();
 }
-function buildFeatureArrowSchema(propertySchema, features) {
-  const geometryField = makeWKBGeometryField(GEOMETRY_COLUMN_NAME);
+function convertFeaturesToNativeGeoArrowTable(features, options, preference) {
+  const geometries = features.map((feature) => feature.geometry || null);
+  const dimension = getFeatureDimension(geometries);
+  const encoding = preference === "geoarrow.geometry" ? preference : selectOptimizedEncoding(geometries);
+  const geometryVector = encoding === "geoarrow.geometry" ? makeGeometryUnionVector(geometries, dimension) : makeNativeGeometryVector(geometries, encoding, dimension);
+  const geometryColumnName = (options == null ? void 0 : options.geometryColumnName) || DEFAULT_GEOMETRY_COLUMN_NAME;
+  const propertyRows = features.map((feature) => {
+    const properties = normalizeProperties(feature.properties);
+    assertNoGeometryPropertyCollision(properties, geometryColumnName);
+    return properties;
+  });
+  const propertySchema = (options == null ? void 0 : options.propertySchema) || getPropertySchema(propertyRows);
+  const schema = convertSchemaToArrow(propertySchema);
+  const inferredGeometryColumnMetadata = {
+    encoding,
+    geometry_types: inferGeoParquetGeometryTypes(geometries)
+  };
+  const existingGeoMetadata = getGeoMetadata2(schema.metadata);
+  const existingGeometryColumnMetadata = existingGeoMetadata == null ? void 0 : existingGeoMetadata.columns[geometryColumnName];
+  const geometryColumnMetadata = existingGeometryColumnMetadata ? { ...existingGeometryColumnMetadata } : inferredGeometryColumnMetadata;
+  const extensionMetadata = existingGeometryColumnMetadata ? { ...existingGeometryColumnMetadata } : inferredGeometryColumnMetadata;
+  if (isLegacyGeoJSONCRS(options == null ? void 0 : options.crs)) {
+    const normalizedCRS = normalizeLegacyGeoJSONCRS(options.crs);
+    geometryColumnMetadata.geojson_crs = options.crs;
+    extensionMetadata.geojson_crs = options.crs;
+    if (normalizedCRS) {
+      geometryColumnMetadata.crs = normalizedCRS.projjson;
+      extensionMetadata.crs = normalizedCRS.projjson;
+      extensionMetadata.crs_type = "projjson";
+    }
+  }
+  const geometryField = new arrow7.Field(
+    geometryColumnName,
+    geometryVector.type,
+    true,
+    /* @__PURE__ */ new Map([
+      ["ARROW:extension:name", encoding],
+      ["ARROW:extension:metadata", JSON.stringify(extensionMetadata)]
+    ])
+  );
+  const nextFields = [...schema.fields, geometryField];
+  const nextMetadata = new Map(schema.metadata || []);
+  nextMetadata.set(
+    "geo",
+    JSON.stringify({
+      version: DEFAULT_GEO_METADATA_VERSION2,
+      primary_column: geometryColumnName,
+      columns: {
+        [geometryColumnName]: geometryColumnMetadata
+      }
+    })
+  );
+  const nextSchema = new arrow7.Schema(nextFields, nextMetadata);
+  const propertyTableBuilder = new ArrowTableBuilder(propertySchema);
+  for (const row of propertyRows) {
+    propertyTableBuilder.addObjectRow(row);
+  }
+  const propertyTable = propertyTableBuilder.finishTable().data;
+  const propertyBatch = propertyTable.batches[0];
+  const children = nextFields.map(
+    (field, fieldIndex) => {
+      var _a2;
+      return fieldIndex < schema.fields.length ? (_a2 = propertyBatch == null ? void 0 : propertyBatch.getChildAt(fieldIndex)) == null ? void 0 : _a2.data[0] : geometryVector.data[0];
+    }
+  );
+  const data = arrow7.makeData({
+    type: new arrow7.Struct(nextFields),
+    length: features.length,
+    nullCount: 0,
+    children
+  });
+  return {
+    shape: "arrow-table",
+    schema: convertArrowToSchema(nextSchema),
+    data: new arrow7.Table(nextSchema, [new arrow7.RecordBatch(nextSchema, data)])
+  };
+}
+function resolveGeoArrowEncodingPreference(options) {
+  var _a2;
+  return ((_a2 = options == null ? void 0 : options.geoarrow) == null ? void 0 : _a2.encodingPreference) ?? (options == null ? void 0 : options.encodingPreference);
+}
+function selectOptimizedEncoding(geometries) {
+  const geometryKinds = new Set(
+    geometries.filter(Boolean).map((geometry) => geometry.type)
+  );
+  if (geometryKinds.size === 0 || geometryKinds.has("GeometryCollection")) {
+    return "geoarrow.geometry";
+  }
+  if (geometryKinds.size === 1) {
+    return getNativeEncoding([...geometryKinds][0]);
+  }
+  if (geometryKinds.size === 2) {
+    if (geometryKinds.has("Point") && geometryKinds.has("MultiPoint")) {
+      return "geoarrow.multipoint";
+    }
+    if (geometryKinds.has("LineString") && geometryKinds.has("MultiLineString")) {
+      return "geoarrow.multilinestring";
+    }
+    if (geometryKinds.has("Polygon") && geometryKinds.has("MultiPolygon")) {
+      return "geoarrow.multipolygon";
+    }
+  }
+  return "geoarrow.geometry";
+}
+function getFeatureDimension(geometries) {
+  let coordinateSize = 2;
+  for (const geometry of geometries) {
+    coordinateSize = Math.max(coordinateSize, getGeometryCoordinateSize(geometry));
+  }
+  return coordinateSize >= 4 ? "xyzm" : coordinateSize === 3 ? "xyz" : "xy";
+}
+function getGeometryCoordinateSize(geometry) {
+  if (!geometry) return 2;
+  if (geometry.type === "GeometryCollection") {
+    return Math.max(2, ...geometry.geometries.map(getGeometryCoordinateSize));
+  }
+  let value = geometry.coordinates;
+  while (Array.isArray(value) && value.length > 0 && Array.isArray(value[0])) {
+    value = value[0];
+  }
+  return Array.isArray(value) && value.every((item) => typeof item === "number") ? value.length : 2;
+}
+function makeNativeGeometryVector(geometries, encoding, dimension) {
+  const writers = geometries.map(
+    (geometry) => geometry ? (builder) => writeGeometryToBuilder(builder, geometry, encoding) : null
+  );
+  const geometryArray = GeoArrowBuilder.buildGeometryArray(writers, { encoding, dimension });
+  return arrow7.makeVector(GeoArrowBuilder.makeGeometryData(geometryArray));
+}
+function makeGeometryUnionVector(geometries, dimension, includeGeometryCollections = true) {
+  const childRows = /* @__PURE__ */ new Map();
+  const typeIds = [];
+  const valueOffsets = [];
+  const nullCarrierKind = "Point";
+  const allGeometryKinds = [
+    "Point",
+    "LineString",
+    "Polygon",
+    "MultiPoint",
+    "MultiLineString",
+    "MultiPolygon",
+    ...includeGeometryCollections ? ["GeometryCollection"] : []
+  ];
+  for (const geometryKind of allGeometryKinds) {
+    childRows.set(geometryKind, []);
+  }
+  for (const geometry of geometries) {
+    const kind = (geometry == null ? void 0 : geometry.type) || nullCarrierKind;
+    const rows = childRows.get(kind) || [];
+    valueOffsets.push(rows.length);
+    typeIds.push(getUnionTypeId(kind, dimension));
+    rows.push(geometry);
+    childRows.set(kind, rows);
+  }
+  const orderedKinds = [...childRows.keys()].sort(
+    (left, right) => getUnionTypeId(left, dimension) - getUnionTypeId(right, dimension)
+  );
+  const fields = orderedKinds.map(
+    (kind) => new arrow7.Field(
+      getUnionFieldName(kind, dimension),
+      kind === "GeometryCollection" ? makeGeometryCollectionVector(childRows.get(kind), dimension).type : makeNativeGeometryVector(childRows.get(kind), getNativeEncoding(kind), dimension).type,
+      true
+    )
+  );
+  const children = orderedKinds.map((kind) => {
+    if (kind === "GeometryCollection") {
+      return makeGeometryCollectionVector(childRows.get(kind), dimension).data[0];
+    }
+    return makeNativeGeometryVector(childRows.get(kind), getNativeEncoding(kind), dimension).data[0];
+  });
+  const unionType = new arrow7.DenseUnion(
+    orderedKinds.map((kind) => getUnionTypeId(kind, dimension)),
+    fields
+  );
+  return arrow7.makeVector(
+    arrow7.makeData({
+      type: unionType,
+      length: geometries.length,
+      nullCount: 0,
+      typeIds: Int8Array.from(typeIds),
+      valueOffsets: Int32Array.from(valueOffsets),
+      children
+    })
+  );
+}
+function makeGeometryCollectionVector(geometries, dimension) {
+  const flattenedGeometries = [];
+  const offsets = [0];
+  for (const geometry of geometries) {
+    if ((geometry == null ? void 0 : geometry.type) === "GeometryCollection") {
+      appendGeometryCollectionMembers(flattenedGeometries, geometry.geometries);
+    }
+    offsets.push(flattenedGeometries.length);
+  }
+  const memberUnion = makeGeometryUnionVector(flattenedGeometries, dimension, false);
+  const listType = new arrow7.List(new arrow7.Field("geometries", memberUnion.type, true));
+  return arrow7.makeVector(
+    arrow7.makeData({
+      type: listType,
+      length: geometries.length,
+      nullCount: 0,
+      valueOffsets: Int32Array.from(offsets),
+      child: memberUnion.data[0]
+    })
+  );
+}
+function appendGeometryCollectionMembers(target, geometries) {
+  for (const geometry of geometries) {
+    if ((geometry == null ? void 0 : geometry.type) === "GeometryCollection") {
+      appendGeometryCollectionMembers(target, geometry.geometries);
+    } else {
+      target.push(geometry);
+    }
+  }
+}
+function writeGeometryToBuilder(builder, geometry, encoding) {
+  switch (geometry.type) {
+    case "Point":
+      if (encoding === "geoarrow.multipoint") builder.beginMultiPoint(1);
+      builder.beginPoint();
+      writeCoordinateToBuilder(builder, geometry.coordinates);
+      return;
+    case "MultiPoint":
+      builder.beginMultiPoint(geometry.coordinates.length);
+      for (const coordinate of geometry.coordinates) {
+        builder.beginPoint();
+        writeCoordinateToBuilder(builder, coordinate);
+      }
+      return;
+    case "LineString":
+      if (encoding === "geoarrow.multilinestring") builder.beginMultiLineString(1);
+      writeLineStringToBuilder(builder, geometry.coordinates);
+      return;
+    case "MultiLineString":
+      builder.beginMultiLineString(geometry.coordinates.length);
+      for (const line of geometry.coordinates) writeLineStringToBuilder(builder, line);
+      return;
+    case "Polygon":
+      if (encoding === "geoarrow.multipolygon") builder.beginMultiPolygon(1);
+      writePolygonToBuilder(builder, geometry.coordinates);
+      return;
+    case "MultiPolygon":
+      builder.beginMultiPolygon(geometry.coordinates.length);
+      for (const polygon of geometry.coordinates) writePolygonToBuilder(builder, polygon);
+      return;
+    case "GeometryCollection":
+      throw new Error("GeometryCollection must be written through the dense union builder.");
+  }
+}
+function writeLineStringToBuilder(builder, coordinates) {
+  builder.beginLineString(coordinates.length);
+  for (const coordinate of coordinates) writeCoordinateToBuilder(builder, coordinate);
+}
+function writePolygonToBuilder(builder, coordinates) {
+  builder.beginPolygon(coordinates.length);
+  for (const ring of coordinates) {
+    builder.beginLinearRing(ring.length);
+    for (const coordinate of ring) writeCoordinateToBuilder(builder, coordinate);
+  }
+}
+function writeCoordinateToBuilder(builder, coordinate) {
+  builder.writeCoordinate(
+    coordinate[0] ?? Number.NaN,
+    coordinate[1] ?? Number.NaN,
+    coordinate[2],
+    coordinate[3]
+  );
+}
+function getNativeEncoding(kind) {
+  switch (kind) {
+    case "Point":
+      return "geoarrow.point";
+    case "LineString":
+      return "geoarrow.linestring";
+    case "Polygon":
+      return "geoarrow.polygon";
+    case "MultiPoint":
+      return "geoarrow.multipoint";
+    case "MultiLineString":
+      return "geoarrow.multilinestring";
+    case "MultiPolygon":
+      return "geoarrow.multipolygon";
+    default:
+      throw new Error(`No native GeoArrow encoding exists for ${kind}.`);
+  }
+}
+function getUnionTypeId(kind, dimension) {
+  const baseTypeId = {
+    Point: 1,
+    LineString: 2,
+    Polygon: 3,
+    MultiPoint: 4,
+    MultiLineString: 5,
+    MultiPolygon: 6,
+    GeometryCollection: 7
+  };
+  const dimensionOffset = dimension === "xyz" ? 10 : dimension === "xym" ? 20 : dimension === "xyzm" ? 30 : 0;
+  return baseTypeId[kind] + dimensionOffset;
+}
+function getUnionFieldName(kind, dimension) {
+  return dimension === "xy" ? kind : `${kind} ${dimension.slice(1).toUpperCase()}`;
+}
+function makeGeoArrowFeatureRows(features, options) {
+  const geometryColumnName = (options == null ? void 0 : options.geometryColumnName) || DEFAULT_GEOMETRY_COLUMN_NAME;
+  const encoding = (options == null ? void 0 : options.encoding) || "wkb";
+  return features.map((feature) => {
+    const properties = normalizeProperties(feature.properties);
+    assertNoGeometryPropertyCollision(properties, geometryColumnName);
+    return {
+      ...properties,
+      [geometryColumnName]: encodeGeoArrowGeometry(feature.geometry, encoding)
+    };
+  });
+}
+function makeGeoArrowFeatureSchema(features, options) {
+  const geometryColumnName = (options == null ? void 0 : options.geometryColumnName) || DEFAULT_GEOMETRY_COLUMN_NAME;
+  const encoding = (options == null ? void 0 : options.encoding) || "wkb";
+  const propertyRows = features.map((feature) => {
+    const properties = normalizeProperties(feature.properties);
+    assertNoGeometryPropertyCollision(properties, geometryColumnName);
+    return properties;
+  });
+  const propertySchema = getPropertySchema(propertyRows);
+  const geometryField = encoding === "wkb" ? makeWKBGeometryField(geometryColumnName, true) : {
+    name: geometryColumnName,
+    type: "utf8",
+    nullable: true,
+    metadata: {}
+  };
   const schema = {
     fields: [...propertySchema.fields, geometryField],
     metadata: { ...propertySchema.metadata || {} }
   };
-  setWKBGeometrySchemaMetadata(schema, {
-    geometryColumnName: GEOMETRY_COLUMN_NAME,
-    geometryTypes: inferGeoParquetGeometryTypes(features.map((feature) => feature.geometry))
-  });
+  if (encoding === "wkb") {
+    setWKBGeometrySchemaMetadata(schema, {
+      geometryColumnName,
+      primaryColumnName: geometryColumnName,
+      geometryTypes: inferGeoParquetGeometryTypes(features.map((feature) => feature.geometry))
+    });
+  } else {
+    schema.metadata.geo = JSON.stringify({
+      version: DEFAULT_GEO_METADATA_VERSION2,
+      primary_column: geometryColumnName,
+      columns: {
+        [geometryColumnName]: {
+          encoding,
+          geometry_types: inferGeoParquetGeometryTypes(features.map((feature) => feature.geometry))
+        }
+      }
+    });
+  }
+  applyLegacyGeoJSONCRSToSchema(schema, geometryColumnName, options == null ? void 0 : options.crs);
+  return schema;
+}
+function applyLegacyGeoJSONCRSToSchema(schema, geometryColumnName, crs) {
+  if (!isLegacyGeoJSONCRS(crs)) {
+    return schema;
+  }
+  const geometryField = schema.fields.find((field) => field.name === geometryColumnName);
+  if (!geometryField) {
+    return schema;
+  }
+  const normalizedCRS = normalizeLegacyGeoJSONCRS(crs);
+  const columnMetadata = {
+    [GEOJSON_CRS_METADATA_KEY]: crs
+  };
+  if (normalizedCRS) {
+    columnMetadata.crs = normalizedCRS.projjson;
+  }
+  schema.metadata ||= {};
+  const geoMetadata = getGeoMetadata2(schema.metadata) || {
+    version: DEFAULT_GEO_METADATA_VERSION2,
+    primary_column: geometryColumnName,
+    columns: {}
+  };
+  geoMetadata.version ||= DEFAULT_GEO_METADATA_VERSION2;
+  geoMetadata.primary_column ||= geometryColumnName;
+  geoMetadata.columns ||= {};
+  const existingColumnMetadata = geoMetadata.columns[geometryColumnName] || {
+    encoding: geometryField.type === "utf8" ? "wkt" : "wkb",
+    geometry_types: []
+  };
+  geoMetadata.columns[geometryColumnName] = {
+    ...existingColumnMetadata,
+    ...columnMetadata
+  };
+  setGeoMetadata2(schema.metadata, geoMetadata);
+  geometryField.metadata ||= {};
+  const extensionMetadata = parseExtensionMetadata(
+    geometryField.metadata[GEOARROW_EXTENSION_METADATA_KEY]
+  );
+  extensionMetadata[GEOJSON_CRS_METADATA_KEY] = crs;
+  if (normalizedCRS) {
+    extensionMetadata.crs = normalizedCRS.projjson;
+    extensionMetadata.crs_type = "projjson";
+  }
+  geometryField.metadata[GEOARROW_EXTENSION_METADATA_KEY] = JSON.stringify(extensionMetadata);
   return schema;
 }
+function encodeGeoArrowGeometry(geometry, encoding) {
+  if (!geometry) {
+    return null;
+  }
+  return encoding === "wkt" ? convertGeometryToWKT(geometry) : encodeWKBGeometryValue(geometry);
+}
 function normalizeProperties(properties) {
   if (!properties || typeof properties !== "object") {
     return {};
@@ -2126,7 +3122,7 @@ function getPropertySchema(propertyRows) {
   return {
     metadata: {},
     fields: fieldNames.map((fieldName) => {
-      const inferredType = getDataTypeFromArray(
+      const inferredType = getPropertyFieldType(
         propertyRows.map((propertyRow) => propertyRow[fieldName])
       );
       return {
@@ -2137,8 +3133,254 @@ function getPropertySchema(propertyRows) {
     })
   };
 }
-function getFieldNames(propertyRows) {
-  const fieldNames = /* @__PURE__ */ new Set();
+function getPropertyFieldType(values) {
+  let type = "null";
+  let nullable = false;
+  for (const value of values) {
+    if (value === null || value === void 0) {
+      nullable = true;
+      continue;
+    }
+    const valueType = getPropertyValueType(value);
+    if (type === "null") {
+      type = valueType;
+      continue;
+    }
+    if (type !== valueType) {
+      throw new Error(`GeoJSONLoader: incompatible property types ${type} and ${valueType}`);
+    }
+  }
+  return { type, nullable };
+}
+function getPropertyValueType(value) {
+  switch (typeof value) {
+    case "boolean":
+      return "bool";
+    case "number":
+      return "float64";
+    case "string":
+      return "utf8";
+    default:
+      return "null";
+  }
+}
+function isLegacyGeoJSONCRS(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeLegacyGeoJSONCRS(crs) {
+  const name = getLegacyGeoJSONCRSName(crs);
+  if (!name) {
+    return null;
+  }
+  const normalizedName = name.toLowerCase();
+  if (normalizedName === "crs84" || normalizedName === "ogc:crs84" || normalizedName === "urn:ogc:def:crs:ogc:1.3:crs84" || normalizedName === "urn:ogc:def:crs:ogc::crs84" || normalizedName === "http://www.opengis.net/def/crs/ogc/1.3/crs84") {
+    return { name, projjson: cloneJSON(CRS84_PROJJSON) };
+  }
+  if (normalizedName === "epsg:4326" || normalizedName === "urn:ogc:def:crs:epsg::4326" || normalizedName === "urn:ogc:def:crs:epsg:6.6:4326" || normalizedName === "http://www.opengis.net/def/crs/epsg/0/4326") {
+    return { name, projjson: cloneJSON(EPSG_4326_PROJJSON) };
+  }
+  return null;
+}
+function getLegacyGeoJSONCRSName(crs) {
+  var _a2;
+  if (typeof ((_a2 = crs.properties) == null ? void 0 : _a2.name) === "string") {
+    return crs.properties.name;
+  }
+  if (typeof crs.name === "string") {
+    return crs.name;
+  }
+  return null;
+}
+function parseExtensionMetadata(metadata) {
+  if (!metadata) {
+    return {};
+  }
+  try {
+    const parsedMetadata = JSON.parse(metadata);
+    return parsedMetadata && typeof parsedMetadata === "object" && !Array.isArray(parsedMetadata) ? parsedMetadata : {};
+  } catch {
+    return {};
+  }
+}
+function cloneJSON(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function getFieldNames(propertyRows) {
+  const fieldNames = /* @__PURE__ */ new Set();
+  for (const propertyRow of propertyRows) {
+    for (const fieldName of Object.keys(propertyRow)) {
+      fieldNames.add(fieldName);
+    }
+  }
+  return [...fieldNames];
+}
+function assertNoGeometryPropertyCollision(properties, geometryColumnName) {
+  if (Object.prototype.hasOwnProperty.call(properties, geometryColumnName)) {
+    throw new Error(
+      `GeoArrow conversion: GeoJSON property "${geometryColumnName}" conflicts with the geometry column name`
+    );
+  }
+}
+var arrow7, DEFAULT_GEOMETRY_COLUMN_NAME, DEFAULT_GEO_METADATA_VERSION2, GEOJSON_CRS_METADATA_KEY, GEOARROW_EXTENSION_METADATA_KEY, CRS84_PROJJSON, EPSG_4326_PROJJSON;
+var init_convert_geojson_to_geoarrow = __esm({
+  "../gis/src/lib/table-converters/convert-geojson-to-geoarrow.ts"() {
+    "use strict";
+    arrow7 = __toESM(require("apache-arrow"), 1);
+    init_src2();
+    init_convert_geometry_to_wkt();
+    init_wkb_geoarrow_utils();
+    init_geoparquet_metadata();
+    init_geoarrow_builder();
+    DEFAULT_GEOMETRY_COLUMN_NAME = "geometry";
+    DEFAULT_GEO_METADATA_VERSION2 = "1.1.0";
+    GEOJSON_CRS_METADATA_KEY = "geojson_crs";
+    GEOARROW_EXTENSION_METADATA_KEY = "ARROW:extension:metadata";
+    CRS84_PROJJSON = {
+      $schema: "https://proj.org/schemas/v0.7/projjson.schema.json",
+      type: "GeographicCRS",
+      name: "WGS 84 longitude-latitude",
+      datum_ensemble: {
+        name: "World Geodetic System 1984 ensemble",
+        members: [
+          { name: "World Geodetic System 1984 (Transit)" },
+          { name: "World Geodetic System 1984 (G730)" },
+          { name: "World Geodetic System 1984 (G873)" },
+          { name: "World Geodetic System 1984 (G1150)" },
+          { name: "World Geodetic System 1984 (G1674)" },
+          { name: "World Geodetic System 1984 (G1762)" },
+          { name: "World Geodetic System 1984 (G2139)" }
+        ],
+        ellipsoid: {
+          name: "WGS 84",
+          semi_major_axis: 6378137,
+          inverse_flattening: 298.257223563
+        },
+        accuracy: "2.0",
+        id: {
+          authority: "EPSG",
+          code: 6326
+        }
+      },
+      coordinate_system: {
+        subtype: "ellipsoidal",
+        axis: [
+          {
+            name: "Geodetic longitude",
+            abbreviation: "Lon",
+            direction: "east",
+            unit: "degree"
+          },
+          {
+            name: "Geodetic latitude",
+            abbreviation: "Lat",
+            direction: "north",
+            unit: "degree"
+          }
+        ]
+      },
+      id: {
+        authority: "OGC",
+        code: "CRS84"
+      }
+    };
+    EPSG_4326_PROJJSON = {
+      ...CRS84_PROJJSON,
+      name: "WGS 84",
+      coordinate_system: {
+        subtype: "ellipsoidal",
+        axis: [
+          {
+            name: "Geodetic latitude",
+            abbreviation: "Lat",
+            direction: "north",
+            unit: "degree"
+          },
+          {
+            name: "Geodetic longitude",
+            abbreviation: "Lon",
+            direction: "east",
+            unit: "degree"
+          }
+        ]
+      },
+      id: {
+        authority: "EPSG",
+        code: 4326
+      }
+    };
+  }
+});
+
+// ../gis/src/lib/geoarrow/feature-collection-to-arrow.ts
+function convertFeaturesToWKBArrowTable(features, options = {}) {
+  const encodingPreference = resolveGeoArrowEncodingPreference(options);
+  if (encodingPreference && encodingPreference !== "geoarrow.wkb") {
+    return convertFeaturesToGeoArrowTable(features, options);
+  }
+  const propertyRows = features.map((feature) => normalizeProperties2(feature.properties));
+  const propertySchema = getPropertySchema2(propertyRows);
+  const schema = buildFeatureArrowSchema(propertySchema, features);
+  const arrowTableBuilder = new ArrowTableBuilder(schema);
+  for (let featureIndex = 0; featureIndex < features.length; featureIndex++) {
+    arrowTableBuilder.addObjectRow({
+      ...propertyRows[featureIndex],
+      [GEOMETRY_COLUMN_NAME]: encodeWKBGeometryValue(features[featureIndex].geometry)
+    });
+  }
+  return arrowTableBuilder.finishTable();
+}
+function buildFeatureArrowSchema(propertySchema, features) {
+  const geometryField = makeWKBGeometryField(GEOMETRY_COLUMN_NAME);
+  const schema = {
+    fields: [...propertySchema.fields, geometryField],
+    metadata: { ...propertySchema.metadata || {} }
+  };
+  setWKBGeometrySchemaMetadata(schema, {
+    geometryColumnName: GEOMETRY_COLUMN_NAME,
+    geometryTypes: inferGeoParquetGeometryTypes(features.map((feature) => feature.geometry))
+  });
+  return schema;
+}
+function normalizeProperties2(properties) {
+  if (!properties || typeof properties !== "object") {
+    return {};
+  }
+  const normalizedProperties = {};
+  for (const [propertyName, propertyValue] of Object.entries(properties)) {
+    normalizedProperties[propertyName] = normalizePropertyValue2(propertyValue);
+  }
+  return normalizedProperties;
+}
+function normalizePropertyValue2(propertyValue) {
+  if (propertyValue === null || propertyValue === void 0 || typeof propertyValue === "string" || typeof propertyValue === "number" || typeof propertyValue === "boolean") {
+    return propertyValue ?? null;
+  }
+  if (propertyValue instanceof Date) {
+    return propertyValue.toISOString();
+  }
+  return JSON.stringify(propertyValue);
+}
+function getPropertySchema2(propertyRows) {
+  if (propertyRows.length === 0) {
+    return { fields: [], metadata: {} };
+  }
+  const fieldNames = getFieldNames2(propertyRows);
+  return {
+    metadata: {},
+    fields: fieldNames.map((fieldName) => {
+      const inferredType = getDataTypeFromArray(
+        propertyRows.map((propertyRow) => propertyRow[fieldName])
+      );
+      return {
+        name: fieldName,
+        type: inferredType.type === "float32" ? "float64" : inferredType.type,
+        nullable: inferredType.nullable
+      };
+    })
+  };
+}
+function getFieldNames2(propertyRows) {
+  const fieldNames = /* @__PURE__ */ new Set();
   for (const propertyRow of propertyRows) {
     for (const fieldName of Object.keys(propertyRow)) {
       fieldNames.add(fieldName);
@@ -2152,6 +3394,7 @@ var init_feature_collection_to_arrow = __esm({
     "use strict";
     init_src2();
     init_wkb_geoarrow_utils();
+    init_convert_geojson_to_geoarrow();
     GEOMETRY_COLUMN_NAME = "geometry";
   }
 });
@@ -2598,6 +3841,10 @@ var init_worker_thread = __esm({
       name;
       source;
       url;
+      /** Lazily resolves the classic worker URL used as a fallback. */
+      getUrl;
+      /** Creates a browser Worker directly. */
+      loadWorker;
       terminated = false;
       worker;
       onMessage;
@@ -2608,11 +3855,13 @@ var init_worker_thread = __esm({
         return typeof Worker !== "undefined" && isBrowser2 || typeof NodeWorker !== "undefined" && !isBrowser2;
       }
       constructor(props) {
-        const { name, source, url } = props;
-        assert2(source || url);
+        const { name, source, url, getUrl, loadWorker } = props;
+        assert2(source || url || getUrl || loadWorker);
         this.name = name;
         this.source = source;
         this.url = url;
+        this.getUrl = getUrl;
+        this.loadWorker = loadWorker;
         this.onMessage = NOOP;
         this.onError = (error) => console.log(error);
         this.worker = isBrowser2 ? this._createBrowserWorker() : this._createNodeWorker();
@@ -2658,7 +3907,7 @@ var init_worker_thread = __esm({
        */
       _getErrorFromErrorEvent(event) {
         let message = "Failed to load ";
-        message += `worker ${this.name} from ${this.url}. `;
+        message += `worker ${this.name} from ${this.url || "built-in worker factory"}. `;
         if (event.message) {
           message += `${event.message} in `;
         }
@@ -2671,8 +3920,26 @@ var init_worker_thread = __esm({
        * Creates a worker thread on the browser
        */
       _createBrowserWorker() {
-        this._loadableURL = getLoadableWorkerURL({ source: this.source, url: this.url });
+        var _a2;
+        if (this.loadWorker) {
+          try {
+            const worker2 = this.loadWorker();
+            if (worker2) {
+              return this._initializeBrowserWorker(worker2);
+            }
+          } catch (error) {
+            if (!this.source && !this.url && !this.getUrl) {
+              throw error;
+            }
+          }
+        }
+        const url = this.url || ((_a2 = this.getUrl) == null ? void 0 : _a2.call(this));
+        this._loadableURL = getLoadableWorkerURL({ source: this.source, url });
         const worker = new Worker(this._loadableURL, { name: this.name });
+        return this._initializeBrowserWorker(worker);
+      }
+      /** Attaches protocol handlers to a browser worker. */
+      _initializeBrowserWorker(worker) {
         worker.onmessage = (event) => {
           if (!event.data) {
             this.onError(new Error("No data received"));
@@ -2731,6 +3998,10 @@ var init_worker_pool = __esm({
       source;
       // | Function;
       url;
+      /** Lazily resolves a classic worker fallback URL. */
+      getUrl;
+      /** Creates a browser Worker directly. */
+      loadWorker;
       maxConcurrency = 1;
       maxMobileConcurrency = 1;
       onDebug = () => {
@@ -2752,6 +4023,8 @@ var init_worker_pool = __esm({
       constructor(props) {
         this.source = props.source;
         this.url = props.url;
+        this.getUrl = props.getUrl;
+        this.loadWorker = props.loadWorker;
         this.setProps(props);
       }
       /**
@@ -2861,7 +4134,13 @@ var init_worker_pool = __esm({
         if (this.count < this._getMaxConcurrency()) {
           this.count++;
           const name = `${this.name.toLowerCase()} (#${this.count} of ${this.maxConcurrency})`;
-          return new WorkerThread({ name, source: this.source, url: this.url });
+          return new WorkerThread({
+            name,
+            source: this.source,
+            url: this.url,
+            getUrl: this.getUrl,
+            loadWorker: this.loadWorker
+          });
         }
         return null;
       }
@@ -2873,7 +4152,22 @@ var init_worker_pool = __esm({
 });
 
 // ../worker-utils/src/lib/worker-farm/worker-farm.ts
-var DEFAULT_PROPS, WorkerFarm;
+function getWorkerPoolKey(options) {
+  const { name, source, url, urlKey, loadWorker } = options;
+  const sourceKey = source ? `source:${source}` : "";
+  const urlKeyPart = url || urlKey ? `url:${url || urlKey}` : "";
+  const loadWorkerKey = loadWorker ? `loadWorker:${getLoadWorkerId(loadWorker)}` : "";
+  return [name, sourceKey, urlKeyPart, loadWorkerKey].filter(Boolean).join("|");
+}
+function getLoadWorkerId(loadWorker) {
+  let loadWorkerId = loadWorkerIds.get(loadWorker);
+  if (!loadWorkerId) {
+    loadWorkerId = nextLoadWorkerId++;
+    loadWorkerIds.set(loadWorker, loadWorkerId);
+  }
+  return loadWorkerId;
+}
+var DEFAULT_PROPS, loadWorkerIds, nextLoadWorkerId, WorkerFarm;
 var init_worker_farm = __esm({
   "../worker-utils/src/lib/worker-farm/worker-farm.ts"() {
     "use strict";
@@ -2886,6 +4180,8 @@ var init_worker_farm = __esm({
       onDebug: () => {
       }
     };
+    loadWorkerIds = /* @__PURE__ */ new WeakMap();
+    nextLoadWorkerId = 1;
     WorkerFarm = class _WorkerFarm {
       props;
       workerPools = /* @__PURE__ */ new Map();
@@ -2929,24 +4225,28 @@ var init_worker_farm = __esm({
       }
       /**
        * Returns a worker pool for the specified worker
-       * @param options - only used first time for a specific worker name
-       * @param options.name - the name of the worker - used to identify worker pool
-       * @param options.url -
-       * @param options.source -
+       * @param options Worker target used to identify and initialize the pool.
+       * @param options.name Worker name used as the base pool identity.
+       * @param options.url Worker script URL.
+       * @param options.source Inline worker source.
+       * @param options.loadWorker Built-in browser worker factory.
        * @example
        *   const job = WorkerFarm.getWorkerFarm().getWorkerPool({name, url}).startJob(...);
        */
       getWorkerPool(options) {
-        const { name, source, url } = options;
-        let workerPool = this.workerPools.get(name);
+        const { name, source, url, getUrl, loadWorker } = options;
+        const workerPoolKey = getWorkerPoolKey(options);
+        let workerPool = this.workerPools.get(workerPoolKey);
         if (!workerPool) {
           workerPool = new WorkerPool({
             name,
             source,
-            url
+            url,
+            getUrl,
+            loadWorker
           });
           workerPool.setProps(this._getWorkerPoolProps());
-          this.workerPools.set(name, workerPool);
+          this.workerPools.set(workerPoolKey, workerPool);
         }
         return workerPool;
       }
@@ -2962,40 +4262,123 @@ var init_worker_farm = __esm({
   }
 });
 
+// ../worker-utils/src/lib/async-queue/async-queue.ts
+var AsyncQueue;
+var init_async_queue = __esm({
+  "../worker-utils/src/lib/async-queue/async-queue.ts"() {
+    "use strict";
+    AsyncQueue = class {
+      _values;
+      _settlers;
+      _closed;
+      constructor() {
+        this._values = [];
+        this._settlers = [];
+        this._closed = false;
+      }
+      /** Return an async iterator for this queue */
+      [Symbol.asyncIterator]() {
+        return this;
+      }
+      /** Push a new value - the async iterator will yield a promise resolved to this value */
+      push(value) {
+        return this.enqueue(value);
+      }
+      /**
+       * Push a new value - the async iterator will yield a promise resolved to this value
+       * Add an error - the async iterator will yield a promise rejected with this value
+       */
+      enqueue(value) {
+        if (this._closed) {
+          throw new Error("Closed");
+        }
+        if (this._settlers.length > 0) {
+          if (this._values.length > 0) {
+            throw new Error("Illegal internal state");
+          }
+          const settler = this._settlers.shift();
+          if (value instanceof Error) {
+            settler.reject(value);
+          } else {
+            settler.resolve({ value });
+          }
+        } else {
+          this._values.push(value);
+        }
+      }
+      /** Indicate that we not waiting for more values - The async iterator will be done */
+      close() {
+        while (this._settlers.length > 0) {
+          const settler = this._settlers.shift();
+          settler.resolve({ done: true });
+        }
+        this._closed = true;
+      }
+      // ITERATOR IMPLEMENTATION
+      /** @returns a Promise for an IteratorResult */
+      next() {
+        if (this._values.length > 0) {
+          const value = this._values.shift();
+          if (value instanceof Error) {
+            return Promise.reject(value);
+          }
+          return Promise.resolve({ done: false, value });
+        }
+        if (this._closed) {
+          if (this._settlers.length > 0) {
+            throw new Error("Illegal internal state");
+          }
+          return Promise.resolve({ done: true, value: void 0 });
+        }
+        return new Promise((resolve2, reject) => {
+          this._settlers.push({ resolve: resolve2, reject });
+        });
+      }
+    };
+  }
+});
+
 // ../worker-utils/src/lib/worker-api/get-worker-url.ts
 function getWorkerName(worker) {
   const warning = worker.version !== VERSION2 ? ` (worker-utils@${VERSION2})` : "";
   return `${worker.name}@${worker.version}${warning}`;
 }
-function getWorkerURL(worker, options = {}) {
+function getCustomWorkerURL(worker, options = {}) {
   var _a2;
   const workerOptions = options[worker.id] || {};
-  const workerFile = isBrowser2 ? `${worker.id}-worker.js` : worker.workerNode || `${worker.id}-worker-node.js`;
+  const workerFile = isBrowser2 ? worker.workerFile || `${worker.id}-worker.js` : worker.workerNode || `${worker.id}-worker-node.js`;
   let url = workerOptions.workerUrl;
-  if (!url && typeof worker.worker === "string") {
-    url = worker.worker;
-  }
   if (!url && worker.id === "compression") {
     url = options.workerUrl;
   }
   const workerType = options._workerType || ((_a2 = options == null ? void 0 : options.core) == null ? void 0 : _a2._workerType);
-  if (workerType === "test") {
+  if (!url && workerType === "test") {
     if (isBrowser2) {
       url = `modules/${worker.module}/dist/${workerFile}`;
     } else {
       url = `modules/${worker.module}/src/workers/${worker.id}-worker-node.ts`;
     }
   }
-  if (!url) {
-    let version2 = worker.version;
-    if (version2 === "latest") {
-      version2 = NPM_TAG;
-    }
-    const versionTag = version2 ? `@${version2}` : "";
-    url = `https://unpkg.com/@loaders.gl/${worker.module}${versionTag}/dist/${workerFile}`;
+  return url || null;
+}
+function getWorkerURL(worker, options = {}) {
+  const customWorkerUrl = getCustomWorkerURL(worker, options);
+  const descriptorWorkerUrl = typeof worker.worker === "string" ? worker.worker : null;
+  const url = customWorkerUrl || descriptorWorkerUrl || getDefaultWorkerURL(worker, true);
+  assert2(url);
+  return url;
+}
+function getDefaultWorkerURL(worker, warn = false) {
+  const workerFile = isBrowser2 ? worker.workerFile || `${worker.id}-worker.js` : worker.workerNode || `${worker.id}-worker-node.js`;
+  let version2 = worker.version;
+  if (version2 === "latest") {
+    version2 = NPM_TAG;
+  }
+  const versionTag = version2 ? `@${version2}` : "";
+  const url = `https://unpkg.com/@loaders.gl/${worker.module}${versionTag}/dist/${workerFile}`;
+  if (warn) {
     warnIfUsingNpmTagFallback(worker, url);
   }
-  assert2(url);
   return url;
 }
 function warnIfUsingNpmTagFallback(worker, url) {
@@ -3029,19 +4412,16 @@ function canProcessOnWorker(worker, options) {
     return false;
   }
   const workerOptions = options == null ? void 0 : options[worker.id];
-  return Boolean((worker.worker || (workerOptions == null ? void 0 : workerOptions.workerUrl)) && (options == null ? void 0 : options.worker));
+  return Boolean(
+    (worker.worker || worker.loadWorker || (workerOptions == null ? void 0 : workerOptions.workerUrl)) && (options == null ? void 0 : options.worker)
+  );
 }
 async function processOnWorker(worker, data, options = {}, context = {}, jobContext = {}) {
   var _a2, _b, _c;
   throwIfAborted(options.signal);
   const name = getWorkerName(worker);
   const workerFarm = WorkerFarm.getWorkerFarm(options);
-  const { source } = options;
-  const workerPoolProps = { name, source };
-  if (!source) {
-    workerPoolProps.url = getWorkerURL(worker, options);
-  }
-  const workerPool = workerFarm.getWorkerPool(workerPoolProps);
+  const workerPool = workerFarm.getWorkerPool(getWorkerPoolTarget(worker, options, name));
   const jobName = options.jobName || worker.name;
   const job = await workerPool.startJob(
     jobName,
@@ -3070,6 +4450,115 @@ async function processOnWorker(worker, data, options = {}, context = {}, jobCont
     (_c = options.signal) == null ? void 0 : _c.removeEventListener("abort", abortJob);
   }
 }
+function processOnWorkerInBatches(worker, input, options = {}, context = {}, jobContext = {}) {
+  return processOnWorkerInBatchesIterator(worker, input, options, context, jobContext);
+}
+async function* processOnWorkerInBatchesIterator(worker, input, options, context, jobContext) {
+  var _a2, _b, _c;
+  throwIfAborted(options.signal);
+  const name = getWorkerName(worker);
+  const workerFarm = WorkerFarm.getWorkerFarm(options);
+  const workerPool = workerFarm.getWorkerPool(getWorkerPoolTarget(worker, options, name));
+  const outputBatches = new AsyncQueue();
+  const inputIterator = getAsyncIterator(input);
+  let outputFinished = false;
+  let inputFinished = false;
+  let inputRequest = Promise.resolve();
+  const batchJobFailed = new Error("Worker batch job failed");
+  const finishOutput = () => {
+    if (!outputFinished) {
+      outputFinished = true;
+      outputBatches.close();
+    }
+  };
+  const failOutput = (_error) => {
+    if (!outputFinished) {
+      outputFinished = true;
+      outputBatches.enqueue(batchJobFailed);
+      outputBatches.close();
+    }
+  };
+  const job = await workerPool.startJob(
+    options.jobName || worker.name,
+    (activeJob, type, payload) => {
+      switch (type) {
+        case "input-request":
+          inputRequest = inputRequest.then(async () => {
+            const nextBatch = await inputIterator.next();
+            if (!activeJob.isRunning) {
+              return;
+            }
+            if (nextBatch.done) {
+              inputFinished = true;
+              activeJob.postMessage("input-done", {});
+            } else {
+              activeJob.postMessage("input-batch", { input: nextBatch.value });
+            }
+          }).catch((error) => activeJob.abort(error));
+          break;
+        case "output-batch":
+          outputBatches.push(payload.result);
+          break;
+        case "done":
+          activeJob.done(payload);
+          finishOutput();
+          break;
+        case "error": {
+          const error = new Error(payload.error || "Worker batch processing failed");
+          activeJob.error(error);
+          failOutput(error);
+          break;
+        }
+        case "process":
+          void onMessage(context, activeJob, type, payload);
+          break;
+        default: {
+          const error = new Error(`Unexpected worker batch message: ${type}`);
+          activeJob.error(error);
+          failOutput(error);
+          break;
+        }
+      }
+    }
+  );
+  const abortJob = () => job.abort(getAbortReason(options.signal));
+  (_a2 = options.signal) == null ? void 0 : _a2.addEventListener("abort", abortJob, { once: true });
+  if ((_b = options.signal) == null ? void 0 : _b.aborted) {
+    abortJob();
+  }
+  void job.result.catch(failOutput);
+  try {
+    const { signal: _signal, ...workerOptions } = options;
+    if (job.isRunning) {
+      job.postMessage("process-in-batches", {
+        options: getTransferListForWriter(workerOptions),
+        context: getTransferListForWriter(jobContext)
+      });
+    }
+    try {
+      for await (const outputBatch of outputBatches) {
+        yield outputBatch;
+        if (job.isRunning) {
+          job.postMessage("output-ack", {});
+        }
+      }
+    } catch (error) {
+      if (error === batchJobFailed) {
+        await job.result;
+      }
+      throw error;
+    }
+    await job.result;
+  } finally {
+    (_c = options.signal) == null ? void 0 : _c.removeEventListener("abort", abortJob);
+    if (job.isRunning) {
+      job.abort(createAbortError2("Worker batch iterator was closed"));
+    }
+    if (!inputFinished) {
+      closeInputIterator(inputIterator);
+    }
+  }
+}
 function throwIfAborted(signal) {
   if (!(signal == null ? void 0 : signal.aborted)) {
     return;
@@ -3084,6 +4573,39 @@ function createAbortError2(message) {
   error.name = "AbortError";
   return error;
 }
+function getAsyncIterator(input) {
+  if (Symbol.asyncIterator in input) {
+    return input[Symbol.asyncIterator]();
+  }
+  return (async function* iterateSynchronously() {
+    yield* input;
+  })();
+}
+function closeInputIterator(inputIterator) {
+  var _a2;
+  try {
+    void Promise.resolve((_a2 = inputIterator.return) == null ? void 0 : _a2.call(inputIterator)).catch(() => void 0);
+  } catch {
+  }
+}
+function getWorkerPoolTarget(worker, options, name) {
+  if (options.source) {
+    return { name, source: options.source };
+  }
+  const customWorkerUrl = getCustomWorkerURL(worker, options);
+  if (customWorkerUrl) {
+    return { name, url: customWorkerUrl };
+  }
+  if (isBrowser2 && worker.loadWorker) {
+    return {
+      name,
+      loadWorker: worker.loadWorker,
+      getUrl: () => getWorkerURL(worker, options),
+      urlKey: getDefaultWorkerURL(worker)
+    };
+  }
+  return { name, url: getWorkerURL(worker, options) };
+}
 async function onMessage(context, job, type, payload) {
   switch (type) {
     case "done":
@@ -3113,9 +4635,11 @@ async function onMessage(context, job, type, payload) {
 var init_process_on_worker = __esm({
   "../worker-utils/src/lib/worker-api/process-on-worker.ts"() {
     "use strict";
+    init_async_queue();
     init_worker_farm();
     init_get_worker_url();
     init_get_transfer_list();
+    init_globals2();
   }
 });
 
@@ -3308,12 +4832,30 @@ function canParseWithWorker(loader, options) {
   }
   return Boolean(canProcessOnWorker(loader, workerOptions));
 }
+function shouldParseWithWorker(loader, data, options, context, estimateLoader = loader) {
+  var _a2, _b;
+  if (!canParseWithWorker(loader, options)) {
+    return false;
+  }
+  if (((_a2 = options == null ? void 0 : options.core) == null ? void 0 : _a2.worker) !== "auto" || !estimateLoader.getWorkerEstimate) {
+    return true;
+  }
+  try {
+    const estimate = estimateLoader.getWorkerEstimate(data, options, context);
+    if (estimate === void 0 || !Number.isFinite(estimate) || estimate < 0 || estimate > 1) {
+      return true;
+    }
+    return estimate >= (((_b = options.core) == null ? void 0 : _b.workerThreshold) ?? 0.1);
+  } catch {
+    return true;
+  }
+}
 async function parseWithWorker(loader, data, options, context, parseOnMainThread, signal) {
   const workerSignal = signal || getWorkerAbortSignal(options);
   const result = await processOnWorker(
     loader,
     data,
-    { ...getWorkerOptions(options), signal: workerSignal },
+    { ...getWorkerOptions(options, loader), signal: workerSignal },
     {
       process: async (input, processOptions, _workerContext, parseContext) => {
         if (!parseOnMainThread) {
@@ -3332,8 +4874,34 @@ async function parseWithWorker(loader, data, options, context, parseOnMainThread
   );
   return isLoaderWithWorkerResultDeserializer(loader) ? loader.deserializeWorkerResult(result, options, context) : result;
 }
-function getWorkerAbortSignal(options) {
-  var _a2;
+async function* parseWithWorkerInBatches(loader, inputIterator, options, context, parseOnMainThread, signal) {
+  const workerSignal = signal || getWorkerAbortSignal(options);
+  const outputIterator = processOnWorkerInBatches(
+    loader,
+    inputIterator,
+    { ...getWorkerOptions(options), signal: workerSignal },
+    {
+      process: async (input, processOptions, _workerContext, parseContext) => {
+        if (!parseOnMainThread) {
+          throw new Error("Worker not set up to parse on main thread");
+        }
+        const mainThreadContext = context ? { ...context, ...parseContext || {} } : void 0;
+        return await callParseOnMainThread(
+          parseOnMainThread,
+          input,
+          processOptions,
+          mainThreadContext
+        );
+      }
+    },
+    getSerializableLoaderContext(context)
+  );
+  for await (const batch of outputIterator) {
+    yield loader.deserializeWorkerBatch ? loader.deserializeWorkerBatch(batch, options, context) : batch;
+  }
+}
+function getWorkerAbortSignal(options) {
+  var _a2;
   const parquetSignal = (_a2 = options == null ? void 0 : options.parquet) == null ? void 0 : _a2.signal;
   if (typeof AbortSignal !== "undefined" && parquetSignal instanceof AbortSignal) {
     return parquetSignal;
@@ -3346,12 +4914,19 @@ function callParseOnMainThread(parseOnMainThread, input, options, context) {
   }
   return parseOnMainThread(input, void 0, options, context);
 }
-function getWorkerOptions(options = {}) {
+function getWorkerOptions(options = {}, loader) {
   const serializedOptions = JSON.parse(JSON.stringify(options));
-  return {
+  const workerOptions = {
     ...serializedOptions.core,
     ...serializedOptions
   };
+  if (workerOptions.worker === "auto") {
+    workerOptions.worker = true;
+  }
+  if (loader) {
+    workerOptions._workerLoaderId = loader.id;
+  }
+  return workerOptions;
 }
 function getSerializableLoaderContext(context) {
   if (!context) {
@@ -3506,6 +5081,31 @@ function createAuthenticatedFetch(options) {
   });
   return authenticatedFetch;
 }
+function getAuthenticatedFetch(options = {}) {
+  var _a2, _b;
+  const fetchOption = options.fetch ?? ((_a2 = options.core) == null ? void 0 : _a2.fetch);
+  let fetchFunction;
+  if (typeof fetchOption === "function") {
+    fetchFunction = fetchOption;
+  } 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.core) == null ? void 0 : _b.credentials) || []
+  });
+}
+function mergeFetchOptions(defaultOptions, requestOptions) {
+  const mergedOptions = { ...defaultOptions, ...requestOptions };
+  if (defaultOptions.headers || (requestOptions == null ? void 0 : requestOptions.headers)) {
+    const headers = new Headers(defaultOptions.headers);
+    new Headers(requestOptions == null ? void 0 : requestOptions.headers).forEach((value, key) => headers.set(key, value));
+    mergedOptions.headers = headers;
+  }
+  return mergedOptions;
+}
 async function authorizeRequest(sourceURL, requestOptions, credentials, tokenOverrides = /* @__PURE__ */ new Map(), previousCredentials = []) {
   const url = new URL(sourceURL);
   const headers = new Headers(requestOptions.headers);
@@ -4977,7 +6577,7 @@ function getFetchFunction(options) {
   if (typeof fetchOption === "function") {
     fetchFunction = (url, fetchOptions) => fetchOption(url, fetchOptions);
   } else if (fetchOption) {
-    fetchFunction = (url, requestOptions) => fetch(url, mergeFetchOptions(fetchOption, requestOptions));
+    fetchFunction = (url, requestOptions) => fetch(url, mergeFetchOptions2(fetchOption, requestOptions));
   } else {
     fetchFunction = (url, requestOptions) => fetch(url, requestOptions);
   }
@@ -4986,7 +6586,7 @@ function getFetchFunction(options) {
     credentials: ((_b = options == null ? void 0 : options.core) == null ? void 0 : _b.credentials) || []
   });
 }
-function mergeFetchOptions(fetchOptions, requestOptions) {
+function mergeFetchOptions2(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);
@@ -5962,10 +7562,10 @@ function splitArrowTableBuffersInternal(table, options) {
   const recordBatches = table.batches.map(
     (recordBatch) => splitArrowRecordBatchBuffers(recordBatch, options)
   );
-  return new arrow6.Table(table.schema, recordBatches);
+  return new arrow8.Table(table.schema, recordBatches);
 }
 function splitArrowRecordBatchBuffers(recordBatch, options) {
-  return new arrow6.RecordBatch(
+  return new arrow8.RecordBatch(
     recordBatch.schema,
     splitArrowDataBuffers(recordBatch.data, options)
   );
@@ -5974,12 +7574,12 @@ function splitArrowDataBuffers(data, options) {
   const children = data.children.map((childData) => splitArrowDataBuffers(childData, options));
   const dictionary = data.dictionary ? splitArrowVectorBuffers(data.dictionary, options) : void 0;
   const buffers = {
-    [arrow6.BufferType.OFFSET]: splitArrowBuffer(data.buffers[arrow6.BufferType.OFFSET], options),
-    [arrow6.BufferType.DATA]: splitArrowBuffer(data.buffers[arrow6.BufferType.DATA], options),
-    [arrow6.BufferType.VALIDITY]: splitArrowBuffer(data.buffers[arrow6.BufferType.VALIDITY], options),
-    [arrow6.BufferType.TYPE]: splitArrowBuffer(data.buffers[arrow6.BufferType.TYPE], options)
+    [arrow8.BufferType.OFFSET]: splitArrowBuffer(data.buffers[arrow8.BufferType.OFFSET], options),
+    [arrow8.BufferType.DATA]: splitArrowBuffer(data.buffers[arrow8.BufferType.DATA], options),
+    [arrow8.BufferType.VALIDITY]: splitArrowBuffer(data.buffers[arrow8.BufferType.VALIDITY], options),
+    [arrow8.BufferType.TYPE]: splitArrowBuffer(data.buffers[arrow8.BufferType.TYPE], options)
   };
-  return new arrow6.Data(
+  return new arrow8.Data(
     data.type,
     data.offset,
     data.length,
@@ -5991,7 +7591,7 @@ function splitArrowDataBuffers(data, options) {
   );
 }
 function splitArrowVectorBuffers(vector, options) {
-  return new arrow6.Vector(vector.data.map((data) => splitArrowDataBuffers(data, options)));
+  return new arrow8.Vector(vector.data.map((data) => splitArrowDataBuffers(data, options)));
 }
 function splitArrowBuffer(array, options) {
   if (!isArrowTypedArray(array)) {
@@ -6008,11 +7608,11 @@ function splitArrowBuffer(array, options) {
 function isArrowTypedArray(value) {
   return ArrayBuffer.isView(value) && !(value instanceof DataView);
 }
-var arrow6;
+var arrow8;
 var init_split_arrow_buffers = __esm({
   "../arrow/src/lib/utils/split-arrow-buffers.ts"() {
     "use strict";
-    arrow6 = __toESM(require("apache-arrow"), 1);
+    arrow8 = __toESM(require("apache-arrow"), 1);
   }
 });
 
@@ -6029,9 +7629,9 @@ function dehydrateArrowTable(table, options) {
 function hydrateArrowTable(table) {
   const schema = deserializeArrowSchema(table.schema);
   const recordBatches = table.batches.map(
-    (recordBatch) => new arrow7.RecordBatch(schema, hydrateArrowData(recordBatch.data))
+    (recordBatch) => new arrow9.RecordBatch(schema, hydrateArrowData(recordBatch.data))
   );
-  return new arrow7.Table(schema, recordBatches);
+  return new arrow9.Table(schema, recordBatches);
 }
 function dehydrateArrowRecordBatch(recordBatch) {
   return { data: dehydrateArrowData(recordBatch.data) };
@@ -6044,10 +7644,10 @@ function dehydrateArrowData(data) {
     // @ts-expect-error _nullCount is protected. Preserve the Arrow lazy null-count state.
     nullCount: data._nullCount,
     buffers: {
-      [arrow7.BufferType.OFFSET]: data.buffers[arrow7.BufferType.OFFSET],
-      [arrow7.BufferType.DATA]: data.buffers[arrow7.BufferType.DATA],
-      [arrow7.BufferType.VALIDITY]: data.buffers[arrow7.BufferType.VALIDITY],
-      [arrow7.BufferType.TYPE]: data.buffers[arrow7.BufferType.TYPE]
+      [arrow9.BufferType.OFFSET]: data.buffers[arrow9.BufferType.OFFSET],
+      [arrow9.BufferType.DATA]: data.buffers[arrow9.BufferType.DATA],
+      [arrow9.BufferType.VALIDITY]: data.buffers[arrow9.BufferType.VALIDITY],
+      [arrow9.BufferType.TYPE]: data.buffers[arrow9.BufferType.TYPE]
     },
     children: data.children.map((childData) => dehydrateArrowData(childData)),
     dictionary: data.dictionary ? dehydrateArrowVector(data.dictionary) : void 0
@@ -6059,7 +7659,7 @@ function dehydrateArrowVector(vector) {
 function hydrateArrowData(data) {
   const children = data.children.map((childData) => hydrateArrowData(childData));
   const dictionary = data.dictionary ? hydrateArrowVector(data.dictionary) : void 0;
-  return new arrow7.Data(
+  return new arrow9.Data(
     deserializeArrowType(data.type),
     data.offset,
     data.length,
@@ -6070,13 +7670,13 @@ function hydrateArrowData(data) {
   );
 }
 function hydrateArrowVector(vector) {
-  return new arrow7.Vector(vector.data.map((data) => hydrateArrowData(data)));
+  return new arrow9.Vector(vector.data.map((data) => hydrateArrowData(data)));
 }
-var arrow7;
+var arrow9;
 var init_arrow_table_transport = __esm({
   "../arrow/src/lib/utils/arrow-table-transport.ts"() {
     "use strict";
-    arrow7 = __toESM(require("apache-arrow"), 1);
+    arrow9 = __toESM(require("apache-arrow"), 1);
     init_src2();
     init_split_arrow_buffers();
   }
@@ -6682,7 +8282,7 @@ var init_vector_tile = __esm({
 
 // ../mvt/src/lib/parse-mvt.ts
 function parseMVT(arrayBuffer, options) {
-  var _a2, _b;
+  var _a2, _b, _c, _d;
   const mvtOptions = checkOptions(options);
   const shape = ((_a2 = options == null ? void 0 : options.gis) == null ? void 0 : _a2.format) || ((_b = options == null ? void 0 : options.mvt) == null ? void 0 : _b.shape) || (options == null ? void 0 : options.shape);
   switch (shape) {
@@ -6698,7 +8298,10 @@ function parseMVT(arrayBuffer, options) {
     }
     case "arrow-table": {
       const table = convertFeaturesToWKBArrowTable(
-        parseToGeojsonFeatures(arrayBuffer, mvtOptions)
+        parseToGeojsonFeatures(arrayBuffer, mvtOptions),
+        {
+          encodingPreference: ((_c = options == null ? void 0 : options.geoarrow) == null ? void 0 : _c.encodingPreference) || ((_d = mvtOptions.geoarrow) == null ? void 0 : _d.encodingPreference)
+        }
       );
       return table;
     }
@@ -7117,7 +8720,7 @@ var init_constants = __esm({
 });
 
 // ../i3s/src/i3s-format.ts
-var binary, json, I3SFormat, I3SContentFormat, I3SAttributeFormat, I3SNodePageFormat, ArcGISWebSceneFormat, I3SBuildingSceneLayerFormat;
+var binary, json, I3SFormat, I3SContentFormat, I3SAttributeFormat, I3SLEPCCFormat, I3SNodePageFormat, ArcGISWebSceneFormat, I3SBuildingSceneLayerFormat;
 var init_i3s_format = __esm({
   "../i3s/src/i3s-format.ts"() {
     "use strict";
@@ -7146,6 +8749,7 @@ var init_i3s_format = __esm({
     I3SAttributeFormat = binary("I3S Attribute", "i3s-attribute", "i3s-attribute", [
       "bin"
     ]);
+    I3SLEPCCFormat = binary("I3S LEPCC", "i3s-lepcc", "i3s-lepcc", ["bin"]);
     I3SNodePageFormat = json("I3S Node Page", "i3s-node-page", "i3s-node-page");
     ArcGISWebSceneFormat = json(
       "ArcGIS Web Scene",
@@ -7160,6 +8764,28 @@ var init_i3s_format = __esm({
   }
 });
 
+// ../i3s/src/i3s-loader-options.ts
+var I3S_LOADER_OPTIONS;
+var init_i3s_loader_options = __esm({
+  "../i3s/src/i3s-loader-options.ts"() {
+    "use strict";
+    init_constants();
+    I3S_LOADER_OPTIONS = {
+      token: void 0,
+      isTileset: "auto",
+      isTileHeader: "auto",
+      tile: void 0,
+      tileset: void 0,
+      _tileOptions: void 0,
+      _tilesetOptions: void 0,
+      useDracoGeometry: true,
+      useCompressedTextures: true,
+      decodeTextures: true,
+      coordinateSystem: COORDINATE_SYSTEM.METER_OFFSETS
+    };
+  }
+});
+
 // ../draco/src/lib/draco-module-loader.ts
 async function loadDracoDecoderModule(options = {}, type, profile = "full") {
   const draco3DModule = getInjectedDraco3DModule(options);
@@ -10696,6 +12322,10 @@ var init_tileset_traverser = __esm({
     DEFAULT_PROPS3 = {
       loadSiblings: false,
       skipLevelOfDetail: false,
+      baseScreenSpaceError: 1024,
+      skipScreenSpaceErrorFactor: 16,
+      skipLevels: 1,
+      immediatelyLoadDesiredLevelOfDetail: false,
       updateTransforms: true,
       onTraversalEnd: () => {
       },
@@ -10704,6 +12334,8 @@ var init_tileset_traverser = __esm({
     };
     TilesetTraverser = class {
       options;
+      /** Whether loaded content has disabled skip-LOD traversal for this tileset. */
+      disableSkipLevelOfDetail = false;
       // fulfill in traverse call
       root = null;
       // tiles should be rendered
@@ -10729,6 +12361,10 @@ var init_tileset_traverser = __esm({
       constructor(options) {
         this.options = { ...DEFAULT_PROPS3, ...options };
       }
+      /** Returns whether skip-LOD traversal is enabled and supported by the loaded content. */
+      isSkipLevelOfDetailEnabled() {
+        return this.options.skipLevelOfDetail && !this.disableSkipLevelOfDetail;
+      }
       // tiles should be visible
       traverse(root, frameState, options) {
         this.root = root;
@@ -10786,13 +12422,17 @@ var init_tileset_traverser = __esm({
             this.selectTile(tile, frameState);
           } else if (tile.refine === 2 /* REPLACE */) {
             this.loadTile(tile, frameState);
-            if (stoppedRefining || this.options.skipLevelOfDetail) {
+            if (stoppedRefining || this.isSkipLevelOfDetailEnabled()) {
               this.selectTile(tile, frameState);
             }
           }
           this.touchTile(tile, frameState);
           tile._shouldRefine = shouldRefine && parentRefines;
         }
+        this.completeTraversal(frameState);
+      }
+      /** Notifies the owning tileset when traversal is complete or its debounce interval expires. */
+      completeTraversal(frameState) {
         const newTime = (/* @__PURE__ */ new Date()).getTime();
         if (this.traversalFinished(frameState) || newTime - this.lastUpdate > this.updateDebounceTime) {
           this.lastUpdate = newTime;
@@ -10807,7 +12447,8 @@ var init_tileset_traverser = __esm({
       }
       /* eslint-disable complexity, max-statements */
       updateAndPushChildren(tile, frameState, stack, depth) {
-        const { loadSiblings, skipLevelOfDetail } = this.options;
+        const { loadSiblings } = this.options;
+        const skipLevelOfDetail = this.isSkipLevelOfDetailEnabled();
         const children = tile.children;
         children.sort(this.compareDistanceToCamera.bind(this));
         const checkRefines = tile.refine === 2 /* REPLACE */ && tile.hasRenderContent && !skipLevelOfDetail;
@@ -11343,7 +12984,7 @@ var init_tile_3d = __esm({
       // eslint-disable-next-line complexity
       _calculateRequestPriority(allowUnloadedContent) {
         const traverser = this.tileset._traverser;
-        const { skipLevelOfDetail } = traverser.options;
+        const skipLevelOfDetail = traverser.options.skipLevelOfDetail && !traverser.disableSkipLevelOfDetail;
         const maySkipTile = this.refine === 1 /* ADD */ || skipLevelOfDetail;
         if (maySkipTile && !this.isVisible && this._visible !== void 0) {
           return -1;
@@ -11574,9 +13215,11 @@ var init_tile_3d = __esm({
           return;
         }
         this._foveatedFactor = calculateFoveatedFactor(this.boundingVolume, frameState.camera);
+        const traverser = this.tileset._traverser;
+        const skipLevelOfDetail = traverser.options.skipLevelOfDetail && !traverser.disableSkipLevelOfDetail;
         const deferralEligible = isFoveatedRequestDeferred({
           refinement: this.refine,
-          skipLevelOfDetail: this.tileset._traverser.options.skipLevelOfDetail,
+          skipLevelOfDetail,
           foveatedScreenSpaceError: options.foveatedScreenSpaceError,
           foveatedConeSize: options.foveatedConeSize,
           minimumScreenSpaceErrorRelaxation: options.foveatedMinimumScreenSpaceErrorRelaxation,
@@ -13217,6 +14860,9 @@ var init_i3s_spatial_transformer = __esm({
 });
 
 // ../tiles/src/tileset-3d/format-i3s/i3s-source.ts
+function getI3SContentLoader(loader) {
+  return loader.contentLoader || loader;
+}
 function isTilesetRequest(input) {
   return Boolean(
     input && typeof input === "object" && "url" in input && "loader" in input && !("type" in input)
@@ -13258,8 +14904,10 @@ var init_i3s_source = __esm({
     I3SSource = class {
       /** I3S format discriminator. */
       type = "I3S" /* I3S */;
-      /** Loader used for tile metadata and content requests. */
+      /** Primary I3S loader used for root and child metadata requests. */
       loader;
+      /** Worker-capable loader used for binary tile content when supplied by the format loader. */
+      contentLoader;
       /** Root I3S layer URL. */
       url;
       /** Base path used for relative tile resource resolution. */
@@ -13294,6 +14942,7 @@ var init_i3s_source = __esm({
         this.rootTileset = isTilesetRequest(input) ? null : input;
         this.tileset = this.rootTileset;
         this.loader = request.loader;
+        this.contentLoader = getI3SContentLoader(request.loader);
         this.url = request.url;
         this.basePath = request.basePath || path_exports.dirname(request.url);
         this.resolver = request.resolver;
@@ -13415,7 +15064,7 @@ var init_i3s_source = __esm({
             isTileHeader: false
           }
         };
-        tile.content = await this.loadResourceData(contentUrl, options);
+        tile.content = await this.loadResourceData(contentUrl, options, this.contentLoader);
         return { loaded: true };
       }
       /**
@@ -13552,11 +15201,11 @@ var init_i3s_source = __esm({
       /**
        * Loads data through injected core APIs so this module stays independent from `@loaders.gl/core`.
        */
-      async loadWithCoreApi(url, options) {
+      async loadWithCoreApi(url, options, loader = this.loader) {
         if (!this.coreApi) {
           throw new Error("I3SSource requires an injected coreApi to load tileset data");
         }
-        return await this.coreApi.load(url, this.loader, options);
+        return await this.coreApi.load(url, loader, options);
       }
       /**
        * Loads data through an injected resolver when present, otherwise through the injected core API.
@@ -13583,11 +15232,11 @@ var init_i3s_source = __esm({
       /**
        * Loads tile metadata or content through an injected resolver when present, otherwise through the injected core API.
        */
-      async loadResourceData(url, options) {
+      async loadResourceData(url, options, loader = this.loader) {
         if (this.resolver) {
-          return await this.resolver.loadResource(url, this.loader, options);
+          return await this.resolver.loadResource(url, loader, options);
         }
-        return await this.loadWithCoreApi(url, options);
+        return await this.loadWithCoreApi(url, options, loader);
       }
       /** Transform one I3S header bound after target options and elevation providers are available. */
       async transformTileHeader(header) {
@@ -14330,33 +15979,6 @@ var init_parse_i3s_tile_content = __esm({
   }
 });
 
-// ../i3s/src/i3s-content-loader.ts
-var VERSION8, I3SContentLoader;
-var init_i3s_content_loader = __esm({
-  "../i3s/src/i3s-content-loader.ts"() {
-    "use strict";
-    init_i3s_format();
-    VERSION8 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
-    I3SContentLoader = {
-      ...I3SContentFormat,
-      dataType: null,
-      batchType: null,
-      name: "I3S Content (Indexed Scene Layers)",
-      id: "i3s-content",
-      module: "i3s",
-      worker: true,
-      version: VERSION8,
-      mimeTypes: ["application/octet-stream"],
-      /** Loads the parser-bearing I3S content loader implementation. */
-      preload: async () => (await Promise.resolve().then(() => (init_i3s_content_loader_with_parser(), i3s_content_loader_with_parser_exports))).I3SContentLoaderWithParser,
-      extensions: ["bin"],
-      options: {
-        "i3s-content": {}
-      }
-    };
-  }
-});
-
 // ../i3s/src/i3s-content-loader-with-parser.ts
 var i3s_content_loader_with_parser_exports = {};
 __export(i3s_content_loader_with_parser_exports, {
@@ -14391,6 +16013,35 @@ var init_i3s_content_loader_with_parser = __esm({
   }
 });
 
+// ../i3s/src/i3s-content-loader.ts
+var VERSION8, I3SContentLoader;
+var init_i3s_content_loader = __esm({
+  "../i3s/src/i3s-content-loader.ts"() {
+    "use strict";
+    init_i3s_format();
+    init_i3s_loader_options();
+    VERSION8 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+    I3SContentLoader = {
+      ...I3SContentFormat,
+      dataType: null,
+      batchType: null,
+      name: "I3S Content (Indexed Scene Layers)",
+      id: "i3s-content",
+      module: "i3s",
+      worker: true,
+      version: VERSION8,
+      mimeTypes: ["application/octet-stream"],
+      /** Loads the parser-bearing I3S content loader implementation. */
+      preload: async () => (await Promise.resolve().then(() => (init_i3s_content_loader_with_parser(), i3s_content_loader_with_parser_exports))).I3SContentLoaderWithParser,
+      extensions: ["bin"],
+      options: {
+        i3s: I3S_LOADER_OPTIONS,
+        "i3s-content": {}
+      }
+    };
+  }
+});
+
 // ../core/src/lib/fetch/fetch-error.ts
 var FetchError;
 var init_fetch_error = __esm({
@@ -14740,6 +16391,7 @@ var init_option_defaults = __esm({
         CDN: "https://unpkg.com/@loaders.gl",
         worker: true,
         // By default, use worker if provided by loader.
+        workerThreshold: 0.1,
         maxConcurrency: 3,
         // How many worker instances should be created for each loader.
         maxMobileConcurrency: 1,
@@ -14826,7 +16478,10 @@ function normalizeOptions(options, loader, loaders, url) {
   loaders = loaders || [];
   loaders = Array.isArray(loaders) ? loaders : [loaders];
   validateOptions(options, loaders);
-  return normalizeLoaderOptions(normalizeOptionsInternal(loader, options, url));
+  validateWorkerThreshold(options);
+  const normalizedOptions = normalizeLoaderOptions(normalizeOptionsInternal(loader, options, url));
+  validateWorkerThreshold(normalizedOptions);
+  return normalizedOptions;
 }
 function normalizeLoaderOptions(options) {
   const normalized = cloneLoaderOptions(options);
@@ -14850,6 +16505,13 @@ function validateOptions(options, loaders) {
     validateOptionsObject(idOptions, loader.id, loaderOptions, deprecatedOptions, loaders);
   }
 }
+function validateWorkerThreshold(options) {
+  var _a2;
+  const threshold = (_a2 = options.core) == null ? void 0 : _a2.workerThreshold;
+  if (threshold !== void 0 && (!Number.isFinite(threshold) || threshold < 0 || threshold > 1)) {
+    throw new Error("core.workerThreshold must be a finite number between 0 and 1");
+  }
+}
 function validateOptionsObject(options, id, defaultOptions, deprecatedOptions, loaders) {
   const loaderName = id || "Top level";
   const prefix = id ? `${id}.` : "";
@@ -15023,6 +16685,7 @@ var init_option_utils = __esm({
       "useLocalLibraries",
       "CDN",
       "worker",
+      "workerThreshold",
       "maxConcurrency",
       "maxMobileConcurrency",
       "reuseWorkers",
@@ -15661,7 +17324,8 @@ function getFetchFunction2(options, context) {
   if (typeof fetchOption === "function") {
     fetchFunction = fetchOption;
   } else if (isObject(fetchOption)) {
-    fetchFunction = (url, requestOptions) => fetchFile(url, mergeFetchOptions2(fetchOption, requestOptions));
+    const baseFetch = (context == null ? void 0 : context.fetch) || fetchFile;
+    fetchFunction = (url, requestOptions) => baseFetch(url, mergeFetchOptions3(fetchOption, requestOptions));
   } else if (context == null ? void 0 : context.fetch) {
     fetchFunction = context.fetch;
   } else {
@@ -15672,7 +17336,7 @@ function getFetchFunction2(options, context) {
     credentials: ((_b = loaderOptions.core) == null ? void 0 : _b.credentials) || []
   });
 }
-function mergeFetchOptions2(defaultOptions, requestOptions) {
+function mergeFetchOptions3(defaultOptions, requestOptions) {
   const options = { ...defaultOptions, ...requestOptions };
   if (defaultOptions.headers || (requestOptions == null ? void 0 : requestOptions.headers)) {
     const headers = new Headers(defaultOptions.headers);
@@ -15983,6 +17647,9 @@ async function parseToOutputIterator(loader, data, options, context) {
     ((_a2 = options == null ? void 0 : options.core) == null ? void 0 : _a2.transforms) || []
   );
   if (loader.parseInBatches) {
+    if (loader.id === "csv" && isBrowser && canParseWithWorker(loader, options)) {
+      return parseWithWorkerInBatches(loader, transformedIterator, options, context, parse2);
+    }
     return loader.parseInBatches(transformedIterator, options, context);
   }
   return parseChunkInBatches(transformedIterator, loader, options, context);
@@ -16223,7 +17890,10 @@ var init_core_api = __esm({
 // ../core/src/lib/loader-utils/loader-context.ts
 function getLoaderContext(context, options, parentContext) {
   if (parentContext) {
-    return parentContext;
+    return {
+      ...parentContext,
+      fetch: getFetchFunction2(options, parentContext)
+    };
   }
   const newContext = {
     ...context,
@@ -16305,7 +17975,7 @@ async function parseWithLoader(loader, data, options, context) {
     context.response = { headers, ok, redirected, status, statusText, type, url };
   }
   const loaderWithParser = await getLoaderImplementation(loader, options, context.url);
-  if (canParseWithWorker(loaderWithParser, options)) {
+  if (shouldParseWithWorker(loaderWithParser, data, options, context, loader)) {
     data = await getArrayBufferFromData(data, options);
     return await parseWithWorker(loaderWithParser, data, options, context, parse2);
   }
@@ -16407,15 +18077,13 @@ var init_i3s_node_page_loader_with_parser = __esm({
 });
 
 // ../i3s/src/lib/helpers/i3s-nodepages-tiles.ts
-async function loadNodePage(url, options) {
-  var _a2;
-  const fetchFunction = typeof options.fetch === "function" ? options.fetch : typeof ((_a2 = options.core) == null ? void 0 : _a2.fetch) === "function" ? options.core.fetch : fetch;
+async function loadNodePage(url, fetchFunction) {
   const response = await fetchFunction(url);
   if (!response.ok) {
     throw new Error(`Failed to load I3S node page: ${response.status} ${response.statusText}`);
   }
   const arrayBuffer = await response.arrayBuffer();
-  return await I3SNodePageLoaderWithParser.parse(arrayBuffer, options);
+  return await I3SNodePageLoaderWithParser.parse(arrayBuffer);
 }
 function getSupportedGPUTextureFormats(gl) {
   const formats = /* @__PURE__ */ new Set();
@@ -16456,6 +18124,7 @@ var init_i3s_nodepages_tiles = __esm({
     init_i3s_node_page_loader_with_parser();
     init_parse_i3s();
     init_url_utils();
+    init_src5();
     BROWSER_PREFIXES2 = ["", "WEBKIT_", "MOZ_"];
     WEBGL_EXTENSIONS = {
       /* eslint-disable camelcase */
@@ -16479,6 +18148,7 @@ var init_i3s_nodepages_tiles = __esm({
       textureDefinitionsSelectedFormats = [];
       nodesInNodePages;
       url;
+      fetchFunction;
       textureLoaderOptions = {};
       /**
        * @constructs
@@ -16486,14 +18156,16 @@ var init_i3s_nodepages_tiles = __esm({
        * @param tileset - i3s tileset header ('layers/0')
        * @param url - tileset url
        * @param options - i3s loader options
+       * @param context - loader context carrying the authenticated fetch function
        */
-      constructor(tileset, url = "", options) {
+      constructor(tileset, url = "", options, context) {
         this.tileset = { ...tileset };
         this.url = url;
         const nodePageDefinition = tileset.nodePages || tileset.pointNodePages;
         this.nodesPerPage = (nodePageDefinition == null ? void 0 : nodePageDefinition.nodesPerPage) || 64;
         this.lodSelectionMetricType = nodePageDefinition == null ? void 0 : nodePageDefinition.lodSelectionMetricType;
         this.options = options;
+        this.fetchFunction = (context == null ? void 0 : context.fetch) || getAuthenticatedFetch(options);
         this.nodesInNodePages = 0;
         this.initSelectedFormatsForTextureDefinitions(tileset);
       }
@@ -16512,7 +18184,7 @@ var init_i3s_nodepages_tiles = __esm({
           );
           this.pendingNodePages[pageIndex] = {
             status: "Pending",
-            promise: loadNodePage(nodePageUrl, this.options)
+            promise: loadNodePage(nodePageUrl, this.fetchFunction)
           };
           this.nodePages[pageIndex] = await this.pendingNodePages[pageIndex].promise;
           this.nodesInNodePages += this.nodePages[pageIndex].nodes.length;
@@ -16943,7 +18615,7 @@ async function normalizeTilesetData(tileset, options, context) {
   let root;
   const nodePageDefinition = tileset.nodePages || tileset.pointNodePages;
   if (nodePageDefinition) {
-    nodePagesTile = new I3SNodePagesTiles(tileset, url, options);
+    nodePagesTile = new I3SNodePagesTiles(tileset, url, options, context);
     root = await nodePagesTile.formTileFromNodePages(nodePageDefinition.rootIndex || 0);
   } else {
     const parseOptions = options.i3s && typeof options.i3s === "object" ? options.i3s : {};
@@ -17074,8 +18746,9 @@ var VERSION10, I3SLoader;
 var init_i3s_loader = __esm({
   "../i3s/src/i3s-loader.ts"() {
     "use strict";
-    init_constants();
     init_i3s_format();
+    init_i3s_content_loader();
+    init_i3s_loader_options();
     VERSION10 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
     I3SLoader = {
       ...I3SFormat,
@@ -17084,25 +18757,15 @@ var init_i3s_loader = __esm({
       name: "I3S (Indexed Scene Layers)",
       id: "i3s",
       module: "i3s",
+      /** Worker-capable loader used by I3S sources for binary tile content. */
+      contentLoader: I3SContentLoader,
       version: VERSION10,
       mimeTypes: ["application/octet-stream"],
       /** Loads the parser-bearing I3S loader implementation. */
       preload: async () => (await Promise.resolve().then(() => (init_i3s_loader_with_parser(), i3s_loader_with_parser_exports))).I3SLoaderWithParser,
       extensions: ["bin"],
       options: {
-        i3s: {
-          token: void 0,
-          isTileset: "auto",
-          isTileHeader: "auto",
-          tile: void 0,
-          tileset: void 0,
-          _tileOptions: void 0,
-          _tilesetOptions: void 0,
-          useDracoGeometry: true,
-          useCompressedTextures: true,
-          decodeTextures: true,
-          coordinateSystem: COORDINATE_SYSTEM.METER_OFFSETS
-        }
+        i3s: I3S_LOADER_OPTIONS
       }
     };
   }
@@ -19286,113 +20949,650 @@ var init_parse_slpk = __esm({
   }
 });
 
-// dist/index.js
-var index_exports = {};
-__export(index_exports, {
-  ArcGISFeatureServerSourceLoader: () => ArcGISFeatureServerSourceLoader,
-  ArcGISImageServerSourceLoader: () => ArcGISImageServerSourceLoader,
-  ArcGISImageSource: () => ArcGISImageSource,
-  ArcGISImageTileSource: () => ArcGISImageTileSource,
-  ArcGISImageTileSourceLoader: () => ArcGISImageTileSourceLoader,
-  ArcGISMapTileSource: () => ArcGISMapTileSource,
-  ArcGISMapTileSourceLoader: () => ArcGISMapTileSourceLoader,
-  ArcGISSceneServerQueryError: () => ArcGISSceneServerQueryError,
-  ArcGISSceneServerSource: () => ArcGISSceneServerSource,
-  ArcGISSceneServerSourceLoader: () => ArcGISSceneServerSourceLoader,
-  ArcGISVectorSource: () => ArcGISVectorSource,
-  ArcGISVectorTileServerSource: () => ArcGISVectorTileServerSource,
-  ArcGISVectorTileServerSourceLoader: () => ArcGISVectorTileServerSourceLoader,
-  SERVICE_LOADERS: () => SERVICE_LOADERS,
-  aggregateArcGISSceneFeatures: () => aggregateArcGISSceneFeatures,
-  createArcGISCredential: () => createArcGISCredential,
-  createCesiumIonCredential: () => createCesiumIonCredential,
-  createGoogleMapsCredential: () => createGoogleMapsCredential,
-  createMapboxCredential: () => createMapboxCredential,
-  discoverArcGISCapabilities: () => discoverArcGISCapabilities,
-  getArcGISServices: () => getArcGISServices,
-  getServiceLoader: () => getServiceLoader,
-  selectArcGISService: () => selectArcGISService
-});
-module.exports = __toCommonJS(index_exports);
-
-// dist/arcgis/arcgis-server.js
-async function getArcGISServices(url, fetchFile2 = fetch) {
-  if (url.includes("rest/services")) {
-    const serverUrl = url.replace(/rest\/services.*$/i, "rest/services");
-    return loadServiceDirectory(serverUrl, fetchFile2, []);
+// ../i3s/src/i3s-lepcc.ts
+function readMagic(bytes) {
+  if (bytes.byteLength < 10) {
+    throw new Error("Truncated LEPCC blob header");
   }
-  return null;
+  return new TextDecoder().decode(bytes.subarray(0, 10));
 }
-async function loadServiceDirectory(serverUrl, fetch2, path) {
-  const serviceUrl = path.length ? `${serverUrl}/${path.join("/")}` : serverUrl;
-  const response = await fetch2(`${serviceUrl}?f=pjson`);
-  const directory = await response.json();
-  const services = extractServices(directory, serviceUrl, serverUrl);
-  const folders = directory.folders || [];
-  const promises = folders.map((folder) => loadServiceDirectory(`${serverUrl}`, fetch2, [...path, folder]));
-  for (const folderServices of await Promise.all(promises)) {
-    services.push(...folderServices);
+function readHeader(reader, expectedMagic, headerSize, verifyChecksum) {
+  const magic = new TextDecoder().decode(reader.readBytes(10));
+  if (magic !== expectedMagic) {
+    throw new Error(`Unexpected LEPCC blob type: ${JSON.stringify(magic)}`);
   }
-  return services;
-}
-function extractServices(directory, url, serverUrl) {
-  const arcgisServices = directory.services || [];
-  const services = [];
-  for (const service of arcgisServices) {
-    services.push({
-      name: service.name,
-      type: `arcgis-${service.type.toLocaleLowerCase().replace("server", "-server")}`,
-      url: `${service.name.includes("/") ? serverUrl : url}/${service.name}/${service.type}`
-    });
+  const version2 = reader.readUint16();
+  if (version2 > 1) {
+    throw new Error(`Unsupported LEPCC version: ${version2}`);
   }
-  return services;
-}
-
-// dist/arcgis/arcgis-capability-graph.js
-async function discoverArcGISCapabilities(url, options = {}) {
-  const fetchFile2 = options.fetch || fetch;
-  const services = await getArcGISServices(url, fetchFile2);
-  if (!services)
-    return null;
-  const nodes = await Promise.all(services.map(async (service) => {
-    let metadata = await fetchServiceMetadata(service.url, fetchFile2);
-    if (service.type.toLowerCase().includes("scene")) {
-      metadata = await enrichSceneServerMetadata(service.url, metadata, fetchFile2);
+  const expectedChecksum = reader.readUint32();
+  const blobSize = reader.readBigUint64();
+  if (blobSize < headerSize || blobSize > reader.bytes.byteLength) {
+    throw new Error(`Invalid LEPCC blob size: ${blobSize}`);
+  }
+  if (verifyChecksum) {
+    const actualChecksum = computeFletcher32(reader.bytes.subarray(16, blobSize));
+    if (actualChecksum !== expectedChecksum) {
+      throw new Error("LEPCC checksum mismatch");
     }
-    return normalizeServiceCapabilities(service, metadata);
-  }));
-  return { rootUrl: url, nodes };
-}
-function selectArcGISService(graph, requirements = {}) {
-  return graph.nodes.find((node) => {
-    if (requirements.kind && node.kind !== requirements.kind)
-      return false;
-    if (requirements.format && !node.capabilities.formats.includes(requirements.format.toLowerCase()))
-      return false;
-    if (requirements.crs && !node.capabilities.crs.includes(requirements.crs))
-      return false;
-    if (requirements.profile && node.metadata.profile !== requirements.profile && !node.capabilities.layers.some((layer) => layer.profile === requirements.profile))
-      return false;
-    if (requirements.layerId !== void 0 && !node.capabilities.layers.some((layer) => layer.id === String(requirements.layerId) || layer.name === String(requirements.layerId)))
-      return false;
-    return true;
-  });
+  }
+  return { blobSize };
 }
-async function fetchServiceMetadata(serviceUrl, fetchFile2) {
-  const url = new URL(serviceUrl);
-  url.searchParams.set("f", "pjson");
-  const response = await fetchFile2(url.toString());
-  if (!response.ok) {
-    throw new Error(`ArcGIS service metadata request failed: ${response.status}`);
+function assertBlobConsumed(reader, blobSize) {
+  if (reader.offset !== blobSize) {
+    throw new Error(`LEPCC decoder consumed ${reader.offset} bytes, expected ${blobSize}`);
   }
-  return await response.json();
 }
-async function enrichSceneServerMetadata(serviceUrl, metadata, fetchFile2) {
-  const layers = Array.isArray(metadata.layers) ? metadata.layers : [];
-  if (!layers.length)
-    return metadata;
-  const enrichedLayers = await Promise.all(layers.map(async (value) => {
-    if (!value || typeof value !== "object")
+function computeFletcher32(bytes) {
+  let sum1 = 65535;
+  let sum2 = 65535;
+  let offset = 0;
+  let words = Math.floor(bytes.length / 2);
+  while (words > 0) {
+    const count = Math.min(words, 359);
+    words -= count;
+    for (let index = 0; index < count; index++) {
+      sum1 += bytes[offset++] << 8;
+      sum1 += bytes[offset++];
+      sum2 += sum1;
+    }
+    sum1 = (sum1 & 65535) + (sum1 >>> 16);
+    sum2 = (sum2 & 65535) + (sum2 >>> 16);
+  }
+  if (bytes.length & 1) {
+    sum1 += bytes[offset] << 8;
+    sum2 += sum1;
+  }
+  sum1 = (sum1 & 65535) + (sum1 >>> 16);
+  sum2 = (sum2 & 65535) + (sum2 >>> 16);
+  return (sum2 << 16 | sum1) >>> 0;
+}
+function decodeCutInSegments(reader) {
+  const sectionMinimums = decodeSimple(reader);
+  const values = [];
+  for (const sectionMinimum of sectionMinimums) {
+    const sectionValues = decodeSimple(reader);
+    for (const sectionValue of sectionValues) {
+      values.push(sectionValue + sectionMinimum);
+    }
+  }
+  return values;
+}
+function decodeSimple(reader) {
+  const header = reader.readUint8();
+  const numberOfBits = header & 31;
+  const encodedNumberOfBytes = header >>> 6;
+  const numberOfBytes = encodedNumberOfBytes === 0 ? 4 : 3 - encodedNumberOfBytes;
+  if (numberOfBytes !== 1 && numberOfBytes !== 2 && numberOfBytes !== 4) {
+    throw new Error("Invalid LEPCC bit-stuffer element width");
+  }
+  const elementCount = numberOfBytes === 1 ? reader.readUint8() : numberOfBytes === 2 ? reader.readUint16() : reader.readUint32();
+  if (header & 32) {
+    throw new Error("LEPCC lookup-table bit stuffing is not supported");
+  }
+  if (numberOfBits === 0) {
+    return new Array(elementCount).fill(0);
+  }
+  const bitReader = new BitReader(reader);
+  const values = new Array(elementCount);
+  for (let index = 0; index < elementCount; index++) {
+    values[index] = bitReader.readBits(numberOfBits);
+  }
+  bitReader.alignToByte();
+  return values;
+}
+function decodeHuffman(reader, elementCount) {
+  const version2 = reader.readUint32();
+  const tableSize = reader.readUint32();
+  const firstSymbol = reader.readUint32();
+  const lastSymbol = reader.readUint32();
+  if (version2 < 2 || tableSize === 0 || tableSize > 32768 || firstSymbol >= lastSymbol) {
+    throw new Error("Invalid LEPCC Huffman code table");
+  }
+  const codeLengths = decodeSimple(reader);
+  if (codeLengths.length !== lastSymbol - firstSymbol) {
+    throw new Error("LEPCC Huffman code table length mismatch");
+  }
+  const lengthsBySymbol = new Array(tableSize).fill(0);
+  let codeBitCount = 0;
+  for (let symbol = firstSymbol; symbol < lastSymbol; symbol++) {
+    const tableIndex = symbol < tableSize ? symbol : symbol - tableSize;
+    const codeLength = codeLengths[symbol - firstSymbol];
+    if (codeLength > 32) {
+      throw new Error("LEPCC Huffman code is too long");
+    }
+    lengthsBySymbol[tableIndex] = codeLength;
+    codeBitCount += codeLength;
+  }
+  const symbols = lengthsBySymbol.map((codeLength, symbol) => ({ codeLength, symbol })).filter((value) => value.codeLength > 0).sort((left, right) => right.codeLength - left.codeLength || left.symbol - right.symbol);
+  if (symbols.length < 2) {
+    throw new Error("LEPCC Huffman table has fewer than two symbols");
+  }
+  const codeLookup = /* @__PURE__ */ new Map();
+  let canonicalCode = 0;
+  let canonicalLength = symbols[0].codeLength;
+  for (const symbol of symbols) {
+    const delta = canonicalLength - symbol.codeLength;
+    canonicalCode = Math.floor(canonicalCode / 2 ** delta);
+    canonicalLength = symbol.codeLength;
+    codeLookup.set(`${canonicalLength}:${canonicalCode}`, symbol.symbol);
+    canonicalCode++;
+  }
+  const codeReader = new MsbBitReader(reader);
+  for (const codeLength of lengthsBySymbol) {
+    if (codeLength > 0) {
+      codeReader.readBits(codeLength);
+    }
+  }
+  codeReader.finishWords();
+  if (codeBitCount === 0) {
+    throw new Error("LEPCC Huffman table has no code bits");
+  }
+  const valueReader = new MsbBitReader(reader);
+  const values = new Array(elementCount);
+  for (let index = 0; index < elementCount; index++) {
+    let code = 0;
+    let decodedSymbol;
+    for (let codeLength = 1; codeLength <= 32; codeLength++) {
+      code = code * 2 + valueReader.readBits(1);
+      decodedSymbol = codeLookup.get(`${codeLength}:${code}`);
+      if (decodedSymbol !== void 0) {
+        break;
+      }
+    }
+    if (decodedSymbol === void 0) {
+      throw new Error("Invalid LEPCC Huffman value");
+    }
+    values[index] = decodedSymbol;
+  }
+  valueReader.finishWords(1);
+  return values;
+}
+var I3SLEPCCDecoder, BinaryReader, BitReader, MsbBitReader;
+var init_i3s_lepcc = __esm({
+  "../i3s/src/i3s-lepcc.ts"() {
+    "use strict";
+    I3SLEPCCDecoder = class {
+      /** Whether blob checksums are verified before decoding. */
+      verifyChecksum;
+      /**
+       * @param options - Optional decoder settings.
+       */
+      constructor(options = {}) {
+        this.verifyChecksum = options.verifyChecksum ?? true;
+      }
+      /**
+       * Identifies the attribute represented by a LEPCC blob.
+       *
+       * @param bytes - One standalone I3S LEPCC resource.
+       * @returns The normalized I3S attribute type.
+       */
+      getBlobType(bytes) {
+        const magic = readMagic(bytes);
+        switch (magic) {
+          case "LEPCC     ":
+            return "xyz";
+          case "ClusterRGB":
+            return "rgb";
+          case "Intensity ":
+            return "intensity";
+          case "FlagBytes ":
+            return "flagBytes";
+          default:
+            throw new Error(`Unsupported LEPCC blob magic: ${JSON.stringify(magic)}`);
+        }
+      }
+      /**
+       * Decodes an I3S LEPCC position resource.
+       *
+       * @param bytes - A `lepcc-xyz` resource.
+       * @returns Interleaved longitude, latitude, and elevation values.
+       */
+      decodeXyz(bytes) {
+        const reader = new BinaryReader(bytes);
+        const header = readHeader(reader, "LEPCC     ", 104, this.verifyChecksum);
+        const extent = {
+          lower: [reader.readFloat64(), reader.readFloat64(), reader.readFloat64()],
+          upper: [reader.readFloat64(), reader.readFloat64(), reader.readFloat64()]
+        };
+        const maxError = [reader.readFloat64(), reader.readFloat64(), reader.readFloat64()];
+        const pointCount = reader.readUint32();
+        reader.readUint32();
+        const yDelta = decodeCutInSegments(reader);
+        const pointsPerRow = decodeCutInSegments(reader);
+        const xDelta = decodeCutInSegments(reader);
+        const zValues = decodeCutInSegments(reader);
+        if (pointsPerRow.reduce((sum, value) => sum + value, 0) !== pointCount) {
+          throw new Error("LEPCC XYZ row count does not match the point count");
+        }
+        if (yDelta.length !== pointsPerRow.length || xDelta.length !== pointCount || zValues.length !== pointCount) {
+          throw new Error("LEPCC XYZ delta arrays have inconsistent lengths");
+        }
+        assertBlobConsumed(reader, header.blobSize);
+        const output = new Float64Array(pointCount * 3);
+        const cellWidth = maxError.map((value) => value * 2);
+        let y = 0;
+        let pointIndex = 0;
+        for (let rowIndex = 0; rowIndex < yDelta.length; rowIndex++) {
+          y += yDelta[rowIndex];
+          let x = 0;
+          for (let columnIndex = 0; columnIndex < pointsPerRow[rowIndex]; columnIndex++) {
+            x += xDelta[pointIndex];
+            const offset = pointIndex * 3;
+            output[offset] = Math.min(extent.upper[0], extent.lower[0] + x * cellWidth[0]);
+            output[offset + 1] = Math.min(extent.upper[1], extent.lower[1] + y * cellWidth[1]);
+            output[offset + 2] = Math.min(
+              extent.upper[2],
+              extent.lower[2] + zValues[pointIndex] * cellWidth[2]
+            );
+            pointIndex++;
+          }
+        }
+        return output;
+      }
+      /**
+       * Decodes an I3S LEPCC RGB resource.
+       *
+       * @param bytes - A `lepcc-rgb` resource.
+       * @returns Interleaved 8-bit red, green, and blue values.
+       */
+      decodeRgb(bytes) {
+        const reader = new BinaryReader(bytes);
+        const header = readHeader(reader, "ClusterRGB", 32, this.verifyChecksum);
+        const pointCount = reader.readUint32();
+        const colorCount = reader.readUint16();
+        const lookupMethod = reader.readUint8();
+        const compressionMethod = reader.readUint8();
+        const output = new Uint8Array(pointCount * 3);
+        if (colorCount === 0) {
+          output.set(reader.readBytes(pointCount * 3));
+        } else {
+          const colorMap = reader.readBytes(colorCount * 3);
+          if (lookupMethod !== 1 && lookupMethod !== 2) {
+            throw new Error(`Unsupported LEPCC RGB lookup method: ${lookupMethod}`);
+          }
+          if (compressionMethod === 0) {
+            for (let pointIndex = 0; pointIndex < pointCount; pointIndex++) {
+              const colorIndex = reader.readUint8();
+              if (colorIndex >= colorCount) {
+                throw new Error("LEPCC RGB color index is outside the color map");
+              }
+              output.set(colorMap.subarray(colorIndex * 3, colorIndex * 3 + 3), pointIndex * 3);
+            }
+          } else if (compressionMethod === 1) {
+            for (let pointIndex = 0; pointIndex < pointCount; pointIndex++) {
+              output.set(colorMap.subarray(0, 3), pointIndex * 3);
+            }
+          } else if (compressionMethod === 2) {
+            const indexes = decodeHuffman(reader, pointCount);
+            for (let pointIndex = 0; pointIndex < pointCount; pointIndex++) {
+              const colorIndex = indexes[pointIndex];
+              if (colorIndex >= colorCount) {
+                throw new Error("LEPCC RGB Huffman color index is outside the color map");
+              }
+              output.set(colorMap.subarray(colorIndex * 3, colorIndex * 3 + 3), pointIndex * 3);
+            }
+          } else {
+            throw new Error(`Unsupported LEPCC RGB compression method: ${compressionMethod}`);
+          }
+        }
+        assertBlobConsumed(reader, header.blobSize);
+        return output;
+      }
+      /**
+       * Decodes an I3S LEPCC intensity resource.
+       *
+       * @param bytes - A `lepcc-intensity` resource.
+       * @returns One unsigned 16-bit intensity value per point.
+       */
+      decodeIntensity(bytes) {
+        const reader = new BinaryReader(bytes);
+        const header = readHeader(reader, "Intensity ", 32, this.verifyChecksum);
+        const pointCount = reader.readUint32();
+        const scaleFactor = reader.readUint16();
+        const bitsPerPoint = reader.readUint8();
+        reader.readUint8();
+        if (scaleFactor < 1 || bitsPerPoint > 16) {
+          throw new Error("Invalid LEPCC intensity header");
+        }
+        const values = new Uint16Array(pointCount);
+        if (bitsPerPoint === 16) {
+          for (let index = 0; index < pointCount; index++) {
+            values[index] = reader.readUint16();
+          }
+        } else if (bitsPerPoint === 8) {
+          for (let index = 0; index < pointCount; index++) {
+            values[index] = reader.readUint8() * scaleFactor;
+          }
+        } else {
+          const packedValues = decodeSimple(reader);
+          if (packedValues.length !== pointCount) {
+            throw new Error("LEPCC intensity value count does not match the header");
+          }
+          for (let index = 0; index < pointCount; index++) {
+            values[index] = packedValues[index] * scaleFactor;
+          }
+        }
+        assertBlobConsumed(reader, header.blobSize);
+        return values;
+      }
+      /**
+       * Decodes an I3S LEPCC packed LAS flags resource.
+       *
+       * @param bytes - A LEPCC flag-bytes resource.
+       * @returns One packed flag byte per point.
+       */
+      decodeFlagBytes(bytes) {
+        const reader = new BinaryReader(bytes);
+        const header = readHeader(reader, "FlagBytes ", 32, this.verifyChecksum);
+        const pointCount = reader.readUint32();
+        const compressionMethod = reader.readUint8();
+        const minimumValue = reader.readUint8();
+        reader.readUint16();
+        const packedValues = compressionMethod === 0 ? decodeSimple(reader) : decodeHuffman(reader, pointCount);
+        if (packedValues.length !== pointCount) {
+          throw new Error("LEPCC flag-byte value count does not match the header");
+        }
+        const output = new Uint8Array(pointCount);
+        for (let index = 0; index < pointCount; index++) {
+          output[index] = packedValues[index] + minimumValue;
+        }
+        assertBlobConsumed(reader, header.blobSize);
+        return output;
+      }
+      /**
+       * Decodes a blob using its self-described attribute type.
+       *
+       * @param bytes - One standalone I3S LEPCC resource.
+       * @returns The typed decoded values.
+       */
+      decode(bytes) {
+        switch (this.getBlobType(bytes)) {
+          case "xyz":
+            return this.decodeXyz(bytes);
+          case "rgb":
+            return this.decodeRgb(bytes);
+          case "intensity":
+            return this.decodeIntensity(bytes);
+          case "flagBytes":
+            return this.decodeFlagBytes(bytes);
+        }
+      }
+    };
+    BinaryReader = class {
+      bytes;
+      offset = 0;
+      constructor(bytes) {
+        this.bytes = bytes;
+      }
+      readUint8() {
+        this.ensure(1);
+        return this.bytes[this.offset++];
+      }
+      readUint16() {
+        this.ensure(2);
+        const value = this.bytes[this.offset] | this.bytes[this.offset + 1] << 8;
+        this.offset += 2;
+        return value;
+      }
+      readUint32() {
+        this.ensure(4);
+        const value = this.bytes[this.offset] | this.bytes[this.offset + 1] << 8 | this.bytes[this.offset + 2] << 16 | this.bytes[this.offset + 3] << 24;
+        this.offset += 4;
+        return value >>> 0;
+      }
+      readBigUint64() {
+        this.ensure(8);
+        let value = 0;
+        for (let index = 7; index >= 0; index--) {
+          value = value * 256 + this.bytes[this.offset + index];
+        }
+        this.offset += 8;
+        if (!Number.isSafeInteger(value)) {
+          throw new Error("LEPCC blob size exceeds JavaScript safe integer range");
+        }
+        return value;
+      }
+      readFloat64() {
+        this.ensure(8);
+        const view = new DataView(this.bytes.buffer, this.bytes.byteOffset + this.offset, 8);
+        const value = view.getFloat64(0, true);
+        this.offset += 8;
+        return value;
+      }
+      readBytes(length) {
+        this.ensure(length);
+        const value = this.bytes.subarray(this.offset, this.offset + length);
+        this.offset += length;
+        return value;
+      }
+      ensure(length) {
+        if (length < 0 || this.offset + length > this.bytes.byteLength) {
+          throw new Error("Truncated LEPCC blob");
+        }
+      }
+    };
+    BitReader = class {
+      reader;
+      bitOffset = 0;
+      constructor(reader) {
+        this.reader = reader;
+      }
+      readBits(numberOfBits) {
+        let value = 0;
+        for (let bitIndex = 0; bitIndex < numberOfBits; bitIndex++) {
+          if (this.bitOffset === 0) {
+            this.reader.ensure(1);
+          }
+          const currentByte = this.reader.bytes[this.reader.offset];
+          value += (currentByte >>> this.bitOffset & 1) * 2 ** bitIndex;
+          this.bitOffset++;
+          if (this.bitOffset === 8) {
+            this.bitOffset = 0;
+            this.reader.offset++;
+          }
+        }
+        return value;
+      }
+      alignToByte() {
+        if (this.bitOffset !== 0) {
+          this.reader.offset++;
+          this.bitOffset = 0;
+        }
+      }
+    };
+    MsbBitReader = class {
+      reader;
+      startOffset;
+      bitOffset = 0;
+      bitsRead = 0;
+      constructor(reader) {
+        this.reader = reader;
+        this.startOffset = reader.offset;
+      }
+      readBits(numberOfBits) {
+        let value = 0;
+        for (let bitIndex = 0; bitIndex < numberOfBits; bitIndex++) {
+          if (this.bitOffset === 0) {
+            this.reader.ensure(4);
+          }
+          const word = this.reader.bytes[this.reader.offset] | this.reader.bytes[this.reader.offset + 1] << 8 | this.reader.bytes[this.reader.offset + 2] << 16 | this.reader.bytes[this.reader.offset + 3] << 24;
+          value = value * 2 + (word >>> 31 - this.bitOffset & 1);
+          this.bitOffset++;
+          this.bitsRead++;
+          if (this.bitOffset === 32) {
+            this.bitOffset = 0;
+            this.reader.offset += 4;
+          }
+        }
+        return value;
+      }
+      finishWords(extraWords = 0) {
+        this.reader.offset = this.startOffset + Math.ceil(this.bitsRead / 32) * 4 + extraWords * 4;
+        this.bitOffset = 0;
+      }
+    };
+  }
+});
+
+// ../i3s/src/i3s-lepcc-loader.ts
+var i3s_lepcc_loader_exports = {};
+__export(i3s_lepcc_loader_exports, {
+  I3SLEPCCLoaderWithParser: () => I3SLEPCCLoaderWithParser
+});
+var I3SLEPCCLoaderWithParser;
+var init_i3s_lepcc_loader = __esm({
+  "../i3s/src/i3s-lepcc-loader.ts"() {
+    "use strict";
+    init_i3s_lepcc();
+    init_i3s_lepcc_loader_types();
+    I3SLEPCCLoaderWithParser = {
+      ...I3SLEPCCLoader,
+      parse: async (arrayBuffer, options) => {
+        var _a2;
+        const decoder = new I3SLEPCCDecoder({
+          verifyChecksum: (_a2 = options == null ? void 0 : options["i3s-lepcc"]) == null ? void 0 : _a2.verifyChecksum
+        });
+        const bytes = new Uint8Array(arrayBuffer);
+        return {
+          type: decoder.getBlobType(bytes),
+          value: decoder.decode(bytes)
+        };
+      }
+    };
+  }
+});
+
+// ../i3s/src/i3s-lepcc-loader-types.ts
+var VERSION11, I3SLEPCCLoader;
+var init_i3s_lepcc_loader_types = __esm({
+  "../i3s/src/i3s-lepcc-loader-types.ts"() {
+    "use strict";
+    init_i3s_format();
+    VERSION11 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+    I3SLEPCCLoader = {
+      ...I3SLEPCCFormat,
+      dataType: null,
+      batchType: null,
+      version: VERSION11,
+      worker: true,
+      options: {
+        "i3s-lepcc": {
+          verifyChecksum: true
+        }
+      },
+      preload: async () => (await Promise.resolve().then(() => (init_i3s_lepcc_loader(), i3s_lepcc_loader_exports))).I3SLEPCCLoaderWithParser
+    };
+  }
+});
+
+// dist/index.js
+var index_exports = {};
+__export(index_exports, {
+  ArcGISFeatureServerSourceLoader: () => ArcGISFeatureServerSourceLoader,
+  ArcGISImageServerSourceLoader: () => ArcGISImageServerSourceLoader,
+  ArcGISImageSource: () => ArcGISImageSource,
+  ArcGISImageTileSource: () => ArcGISImageTileSource,
+  ArcGISImageTileSourceLoader: () => ArcGISImageTileSourceLoader,
+  ArcGISMapTileSource: () => ArcGISMapTileSource,
+  ArcGISMapTileSourceLoader: () => ArcGISMapTileSourceLoader,
+  ArcGISSceneServerQueryError: () => ArcGISSceneServerQueryError,
+  ArcGISSceneServerSource: () => ArcGISSceneServerSource,
+  ArcGISSceneServerSourceLoader: () => ArcGISSceneServerSourceLoader,
+  ArcGISVectorSource: () => ArcGISVectorSource,
+  ArcGISVectorTileServerSource: () => ArcGISVectorTileServerSource,
+  ArcGISVectorTileServerSourceLoader: () => ArcGISVectorTileServerSourceLoader,
+  SERVICE_LOADERS: () => SERVICE_LOADERS,
+  aggregateArcGISSceneFeatures: () => aggregateArcGISSceneFeatures,
+  createArcGISCredential: () => createArcGISCredential,
+  createCesiumIonCredential: () => createCesiumIonCredential,
+  createGoogleMapsCredential: () => createGoogleMapsCredential,
+  createMapboxCredential: () => createMapboxCredential,
+  discoverArcGISCapabilities: () => discoverArcGISCapabilities,
+  getArcGISServices: () => getArcGISServices,
+  getServiceLoader: () => getServiceLoader,
+  selectArcGISService: () => selectArcGISService
+});
+module.exports = __toCommonJS(index_exports);
+
+// dist/arcgis/arcgis-server.js
+async function getArcGISServices(url, fetchFile2 = fetch) {
+  if (url.includes("rest/services")) {
+    const serverUrl = url.replace(/rest\/services.*$/i, "rest/services");
+    return loadServiceDirectory(serverUrl, fetchFile2, []);
+  }
+  return null;
+}
+async function loadServiceDirectory(serverUrl, fetch2, path) {
+  const serviceUrl = path.length ? `${serverUrl}/${path.join("/")}` : serverUrl;
+  const response = await fetch2(`${serviceUrl}?f=pjson`);
+  const directory = await response.json();
+  const services = extractServices(directory, serviceUrl, serverUrl);
+  const folders = directory.folders || [];
+  const promises = folders.map((folder) => loadServiceDirectory(`${serverUrl}`, fetch2, [...path, folder]));
+  for (const folderServices of await Promise.all(promises)) {
+    services.push(...folderServices);
+  }
+  return services;
+}
+function extractServices(directory, url, serverUrl) {
+  const arcgisServices = directory.services || [];
+  const services = [];
+  for (const service of arcgisServices) {
+    services.push({
+      name: service.name,
+      type: `arcgis-${service.type.toLocaleLowerCase().replace("server", "-server")}`,
+      url: `${service.name.includes("/") ? serverUrl : url}/${service.name}/${service.type}`
+    });
+  }
+  return services;
+}
+
+// dist/arcgis/arcgis-capability-graph.js
+async function discoverArcGISCapabilities(url, options = {}) {
+  const fetchFile2 = options.fetch || fetch;
+  const services = await getArcGISServices(url, fetchFile2);
+  if (!services)
+    return null;
+  const nodes = await Promise.all(services.map(async (service) => {
+    let metadata = await fetchServiceMetadata(service.url, fetchFile2);
+    if (service.type.toLowerCase().includes("scene")) {
+      metadata = await enrichSceneServerMetadata(service.url, metadata, fetchFile2);
+    }
+    return normalizeServiceCapabilities(service, metadata);
+  }));
+  return { rootUrl: url, nodes };
+}
+function selectArcGISService(graph, requirements = {}) {
+  return graph.nodes.find((node) => {
+    if (requirements.kind && node.kind !== requirements.kind)
+      return false;
+    if (requirements.format && !node.capabilities.formats.includes(requirements.format.toLowerCase()))
+      return false;
+    if (requirements.crs && !node.capabilities.crs.includes(requirements.crs))
+      return false;
+    if (requirements.profile && node.metadata.profile !== requirements.profile && !node.capabilities.layers.some((layer) => layer.profile === requirements.profile))
+      return false;
+    if (requirements.layerId !== void 0 && !node.capabilities.layers.some((layer) => layer.id === String(requirements.layerId) || layer.name === String(requirements.layerId)))
+      return false;
+    return true;
+  });
+}
+async function fetchServiceMetadata(serviceUrl, fetchFile2) {
+  const url = new URL(serviceUrl);
+  url.searchParams.set("f", "pjson");
+  const response = await fetchFile2(url.toString());
+  if (!response.ok) {
+    throw new Error(`ArcGIS service metadata request failed: ${response.status}`);
+  }
+  return await response.json();
+}
+async function enrichSceneServerMetadata(serviceUrl, metadata, fetchFile2) {
+  const layers = Array.isArray(metadata.layers) ? metadata.layers : [];
+  if (!layers.length)
+    return metadata;
+  const enrichedLayers = await Promise.all(layers.map(async (value) => {
+    if (!value || typeof value !== "object")
       return value;
     const layer = value;
     if (layer.id === void 0)
@@ -19589,6 +21789,7 @@ var ArcGISVectorSource = class extends DataSource {
   }
   /** Requests features from the ArcGIS FeatureServer query endpoint. */
   async getFeatures(parameters) {
+    var _a2;
     const url = this.getFeaturesURL(parameters);
     const response = await this.fetch(url, parameters.signal ? { signal: parameters.signal } : void 0);
     await this.checkResponse(response);
@@ -19601,7 +21802,9 @@ var ArcGISVectorSource = class extends DataSource {
         return geoJsonTable;
       case "arrow":
       default:
-        return convertFeaturesToWKBArrowTable(geoJsonTable.features);
+        return convertFeaturesToWKBArrowTable(geoJsonTable.features, {
+          encodingPreference: (_a2 = parameters.geoarrow) == null ? void 0 : _a2.encodingPreference
+        });
     }
   }
   /** Requests the raw ArcGIS FeatureServer metadata document. */
@@ -19899,257 +22102,107 @@ var ArcGISMapTileSource = class extends DataSource {
     super(url.replace(/\/$/, ""), options, ArcGISMapTileSourceLoader.defaultOptions, coreApi2);
     this.getTileData = this.getTileData.bind(this);
   }
-  /** Loads and normalizes ArcGIS service metadata. */
-  async getMetadata() {
-    var _a2, _b, _c, _d;
-    const metadata = await this._getMetadata();
-    const extent = metadata.fullExtent;
-    const spatialReference = metadata.spatialReference || (extent == null ? void 0 : extent.spatialReference);
-    const spatialReferenceWkid = spatialReference == null ? void 0 : spatialReference.wkid;
-    return {
-      name: metadata.name || "",
-      title: metadata.name || "",
-      abstract: metadata.description || metadata.serviceDescription || "",
-      attributions: metadata.copyrightText ? [metadata.copyrightText] : void 0,
-      minZoom: 0,
-      maxZoom: ((_b = (_a2 = metadata.tileInfo) == null ? void 0 : _a2.lods) == null ? void 0 : _b.length) ? Math.max(...metadata.tileInfo.lods.map((lod) => lod.level)) : void 0,
-      boundingBox: extent ? [
-        [extent.xmin, extent.ymin],
-        [extent.xmax, extent.ymax]
-      ] : void 0,
-      layer: {
-        name: metadata.name || "",
-        srs: spatialReferenceWkid ? [`EPSG:${spatialReferenceWkid}`] : [],
-        layers: []
-      },
-      tileGrid: metadata.tileInfo ? {
-        crs: ((_c = metadata.tileInfo.spatialReference) == null ? void 0 : _c.wkid) ? `EPSG:${metadata.tileInfo.spatialReference.wkid}` : void 0,
-        tileSize: metadata.tileInfo.rows && metadata.tileInfo.cols ? [metadata.tileInfo.cols, metadata.tileInfo.rows] : void 0,
-        origin: metadata.tileInfo.origin ? [metadata.tileInfo.origin.x, metadata.tileInfo.origin.y] : void 0,
-        matrixIds: (_d = metadata.tileInfo.lods) == null ? void 0 : _d.map((lod) => String(lod.level))
-      } : void 0
-    };
-  }
-  /** Fetches and decodes one cached ArcGIS tile. */
-  async getTile(parameters, signal) {
-    const options = this.options["arcgis-map-server"] || {};
-    const mode = options.mode || "auto";
-    const metadata = mode === "auto" ? await this._getMetadata() : null;
-    const useCachedTiles = mode === "cached" || mode === "auto" && isCompatibleCache(metadata);
-    const tileURL = useCachedTiles ? this.getTileURL(parameters) : this.getExportTileURL(parameters, options.tileSize || 256);
-    const response = await this.fetch(tileURL, signal ? { signal } : void 0);
-    if (!response.ok) {
-      throw new Error(`ArcGIS MapServer tile request failed: ${response.status} ${response.statusText}`);
-    }
-    return await this.coreApi.parse(await response.arrayBuffer(), ImageLoader, this.loadOptions);
-  }
-  /** Fetches a tile using the deck.gl-compatible request shape. */
-  async getTileData(parameters) {
-    return this.getTile(parameters.index, parameters.signal);
-  }
-  /** Builds the standard ArcGIS cached tile URL. */
-  getTileURL(parameters) {
-    var _a2;
-    const template = (_a2 = this.options["arcgis-map-server"]) == null ? void 0 : _a2.urlTemplate;
-    if (template) {
-      const templateURL = new URL(template.replaceAll("{z}", String(parameters.z)).replaceAll("{y}", String(parameters.y)).replaceAll("{x}", String(parameters.x)));
-      return templateURL.toString();
-    }
-    const url = new URL(this.getServiceURL(parameters));
-    url.pathname = `${url.pathname.replace(/\/$/, "")}/tile/${parameters.z}/${parameters.y}/${parameters.x}`;
-    return url.toString();
-  }
-  /** Updates parameters applied to subsequent dynamic MapServer export requests. */
-  updateParameters(parameters) {
-    this._runtimeParameters = { ...this._runtimeParameters, ...parameters };
-  }
-  /** Builds a dynamic MapServer `export` request for one web-mercator tile. */
-  getExportTileURL(parameters, tileSize) {
-    const options = this.options["arcgis-map-server"] || {};
-    const resolvedTileSize = tileSize || options.tileSize || 256;
-    const [west, south, east, north] = getWebMercatorTileBounds(parameters);
-    const url = new URL(this.getServiceURL(parameters));
-    url.pathname = `${url.pathname.replace(/\/$/, "")}/export`;
-    const searchParameters = {
-      f: "image",
-      bbox: `${west},${south},${east},${north}`,
-      bboxSR: 3857,
-      imageSR: 3857,
-      size: `${resolvedTileSize},${resolvedTileSize}`,
-      format: "png32",
-      transparent: true,
-      ...options.exportParameters,
-      ...this._runtimeParameters
-    };
-    for (const [key, value] of Object.entries(searchParameters)) {
-      url.searchParams.set(key, String(value));
-    }
-    return url.toString();
-  }
-  /** Fetches the MapServer metadata document and applies configured parameters. */
-  async _loadMetadata() {
-    var _a2, _b;
-    const configuredMetadata = (_a2 = this.options["arcgis-map-server"]) == null ? void 0 : _a2.metadata;
-    if (configuredMetadata)
-      return configuredMetadata;
-    const url = new URL(this.url);
-    url.searchParams.set("f", "pjson");
-    for (const [key, value] of Object.entries(((_b = this.options["arcgis-map-server"]) == null ? void 0 : _b.parameters) || {})) {
-      url.searchParams.set(key, value);
-    }
-    const response = await this.fetch(url.toString());
-    if (!response.ok) {
-      throw new Error(`ArcGIS MapServer metadata request failed: ${response.status} ${response.statusText}`);
-    }
-    return response.json();
-  }
-  /** Returns cached metadata and shares a single request among concurrent callers. */
-  async _getMetadata() {
-    if (this._metadata)
-      return this._metadata;
-    if (!this._metadataPromise) {
-      this._metadataPromise = this._loadMetadata();
-    }
-    try {
-      const metadata = await this._metadataPromise;
-      this._metadata = metadata;
-      return metadata;
-    } finally {
-      this._metadataPromise = null;
-    }
-  }
-  /** Selects a service endpoint for a tile using a stable URL-pool mapping. */
-  getServiceURL(parameters) {
-    var _a2;
-    const urls = (_a2 = this.options["arcgis-map-server"]) == null ? void 0 : _a2.urls;
-    return (urls == null ? void 0 : urls.length) ? urls[(parameters.x + parameters.y) % urls.length] : this.url;
-  }
-};
-function isCompatibleCache(metadata) {
-  const tileInfo = metadata == null ? void 0 : metadata.tileInfo;
-  if (!tileInfo || tileInfo.rows !== 256 || tileInfo.cols !== 256)
-    return false;
-  const spatialReference = tileInfo.spatialReference || (metadata == null ? void 0 : metadata.spatialReference);
-  const wkid = spatialReference == null ? void 0 : spatialReference.wkid;
-  if (wkid !== 3857 && wkid !== 102100 && wkid !== 102113)
-    return false;
-  const origin = tileInfo.origin;
-  return !origin || Math.abs(origin.x + 20037508342789244e-9) < 1 && Math.abs(origin.y - 20037508342789244e-9) < 1;
-}
-function getWebMercatorTileBounds(parameters) {
-  const worldSize = 20037508342789244e-9;
-  const tileCount = 2 ** parameters.z;
-  const tileSize = worldSize * 2 / tileCount;
-  const west = -worldSize + parameters.x * tileSize;
-  const east = west + tileSize;
-  const north = worldSize - parameters.y * tileSize;
-  const south = north - tileSize;
-  return [west, south, east, north];
-}
-var ArcGISMapTileSourceLoader = {
-  dataType: null,
-  batchType: null,
-  name: "ArcGIS MapServer tiles",
-  id: "arcgis-map-server",
-  module: "services",
-  version: "0.0.0",
-  extensions: [],
-  mimeTypes: [],
-  type: "arcgis-map-server",
-  fromUrl: true,
-  fromBlob: false,
-  options: { "arcgis-map-server": {} },
-  defaultOptions: { "arcgis-map-server": {} },
-  testURL: (url) => /mapserver/i.test(url) && !/imageserver|featureserver/i.test(url),
-  createDataSource: (url, options = {}, coreApi2) => new ArcGISMapTileSource(url, options, coreApi2)
-};
-
-// dist/arcgis/arcgis-image-tile-source-loader.js
-init_src6();
-init_src5();
-var ArcGISImageTileSource = class extends DataSource {
-  /** MIME type represented by the tile response. */
-  mimeType;
-  /** Cached ImageServer metadata. */
-  _metadata = null;
-  /** In-flight metadata request shared by concurrent callers. */
-  _metadataPromise = null;
-  /** Parameters applied to subsequent export requests. */
-  _runtimeParameters = {};
-  /** Creates an ArcGIS ImageServer tile source. */
-  constructor(url, options = {}, coreApi2) {
-    super(url.replace(/\/$/, ""), options, ArcGISImageTileSourceLoader.defaultOptions, coreApi2);
-    this.mimeType = this._getResponseFormat() === "lerc" ? "application/octet-stream" : "image/png";
-    this.getTileData = this.getTileData.bind(this);
-  }
-  /** Returns normalized ImageServer metadata. */
+  /** Loads and normalizes ArcGIS service metadata. */
   async getMetadata() {
+    var _a2, _b, _c, _d;
     const metadata = await this._getMetadata();
-    const extent = metadata.fullExtent || metadata.extent;
+    const extent = metadata.fullExtent;
     const spatialReference = metadata.spatialReference || (extent == null ? void 0 : extent.spatialReference);
+    const spatialReferenceWkid = spatialReference == null ? void 0 : spatialReference.wkid;
     return {
-      name: metadata.name || metadata.serviceDescription || "",
-      title: metadata.name || metadata.serviceDescription || "",
+      name: metadata.name || "",
+      title: metadata.name || "",
       abstract: metadata.description || metadata.serviceDescription || "",
       attributions: metadata.copyrightText ? [metadata.copyrightText] : void 0,
+      minZoom: 0,
+      maxZoom: ((_b = (_a2 = metadata.tileInfo) == null ? void 0 : _a2.lods) == null ? void 0 : _b.length) ? Math.max(...metadata.tileInfo.lods.map((lod) => lod.level)) : void 0,
       boundingBox: extent ? [
         [extent.xmin, extent.ymin],
         [extent.xmax, extent.ymax]
       ] : void 0,
       layer: {
         name: metadata.name || "",
-        srs: (spatialReference == null ? void 0 : spatialReference.wkid) ? [`EPSG:${spatialReference.wkid}`] : [],
+        srs: spatialReferenceWkid ? [`EPSG:${spatialReferenceWkid}`] : [],
         layers: []
-      }
+      },
+      tileGrid: metadata.tileInfo ? {
+        crs: ((_c = metadata.tileInfo.spatialReference) == null ? void 0 : _c.wkid) ? `EPSG:${metadata.tileInfo.spatialReference.wkid}` : void 0,
+        tileSize: metadata.tileInfo.rows && metadata.tileInfo.cols ? [metadata.tileInfo.cols, metadata.tileInfo.rows] : void 0,
+        origin: metadata.tileInfo.origin ? [metadata.tileInfo.origin.x, metadata.tileInfo.origin.y] : void 0,
+        matrixIds: (_d = metadata.tileInfo.lods) == null ? void 0 : _d.map((lod) => String(lod.level))
+      } : void 0
     };
   }
-  /** Fetches one ImageServer export tile. */
+  /** Fetches and decodes one cached ArcGIS tile. */
   async getTile(parameters, signal) {
-    const response = await this.fetch(this.getTileURL(parameters), signal ? { signal } : void 0);
+    const options = this.options["arcgis-map-server"] || {};
+    const mode = options.mode || "auto";
+    const metadata = mode === "auto" ? await this._getMetadata() : null;
+    const useCachedTiles = mode === "cached" || mode === "auto" && isCompatibleCache(metadata);
+    const tileURL = useCachedTiles ? this.getTileURL(parameters) : this.getExportTileURL(parameters, options.tileSize || 256);
+    const response = await this.fetch(tileURL, signal ? { signal } : void 0);
     if (!response.ok) {
-      throw new Error(`ArcGIS ImageServer tile request failed: ${response.status} ${response.statusText}`);
+      throw new Error(`ArcGIS MapServer tile request failed: ${response.status} ${response.statusText}`);
     }
-    const loader = this._getResponseFormat() === "lerc" ? LERCLoader : ImageLoader;
-    return await this.coreApi.parse(await response.arrayBuffer(), loader, this.loadOptions);
+    return await this.coreApi.parse(await response.arrayBuffer(), ImageLoader, this.loadOptions);
   }
   /** Fetches a tile using the deck.gl-compatible request shape. */
   async getTileData(parameters) {
     return this.getTile(parameters.index, parameters.signal);
   }
-  /** Updates parameters applied to subsequent ImageServer export requests. */
+  /** Builds the standard ArcGIS cached tile URL. */
+  getTileURL(parameters) {
+    var _a2;
+    const template = (_a2 = this.options["arcgis-map-server"]) == null ? void 0 : _a2.urlTemplate;
+    if (template) {
+      const templateURL = new URL(template.replaceAll("{z}", String(parameters.z)).replaceAll("{y}", String(parameters.y)).replaceAll("{x}", String(parameters.x)));
+      return templateURL.toString();
+    }
+    const url = new URL(this.getServiceURL(parameters));
+    url.pathname = `${url.pathname.replace(/\/$/, "")}/tile/${parameters.z}/${parameters.y}/${parameters.x}`;
+    return url.toString();
+  }
+  /** Updates parameters applied to subsequent dynamic MapServer export requests. */
   updateParameters(parameters) {
     this._runtimeParameters = { ...this._runtimeParameters, ...parameters };
   }
-  /** Builds an ImageServer exportImage URL for one web-mercator tile. */
-  getTileURL(parameters, tileSize) {
-    const options = this.options["arcgis-image-server-tiles"] || {};
+  /** Builds a dynamic MapServer `export` request for one web-mercator tile. */
+  getExportTileURL(parameters, tileSize) {
+    const options = this.options["arcgis-map-server"] || {};
     const resolvedTileSize = tileSize || options.tileSize || 256;
-    const [west, south, east, north] = getWebMercatorTileBounds2(parameters);
+    const [west, south, east, north] = getWebMercatorTileBounds(parameters);
     const url = new URL(this.getServiceURL(parameters));
-    url.pathname = `${url.pathname.replace(/\/$/, "")}/exportImage`;
-    const requestParameters = {
+    url.pathname = `${url.pathname.replace(/\/$/, "")}/export`;
+    const searchParameters = {
       f: "image",
       bbox: `${west},${south},${east},${north}`,
       bboxSR: 3857,
       imageSR: 3857,
       size: `${resolvedTileSize},${resolvedTileSize}`,
-      format: this._getResponseFormat(),
+      format: "png32",
       transparent: true,
-      ...options.parameters,
+      ...options.exportParameters,
       ...this._runtimeParameters
     };
-    for (const [key, value] of Object.entries(requestParameters)) {
+    for (const [key, value] of Object.entries(searchParameters)) {
       url.searchParams.set(key, String(value));
     }
     return url.toString();
   }
-  /** Fetches the ImageServer metadata document. */
+  /** Fetches the MapServer metadata document and applies configured parameters. */
   async _loadMetadata() {
+    var _a2, _b;
+    const configuredMetadata = (_a2 = this.options["arcgis-map-server"]) == null ? void 0 : _a2.metadata;
+    if (configuredMetadata)
+      return configuredMetadata;
     const url = new URL(this.url);
     url.searchParams.set("f", "pjson");
+    for (const [key, value] of Object.entries(((_b = this.options["arcgis-map-server"]) == null ? void 0 : _b.parameters) || {})) {
+      url.searchParams.set(key, value);
+    }
     const response = await this.fetch(url.toString());
     if (!response.ok) {
-      throw new Error(`ArcGIS ImageServer metadata request failed: ${response.status}`);
+      throw new Error(`ArcGIS MapServer metadata request failed: ${response.status} ${response.statusText}`);
     }
     return response.json();
   }
@@ -20171,35 +22224,22 @@ var ArcGISImageTileSource = class extends DataSource {
   /** Selects a service endpoint for a tile using a stable URL-pool mapping. */
   getServiceURL(parameters) {
     var _a2;
-    const urls = (_a2 = this.options["arcgis-image-server-tiles"]) == null ? void 0 : _a2.urls;
+    const urls = (_a2 = this.options["arcgis-map-server"]) == null ? void 0 : _a2.urls;
     return (urls == null ? void 0 : urls.length) ? urls[(parameters.x + parameters.y) % urls.length] : this.url;
   }
-  /** Returns the response format after applying configured and runtime overrides. */
-  _getResponseFormat() {
-    var _a2;
-    const options = this.options["arcgis-image-server-tiles"] || {};
-    const format = this._runtimeParameters.format || ((_a2 = options.parameters) == null ? void 0 : _a2.format) || options.format;
-    return format === "lerc" ? "lerc" : "png32";
-  }
-};
-var ArcGISImageTileSourceLoader = {
-  dataType: null,
-  batchType: null,
-  name: "ArcGIS ImageServer tiles",
-  id: "arcgis-image-server-tiles",
-  module: "services",
-  version: "0.0.0",
-  extensions: [],
-  mimeTypes: [],
-  type: "arcgis-image-server-tiles",
-  fromUrl: true,
-  fromBlob: false,
-  options: { "arcgis-image-server-tiles": {} },
-  defaultOptions: { "arcgis-image-server-tiles": {} },
-  testURL: (url) => /imageserver/i.test(url),
-  createDataSource: (url, options = {}, coreApi2) => new ArcGISImageTileSource(url, options, coreApi2)
 };
-function getWebMercatorTileBounds2(parameters) {
+function isCompatibleCache(metadata) {
+  const tileInfo = metadata == null ? void 0 : metadata.tileInfo;
+  if (!tileInfo || tileInfo.rows !== 256 || tileInfo.cols !== 256)
+    return false;
+  const spatialReference = tileInfo.spatialReference || (metadata == null ? void 0 : metadata.spatialReference);
+  const wkid = spatialReference == null ? void 0 : spatialReference.wkid;
+  if (wkid !== 3857 && wkid !== 102100 && wkid !== 102113)
+    return false;
+  const origin = tileInfo.origin;
+  return !origin || Math.abs(origin.x + 20037508342789244e-9) < 1 && Math.abs(origin.y - 20037508342789244e-9) < 1;
+}
+function getWebMercatorTileBounds(parameters) {
   const worldSize = 20037508342789244e-9;
   const tileCount = 2 ** parameters.z;
   const tileSize = worldSize * 2 / tileCount;
@@ -20209,643 +22249,326 @@ function getWebMercatorTileBounds2(parameters) {
   const south = north - tileSize;
   return [west, south, east, north];
 }
-
-// dist/arcgis/arcgis-vector-tile-server-source-loader.js
-init_src5();
-
-// ../mvt/src/index.ts
-init_mvt_loader();
-
-// dist/arcgis/arcgis-vector-tile-server-source-loader.js
-var ArcGISVectorTileServerSource = class extends DataSource {
-  /** Decoded tile family consumed by generic tile renderers. */
-  mimeType = "application/vnd.mapbox-vector-tile";
-  /** ArcGIS tiles are decoded to WGS84 coordinates before rendering. */
-  localCoordinates = false;
-  /** Cached service metadata request. */
-  serviceMetadata = null;
-  /** Query parameters supplied with the service URL, such as an access token. */
-  serviceQueryParameters;
-  /** Creates an ArcGIS VectorTileServer source. */
-  constructor(url, options = {}, coreApi2) {
-    const serviceURL = new URL(url);
-    serviceURL.pathname = serviceURL.pathname.replace(/\/$/, "");
-    super(`${serviceURL.origin}${serviceURL.pathname}`, options, ArcGISVectorTileServerSourceLoader.defaultOptions, coreApi2);
-    this.serviceQueryParameters = new URLSearchParams(serviceURL.search);
-  }
-  /** Returns normalized service and tile-grid metadata. */
-  async getMetadata() {
-    var _a2, _b;
-    const metadata = await this.getServiceMetadata();
-    const tileInfo = metadata.tileInfo;
-    const lods = (tileInfo == null ? void 0 : tileInfo.lods) || [];
-    const extent = metadata.fullExtent || metadata.initialExtent;
-    return {
-      name: metadata.mapName || this.url.split("/").pop() || "",
-      title: metadata.mapName,
-      abstract: metadata.serviceDescription,
-      format: "application/vnd.mapbox-vector-tile",
-      minZoom: (_a2 = lods[0]) == null ? void 0 : _a2.level,
-      maxZoom: (_b = lods.at(-1)) == null ? void 0 : _b.level,
-      boundingBox: extent ? [
-        [extent.xmin, extent.ymin],
-        [extent.xmax, extent.ymax]
-      ] : void 0,
-      layer: {
-        name: metadata.mapName || "",
-        srs: (tileInfo == null ? void 0 : tileInfo.spatialReference) ? [getSpatialReference(tileInfo.spatialReference)] : [],
-        layers: []
-      },
-      formatHeader: {
-        tileInfo,
-        styleURL: this.getStyleURL(),
-        spriteURL: this.getSpriteURL()
-      }
-    };
-  }
-  /** Fetches one raw PBF tile from the ArcGIS tile endpoint. */
-  async getTile(parameters, signal) {
-    const response = await this.fetch(this.getTileURL(parameters), {
-      signal,
-      headers: { Accept: "application/vnd.mapbox-vector-tile, application/x-protobuf" }
-    });
-    if (!response.ok)
-      return null;
-    return response.arrayBuffer();
-  }
-  /** Returns the schema advertised by decoded vector tiles. */
-  async getSchema() {
-    return { fields: [], metadata: {} };
-  }
-  /** Fetches and decodes one ArcGIS vector tile to geographic coordinates. */
-  async getVectorTile(parameters) {
-    var _a2;
-    const arrayBuffer = await this.getTile(parameters, parameters.signal);
-    if (!arrayBuffer) {
-      return null;
-    }
-    const inheritedOptions = this.loadOptions.mvt;
-    const sourceOptions = (_a2 = this.options["arcgis-vector-tile-server"]) == null ? void 0 : _a2.mvt;
-    return await this.coreApi.parse(arrayBuffer, MVTLoader, {
-      ...this.loadOptions,
-      mvt: {
-        ...inheritedOptions,
-        ...sourceOptions,
-        coordinates: "wgs84",
-        tileIndex: { x: parameters.x, y: parameters.y, z: parameters.z },
-        layers: normalizeLayers(parameters.layers) || (sourceOptions == null ? void 0 : sourceOptions.layers) || (inheritedOptions == null ? void 0 : inheritedOptions.layers)
-      }
-    });
-  }
-  /** Provides decoded vector tiles through the deck.gl source interface. */
-  async getTileData(parameters) {
-    return this.getVectorTile({ ...parameters.index, signal: parameters.signal });
-  }
-  /** Builds the ArcGIS cached vector tile URL. */
-  getTileURL(parameters) {
-    return this.getResourceURL(`/tile/${parameters.z}/${parameters.y}/${parameters.x}.pbf`);
-  }
-  /** Returns the service metadata URL. */
-  getMetadataURL() {
-    const url = new URL(this.getResourceURL(""));
-    url.searchParams.set("f", "pjson");
-    return url.toString();
-  }
-  /** Returns the ArcGIS Mapbox style resource URL. */
-  getStyleURL() {
-    return this.getResourceURL("/resources/styles/root.json");
-  }
-  /** Returns the ArcGIS sprite resource base URL. */
-  getSpriteURL() {
-    return this.getResourceURL("/resources/sprites/sprite");
-  }
-  /** Loads and caches the ArcGIS VectorTileServer metadata document. */
-  async getServiceMetadata() {
-    this.serviceMetadata ||= this.fetch(this.getMetadataURL()).then(async (response) => {
-      if (!response.ok)
-        throw new Error(`ArcGIS VectorTileServer request failed: ${response.status}`);
-      return await response.json();
-    });
-    return this.serviceMetadata;
-  }
-  /** Builds a resource URL while retaining service query parameters. */
-  getResourceURL(resourcePath) {
-    const url = new URL(this.url);
-    url.pathname = `${url.pathname.replace(/\/$/, "")}${resourcePath}`;
-    for (const [key, value] of this.serviceQueryParameters) {
-      url.searchParams.set(key, value);
-    }
-    return url.toString();
-  }
-};
-var ArcGISVectorTileServerSourceLoader = {
+var ArcGISMapTileSourceLoader = {
   dataType: null,
   batchType: null,
-  name: "ArcGIS VectorTileServer",
-  id: "arcgis-vector-tile-server",
+  name: "ArcGIS MapServer tiles",
+  id: "arcgis-map-server",
   module: "services",
   version: "0.0.0",
   extensions: [],
-  mimeTypes: ["application/vnd.mapbox-vector-tile", "application/x-protobuf"],
-  type: "arcgis-vector-tile-server",
+  mimeTypes: [],
+  type: "arcgis-map-server",
   fromUrl: true,
   fromBlob: false,
-  options: { "arcgis-vector-tile-server": {} },
-  defaultOptions: { "arcgis-vector-tile-server": {} },
-  testURL: (url) => /\/vectortileserver(?:[\/?#]|$)/i.test(url),
-  createDataSource: (url, options = {}, coreApi2) => new ArcGISVectorTileServerSource(url, options, coreApi2)
+  options: { "arcgis-map-server": {} },
+  defaultOptions: { "arcgis-map-server": {} },
+  testURL: (url) => /mapserver/i.test(url) && !/imageserver|featureserver/i.test(url),
+  createDataSource: (url, options = {}, coreApi2) => new ArcGISMapTileSource(url, options, coreApi2)
 };
-function getSpatialReference(spatialReference) {
-  return `EPSG:${spatialReference.latestWkid || spatialReference.wkid}`;
-}
-function normalizeLayers(layers) {
-  if (!layers)
-    return void 0;
-  return Array.isArray(layers) ? layers : [layers];
-}
 
-// dist/arcgis/arcgis-scene-server-source-loader.js
+// dist/arcgis/arcgis-image-tile-source-loader.js
+init_src6();
 init_src5();
-
-// ../i3s/src/i3s-lepcc.ts
-var I3SLEPCCDecoder = class {
-  /** Whether blob checksums are verified before decoding. */
-  verifyChecksum;
-  /**
-   * @param options - Optional decoder settings.
-   */
-  constructor(options = {}) {
-    this.verifyChecksum = options.verifyChecksum ?? true;
-  }
-  /**
-   * Identifies the attribute represented by a LEPCC blob.
-   *
-   * @param bytes - One standalone I3S LEPCC resource.
-   * @returns The normalized I3S attribute type.
-   */
-  getBlobType(bytes) {
-    const magic = readMagic(bytes);
-    switch (magic) {
-      case "LEPCC     ":
-        return "xyz";
-      case "ClusterRGB":
-        return "rgb";
-      case "Intensity ":
-        return "intensity";
-      case "FlagBytes ":
-        return "flagBytes";
-      default:
-        throw new Error(`Unsupported LEPCC blob magic: ${JSON.stringify(magic)}`);
-    }
+var ArcGISImageTileSource = class extends DataSource {
+  /** MIME type represented by the tile response. */
+  mimeType;
+  /** Cached ImageServer metadata. */
+  _metadata = null;
+  /** In-flight metadata request shared by concurrent callers. */
+  _metadataPromise = null;
+  /** Parameters applied to subsequent export requests. */
+  _runtimeParameters = {};
+  /** Creates an ArcGIS ImageServer tile source. */
+  constructor(url, options = {}, coreApi2) {
+    super(url.replace(/\/$/, ""), options, ArcGISImageTileSourceLoader.defaultOptions, coreApi2);
+    this.mimeType = this._getResponseFormat() === "lerc" ? "application/octet-stream" : "image/png";
+    this.getTileData = this.getTileData.bind(this);
   }
-  /**
-   * Decodes an I3S LEPCC position resource.
-   *
-   * @param bytes - A `lepcc-xyz` resource.
-   * @returns Interleaved longitude, latitude, and elevation values.
-   */
-  decodeXyz(bytes) {
-    const reader = new BinaryReader(bytes);
-    const header = readHeader(reader, "LEPCC     ", 104, this.verifyChecksum);
-    const extent = {
-      lower: [reader.readFloat64(), reader.readFloat64(), reader.readFloat64()],
-      upper: [reader.readFloat64(), reader.readFloat64(), reader.readFloat64()]
-    };
-    const maxError = [reader.readFloat64(), reader.readFloat64(), reader.readFloat64()];
-    const pointCount = reader.readUint32();
-    reader.readUint32();
-    const yDelta = decodeCutInSegments(reader);
-    const pointsPerRow = decodeCutInSegments(reader);
-    const xDelta = decodeCutInSegments(reader);
-    const zValues = decodeCutInSegments(reader);
-    if (pointsPerRow.reduce((sum, value) => sum + value, 0) !== pointCount) {
-      throw new Error("LEPCC XYZ row count does not match the point count");
-    }
-    if (yDelta.length !== pointsPerRow.length || xDelta.length !== pointCount || zValues.length !== pointCount) {
-      throw new Error("LEPCC XYZ delta arrays have inconsistent lengths");
-    }
-    assertBlobConsumed(reader, header.blobSize);
-    const output = new Float64Array(pointCount * 3);
-    const cellWidth = maxError.map((value) => value * 2);
-    let y = 0;
-    let pointIndex = 0;
-    for (let rowIndex = 0; rowIndex < yDelta.length; rowIndex++) {
-      y += yDelta[rowIndex];
-      let x = 0;
-      for (let columnIndex = 0; columnIndex < pointsPerRow[rowIndex]; columnIndex++) {
-        x += xDelta[pointIndex];
-        const offset = pointIndex * 3;
-        output[offset] = Math.min(extent.upper[0], extent.lower[0] + x * cellWidth[0]);
-        output[offset + 1] = Math.min(extent.upper[1], extent.lower[1] + y * cellWidth[1]);
-        output[offset + 2] = Math.min(
-          extent.upper[2],
-          extent.lower[2] + zValues[pointIndex] * cellWidth[2]
-        );
-        pointIndex++;
+  /** Returns normalized ImageServer metadata. */
+  async getMetadata() {
+    const metadata = await this._getMetadata();
+    const extent = metadata.fullExtent || metadata.extent;
+    const spatialReference = metadata.spatialReference || (extent == null ? void 0 : extent.spatialReference);
+    return {
+      name: metadata.name || metadata.serviceDescription || "",
+      title: metadata.name || metadata.serviceDescription || "",
+      abstract: metadata.description || metadata.serviceDescription || "",
+      attributions: metadata.copyrightText ? [metadata.copyrightText] : void 0,
+      boundingBox: extent ? [
+        [extent.xmin, extent.ymin],
+        [extent.xmax, extent.ymax]
+      ] : void 0,
+      layer: {
+        name: metadata.name || "",
+        srs: (spatialReference == null ? void 0 : spatialReference.wkid) ? [`EPSG:${spatialReference.wkid}`] : [],
+        layers: []
       }
-    }
-    return output;
+    };
   }
-  /**
-   * Decodes an I3S LEPCC RGB resource.
-   *
-   * @param bytes - A `lepcc-rgb` resource.
-   * @returns Interleaved 8-bit red, green, and blue values.
-   */
-  decodeRgb(bytes) {
-    const reader = new BinaryReader(bytes);
-    const header = readHeader(reader, "ClusterRGB", 32, this.verifyChecksum);
-    const pointCount = reader.readUint32();
-    const colorCount = reader.readUint16();
-    const lookupMethod = reader.readUint8();
-    const compressionMethod = reader.readUint8();
-    const output = new Uint8Array(pointCount * 3);
-    if (colorCount === 0) {
-      output.set(reader.readBytes(pointCount * 3));
-    } else {
-      const colorMap = reader.readBytes(colorCount * 3);
-      if (lookupMethod !== 1 && lookupMethod !== 2) {
-        throw new Error(`Unsupported LEPCC RGB lookup method: ${lookupMethod}`);
-      }
-      if (compressionMethod === 0) {
-        for (let pointIndex = 0; pointIndex < pointCount; pointIndex++) {
-          const colorIndex = reader.readUint8();
-          if (colorIndex >= colorCount) {
-            throw new Error("LEPCC RGB color index is outside the color map");
-          }
-          output.set(colorMap.subarray(colorIndex * 3, colorIndex * 3 + 3), pointIndex * 3);
-        }
-      } else if (compressionMethod === 1) {
-        for (let pointIndex = 0; pointIndex < pointCount; pointIndex++) {
-          output.set(colorMap.subarray(0, 3), pointIndex * 3);
-        }
-      } else if (compressionMethod === 2) {
-        const indexes = decodeHuffman(reader, pointCount);
-        for (let pointIndex = 0; pointIndex < pointCount; pointIndex++) {
-          const colorIndex = indexes[pointIndex];
-          if (colorIndex >= colorCount) {
-            throw new Error("LEPCC RGB Huffman color index is outside the color map");
-          }
-          output.set(colorMap.subarray(colorIndex * 3, colorIndex * 3 + 3), pointIndex * 3);
-        }
-      } else {
-        throw new Error(`Unsupported LEPCC RGB compression method: ${compressionMethod}`);
-      }
+  /** Fetches one ImageServer export tile. */
+  async getTile(parameters, signal) {
+    const response = await this.fetch(this.getTileURL(parameters), signal ? { signal } : void 0);
+    if (!response.ok) {
+      throw new Error(`ArcGIS ImageServer tile request failed: ${response.status} ${response.statusText}`);
     }
-    assertBlobConsumed(reader, header.blobSize);
-    return output;
+    const loader = this._getResponseFormat() === "lerc" ? LERCLoader : ImageLoader;
+    return await this.coreApi.parse(await response.arrayBuffer(), loader, this.loadOptions);
   }
-  /**
-   * Decodes an I3S LEPCC intensity resource.
-   *
-   * @param bytes - A `lepcc-intensity` resource.
-   * @returns One unsigned 16-bit intensity value per point.
-   */
-  decodeIntensity(bytes) {
-    const reader = new BinaryReader(bytes);
-    const header = readHeader(reader, "Intensity ", 32, this.verifyChecksum);
-    const pointCount = reader.readUint32();
-    const scaleFactor = reader.readUint16();
-    const bitsPerPoint = reader.readUint8();
-    reader.readUint8();
-    if (scaleFactor < 1 || bitsPerPoint > 16) {
-      throw new Error("Invalid LEPCC intensity header");
-    }
-    const values = new Uint16Array(pointCount);
-    if (bitsPerPoint === 16) {
-      for (let index = 0; index < pointCount; index++) {
-        values[index] = reader.readUint16();
-      }
-    } else if (bitsPerPoint === 8) {
-      for (let index = 0; index < pointCount; index++) {
-        values[index] = reader.readUint8() * scaleFactor;
-      }
-    } else {
-      const packedValues = decodeSimple(reader);
-      if (packedValues.length !== pointCount) {
-        throw new Error("LEPCC intensity value count does not match the header");
-      }
-      for (let index = 0; index < pointCount; index++) {
-        values[index] = packedValues[index] * scaleFactor;
-      }
-    }
-    assertBlobConsumed(reader, header.blobSize);
-    return values;
+  /** Fetches a tile using the deck.gl-compatible request shape. */
+  async getTileData(parameters) {
+    return this.getTile(parameters.index, parameters.signal);
   }
-  /**
-   * Decodes an I3S LEPCC packed LAS flags resource.
-   *
-   * @param bytes - A LEPCC flag-bytes resource.
-   * @returns One packed flag byte per point.
-   */
-  decodeFlagBytes(bytes) {
-    const reader = new BinaryReader(bytes);
-    const header = readHeader(reader, "FlagBytes ", 32, this.verifyChecksum);
-    const pointCount = reader.readUint32();
-    const compressionMethod = reader.readUint8();
-    const minimumValue = reader.readUint8();
-    reader.readUint16();
-    const packedValues = compressionMethod === 0 ? decodeSimple(reader) : decodeHuffman(reader, pointCount);
-    if (packedValues.length !== pointCount) {
-      throw new Error("LEPCC flag-byte value count does not match the header");
-    }
-    const output = new Uint8Array(pointCount);
-    for (let index = 0; index < pointCount; index++) {
-      output[index] = packedValues[index] + minimumValue;
-    }
-    assertBlobConsumed(reader, header.blobSize);
-    return output;
+  /** Updates parameters applied to subsequent ImageServer export requests. */
+  updateParameters(parameters) {
+    this._runtimeParameters = { ...this._runtimeParameters, ...parameters };
   }
-  /**
-   * Decodes a blob using its self-described attribute type.
-   *
-   * @param bytes - One standalone I3S LEPCC resource.
-   * @returns The typed decoded values.
-   */
-  decode(bytes) {
-    switch (this.getBlobType(bytes)) {
-      case "xyz":
-        return this.decodeXyz(bytes);
-      case "rgb":
-        return this.decodeRgb(bytes);
-      case "intensity":
-        return this.decodeIntensity(bytes);
-      case "flagBytes":
-        return this.decodeFlagBytes(bytes);
+  /** Builds an ImageServer exportImage URL for one web-mercator tile. */
+  getTileURL(parameters, tileSize) {
+    const options = this.options["arcgis-image-server-tiles"] || {};
+    const resolvedTileSize = tileSize || options.tileSize || 256;
+    const [west, south, east, north] = getWebMercatorTileBounds2(parameters);
+    const url = new URL(this.getServiceURL(parameters));
+    url.pathname = `${url.pathname.replace(/\/$/, "")}/exportImage`;
+    const requestParameters = {
+      f: "image",
+      bbox: `${west},${south},${east},${north}`,
+      bboxSR: 3857,
+      imageSR: 3857,
+      size: `${resolvedTileSize},${resolvedTileSize}`,
+      format: this._getResponseFormat(),
+      transparent: true,
+      ...options.parameters,
+      ...this._runtimeParameters
+    };
+    for (const [key, value] of Object.entries(requestParameters)) {
+      url.searchParams.set(key, String(value));
     }
+    return url.toString();
   }
-};
-var BinaryReader = class {
-  bytes;
-  offset = 0;
-  constructor(bytes) {
-    this.bytes = bytes;
-  }
-  readUint8() {
-    this.ensure(1);
-    return this.bytes[this.offset++];
-  }
-  readUint16() {
-    this.ensure(2);
-    const value = this.bytes[this.offset] | this.bytes[this.offset + 1] << 8;
-    this.offset += 2;
-    return value;
-  }
-  readUint32() {
-    this.ensure(4);
-    const value = this.bytes[this.offset] | this.bytes[this.offset + 1] << 8 | this.bytes[this.offset + 2] << 16 | this.bytes[this.offset + 3] << 24;
-    this.offset += 4;
-    return value >>> 0;
-  }
-  readBigUint64() {
-    this.ensure(8);
-    let value = 0;
-    for (let index = 7; index >= 0; index--) {
-      value = value * 256 + this.bytes[this.offset + index];
-    }
-    this.offset += 8;
-    if (!Number.isSafeInteger(value)) {
-      throw new Error("LEPCC blob size exceeds JavaScript safe integer range");
-    }
-    return value;
-  }
-  readFloat64() {
-    this.ensure(8);
-    const view = new DataView(this.bytes.buffer, this.bytes.byteOffset + this.offset, 8);
-    const value = view.getFloat64(0, true);
-    this.offset += 8;
-    return value;
-  }
-  readBytes(length) {
-    this.ensure(length);
-    const value = this.bytes.subarray(this.offset, this.offset + length);
-    this.offset += length;
-    return value;
-  }
-  ensure(length) {
-    if (length < 0 || this.offset + length > this.bytes.byteLength) {
-      throw new Error("Truncated LEPCC blob");
+  /** Fetches the ImageServer metadata document. */
+  async _loadMetadata() {
+    const url = new URL(this.url);
+    url.searchParams.set("f", "pjson");
+    const response = await this.fetch(url.toString());
+    if (!response.ok) {
+      throw new Error(`ArcGIS ImageServer metadata request failed: ${response.status}`);
     }
+    return response.json();
   }
-};
-function readMagic(bytes) {
-  if (bytes.byteLength < 10) {
-    throw new Error("Truncated LEPCC blob header");
-  }
-  return new TextDecoder().decode(bytes.subarray(0, 10));
-}
-function readHeader(reader, expectedMagic, headerSize, verifyChecksum) {
-  const magic = new TextDecoder().decode(reader.readBytes(10));
-  if (magic !== expectedMagic) {
-    throw new Error(`Unexpected LEPCC blob type: ${JSON.stringify(magic)}`);
-  }
-  const version2 = reader.readUint16();
-  if (version2 > 1) {
-    throw new Error(`Unsupported LEPCC version: ${version2}`);
-  }
-  const expectedChecksum = reader.readUint32();
-  const blobSize = reader.readBigUint64();
-  if (blobSize < headerSize || blobSize > reader.bytes.byteLength) {
-    throw new Error(`Invalid LEPCC blob size: ${blobSize}`);
-  }
-  if (verifyChecksum) {
-    const actualChecksum = computeFletcher32(reader.bytes.subarray(16, blobSize));
-    if (actualChecksum !== expectedChecksum) {
-      throw new Error("LEPCC checksum mismatch");
+  /** Returns cached metadata and shares a single request among concurrent callers. */
+  async _getMetadata() {
+    if (this._metadata)
+      return this._metadata;
+    if (!this._metadataPromise) {
+      this._metadataPromise = this._loadMetadata();
     }
-  }
-  return { blobSize };
-}
-function assertBlobConsumed(reader, blobSize) {
-  if (reader.offset !== blobSize) {
-    throw new Error(`LEPCC decoder consumed ${reader.offset} bytes, expected ${blobSize}`);
-  }
-}
-function computeFletcher32(bytes) {
-  let sum1 = 65535;
-  let sum2 = 65535;
-  let offset = 0;
-  let words = Math.floor(bytes.length / 2);
-  while (words > 0) {
-    const count = Math.min(words, 359);
-    words -= count;
-    for (let index = 0; index < count; index++) {
-      sum1 += bytes[offset++] << 8;
-      sum1 += bytes[offset++];
-      sum2 += sum1;
+    try {
+      const metadata = await this._metadataPromise;
+      this._metadata = metadata;
+      return metadata;
+    } finally {
+      this._metadataPromise = null;
     }
-    sum1 = (sum1 & 65535) + (sum1 >>> 16);
-    sum2 = (sum2 & 65535) + (sum2 >>> 16);
   }
-  if (bytes.length & 1) {
-    sum1 += bytes[offset] << 8;
-    sum2 += sum1;
+  /** Selects a service endpoint for a tile using a stable URL-pool mapping. */
+  getServiceURL(parameters) {
+    var _a2;
+    const urls = (_a2 = this.options["arcgis-image-server-tiles"]) == null ? void 0 : _a2.urls;
+    return (urls == null ? void 0 : urls.length) ? urls[(parameters.x + parameters.y) % urls.length] : this.url;
   }
-  sum1 = (sum1 & 65535) + (sum1 >>> 16);
-  sum2 = (sum2 & 65535) + (sum2 >>> 16);
-  return (sum2 << 16 | sum1) >>> 0;
-}
-function decodeCutInSegments(reader) {
-  const sectionMinimums = decodeSimple(reader);
-  const values = [];
-  for (const sectionMinimum of sectionMinimums) {
-    const sectionValues = decodeSimple(reader);
-    for (const sectionValue of sectionValues) {
-      values.push(sectionValue + sectionMinimum);
-    }
+  /** Returns the response format after applying configured and runtime overrides. */
+  _getResponseFormat() {
+    var _a2;
+    const options = this.options["arcgis-image-server-tiles"] || {};
+    const format = this._runtimeParameters.format || ((_a2 = options.parameters) == null ? void 0 : _a2.format) || options.format;
+    return format === "lerc" ? "lerc" : "png32";
   }
-  return values;
+};
+var ArcGISImageTileSourceLoader = {
+  dataType: null,
+  batchType: null,
+  name: "ArcGIS ImageServer tiles",
+  id: "arcgis-image-server-tiles",
+  module: "services",
+  version: "0.0.0",
+  extensions: [],
+  mimeTypes: [],
+  type: "arcgis-image-server-tiles",
+  fromUrl: true,
+  fromBlob: false,
+  options: { "arcgis-image-server-tiles": {} },
+  defaultOptions: { "arcgis-image-server-tiles": {} },
+  testURL: (url) => /imageserver/i.test(url),
+  createDataSource: (url, options = {}, coreApi2) => new ArcGISImageTileSource(url, options, coreApi2)
+};
+function getWebMercatorTileBounds2(parameters) {
+  const worldSize = 20037508342789244e-9;
+  const tileCount = 2 ** parameters.z;
+  const tileSize = worldSize * 2 / tileCount;
+  const west = -worldSize + parameters.x * tileSize;
+  const east = west + tileSize;
+  const north = worldSize - parameters.y * tileSize;
+  const south = north - tileSize;
+  return [west, south, east, north];
 }
-function decodeSimple(reader) {
-  const header = reader.readUint8();
-  const numberOfBits = header & 31;
-  const encodedNumberOfBytes = header >>> 6;
-  const numberOfBytes = encodedNumberOfBytes === 0 ? 4 : 3 - encodedNumberOfBytes;
-  if (numberOfBytes !== 1 && numberOfBytes !== 2 && numberOfBytes !== 4) {
-    throw new Error("Invalid LEPCC bit-stuffer element width");
-  }
-  const elementCount = numberOfBytes === 1 ? reader.readUint8() : numberOfBytes === 2 ? reader.readUint16() : reader.readUint32();
-  if (header & 32) {
-    throw new Error("LEPCC lookup-table bit stuffing is not supported");
-  }
-  if (numberOfBits === 0) {
-    return new Array(elementCount).fill(0);
+
+// dist/arcgis/arcgis-vector-tile-server-source-loader.js
+init_src5();
+
+// ../mvt/src/index.ts
+init_mvt_loader();
+
+// dist/arcgis/arcgis-vector-tile-server-source-loader.js
+var ArcGISVectorTileServerSource = class extends DataSource {
+  /** Decoded tile family consumed by generic tile renderers. */
+  mimeType = "application/vnd.mapbox-vector-tile";
+  /** ArcGIS tiles are decoded to WGS84 coordinates before rendering. */
+  localCoordinates = false;
+  /** Cached service metadata request. */
+  serviceMetadata = null;
+  /** Query parameters supplied with the service URL, such as an access token. */
+  serviceQueryParameters;
+  /** Creates an ArcGIS VectorTileServer source. */
+  constructor(url, options = {}, coreApi2) {
+    const serviceURL = new URL(url);
+    serviceURL.pathname = serviceURL.pathname.replace(/\/$/, "");
+    super(`${serviceURL.origin}${serviceURL.pathname}`, options, ArcGISVectorTileServerSourceLoader.defaultOptions, coreApi2);
+    this.serviceQueryParameters = new URLSearchParams(serviceURL.search);
   }
-  const bitReader = new BitReader(reader);
-  const values = new Array(elementCount);
-  for (let index = 0; index < elementCount; index++) {
-    values[index] = bitReader.readBits(numberOfBits);
+  /** Returns normalized service and tile-grid metadata. */
+  async getMetadata() {
+    var _a2, _b;
+    const metadata = await this.getServiceMetadata();
+    const tileInfo = metadata.tileInfo;
+    const lods = (tileInfo == null ? void 0 : tileInfo.lods) || [];
+    const extent = metadata.fullExtent || metadata.initialExtent;
+    return {
+      name: metadata.mapName || this.url.split("/").pop() || "",
+      title: metadata.mapName,
+      abstract: metadata.serviceDescription,
+      format: "application/vnd.mapbox-vector-tile",
+      minZoom: (_a2 = lods[0]) == null ? void 0 : _a2.level,
+      maxZoom: (_b = lods.at(-1)) == null ? void 0 : _b.level,
+      boundingBox: extent ? [
+        [extent.xmin, extent.ymin],
+        [extent.xmax, extent.ymax]
+      ] : void 0,
+      layer: {
+        name: metadata.mapName || "",
+        srs: (tileInfo == null ? void 0 : tileInfo.spatialReference) ? [getSpatialReference(tileInfo.spatialReference)] : [],
+        layers: []
+      },
+      formatHeader: {
+        tileInfo,
+        styleURL: this.getStyleURL(),
+        spriteURL: this.getSpriteURL()
+      }
+    };
   }
-  bitReader.alignToByte();
-  return values;
-}
-function decodeHuffman(reader, elementCount) {
-  const version2 = reader.readUint32();
-  const tableSize = reader.readUint32();
-  const firstSymbol = reader.readUint32();
-  const lastSymbol = reader.readUint32();
-  if (version2 < 2 || tableSize === 0 || tableSize > 32768 || firstSymbol >= lastSymbol) {
-    throw new Error("Invalid LEPCC Huffman code table");
+  /** Fetches one raw PBF tile from the ArcGIS tile endpoint. */
+  async getTile(parameters, signal) {
+    const response = await this.fetch(this.getTileURL(parameters), {
+      signal,
+      headers: { Accept: "application/vnd.mapbox-vector-tile, application/x-protobuf" }
+    });
+    if (!response.ok)
+      return null;
+    return response.arrayBuffer();
   }
-  const codeLengths = decodeSimple(reader);
-  if (codeLengths.length !== lastSymbol - firstSymbol) {
-    throw new Error("LEPCC Huffman code table length mismatch");
+  /** Returns the schema advertised by decoded vector tiles. */
+  async getSchema() {
+    return { fields: [], metadata: {} };
   }
-  const lengthsBySymbol = new Array(tableSize).fill(0);
-  let codeBitCount = 0;
-  for (let symbol = firstSymbol; symbol < lastSymbol; symbol++) {
-    const tableIndex = symbol < tableSize ? symbol : symbol - tableSize;
-    const codeLength = codeLengths[symbol - firstSymbol];
-    if (codeLength > 32) {
-      throw new Error("LEPCC Huffman code is too long");
+  /** Fetches and decodes one ArcGIS vector tile to geographic coordinates. */
+  async getVectorTile(parameters) {
+    var _a2;
+    const arrayBuffer = await this.getTile(parameters, parameters.signal);
+    if (!arrayBuffer) {
+      return null;
     }
-    lengthsBySymbol[tableIndex] = codeLength;
-    codeBitCount += codeLength;
+    const inheritedOptions = this.loadOptions.mvt;
+    const sourceOptions = (_a2 = this.options["arcgis-vector-tile-server"]) == null ? void 0 : _a2.mvt;
+    return await this.coreApi.parse(arrayBuffer, MVTLoader, {
+      ...this.loadOptions,
+      mvt: {
+        ...inheritedOptions,
+        ...sourceOptions,
+        coordinates: "wgs84",
+        tileIndex: { x: parameters.x, y: parameters.y, z: parameters.z },
+        layers: normalizeLayers(parameters.layers) || (sourceOptions == null ? void 0 : sourceOptions.layers) || (inheritedOptions == null ? void 0 : inheritedOptions.layers)
+      }
+    });
   }
-  const symbols = lengthsBySymbol.map((codeLength, symbol) => ({ codeLength, symbol })).filter((value) => value.codeLength > 0).sort((left, right) => right.codeLength - left.codeLength || left.symbol - right.symbol);
-  if (symbols.length < 2) {
-    throw new Error("LEPCC Huffman table has fewer than two symbols");
+  /** Provides decoded vector tiles through the deck.gl source interface. */
+  async getTileData(parameters) {
+    return this.getVectorTile({ ...parameters.index, signal: parameters.signal });
   }
-  const codeLookup = /* @__PURE__ */ new Map();
-  let canonicalCode = 0;
-  let canonicalLength = symbols[0].codeLength;
-  for (const symbol of symbols) {
-    const delta = canonicalLength - symbol.codeLength;
-    canonicalCode = Math.floor(canonicalCode / 2 ** delta);
-    canonicalLength = symbol.codeLength;
-    codeLookup.set(`${canonicalLength}:${canonicalCode}`, symbol.symbol);
-    canonicalCode++;
+  /** Builds the ArcGIS cached vector tile URL. */
+  getTileURL(parameters) {
+    return this.getResourceURL(`/tile/${parameters.z}/${parameters.y}/${parameters.x}.pbf`);
   }
-  const codeReader = new MsbBitReader(reader);
-  for (const codeLength of lengthsBySymbol) {
-    if (codeLength > 0) {
-      codeReader.readBits(codeLength);
-    }
+  /** Returns the service metadata URL. */
+  getMetadataURL() {
+    const url = new URL(this.getResourceURL(""));
+    url.searchParams.set("f", "pjson");
+    return url.toString();
   }
-  codeReader.finishWords();
-  if (codeBitCount === 0) {
-    throw new Error("LEPCC Huffman table has no code bits");
+  /** Returns the ArcGIS Mapbox style resource URL. */
+  getStyleURL() {
+    return this.getResourceURL("/resources/styles/root.json");
   }
-  const valueReader = new MsbBitReader(reader);
-  const values = new Array(elementCount);
-  for (let index = 0; index < elementCount; index++) {
-    let code = 0;
-    let decodedSymbol;
-    for (let codeLength = 1; codeLength <= 32; codeLength++) {
-      code = code * 2 + valueReader.readBits(1);
-      decodedSymbol = codeLookup.get(`${codeLength}:${code}`);
-      if (decodedSymbol !== void 0) {
-        break;
-      }
-    }
-    if (decodedSymbol === void 0) {
-      throw new Error("Invalid LEPCC Huffman value");
-    }
-    values[index] = decodedSymbol;
+  /** Returns the ArcGIS sprite resource base URL. */
+  getSpriteURL() {
+    return this.getResourceURL("/resources/sprites/sprite");
   }
-  valueReader.finishWords(1);
-  return values;
-}
-var BitReader = class {
-  reader;
-  bitOffset = 0;
-  constructor(reader) {
-    this.reader = reader;
-  }
-  readBits(numberOfBits) {
-    let value = 0;
-    for (let bitIndex = 0; bitIndex < numberOfBits; bitIndex++) {
-      if (this.bitOffset === 0) {
-        this.reader.ensure(1);
-      }
-      const currentByte = this.reader.bytes[this.reader.offset];
-      value += (currentByte >>> this.bitOffset & 1) * 2 ** bitIndex;
-      this.bitOffset++;
-      if (this.bitOffset === 8) {
-        this.bitOffset = 0;
-        this.reader.offset++;
-      }
-    }
-    return value;
+  /** Loads and caches the ArcGIS VectorTileServer metadata document. */
+  async getServiceMetadata() {
+    this.serviceMetadata ||= this.fetch(this.getMetadataURL()).then(async (response) => {
+      if (!response.ok)
+        throw new Error(`ArcGIS VectorTileServer request failed: ${response.status}`);
+      return await response.json();
+    });
+    return this.serviceMetadata;
   }
-  alignToByte() {
-    if (this.bitOffset !== 0) {
-      this.reader.offset++;
-      this.bitOffset = 0;
+  /** Builds a resource URL while retaining service query parameters. */
+  getResourceURL(resourcePath) {
+    const url = new URL(this.url);
+    url.pathname = `${url.pathname.replace(/\/$/, "")}${resourcePath}`;
+    for (const [key, value] of this.serviceQueryParameters) {
+      url.searchParams.set(key, value);
     }
+    return url.toString();
   }
 };
-var MsbBitReader = class {
-  reader;
-  startOffset;
-  bitOffset = 0;
-  bitsRead = 0;
-  constructor(reader) {
-    this.reader = reader;
-    this.startOffset = reader.offset;
-  }
-  readBits(numberOfBits) {
-    let value = 0;
-    for (let bitIndex = 0; bitIndex < numberOfBits; bitIndex++) {
-      if (this.bitOffset === 0) {
-        this.reader.ensure(4);
-      }
-      const word = this.reader.bytes[this.reader.offset] | this.reader.bytes[this.reader.offset + 1] << 8 | this.reader.bytes[this.reader.offset + 2] << 16 | this.reader.bytes[this.reader.offset + 3] << 24;
-      value = value * 2 + (word >>> 31 - this.bitOffset & 1);
-      this.bitOffset++;
-      this.bitsRead++;
-      if (this.bitOffset === 32) {
-        this.bitOffset = 0;
-        this.reader.offset += 4;
-      }
-    }
-    return value;
-  }
-  finishWords(extraWords = 0) {
-    this.reader.offset = this.startOffset + Math.ceil(this.bitsRead / 32) * 4 + extraWords * 4;
-    this.bitOffset = 0;
-  }
+var ArcGISVectorTileServerSourceLoader = {
+  dataType: null,
+  batchType: null,
+  name: "ArcGIS VectorTileServer",
+  id: "arcgis-vector-tile-server",
+  module: "services",
+  version: "0.0.0",
+  extensions: [],
+  mimeTypes: ["application/vnd.mapbox-vector-tile", "application/x-protobuf"],
+  type: "arcgis-vector-tile-server",
+  fromUrl: true,
+  fromBlob: false,
+  options: { "arcgis-vector-tile-server": {} },
+  defaultOptions: { "arcgis-vector-tile-server": {} },
+  testURL: (url) => /\/vectortileserver(?:[\/?#]|$)/i.test(url),
+  createDataSource: (url, options = {}, coreApi2) => new ArcGISVectorTileServerSource(url, options, coreApi2)
 };
+function getSpatialReference(spatialReference) {
+  return `EPSG:${spatialReference.latestWkid || spatialReference.wkid}`;
+}
+function normalizeLayers(layers) {
+  if (!layers)
+    return void 0;
+  return Array.isArray(layers) ? layers : [layers];
+}
+
+// dist/arcgis/arcgis-scene-server-source-loader.js
+init_src5();
 
 // ../i3s/src/i3s-point-cloud-source.ts
 init_src5();
@@ -20855,6 +22578,8 @@ var import_geospatial9 = require("@math.gl/geospatial");
 init_src9();
 init_src5();
 init_parse_slpk();
+init_i3s_lepcc();
+init_i3s_lepcc_loader_types();
 init_i3s_zod_schema();
 init_url_utils();
 var I3SPointCloudSource = class extends DataSource {
@@ -20887,9 +22612,9 @@ var I3SPointCloudSource = class extends DataSource {
    * @param data Layer REST URL or an SLPK Blob/URL.
    * @param options Source and loader options.
    */
-  constructor(data, options = {}) {
+  constructor(data, options = {}, coreApi2) {
     var _a2;
-    super(data, options);
+    super(data, options, void 0, coreApi2);
     this.decoder = new I3SLEPCCDecoder({ verifyChecksum: (_a2 = options.i3s) == null ? void 0 : _a2.verifyChecksum });
   }
   /** Load and validate the scene-layer metadata. */
@@ -20969,7 +22694,11 @@ var I3SPointCloudSource = class extends DataSource {
     const geometryBytes = await this.readBinary(
       this.resourceCandidates(`nodes/${resourceId}/geometries/${geometryResource}`)
     );
-    const positions = this.decoder.decodeXyz(new Uint8Array(geometryBytes));
+    const geometry = await this.decodeLEPCC(geometryBytes, "xyz");
+    if (geometry.type !== "xyz" || !(geometry.value instanceof Float64Array)) {
+      throw new Error(`I3S PointCloud geometry resource decoded as ${geometry.type}, expected xyz`);
+    }
+    const positions = geometry.value;
     const pointCount = positions.length / 3;
     if (node.vertexCount && node.vertexCount !== pointCount) {
       throw new Error(
@@ -20997,7 +22726,7 @@ var I3SPointCloudSource = class extends DataSource {
         if (!bytes) {
           return;
         }
-        const decoded = this.decodeAttribute(bytes, descriptor);
+        const decoded = await this.decodeAttribute(bytes, descriptor);
         if (decoded.value.length !== pointCount * decoded.size) {
           throw new Error(
             `I3S PointCloud attribute ${descriptor.name || descriptor.key || "unknown"} count mismatch`
@@ -21143,7 +22872,7 @@ var I3SPointCloudSource = class extends DataSource {
     return (layer == null ? void 0 : layer.attributeInfo) || (layer == null ? void 0 : layer.attributeStorageInfo) || [];
   }
   decodeAttribute(bytes, descriptor) {
-    var _a2, _b;
+    var _a2, _b, _c, _d, _e;
     const data = new Uint8Array(bytes);
     const encoding = String(descriptor.encoding || "").toLowerCase();
     let magic = "";
@@ -21153,18 +22882,51 @@ var I3SPointCloudSource = class extends DataSource {
     }
     const kind = encoding || magic;
     if (magic === "rgb" || encoding.includes("rgb")) {
-      return { value: this.decoder.decodeRgb(data), size: 3, kind: "rgb" };
+      if (magic && this.hasCoreApi && ((_a2 = this.loadOptions.core) == null ? void 0 : _a2.worker) !== false) {
+        return this.decodeLEPCC(bytes).then((decoded) => ({
+          value: decoded.value instanceof Uint8Array ? decoded.value : this.decoder.decodeRgb(data),
+          size: 3,
+          kind: "rgb"
+        }));
+      }
+      return {
+        value: this.decoder.decodeRgb(data),
+        size: 3,
+        kind: "rgb"
+      };
     }
     if (magic === "intensity" || encoding.includes("intensity")) {
-      return { value: this.decoder.decodeIntensity(data), size: 1, kind: "intensity" };
+      if (magic && this.hasCoreApi && ((_b = this.loadOptions.core) == null ? void 0 : _b.worker) !== false) {
+        return this.decodeLEPCC(bytes).then((decoded) => ({
+          value: decoded.value instanceof Uint16Array ? decoded.value : this.decoder.decodeIntensity(data),
+          size: 1,
+          kind: "intensity"
+        }));
+      }
+      return {
+        value: this.decoder.decodeIntensity(data),
+        size: 1,
+        kind: "intensity"
+      };
     }
     if (magic === "flagBytes" || encoding.includes("flag")) {
-      return { value: this.decoder.decodeFlagBytes(data), size: 1, kind: "flags" };
+      if (magic && this.hasCoreApi && ((_c = this.loadOptions.core) == null ? void 0 : _c.worker) !== false) {
+        return this.decodeLEPCC(bytes).then((decoded) => ({
+          value: decoded.value instanceof Uint8Array ? decoded.value : this.decoder.decodeFlagBytes(data),
+          size: 1,
+          kind: "flags"
+        }));
+      }
+      return {
+        value: this.decoder.decodeFlagBytes(data),
+        size: 1,
+        kind: "flags"
+      };
     }
     const valueType = String(
-      ((_a2 = descriptor.attributeValues) == null ? void 0 : _a2.valueType) || descriptor.valueType || "UInt8"
+      ((_d = descriptor.attributeValues) == null ? void 0 : _d.valueType) || descriptor.valueType || "UInt8"
     ).toLowerCase();
-    const valueSize = ((_b = descriptor.attributeValues) == null ? void 0 : _b.valuesPerElement) || descriptor.valueSize || 1;
+    const valueSize = ((_e = descriptor.attributeValues) == null ? void 0 : _e.valuesPerElement) || descriptor.valueSize || 1;
     if (valueType.includes("float32")) {
       return { value: new Float32Array(bytes), size: valueSize, kind };
     }
@@ -21179,6 +22941,27 @@ var I3SPointCloudSource = class extends DataSource {
     }
     return { value: new Uint8Array(bytes), size: valueSize, kind };
   }
+  /** Decode a LEPCC resource using the shared worker pool when one is available. */
+  async decodeLEPCC(bytes, expectedType) {
+    var _a2, _b;
+    const loaderOptions = {
+      ...this.loadOptions,
+      "i3s-lepcc": {
+        verifyChecksum: (_a2 = this.options.i3s) == null ? void 0 : _a2.verifyChecksum
+      }
+    };
+    if (this.hasCoreApi && ((_b = loaderOptions.core) == null ? void 0 : _b.worker) !== false) {
+      return await this.coreApi.parse(bytes, I3SLEPCCLoader, {
+        ...loaderOptions
+      });
+    }
+    const data = new Uint8Array(bytes);
+    const type = expectedType || this.decoder.getBlobType(data);
+    return {
+      type,
+      value: type === "xyz" ? this.decoder.decodeXyz(data) : type === "rgb" ? this.decoder.decodeRgb(data) : type === "intensity" ? this.decoder.decodeIntensity(data) : this.decoder.decodeFlagBytes(data)
+    };
+  }
   getAttributeName(descriptor, kind) {
     if (kind.includes("rgb")) return "COLOR_0";
     if (kind.includes("intensity")) return "intensity";
@@ -21420,7 +23203,7 @@ function normalizeI3SRendererMetadata(layer) {
 function createI3SLayerSource(url, layer, options = {}, coreApi2) {
   var _a2, _b, _c;
   if (layer.layerType === "PointCloud") {
-    return new I3SPointCloudSource(url, options);
+    return new I3SPointCloudSource(url, options, coreApi2);
   }
   const loadOptions = {
     ...((_a2 = options.core) == null ? void 0 : _a2.loadOptions) || {},
@@ -21642,6 +23425,11 @@ function getServiceLoader(serviceType) {
 
 // dist/authentication.js
 init_src5();
+var CESIUM_ION_API_ORIGIN = "https://api.cesium.com";
+var CESIUM_ION_ASSET_ORIGINS = [
+  "https://assets.ion.cesium.com",
+  "https://assets.cesium.com"
+];
 function createArcGISCredential(options) {
   return createQueryParameterCredential({
     id: "arcgis-token",
@@ -21668,10 +23456,70 @@ function createGoogleMapsCredential(options) {
   });
 }
 function createCesiumIonCredential(options) {
+  if (options.assetId === void 0 || options.assetId === null) {
+    return createBearerTokenCredential({
+      id: "cesium-ion-access-token",
+      origins: options.origins || [CESIUM_ION_API_ORIGIN],
+      token: options.accessToken
+    });
+  }
+  const assetId = options.assetId;
+  const origins = options.origins || CESIUM_ION_ASSET_ORIGINS;
+  let endpointTokenPromise = null;
   return createBearerTokenCredential({
-    id: "cesium-ion-access-token",
-    origins: options.origins || ["https://api.cesium.com"],
-    token: options.accessToken
+    id: `cesium-ion-asset-${assetId}`,
+    origins,
+    token: (context) => {
+      if (context.reason === "refresh") {
+        endpointTokenPromise = null;
+      }
+      endpointTokenPromise ||= resolveCesiumIonAssetToken(options, assetId, origins, context);
+      return endpointTokenPromise;
+    }
+  });
+}
+async function resolveCesiumIonAssetToken(options, assetId, origins, context) {
+  const endpointURL = `${CESIUM_ION_API_ORIGIN}/v1/assets/${assetId}/endpoint`;
+  const accessToken = typeof options.accessToken === "function" ? await options.accessToken({ ...context, url: endpointURL }) : options.accessToken;
+  if (!accessToken)
+    return null;
+  const tokenType = options.tokenType || "auto";
+  if (tokenType === "asset" || tokenType === "auto" && isCesiumIonAssetToken(accessToken, assetId)) {
+    return accessToken;
+  }
+  const apiCredential = createBearerTokenCredential({
+    id: `cesium-ion-api-${assetId}`,
+    origins: [CESIUM_ION_API_ORIGIN],
+    token: accessToken
+  });
+  const ionFetch = createAuthenticatedFetch({
+    fetch: options.fetch,
+    credentials: [apiCredential]
   });
+  const response = await ionFetch(endpointURL);
+  if (!response.ok) {
+    throw new Error(`Cesium ion asset ${assetId} endpoint request failed: ${response.status}`);
+  }
+  const endpoint = await response.json();
+  if (typeof endpoint.url !== "string" || !origins.includes(new URL(endpoint.url).origin)) {
+    throw new Error(`Cesium ion asset ${assetId} resolved to an unconfigured origin.`);
+  }
+  if (typeof endpoint.accessToken !== "string" || !endpoint.accessToken) {
+    throw new Error(`Cesium ion did not return an endpoint token for asset ${assetId}.`);
+  }
+  return endpoint.accessToken;
+}
+function isCesiumIonAssetToken(token, assetId) {
+  try {
+    const encodedClaims = token.split(".")[1];
+    if (!encodedClaims)
+      return false;
+    const base64 = encodedClaims.replace(/-/g, "+").replace(/_/g, "/");
+    const paddedBase64 = base64.padEnd(Math.ceil(base64.length / 4) * 4, "=");
+    const claims = JSON.parse(atob(paddedBase64));
+    return Array.isArray(claims.assets) && claims.assets.some((claimAssetId) => String(claimAssetId) === String(assetId));
+  } catch {
+    return false;
+  }
 }
 //# sourceMappingURL=index.cjs.map