@loaders.gl/flatgeobuf 4.0.4 → 4.1.0-alpha.10

package/dist/index.cjs

@@ -30,32 +30,11 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  FlatGeobufLoader: () => FlatGeobufLoader2,
-  FlatGeobufWorkerLoader: () => FlatGeobufLoader
+  FlatGeobufLoader: () => FlatGeobufLoader,
+  FlatGeobufWorkerLoader: () => FlatGeobufWorkerLoader
 });
 module.exports = __toCommonJS(src_exports);
 
-// src/flatgeobuf-loader.ts
-var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
-var FlatGeobufLoader = {
-  id: "flatgeobuf",
-  name: "FlatGeobuf",
-  module: "flatgeobuf",
-  version: VERSION,
-  worker: true,
-  extensions: ["fgb"],
-  mimeTypes: ["application/octet-stream"],
-  category: "geometry",
-  options: {
-    flatgeobuf: {
-      shape: "geojson-table"
-    },
-    gis: {
-      reproject: false
-    }
-  }
-};
-
 // src/lib/parse-flatgeobuf.ts
 var import_proj4 = require("@math.gl/proj4");
 var import_gis = require("@loaders.gl/gis");
@@ -171,17 +150,1628 @@ function blitArrays(xy, z) {
   return { value: xyz, size: 3 };
 }
 
+// src/lib/get-schema-from-fgb-header.ts
+function getSchemaFromFGBHeader(fgbHeader) {
+  var _a, _b;
+  const metadata = {
+    title: fgbHeader.title || "",
+    description: fgbHeader.description || "",
+    crs: JSON.stringify(fgbHeader.crs) || "",
+    metadata: fgbHeader.metadata || "",
+    geometryType: String(fgbHeader.geometryType),
+    indexNodeSize: String(fgbHeader.indexNodeSize),
+    featureCount: String(fgbHeader.featuresCount),
+    bounds: ((_a = fgbHeader.envelope) == null ? void 0 : _a.join(",")) || ""
+  };
+  const fields = ((_b = fgbHeader.columns) == null ? void 0 : _b.map((column) => getFieldFromFGBColumn(column))) || [];
+  return { metadata, fields };
+}
+function getFieldFromFGBColumn(fgbColumn) {
+  const metadata = {
+    title: fgbColumn.title || "",
+    description: fgbColumn.description || "",
+    width: String(fgbColumn.width),
+    precision: String(fgbColumn.precision),
+    scale: String(fgbColumn.scale),
+    unique: String(fgbColumn.unique),
+    primary_key: String(fgbColumn.primary_key)
+  };
+  return {
+    name: fgbColumn.name,
+    type: getTypeFromFGBType(fgbColumn.type),
+    nullable: fgbColumn.nullable,
+    metadata
+  };
+}
+function getTypeFromFGBType(fgbType) {
+  switch (fgbType) {
+    case 0 /* Byte */:
+      return "int8";
+    case 1 /* UByte */:
+      return "uint8";
+    case 2 /* Bool */:
+      return "bool";
+    case 3 /* Short */:
+      return "int16";
+    case 4 /* UShort */:
+      return "uint16";
+    case 5 /* Int */:
+      return "int32";
+    case 6 /* UInt */:
+      return "uint32";
+    case 7 /* Long */:
+      return "int64";
+    case 8 /* ULong */:
+      return "uint64";
+    case 9 /* Float */:
+      return "float32";
+    case 10 /* Double */:
+      return "float64";
+    case 11 /* String */:
+      return "utf8";
+    case 12 /* Json */:
+      return "null";
+    case 13 /* DateTime */:
+      return "date-millisecond";
+    case 14 /* Binary */:
+      return "binary";
+    default:
+      return "null";
+  }
+}
+
+// src/flatgeobuf/3.27.2/flat-geobuf/geometry-type.ts
+var GeometryType2 = /* @__PURE__ */ ((GeometryType3) => {
+  GeometryType3[GeometryType3["Unknown"] = 0] = "Unknown";
+  GeometryType3[GeometryType3["Point"] = 1] = "Point";
+  GeometryType3[GeometryType3["LineString"] = 2] = "LineString";
+  GeometryType3[GeometryType3["Polygon"] = 3] = "Polygon";
+  GeometryType3[GeometryType3["MultiPoint"] = 4] = "MultiPoint";
+  GeometryType3[GeometryType3["MultiLineString"] = 5] = "MultiLineString";
+  GeometryType3[GeometryType3["MultiPolygon"] = 6] = "MultiPolygon";
+  GeometryType3[GeometryType3["GeometryCollection"] = 7] = "GeometryCollection";
+  GeometryType3[GeometryType3["CircularString"] = 8] = "CircularString";
+  GeometryType3[GeometryType3["CompoundCurve"] = 9] = "CompoundCurve";
+  GeometryType3[GeometryType3["CurvePolygon"] = 10] = "CurvePolygon";
+  GeometryType3[GeometryType3["MultiCurve"] = 11] = "MultiCurve";
+  GeometryType3[GeometryType3["MultiSurface"] = 12] = "MultiSurface";
+  GeometryType3[GeometryType3["Curve"] = 13] = "Curve";
+  GeometryType3[GeometryType3["Surface"] = 14] = "Surface";
+  GeometryType3[GeometryType3["PolyhedralSurface"] = 15] = "PolyhedralSurface";
+  GeometryType3[GeometryType3["TIN"] = 16] = "TIN";
+  GeometryType3[GeometryType3["Triangle"] = 17] = "Triangle";
+  return GeometryType3;
+})(GeometryType2 || {});
+
+// src/flatgeobuf/3.27.2/flat-geobuf/geometry.ts
+var flatbuffers = __toESM(require("flatbuffers"), 1);
+var Geometry = class {
+  constructor() {
+    this.bb = null;
+    this.bb_pos = 0;
+  }
+  __init(i, bb) {
+    this.bb_pos = i;
+    this.bb = bb;
+    return this;
+  }
+  static getRootAsGeometry(bb, obj) {
+    return (obj || new Geometry()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+  }
+  static getSizePrefixedRootAsGeometry(bb, obj) {
+    bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+    return (obj || new Geometry()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+  }
+  ends(index) {
+    const offset = this.bb.__offset(this.bb_pos, 4);
+    return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
+  }
+  endsLength() {
+    const offset = this.bb.__offset(this.bb_pos, 4);
+    return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+  }
+  endsArray() {
+    const offset = this.bb.__offset(this.bb_pos, 4);
+    return offset ? new Uint32Array(
+      this.bb.bytes().buffer,
+      this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset),
+      this.bb.__vector_len(this.bb_pos + offset)
+    ) : null;
+  }
+  xy(index) {
+    const offset = this.bb.__offset(this.bb_pos, 6);
+    return offset ? this.bb.readFloat64(this.bb.__vector(this.bb_pos + offset) + index * 8) : 0;
+  }
+  xyLength() {
+    const offset = this.bb.__offset(this.bb_pos, 6);
+    return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+  }
+  xyArray() {
+    const offset = this.bb.__offset(this.bb_pos, 6);
+    return offset ? new Float64Array(
+      this.bb.bytes().buffer,
+      this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset),
+      this.bb.__vector_len(this.bb_pos + offset)
+    ) : null;
+  }
+  z(index) {
+    const offset = this.bb.__offset(this.bb_pos, 8);
+    return offset ? this.bb.readFloat64(this.bb.__vector(this.bb_pos + offset) + index * 8) : 0;
+  }
+  zLength() {
+    const offset = this.bb.__offset(this.bb_pos, 8);
+    return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+  }
+  zArray() {
+    const offset = this.bb.__offset(this.bb_pos, 8);
+    return offset ? new Float64Array(
+      this.bb.bytes().buffer,
+      this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset),
+      this.bb.__vector_len(this.bb_pos + offset)
+    ) : null;
+  }
+  m(index) {
+    const offset = this.bb.__offset(this.bb_pos, 10);
+    return offset ? this.bb.readFloat64(this.bb.__vector(this.bb_pos + offset) + index * 8) : 0;
+  }
+  mLength() {
+    const offset = this.bb.__offset(this.bb_pos, 10);
+    return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+  }
+  mArray() {
+    const offset = this.bb.__offset(this.bb_pos, 10);
+    return offset ? new Float64Array(
+      this.bb.bytes().buffer,
+      this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset),
+      this.bb.__vector_len(this.bb_pos + offset)
+    ) : null;
+  }
+  t(index) {
+    const offset = this.bb.__offset(this.bb_pos, 12);
+    return offset ? this.bb.readFloat64(this.bb.__vector(this.bb_pos + offset) + index * 8) : 0;
+  }
+  tLength() {
+    const offset = this.bb.__offset(this.bb_pos, 12);
+    return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+  }
+  tArray() {
+    const offset = this.bb.__offset(this.bb_pos, 12);
+    return offset ? new Float64Array(
+      this.bb.bytes().buffer,
+      this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset),
+      this.bb.__vector_len(this.bb_pos + offset)
+    ) : null;
+  }
+  tm(index) {
+    const offset = this.bb.__offset(this.bb_pos, 14);
+    return offset ? this.bb.readUint64(this.bb.__vector(this.bb_pos + offset) + index * 8) : BigInt(0);
+  }
+  tmLength() {
+    const offset = this.bb.__offset(this.bb_pos, 14);
+    return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+  }
+  type() {
+    const offset = this.bb.__offset(this.bb_pos, 16);
+    return offset ? this.bb.readUint8(this.bb_pos + offset) : 0 /* Unknown */;
+  }
+  parts(index, obj) {
+    const offset = this.bb.__offset(this.bb_pos, 18);
+    return offset ? (obj || new Geometry()).__init(
+      this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4),
+      this.bb
+    ) : null;
+  }
+  partsLength() {
+    const offset = this.bb.__offset(this.bb_pos, 18);
+    return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+  }
+  static startGeometry(builder) {
+    builder.startObject(8);
+  }
+  static addEnds(builder, endsOffset) {
+    builder.addFieldOffset(0, endsOffset, 0);
+  }
+  static createEndsVector(builder, data) {
+    builder.startVector(4, data.length, 4);
+    for (let i = data.length - 1; i >= 0; i--) {
+      builder.addInt32(data[i]);
+    }
+    return builder.endVector();
+  }
+  static startEndsVector(builder, numElems) {
+    builder.startVector(4, numElems, 4);
+  }
+  static addXy(builder, xyOffset) {
+    builder.addFieldOffset(1, xyOffset, 0);
+  }
+  static createXyVector(builder, data) {
+    builder.startVector(8, data.length, 8);
+    for (let i = data.length - 1; i >= 0; i--) {
+      builder.addFloat64(data[i]);
+    }
+    return builder.endVector();
+  }
+  static startXyVector(builder, numElems) {
+    builder.startVector(8, numElems, 8);
+  }
+  static addZ(builder, zOffset) {
+    builder.addFieldOffset(2, zOffset, 0);
+  }
+  static createZVector(builder, data) {
+    builder.startVector(8, data.length, 8);
+    for (let i = data.length - 1; i >= 0; i--) {
+      builder.addFloat64(data[i]);
+    }
+    return builder.endVector();
+  }
+  static startZVector(builder, numElems) {
+    builder.startVector(8, numElems, 8);
+  }
+  static addM(builder, mOffset) {
+    builder.addFieldOffset(3, mOffset, 0);
+  }
+  static createMVector(builder, data) {
+    builder.startVector(8, data.length, 8);
+    for (let i = data.length - 1; i >= 0; i--) {
+      builder.addFloat64(data[i]);
+    }
+    return builder.endVector();
+  }
+  static startMVector(builder, numElems) {
+    builder.startVector(8, numElems, 8);
+  }
+  static addT(builder, tOffset) {
+    builder.addFieldOffset(4, tOffset, 0);
+  }
+  static createTVector(builder, data) {
+    builder.startVector(8, data.length, 8);
+    for (let i = data.length - 1; i >= 0; i--) {
+      builder.addFloat64(data[i]);
+    }
+    return builder.endVector();
+  }
+  static startTVector(builder, numElems) {
+    builder.startVector(8, numElems, 8);
+  }
+  static addTm(builder, tmOffset) {
+    builder.addFieldOffset(5, tmOffset, 0);
+  }
+  static createTmVector(builder, data) {
+    builder.startVector(8, data.length, 8);
+    for (let i = data.length - 1; i >= 0; i--) {
+      builder.addInt64(data[i]);
+    }
+    return builder.endVector();
+  }
+  static startTmVector(builder, numElems) {
+    builder.startVector(8, numElems, 8);
+  }
+  static addType(builder, type) {
+    builder.addFieldInt8(6, type, 0 /* Unknown */);
+  }
+  static addParts(builder, partsOffset) {
+    builder.addFieldOffset(7, partsOffset, 0);
+  }
+  static createPartsVector(builder, data) {
+    builder.startVector(4, data.length, 4);
+    for (let i = data.length - 1; i >= 0; i--) {
+      builder.addOffset(data[i]);
+    }
+    return builder.endVector();
+  }
+  static startPartsVector(builder, numElems) {
+    builder.startVector(4, numElems, 4);
+  }
+  static endGeometry(builder) {
+    const offset = builder.endObject();
+    return offset;
+  }
+  static createGeometry(builder, endsOffset, xyOffset, zOffset, mOffset, tOffset, tmOffset, type, partsOffset) {
+    Geometry.startGeometry(builder);
+    Geometry.addEnds(builder, endsOffset);
+    Geometry.addXy(builder, xyOffset);
+    Geometry.addZ(builder, zOffset);
+    Geometry.addM(builder, mOffset);
+    Geometry.addT(builder, tOffset);
+    Geometry.addTm(builder, tmOffset);
+    Geometry.addType(builder, type);
+    Geometry.addParts(builder, partsOffset);
+    return Geometry.endGeometry(builder);
+  }
+};
+
+// src/flatgeobuf/3.27.2/generic/geometry.ts
+function pairFlatCoordinates(xy, z) {
+  const newArray = [];
+  for (let i = 0; i < xy.length; i += 2) {
+    const a = [xy[i], xy[i + 1]];
+    if (z)
+      a.push(z[i >> 1]);
+    newArray.push(a);
+  }
+  return newArray;
+}
+
+// src/flatgeobuf/3.27.2/geojson/geometry.ts
+function extractParts(xy, z, ends) {
+  if (!ends || ends.length === 0)
+    return [pairFlatCoordinates(xy, z)];
+  let s = 0;
+  const xySlices = Array.from(ends).map((e) => xy.slice(s, s = e << 1));
+  let zSlices;
+  if (z) {
+    s = 0;
+    zSlices = Array.from(ends).map((e) => z.slice(s, s = e));
+  }
+  return xySlices.map((xy2, i) => pairFlatCoordinates(xy2, zSlices ? zSlices[i] : void 0));
+}
+function toGeoJsonCoordinates(geometry, type) {
+  const xy = geometry.xyArray();
+  const z = geometry.zArray();
+  switch (type) {
+    case 1 /* Point */: {
+      const a = Array.from(xy);
+      if (z)
+        a.push(z[0]);
+      return a;
+    }
+    case 4 /* MultiPoint */:
+    case 2 /* LineString */:
+      return pairFlatCoordinates(xy, z);
+    case 5 /* MultiLineString */:
+      return extractParts(xy, z, geometry.endsArray());
+    case 3 /* Polygon */:
+      return extractParts(xy, z, geometry.endsArray());
+  }
+}
+function fromGeometry(geometry, headerType) {
+  let type = headerType;
+  if (type === 0 /* Unknown */) {
+    type = geometry.type();
+  }
+  if (type === 7 /* GeometryCollection */) {
+    const geometries = [];
+    for (let i = 0; i < geometry.partsLength(); i++) {
+      const part = geometry.parts(i);
+      const partType = part.type();
+      geometries.push(fromGeometry(part, partType));
+    }
+    return {
+      type: GeometryType2[type],
+      geometries
+    };
+  } else if (type === 6 /* MultiPolygon */) {
+    const geometries = [];
+    for (let i = 0; i < geometry.partsLength(); i++)
+      geometries.push(fromGeometry(geometry.parts(i), 3 /* Polygon */));
+    return {
+      type: GeometryType2[type],
+      coordinates: geometries.map((g) => g.coordinates)
+    };
+  }
+  const coordinates = toGeoJsonCoordinates(geometry, type);
+  return {
+    type: GeometryType2[type],
+    coordinates
+  };
+}
+
+// src/flatgeobuf/3.27.2/generic/feature.ts
+var flatbuffers4 = __toESM(require("flatbuffers"), 1);
+
+// src/flatgeobuf/3.27.2/flat-geobuf/feature.ts
+var flatbuffers3 = __toESM(require("flatbuffers"), 1);
+
+// src/flatgeobuf/3.27.2/flat-geobuf/column.ts
+var flatbuffers2 = __toESM(require("flatbuffers"), 1);
+var Column = class {
+  constructor() {
+    this.bb = null;
+    this.bb_pos = 0;
+  }
+  __init(i, bb) {
+    this.bb_pos = i;
+    this.bb = bb;
+    return this;
+  }
+  static getRootAsColumn(bb, obj) {
+    return (obj || new Column()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+  }
+  static getSizePrefixedRootAsColumn(bb, obj) {
+    bb.setPosition(bb.position() + flatbuffers2.SIZE_PREFIX_LENGTH);
+    return (obj || new Column()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+  }
+  name(optionalEncoding) {
+    const offset = this.bb.__offset(this.bb_pos, 4);
+    return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+  }
+  type() {
+    const offset = this.bb.__offset(this.bb_pos, 6);
+    return offset ? this.bb.readUint8(this.bb_pos + offset) : 0 /* Byte */;
+  }
+  title(optionalEncoding) {
+    const offset = this.bb.__offset(this.bb_pos, 8);
+    return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+  }
+  description(optionalEncoding) {
+    const offset = this.bb.__offset(this.bb_pos, 10);
+    return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+  }
+  width() {
+    const offset = this.bb.__offset(this.bb_pos, 12);
+    return offset ? this.bb.readInt32(this.bb_pos + offset) : -1;
+  }
+  precision() {
+    const offset = this.bb.__offset(this.bb_pos, 14);
+    return offset ? this.bb.readInt32(this.bb_pos + offset) : -1;
+  }
+  scale() {
+    const offset = this.bb.__offset(this.bb_pos, 16);
+    return offset ? this.bb.readInt32(this.bb_pos + offset) : -1;
+  }
+  nullable() {
+    const offset = this.bb.__offset(this.bb_pos, 18);
+    return offset ? Boolean(this.bb.readInt8(this.bb_pos + offset)) : true;
+  }
+  unique() {
+    const offset = this.bb.__offset(this.bb_pos, 20);
+    return offset ? Boolean(this.bb.readInt8(this.bb_pos + offset)) : false;
+  }
+  primaryKey() {
+    const offset = this.bb.__offset(this.bb_pos, 22);
+    return offset ? Boolean(this.bb.readInt8(this.bb_pos + offset)) : false;
+  }
+  metadata(optionalEncoding) {
+    const offset = this.bb.__offset(this.bb_pos, 24);
+    return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+  }
+  static startColumn(builder) {
+    builder.startObject(11);
+  }
+  static addName(builder, nameOffset) {
+    builder.addFieldOffset(0, nameOffset, 0);
+  }
+  static addType(builder, type) {
+    builder.addFieldInt8(1, type, 0 /* Byte */);
+  }
+  static addTitle(builder, titleOffset) {
+    builder.addFieldOffset(2, titleOffset, 0);
+  }
+  static addDescription(builder, descriptionOffset) {
+    builder.addFieldOffset(3, descriptionOffset, 0);
+  }
+  static addWidth(builder, width) {
+    builder.addFieldInt32(4, width, -1);
+  }
+  static addPrecision(builder, precision) {
+    builder.addFieldInt32(5, precision, -1);
+  }
+  static addScale(builder, scale) {
+    builder.addFieldInt32(6, scale, -1);
+  }
+  static addNullable(builder, nullable) {
+    builder.addFieldInt8(7, Number(nullable), Number(true));
+  }
+  static addUnique(builder, unique) {
+    builder.addFieldInt8(8, Number(unique), Number(false));
+  }
+  static addPrimaryKey(builder, primaryKey) {
+    builder.addFieldInt8(9, Number(primaryKey), Number(false));
+  }
+  static addMetadata(builder, metadataOffset) {
+    builder.addFieldOffset(10, metadataOffset, 0);
+  }
+  static endColumn(builder) {
+    const offset = builder.endObject();
+    builder.requiredField(offset, 4);
+    return offset;
+  }
+  static createColumn(builder, nameOffset, type, titleOffset, descriptionOffset, width, precision, scale, nullable, unique, primaryKey, metadataOffset) {
+    Column.startColumn(builder);
+    Column.addName(builder, nameOffset);
+    Column.addType(builder, type);
+    Column.addTitle(builder, titleOffset);
+    Column.addDescription(builder, descriptionOffset);
+    Column.addWidth(builder, width);
+    Column.addPrecision(builder, precision);
+    Column.addScale(builder, scale);
+    Column.addNullable(builder, nullable);
+    Column.addUnique(builder, unique);
+    Column.addPrimaryKey(builder, primaryKey);
+    Column.addMetadata(builder, metadataOffset);
+    return Column.endColumn(builder);
+  }
+};
+
+// src/flatgeobuf/3.27.2/flat-geobuf/feature.ts
+var Feature = class {
+  constructor() {
+    this.bb = null;
+    this.bb_pos = 0;
+  }
+  __init(i, bb) {
+    this.bb_pos = i;
+    this.bb = bb;
+    return this;
+  }
+  static getRootAsFeature(bb, obj) {
+    return (obj || new Feature()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+  }
+  static getSizePrefixedRootAsFeature(bb, obj) {
+    bb.setPosition(bb.position() + flatbuffers3.SIZE_PREFIX_LENGTH);
+    return (obj || new Feature()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+  }
+  geometry(obj) {
+    const offset = this.bb.__offset(this.bb_pos, 4);
+    return offset ? (obj || new Geometry()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
+  }
+  properties(index) {
+    const offset = this.bb.__offset(this.bb_pos, 6);
+    return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0;
+  }
+  propertiesLength() {
+    const offset = this.bb.__offset(this.bb_pos, 6);
+    return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+  }
+  propertiesArray() {
+    const offset = this.bb.__offset(this.bb_pos, 6);
+    return offset ? new Uint8Array(
+      this.bb.bytes().buffer,
+      this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset),
+      this.bb.__vector_len(this.bb_pos + offset)
+    ) : null;
+  }
+  columns(index, obj) {
+    const offset = this.bb.__offset(this.bb_pos, 8);
+    return offset ? (obj || new Column()).__init(
+      this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4),
+      this.bb
+    ) : null;
+  }
+  columnsLength() {
+    const offset = this.bb.__offset(this.bb_pos, 8);
+    return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+  }
+  static startFeature(builder) {
+    builder.startObject(3);
+  }
+  static addGeometry(builder, geometryOffset) {
+    builder.addFieldOffset(0, geometryOffset, 0);
+  }
+  static addProperties(builder, propertiesOffset) {
+    builder.addFieldOffset(1, propertiesOffset, 0);
+  }
+  static createPropertiesVector(builder, data) {
+    builder.startVector(1, data.length, 1);
+    for (let i = data.length - 1; i >= 0; i--) {
+      builder.addInt8(data[i]);
+    }
+    return builder.endVector();
+  }
+  static startPropertiesVector(builder, numElems) {
+    builder.startVector(1, numElems, 1);
+  }
+  static addColumns(builder, columnsOffset) {
+    builder.addFieldOffset(2, columnsOffset, 0);
+  }
+  static createColumnsVector(builder, data) {
+    builder.startVector(4, data.length, 4);
+    for (let i = data.length - 1; i >= 0; i--) {
+      builder.addOffset(data[i]);
+    }
+    return builder.endVector();
+  }
+  static startColumnsVector(builder, numElems) {
+    builder.startVector(4, numElems, 4);
+  }
+  static endFeature(builder) {
+    const offset = builder.endObject();
+    return offset;
+  }
+  static finishFeatureBuffer(builder, offset) {
+    builder.finish(offset);
+  }
+  static finishSizePrefixedFeatureBuffer(builder, offset) {
+    builder.finish(offset, void 0, true);
+  }
+  static createFeature(builder, geometryOffset, propertiesOffset, columnsOffset) {
+    Feature.startFeature(builder);
+    Feature.addGeometry(builder, geometryOffset);
+    Feature.addProperties(builder, propertiesOffset);
+    Feature.addColumns(builder, columnsOffset);
+    return Feature.endFeature(builder);
+  }
+};
+
+// src/flatgeobuf/3.27.2/generic/feature.ts
+var textEncoder = new TextEncoder();
+var textDecoder = new TextDecoder();
+function parseProperties(feature, columns) {
+  const properties = {};
+  if (!columns || columns.length === 0)
+    return properties;
+  const array = feature.propertiesArray();
+  if (!array)
+    return properties;
+  const view = new DataView(array.buffer, array.byteOffset);
+  const length = feature.propertiesLength();
+  let offset = 0;
+  while (offset < length) {
+    const i = view.getUint16(offset, true);
+    offset += 2;
+    const column = columns[i];
+    const name = column.name;
+    switch (column.type) {
+      case 2 /* Bool */: {
+        properties[name] = Boolean(view.getUint8(offset));
+        offset += 1;
+        break;
+      }
+      case 0 /* Byte */: {
+        properties[name] = view.getInt8(offset);
+        offset += 1;
+        break;
+      }
+      case 1 /* UByte */: {
+        properties[name] = view.getUint8(offset);
+        offset += 1;
+        break;
+      }
+      case 3 /* Short */: {
+        properties[name] = view.getInt16(offset, true);
+        offset += 2;
+        break;
+      }
+      case 4 /* UShort */: {
+        properties[name] = view.getUint16(offset, true);
+        offset += 2;
+        break;
+      }
+      case 5 /* Int */: {
+        properties[name] = view.getInt32(offset, true);
+        offset += 4;
+        break;
+      }
+      case 6 /* UInt */: {
+        properties[name] = view.getUint32(offset, true);
+        offset += 4;
+        break;
+      }
+      case 7 /* Long */: {
+        properties[name] = Number(view.getBigInt64(offset, true));
+        offset += 8;
+        break;
+      }
+      case 8 /* ULong */: {
+        properties[name] = Number(view.getBigUint64(offset, true));
+        offset += 8;
+        break;
+      }
+      case 9 /* Float */: {
+        properties[name] = view.getFloat32(offset, true);
+        offset += 4;
+        break;
+      }
+      case 10 /* Double */: {
+        properties[name] = view.getFloat64(offset, true);
+        offset += 8;
+        break;
+      }
+      case 13 /* DateTime */:
+      case 11 /* String */: {
+        const length2 = view.getUint32(offset, true);
+        offset += 4;
+        properties[name] = textDecoder.decode(array.subarray(offset, offset + length2));
+        offset += length2;
+        break;
+      }
+      case 12 /* Json */: {
+        const length2 = view.getUint32(offset, true);
+        offset += 4;
+        const str = textDecoder.decode(array.subarray(offset, offset + length2));
+        properties[name] = JSON.parse(str);
+        offset += length2;
+        break;
+      }
+      default:
+        throw new Error(`Unknown type ${column.type}`);
+    }
+  }
+  return properties;
+}
+
+// src/flatgeobuf/3.27.2/geojson/feature.ts
+function fromFeature(feature, header) {
+  const columns = header.columns;
+  const geometry = fromGeometry(feature.geometry(), header.geometryType);
+  const geoJsonfeature = {
+    type: "Feature",
+    geometry,
+    properties: parseProperties(feature, columns)
+  };
+  return geoJsonfeature;
+}
+
+// src/flatgeobuf/3.27.2/generic/featurecollection.ts
+var flatbuffers8 = __toESM(require("flatbuffers"), 1);
+var import_slice_source = __toESM(require("slice-source"), 1);
+
+// src/flatgeobuf/3.27.2/flat-geobuf/header.ts
+var flatbuffers6 = __toESM(require("flatbuffers"), 1);
+
+// src/flatgeobuf/3.27.2/flat-geobuf/crs.ts
+var flatbuffers5 = __toESM(require("flatbuffers"), 1);
+var Crs = class {
+  constructor() {
+    this.bb = null;
+    this.bb_pos = 0;
+  }
+  __init(i, bb) {
+    this.bb_pos = i;
+    this.bb = bb;
+    return this;
+  }
+  static getRootAsCrs(bb, obj) {
+    return (obj || new Crs()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+  }
+  static getSizePrefixedRootAsCrs(bb, obj) {
+    bb.setPosition(bb.position() + flatbuffers5.SIZE_PREFIX_LENGTH);
+    return (obj || new Crs()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+  }
+  org(optionalEncoding) {
+    const offset = this.bb.__offset(this.bb_pos, 4);
+    return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+  }
+  code() {
+    const offset = this.bb.__offset(this.bb_pos, 6);
+    return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
+  }
+  name(optionalEncoding) {
+    const offset = this.bb.__offset(this.bb_pos, 8);
+    return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+  }
+  description(optionalEncoding) {
+    const offset = this.bb.__offset(this.bb_pos, 10);
+    return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+  }
+  wkt(optionalEncoding) {
+    const offset = this.bb.__offset(this.bb_pos, 12);
+    return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+  }
+  codeString(optionalEncoding) {
+    const offset = this.bb.__offset(this.bb_pos, 14);
+    return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+  }
+  static startCrs(builder) {
+    builder.startObject(6);
+  }
+  static addOrg(builder, orgOffset) {
+    builder.addFieldOffset(0, orgOffset, 0);
+  }
+  static addCode(builder, code) {
+    builder.addFieldInt32(1, code, 0);
+  }
+  static addName(builder, nameOffset) {
+    builder.addFieldOffset(2, nameOffset, 0);
+  }
+  static addDescription(builder, descriptionOffset) {
+    builder.addFieldOffset(3, descriptionOffset, 0);
+  }
+  static addWkt(builder, wktOffset) {
+    builder.addFieldOffset(4, wktOffset, 0);
+  }
+  static addCodeString(builder, codeStringOffset) {
+    builder.addFieldOffset(5, codeStringOffset, 0);
+  }
+  static endCrs(builder) {
+    const offset = builder.endObject();
+    return offset;
+  }
+  static createCrs(builder, orgOffset, code, nameOffset, descriptionOffset, wktOffset, codeStringOffset) {
+    Crs.startCrs(builder);
+    Crs.addOrg(builder, orgOffset);
+    Crs.addCode(builder, code);
+    Crs.addName(builder, nameOffset);
+    Crs.addDescription(builder, descriptionOffset);
+    Crs.addWkt(builder, wktOffset);
+    Crs.addCodeString(builder, codeStringOffset);
+    return Crs.endCrs(builder);
+  }
+};
+
+// src/flatgeobuf/3.27.2/flat-geobuf/header.ts
+var Header = class {
+  constructor() {
+    this.bb = null;
+    this.bb_pos = 0;
+  }
+  __init(i, bb) {
+    this.bb_pos = i;
+    this.bb = bb;
+    return this;
+  }
+  static getRootAsHeader(bb, obj) {
+    return (obj || new Header()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+  }
+  static getSizePrefixedRootAsHeader(bb, obj) {
+    bb.setPosition(bb.position() + flatbuffers6.SIZE_PREFIX_LENGTH);
+    return (obj || new Header()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+  }
+  name(optionalEncoding) {
+    const offset = this.bb.__offset(this.bb_pos, 4);
+    return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+  }
+  envelope(index) {
+    const offset = this.bb.__offset(this.bb_pos, 6);
+    return offset ? this.bb.readFloat64(this.bb.__vector(this.bb_pos + offset) + index * 8) : 0;
+  }
+  envelopeLength() {
+    const offset = this.bb.__offset(this.bb_pos, 6);
+    return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+  }
+  envelopeArray() {
+    const offset = this.bb.__offset(this.bb_pos, 6);
+    return offset ? new Float64Array(
+      this.bb.bytes().buffer,
+      this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset),
+      this.bb.__vector_len(this.bb_pos + offset)
+    ) : null;
+  }
+  geometryType() {
+    const offset = this.bb.__offset(this.bb_pos, 8);
+    return offset ? this.bb.readUint8(this.bb_pos + offset) : 0 /* Unknown */;
+  }
+  hasZ() {
+    const offset = this.bb.__offset(this.bb_pos, 10);
+    return offset ? Boolean(this.bb.readInt8(this.bb_pos + offset)) : false;
+  }
+  hasM() {
+    const offset = this.bb.__offset(this.bb_pos, 12);
+    return offset ? Boolean(this.bb.readInt8(this.bb_pos + offset)) : false;
+  }
+  hasT() {
+    const offset = this.bb.__offset(this.bb_pos, 14);
+    return offset ? Boolean(this.bb.readInt8(this.bb_pos + offset)) : false;
+  }
+  hasTm() {
+    const offset = this.bb.__offset(this.bb_pos, 16);
+    return offset ? Boolean(this.bb.readInt8(this.bb_pos + offset)) : false;
+  }
+  columns(index, obj) {
+    const offset = this.bb.__offset(this.bb_pos, 18);
+    return offset ? (obj || new Column()).__init(
+      this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4),
+      this.bb
+    ) : null;
+  }
+  columnsLength() {
+    const offset = this.bb.__offset(this.bb_pos, 18);
+    return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+  }
+  featuresCount() {
+    const offset = this.bb.__offset(this.bb_pos, 20);
+    return offset ? this.bb.readUint64(this.bb_pos + offset) : BigInt("0");
+  }
+  indexNodeSize() {
+    const offset = this.bb.__offset(this.bb_pos, 22);
+    return offset ? this.bb.readUint16(this.bb_pos + offset) : 16;
+  }
+  crs(obj) {
+    const offset = this.bb.__offset(this.bb_pos, 24);
+    return offset ? (obj || new Crs()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
+  }
+  title(optionalEncoding) {
+    const offset = this.bb.__offset(this.bb_pos, 26);
+    return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+  }
+  description(optionalEncoding) {
+    const offset = this.bb.__offset(this.bb_pos, 28);
+    return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+  }
+  metadata(optionalEncoding) {
+    const offset = this.bb.__offset(this.bb_pos, 30);
+    return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+  }
+  static startHeader(builder) {
+    builder.startObject(14);
+  }
+  static addName(builder, nameOffset) {
+    builder.addFieldOffset(0, nameOffset, 0);
+  }
+  static addEnvelope(builder, envelopeOffset) {
+    builder.addFieldOffset(1, envelopeOffset, 0);
+  }
+  static createEnvelopeVector(builder, data) {
+    builder.startVector(8, data.length, 8);
+    for (let i = data.length - 1; i >= 0; i--) {
+      builder.addFloat64(data[i]);
+    }
+    return builder.endVector();
+  }
+  static startEnvelopeVector(builder, numElems) {
+    builder.startVector(8, numElems, 8);
+  }
+  static addGeometryType(builder, geometryType) {
+    builder.addFieldInt8(2, geometryType, 0 /* Unknown */);
+  }
+  static addHasZ(builder, hasZ) {
+    builder.addFieldInt8(3, Number(hasZ), Number(false));
+  }
+  static addHasM(builder, hasM) {
+    builder.addFieldInt8(4, Number(hasM), Number(false));
+  }
+  static addHasT(builder, hasT) {
+    builder.addFieldInt8(5, Number(hasT), Number(false));
+  }
+  static addHasTm(builder, hasTm) {
+    builder.addFieldInt8(6, Number(hasTm), Number(false));
+  }
+  static addColumns(builder, columnsOffset) {
+    builder.addFieldOffset(7, columnsOffset, 0);
+  }
+  static createColumnsVector(builder, data) {
+    builder.startVector(4, data.length, 4);
+    for (let i = data.length - 1; i >= 0; i--) {
+      builder.addOffset(data[i]);
+    }
+    return builder.endVector();
+  }
+  static startColumnsVector(builder, numElems) {
+    builder.startVector(4, numElems, 4);
+  }
+  static addFeaturesCount(builder, featuresCount) {
+    builder.addFieldInt64(8, featuresCount, BigInt("0"));
+  }
+  static addIndexNodeSize(builder, indexNodeSize) {
+    builder.addFieldInt16(9, indexNodeSize, 16);
+  }
+  static addCrs(builder, crsOffset) {
+    builder.addFieldOffset(10, crsOffset, 0);
+  }
+  static addTitle(builder, titleOffset) {
+    builder.addFieldOffset(11, titleOffset, 0);
+  }
+  static addDescription(builder, descriptionOffset) {
+    builder.addFieldOffset(12, descriptionOffset, 0);
+  }
+  static addMetadata(builder, metadataOffset) {
+    builder.addFieldOffset(13, metadataOffset, 0);
+  }
+  static endHeader(builder) {
+    const offset = builder.endObject();
+    return offset;
+  }
+  static finishHeaderBuffer(builder, offset) {
+    builder.finish(offset);
+  }
+  static finishSizePrefixedHeaderBuffer(builder, offset) {
+    builder.finish(offset, void 0, true);
+  }
+};
+
+// src/flatgeobuf/3.27.2/header-meta.ts
+function fromByteBuffer(bb) {
+  const header = Header.getRootAsHeader(bb);
+  const featuresCount = header.featuresCount();
+  const indexNodeSize = header.indexNodeSize();
+  const columns = [];
+  for (let j = 0; j < header.columnsLength(); j++) {
+    const column = header.columns(j);
+    if (!column)
+      throw new Error("Column unexpectedly missing");
+    if (!column.name())
+      throw new Error("Column name unexpectedly missing");
+    columns.push({
+      name: column.name(),
+      type: column.type(),
+      title: column.title(),
+      description: column.description(),
+      width: column.width(),
+      precision: column.precision(),
+      scale: column.scale(),
+      nullable: column.nullable(),
+      unique: column.unique(),
+      primary_key: column.primaryKey()
+    });
+  }
+  const crs = header.crs();
+  const crsMeta = crs ? {
+    org: crs.org(),
+    code: crs.code(),
+    name: crs.name(),
+    description: crs.description(),
+    wkt: crs.wkt(),
+    code_string: crs.codeString()
+  } : null;
+  const headerMeta = {
+    geometryType: header.geometryType(),
+    columns,
+    envelope: null,
+    featuresCount: Number(featuresCount),
+    indexNodeSize,
+    crs: crsMeta,
+    title: header.title(),
+    description: header.description(),
+    metadata: header.metadata()
+  };
+  return headerMeta;
+}
+
+// src/flatgeobuf/3.27.2/http-reader.ts
+var flatbuffers7 = __toESM(require("flatbuffers"), 1);
+var import_repeater = require("@repeaterjs/repeater");
+
+// src/flatgeobuf/3.27.2/config.ts
+var _Config = class {
+  constructor() {
+    this._extraRequestThreshold = 256 * 1024;
+  }
+  /**
+   * Fetch up to this many extra bytes if it will eliminate an extra request
+   */
+  extraRequestThreshold() {
+    return this._extraRequestThreshold;
+  }
+  setExtraRequestThreshold(bytes) {
+    if (bytes < 0) {
+      throw new Error("extraRequestThreshold cannot be negative");
+    }
+    this._extraRequestThreshold = bytes;
+  }
+};
+var Config = _Config;
+Config.global = new _Config();
+
+// src/flatgeobuf/3.27.2/logger.ts
+var Logger = class {
+  static debug(...args) {
+    this.log(0 /* Debug */, ...args);
+  }
+  static info(...args) {
+    this.log(1 /* Info */, ...args);
+  }
+  static warn(...args) {
+    this.log(2 /* Warn */, ...args);
+  }
+  static error(...args) {
+    this.log(3 /* Error */, ...args);
+  }
+  static log(level, ...args) {
+    if (this.logLevel > level) {
+      return;
+    }
+    switch (level) {
+      case 0 /* Debug */: {
+        console.debug(...args);
+        break;
+      }
+      case 1 /* Info */: {
+        console.info(...args);
+        break;
+      }
+      case 2 /* Warn */: {
+        console.warn(...args);
+        break;
+      }
+      case 3 /* Error */: {
+        console.error(...args);
+        break;
+      }
+    }
+  }
+};
+Logger.logLevel = 2 /* Warn */;
+
+// src/flatgeobuf/3.27.2/packedrtree.ts
+var NODE_ITEM_BYTE_LEN = 8 * 4 + 8;
+var DEFAULT_NODE_SIZE = 16;
+function calcTreeSize(numItems, nodeSize) {
+  nodeSize = Math.min(Math.max(Number(nodeSize), 2), 65535);
+  let n = numItems;
+  let numNodes = n;
+  do {
+    n = Math.ceil(n / nodeSize);
+    numNodes += n;
+  } while (n !== 1);
+  return numNodes * NODE_ITEM_BYTE_LEN;
+}
+function generateLevelBounds(numItems, nodeSize) {
+  if (nodeSize < 2)
+    throw new Error("Node size must be at least 2");
+  if (numItems === 0)
+    throw new Error("Number of items must be greater than 0");
+  let n = numItems;
+  let numNodes = n;
+  const levelNumNodes = [n];
+  do {
+    n = Math.ceil(n / nodeSize);
+    numNodes += n;
+    levelNumNodes.push(n);
+  } while (n !== 1);
+  const levelOffsets = [];
+  n = numNodes;
+  for (const size of levelNumNodes) {
+    levelOffsets.push(n - size);
+    n -= size;
+  }
+  const levelBounds = [];
+  for (let i = 0; i < levelNumNodes.length; i++)
+    levelBounds.push([levelOffsets[i], levelOffsets[i] + levelNumNodes[i]]);
+  return levelBounds;
+}
+async function* streamSearch(numItems, nodeSize, rect, readNode) {
+  class NodeRange {
+    constructor(nodes, level) {
+      this._level = level;
+      this.nodes = nodes;
+    }
+    level() {
+      return this._level;
+    }
+    startNodeIdx() {
+      return this.nodes[0];
+    }
+    endNodeIdx() {
+      return this.nodes[1];
+    }
+    extendEndNodeIdx(newIdx) {
+      console.assert(newIdx > this.nodes[1]);
+      this.nodes[1] = newIdx;
+    }
+    toString() {
+      return `[NodeRange level: ${this._level}, nodes: ${this.nodes[0]}-${this.nodes[1]}]`;
+    }
+  }
+  const { minX, minY, maxX, maxY } = rect;
+  Logger.info(`tree items: ${numItems}, nodeSize: ${nodeSize}`);
+  const levelBounds = generateLevelBounds(numItems, nodeSize);
+  const firstLeafNodeIdx = levelBounds[0][0];
+  const rootNodeRange = (() => {
+    const range = [0, 1];
+    const level = levelBounds.length - 1;
+    return new NodeRange(range, level);
+  })();
+  const queue = [rootNodeRange];
+  Logger.debug(
+    `starting stream search with queue: ${queue}, numItems: ${numItems}, nodeSize: ${nodeSize}, levelBounds: ${levelBounds}`
+  );
+  while (queue.length != 0) {
+    const nodeRange = queue.shift();
+    Logger.debug(`popped node: ${nodeRange}, queueLength: ${queue.length}`);
+    const nodeRangeStartIdx = nodeRange.startNodeIdx();
+    const isLeafNode = nodeRangeStartIdx >= firstLeafNodeIdx;
+    const nodeRangeEndIdx = (() => {
+      const [, levelBound] = levelBounds[nodeRange.level()];
+      const nodeIdx = Math.min(nodeRange.endNodeIdx() + nodeSize, levelBound);
+      if (isLeafNode && nodeIdx < levelBound) {
+        return nodeIdx + 1;
+      }
+      return nodeIdx;
+    })();
+    const numNodesInRange = nodeRangeEndIdx - nodeRangeStartIdx;
+    const buffer = await readNode(
+      nodeRangeStartIdx * NODE_ITEM_BYTE_LEN,
+      numNodesInRange * NODE_ITEM_BYTE_LEN
+    );
+    const dataView = new DataView(buffer);
+    for (let nodeIdx = nodeRangeStartIdx; nodeIdx < nodeRangeEndIdx; nodeIdx++) {
+      const nodeIdxInDataView = nodeIdx - nodeRangeStartIdx;
+      const dataViewByteStart = nodeIdxInDataView * NODE_ITEM_BYTE_LEN;
+      if (maxX < dataView.getFloat64(dataViewByteStart + 0, true))
+        continue;
+      if (maxY < dataView.getFloat64(dataViewByteStart + 8, true))
+        continue;
+      if (minX > dataView.getFloat64(dataViewByteStart + 16, true))
+        continue;
+      if (minY > dataView.getFloat64(dataViewByteStart + 24, true))
+        continue;
+      const offset = dataView.getBigUint64(dataViewByteStart + 32, true);
+      if (isLeafNode) {
+        const featureByteOffset = offset;
+        const featureLength = (() => {
+          if (nodeIdx < numItems - 1) {
+            const nextPos = (nodeIdxInDataView + 1) * NODE_ITEM_BYTE_LEN;
+            const nextOffset = dataView.getBigUint64(nextPos + 32, true);
+            return nextOffset - featureByteOffset;
+          }
+          return null;
+        })();
+        const featureIdx = nodeIdx - firstLeafNodeIdx;
+        yield [Number(featureByteOffset), featureIdx, Number(featureLength)];
+        continue;
+      }
+      const firstChildNodeIdx = offset;
+      const extraRequestThresholdNodes = Config.global.extraRequestThreshold() / NODE_ITEM_BYTE_LEN;
+      const nearestNodeRange = queue[queue.length - 1];
+      if (nearestNodeRange !== void 0 && nearestNodeRange.level() == nodeRange.level() - 1 && firstChildNodeIdx < nearestNodeRange.endNodeIdx() + extraRequestThresholdNodes) {
+        Logger.debug(
+          `Merging "nodeRange" request into existing range: ${nearestNodeRange}, newEndNodeIdx: ${nearestNodeRange.endNodeIdx()} -> ${firstChildNodeIdx}`
+        );
+        nearestNodeRange.extendEndNodeIdx(Number(firstChildNodeIdx));
+        continue;
+      }
+      const newNodeRange = (() => {
+        const level = nodeRange.level() - 1;
+        const range = [Number(firstChildNodeIdx), Number(firstChildNodeIdx) + 1];
+        return new NodeRange(range, level);
+      })();
+      if (nearestNodeRange !== void 0 && nearestNodeRange.level() == newNodeRange.level()) {
+        Logger.info(
+          `Same level, but too far away. Pushing new request for nodeIdx: ${firstChildNodeIdx} rather than merging with distant ${nearestNodeRange}`
+        );
+      } else {
+        Logger.info(
+          `Pushing new level for ${newNodeRange} onto queue with nearestNodeRange: ${nearestNodeRange} since there's not already a range for this level.`
+        );
+      }
+      queue.push(newNodeRange);
+    }
+  }
+}
+
+// src/flatgeobuf/3.27.2/constants.ts
+var magicbytes = new Uint8Array([
+  102,
+  103,
+  98,
+  3,
+  102,
+  103,
+  98,
+  0
+]);
+var SIZE_PREFIX_LEN = 4;
+
+// src/flatgeobuf/3.27.2/http-reader.ts
+var HttpReader = class {
+  constructor(headerClient, header, headerLength, indexLength) {
+    this.headerClient = headerClient;
+    this.header = header;
+    this.headerLength = headerLength;
+    this.indexLength = indexLength;
+  }
+  // Fetch the header, preparing the reader to read Feature data.
+  //
+  // and potentially some opportunistic fetching of the index.
+  static async open(url) {
+    const assumedHeaderLength = 2024;
+    const headerClient = new BufferedHttpRangeClient(url);
+    const assumedIndexLength = (() => {
+      const assumedBranchingFactor = DEFAULT_NODE_SIZE;
+      const prefetchedLayers = 3;
+      let result = 0;
+      let i;
+      for (i = 0; i < prefetchedLayers; i++) {
+        const layer_width = assumedBranchingFactor ** i * NODE_ITEM_BYTE_LEN;
+        result += layer_width;
+      }
+      return result;
+    })();
+    const minReqLength = assumedHeaderLength + assumedIndexLength;
+    Logger.debug(
+      `fetching header. minReqLength: ${minReqLength} (assumedHeaderLength: ${assumedHeaderLength}, assumedIndexLength: ${assumedIndexLength})`
+    );
+    {
+      const bytes2 = new Uint8Array(await headerClient.getRange(0, 8, minReqLength, "header"));
+      if (!bytes2.subarray(0, 3).every((v, i) => magicbytes[i] === v)) {
+        Logger.error(`bytes: ${bytes2} != ${magicbytes}`);
+        throw new Error("Not a FlatGeobuf file");
+      }
+      Logger.debug("magic bytes look good");
+    }
+    let headerLength;
+    {
+      const bytes2 = await headerClient.getRange(8, 4, minReqLength, "header");
+      headerLength = new DataView(bytes2).getUint32(0, true);
+      const HEADER_MAX_BUFFER_SIZE = 1048576 * 10;
+      if (headerLength > HEADER_MAX_BUFFER_SIZE || headerLength < 8) {
+        throw new Error("Invalid header size");
+      }
+      Logger.debug(`headerLength: ${headerLength}`);
+    }
+    const bytes = await headerClient.getRange(12, headerLength, minReqLength, "header");
+    const bb = new flatbuffers7.ByteBuffer(new Uint8Array(bytes));
+    const header = fromByteBuffer(bb);
+    const indexLength = calcTreeSize(header.featuresCount, header.indexNodeSize);
+    Logger.debug("completed: opening http reader");
+    return new HttpReader(headerClient, header, headerLength, indexLength);
+  }
+  async *selectBbox(rect) {
+    const lengthBeforeTree = this.lengthBeforeTree();
+    const bufferedClient = this.headerClient;
+    const readNode = async function(offsetIntoTree, size) {
+      const minReqLength = 0;
+      return bufferedClient.getRange(
+        lengthBeforeTree + offsetIntoTree,
+        size,
+        minReqLength,
+        "index"
+      );
+    };
+    const batches = [];
+    let currentBatch = [];
+    for await (const searchResult of streamSearch(
+      this.header.featuresCount,
+      this.header.indexNodeSize,
+      rect,
+      readNode
+    )) {
+      const [featureOffset, ,] = searchResult;
+      let [, , featureLength] = searchResult;
+      if (!featureLength) {
+        Logger.info("final feature");
+        featureLength = 4;
+      }
+      if (currentBatch.length == 0) {
+        currentBatch.push([featureOffset, featureLength]);
+        continue;
+      }
+      const prevFeature = currentBatch[currentBatch.length - 1];
+      const gap = featureOffset - (prevFeature[0] + prevFeature[1]);
+      if (gap > Config.global.extraRequestThreshold()) {
+        Logger.info(`Pushing new feature batch, since gap ${gap} was too large`);
+        batches.push(currentBatch);
+        currentBatch = [];
+      }
+      currentBatch.push([featureOffset, featureLength]);
+    }
+    this.headerClient.logUsage("header+index");
+    if (currentBatch.length > 0) {
+      batches.push(currentBatch);
+    }
+    const promises = batches.flatMap(
+      (batch) => this.readFeatureBatch(batch)
+    );
+    yield* import_repeater.Repeater.merge(promises);
+  }
+  lengthBeforeTree() {
+    return magicbytes.length + SIZE_PREFIX_LEN + this.headerLength;
+  }
+  lengthBeforeFeatures() {
+    return this.lengthBeforeTree() + this.indexLength;
+  }
+  buildFeatureClient() {
+    return new BufferedHttpRangeClient(this.headerClient.httpClient);
+  }
+  /**
+   * Fetch a batch of features in a single request, yielding each Feature
+   *
+   * `batch`: [offset, length] of features in the batch
+   */
+  async *readFeatureBatch(batch) {
+    const [firstFeatureOffset] = batch[0];
+    const [lastFeatureOffset, lastFeatureLength] = batch[batch.length - 1];
+    const batchStart = firstFeatureOffset;
+    const batchEnd = lastFeatureOffset + lastFeatureLength;
+    const batchSize = batchEnd - batchStart;
+    const featureClient = this.buildFeatureClient();
+    let minFeatureReqLength = batchSize;
+    for (const [featureOffset] of batch) {
+      yield await this.readFeature(featureClient, featureOffset, minFeatureReqLength);
+      minFeatureReqLength = 0;
+    }
+    featureClient.logUsage("feature");
+  }
+  async readFeature(featureClient, featureOffset, minFeatureReqLength) {
+    const offset = featureOffset + this.lengthBeforeFeatures();
+    let featureLength;
+    {
+      const bytes2 = await featureClient.getRange(offset, 4, minFeatureReqLength, "feature length");
+      featureLength = new DataView(bytes2).getUint32(0, true);
+    }
+    const byteBuffer = await featureClient.getRange(
+      offset + 4,
+      featureLength,
+      minFeatureReqLength,
+      "feature data"
+    );
+    const bytes = new Uint8Array(byteBuffer);
+    const bytesAligned = new Uint8Array(featureLength + SIZE_PREFIX_LEN);
+    bytesAligned.set(bytes, SIZE_PREFIX_LEN);
+    const bb = new flatbuffers7.ByteBuffer(bytesAligned);
+    bb.setPosition(SIZE_PREFIX_LEN);
+    return Feature.getRootAsFeature(bb);
+  }
+};
+var BufferedHttpRangeClient = class {
+  constructor(source) {
+    this.bytesEverUsed = 0;
+    this.bytesEverFetched = 0;
+    this.buffer = new ArrayBuffer(0);
+    // Byte offset of `buffer` with respect to the beginning of the file being
+    // buffered
+    this.head = 0;
+    if (typeof source === "string") {
+      this.httpClient = new HttpRangeClient(source);
+    } else if (source instanceof HttpRangeClient) {
+      this.httpClient = source;
+    } else {
+      throw new Error("Unknown source ");
+    }
+  }
+  async getRange(start, length, minReqLength, purpose) {
+    this.bytesEverUsed += length;
+    const start_i = start - this.head;
+    const end_i = start_i + length;
+    if (start_i >= 0 && end_i <= this.buffer.byteLength) {
+      return this.buffer.slice(start_i, end_i);
+    }
+    const lengthToFetch = Math.max(length, minReqLength);
+    this.bytesEverFetched += lengthToFetch;
+    Logger.debug(`requesting for new Range: ${start}-${start + lengthToFetch - 1}`);
+    this.buffer = await this.httpClient.getRange(start, lengthToFetch, purpose);
+    this.head = start;
+    return this.buffer.slice(0, length);
+  }
+  logUsage(purpose) {
+    const category = purpose.split(" ")[0];
+    const used = this.bytesEverUsed;
+    const requested = this.bytesEverFetched;
+    const efficiency = (100 * used / requested).toFixed(2);
+    Logger.info(`${category} bytes used/requested: ${used} / ${requested} = ${efficiency}%`);
+  }
+};
+var HttpRangeClient = class {
+  constructor(url) {
+    this.requestsEverMade = 0;
+    this.bytesEverRequested = 0;
+    this.url = url;
+  }
+  async getRange(begin, length, purpose) {
+    this.requestsEverMade += 1;
+    this.bytesEverRequested += length;
+    const range = `bytes=${begin}-${begin + length - 1}`;
+    Logger.info(
+      `request: #${this.requestsEverMade}, purpose: ${purpose}), bytes: (this_request: ${length}, ever: ${this.bytesEverRequested}), Range: ${range}`
+    );
+    const response = await fetch(this.url, {
+      headers: {
+        Range: range
+        // TODO: better parallelize requests on Chrome
+        //
+        // Safari and Firefox have no issue performing Range requests
+        // for a resource in parallel, but Chrome will stall a
+        // subsequent request to the resource until it's received the
+        // response headers of the prior request. So, it still allows
+        // some limited parallelization, but it's not ideal.
+        //
+        // This is seemingly an artifact of how Chrome manages caching
+        // and it might differ between platforms. We could work around it
+        // by setting the request header:
+        //
+        //      'Cache-Control': 'no-cache, no-store'
+        //
+        // This allows requests to be fully parallelized in Chrome, but
+        // then Chrome won't cache the response, so it seems not a
+        // great trade-off.
+        //
+        // Another work around would be to make each Range request for
+        // a separate URL by appending something like
+        // `?cache_buster=<range>` to the URL, but then Chrome will
+        // require an additional CORS preflight OPTIONS requests per
+        // Range, which is also not a great trade-off.
+        //
+        // See:
+        // https://bugs.chromium.org/p/chromium/issues/detail?id=969828&q=concurrent%20range%20requests&can=2
+        // https://stackoverflow.com/questions/27513994/chrome-stalls-when-making-multiple-requests-to-same-resource
+      }
+    });
+    return response.arrayBuffer();
+  }
+};
+
+// src/flatgeobuf/3.27.2/generic/featurecollection.ts
+function deserialize(bytes, fromFeature2, headerMetaFn) {
+  if (!bytes.subarray(0, 3).every((v, i) => magicbytes[i] === v))
+    throw new Error("Not a FlatGeobuf file");
+  const bb = new flatbuffers8.ByteBuffer(bytes);
+  const headerLength = bb.readUint32(magicbytes.length);
+  bb.setPosition(magicbytes.length + SIZE_PREFIX_LEN);
+  const headerMeta = fromByteBuffer(bb);
+  if (headerMetaFn)
+    headerMetaFn(headerMeta);
+  let offset = magicbytes.length + SIZE_PREFIX_LEN + headerLength;
+  const { indexNodeSize, featuresCount } = headerMeta;
+  if (indexNodeSize > 0)
+    offset += calcTreeSize(featuresCount, indexNodeSize);
+  const features = [];
+  while (offset < bb.capacity()) {
+    const featureLength = bb.readUint32(offset);
+    bb.setPosition(offset + SIZE_PREFIX_LEN);
+    const feature = Feature.getRootAsFeature(bb);
+    features.push(fromFeature2(feature, headerMeta));
+    offset += SIZE_PREFIX_LEN + featureLength;
+  }
+  return features;
+}
+async function* deserializeStream(stream, fromFeature2, headerMetaFn) {
+  const reader = (0, import_slice_source.default)(stream);
+  const read = async (size) => await reader.slice(size);
+  let bytes = new Uint8Array(await read(8, "magic bytes"));
+  if (!bytes.subarray(0, 3).every((v, i) => magicbytes[i] === v))
+    throw new Error("Not a FlatGeobuf file");
+  bytes = new Uint8Array(await read(4, "header length"));
+  let bb = new flatbuffers8.ByteBuffer(bytes);
+  const headerLength = bb.readUint32(0);
+  bytes = new Uint8Array(await read(headerLength, "header data"));
+  bb = new flatbuffers8.ByteBuffer(bytes);
+  const headerMeta = fromByteBuffer(bb);
+  if (headerMetaFn)
+    headerMetaFn(headerMeta);
+  const { indexNodeSize, featuresCount } = headerMeta;
+  if (indexNodeSize > 0) {
+    const treeSize = calcTreeSize(featuresCount, indexNodeSize);
+    await read(treeSize, "entire index, w/o rect");
+  }
+  let feature;
+  while (feature = await readFeature(read, headerMeta, fromFeature2))
+    yield feature;
+}
+async function* deserializeFiltered(url, rect, fromFeature2, headerMetaFn) {
+  const reader = await HttpReader.open(url);
+  Logger.debug("opened reader");
+  if (headerMetaFn)
+    headerMetaFn(reader.header);
+  for await (const feature of reader.selectBbox(rect)) {
+    yield fromFeature2(feature, reader.header);
+  }
+}
+async function readFeature(read, headerMeta, fromFeature2) {
+  let bytes = new Uint8Array(await read(4, "feature length"));
+  if (bytes.byteLength === 0)
+    return;
+  let bb = new flatbuffers8.ByteBuffer(bytes);
+  const featureLength = bb.readUint32(0);
+  bytes = new Uint8Array(await read(featureLength, "feature data"));
+  const bytesAligned = new Uint8Array(featureLength + 4);
+  bytesAligned.set(bytes, 4);
+  bb = new flatbuffers8.ByteBuffer(bytesAligned);
+  bb.setPosition(SIZE_PREFIX_LEN);
+  const feature = Feature.getRootAsFeature(bb);
+  return fromFeature2(feature, headerMeta);
+}
+
+// src/flatgeobuf/3.27.2/geojson/featurecollection.ts
+function deserialize2(bytes, headerMetaFn) {
+  const features = deserialize(bytes, fromFeature, headerMetaFn);
+  return {
+    type: "FeatureCollection",
+    features
+  };
+}
+function deserializeStream2(stream, headerMetaFn) {
+  return deserializeStream(stream, fromFeature, headerMetaFn);
+}
+function deserializeFiltered2(url, rect, headerMetaFn) {
+  return deserializeFiltered(url, rect, fromFeature, headerMetaFn);
+}
+
+// src/flatgeobuf/3.27.2/geojson.ts
+function deserialize3(input, rect, headerMetaFn) {
+  if (input instanceof Uint8Array)
+    return deserialize2(input, headerMetaFn);
+  else if (input instanceof ReadableStream)
+    return deserializeStream2(input, headerMetaFn);
+  return deserializeFiltered2(input, rect, headerMetaFn);
+}
+
+// src/flatgeobuf/3.27.2/generic.ts
+function deserialize4(input, fromFeature2, rect) {
+  if (input instanceof Uint8Array)
+    return deserialize(input, fromFeature2);
+  else if (input instanceof ReadableStream)
+    return deserializeStream(input, fromFeature2);
+  return deserializeFiltered(input, rect, fromFeature2);
+}
+
 // src/lib/parse-flatgeobuf.ts
-var geojson = __toESM(require("flatgeobuf/lib/mjs/geojson.js"), 1);
-var generic = __toESM(require("flatgeobuf/lib/mjs/generic.js"), 1);
-var import_feature = require("flatgeobuf/lib/mjs/generic/feature");
-var deserializeGeoJson = geojson.deserialize;
-var deserializeGeneric = generic.deserialize;
+var deserializeGeoJson = deserialize3;
+var deserializeGeneric = deserialize4;
 function binaryFromFeature(feature, header) {
   const geometry = feature.geometry();
   const geometryType = header.geometryType || (geometry == null ? void 0 : geometry.type());
   const parsedGeometry = fgbToBinaryGeometry(geometry, geometryType);
-  parsedGeometry.properties = (0, import_feature.parseProperties)(feature, header.columns);
+  parsedGeometry.properties = parseProperties(feature, header.columns);
   return parsedGeometry;
 }
 function parseFlatGeobuf(arrayBuffer, options) {
@@ -189,13 +1779,7 @@ function parseFlatGeobuf(arrayBuffer, options) {
   const shape = (_a = options == null ? void 0 : options.flatgeobuf) == null ? void 0 : _a.shape;
   switch (shape) {
     case "geojson-table": {
-      const features = parseFlatGeobufToGeoJSON(arrayBuffer, options);
-      const table = {
-        shape: "geojson-table",
-        type: "FeatureCollection",
-        features
-      };
-      return table;
+      return parseFlatGeobufToGeoJSONTable(arrayBuffer, options);
     }
     case "columnar-table":
       const binary = parseFlatGeobufToBinary(arrayBuffer, options);
@@ -210,17 +1794,19 @@ function parseFlatGeobufToBinary(arrayBuffer, options = {}) {
   const array = new Uint8Array(arrayBuffer);
   return deserializeGeneric(array, fgbToBinaryGeometry);
 }
-function parseFlatGeobufToGeoJSON(arrayBuffer, options = {}) {
+function parseFlatGeobufToGeoJSONTable(arrayBuffer, options = {}) {
   if (arrayBuffer.byteLength === 0) {
-    return [];
+    return { shape: "geojson-table", type: "FeatureCollection", features: [] };
   }
   const { reproject = false, _targetCrs = "WGS84" } = options && options.gis || {};
   const arr = new Uint8Array(arrayBuffer);
-  let headerMeta;
-  const { features } = deserializeGeoJson(arr, void 0, (header) => {
-    headerMeta = header;
+  let fgbHeader;
+  let schema;
+  let { features } = deserializeGeoJson(arr, void 0, (headerMeta) => {
+    fgbHeader = headerMeta;
+    schema = getSchemaFromFGBHeader(fgbHeader);
   });
-  const crs = headerMeta && headerMeta.crs;
+  const crs = fgbHeader && fgbHeader.crs;
   let projection;
   if (reproject && crs) {
     try {
@@ -229,9 +1815,9 @@ function parseFlatGeobufToGeoJSON(arrayBuffer, options = {}) {
     }
   }
   if (projection) {
-    return (0, import_gis.transformGeoJsonCoords)(features, (coords) => projection.project(coords));
+    features = (0, import_gis.transformGeoJsonCoords)(features, (coords) => projection.project(coords));
   }
-  return features;
+  return { shape: "geojson-table", schema, type: "FeatureCollection", features };
 }
 function parseFlatGeobufInBatches(stream, options) {
   var _a;
@@ -251,15 +1837,15 @@ function parseFlatGeobufInBatchesToBinary(stream, options) {
 }
 async function* parseFlatGeobufInBatchesToGeoJSON(stream, options) {
   const { reproject = false, _targetCrs = "WGS84" } = options && options.gis || {};
-  let headerMeta;
-  const iterator = deserializeGeoJson(stream, void 0, (header) => {
-    headerMeta = header;
+  let fgbHeader;
+  const iterator = deserializeGeoJson(stream, void 0, (headerMeta) => {
+    fgbHeader = headerMeta;
   });
   let projection;
   let firstRecord = true;
   for await (const feature of iterator) {
     if (firstRecord) {
-      const crs = headerMeta && headerMeta.crs;
+      const crs = fgbHeader && fgbHeader.crs;
       if (reproject && crs) {
         projection = new import_proj4.Proj4Projection({ from: crs.wkt, to: _targetCrs });
       }
@@ -273,9 +1859,30 @@ async function* parseFlatGeobufInBatchesToGeoJSON(stream, options) {
   }
 }
 
-// src/index.ts
-var FlatGeobufLoader2 = {
-  ...FlatGeobufLoader,
+// src/flatgeobuf-loader.ts
+var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+var FGB_MAGIC_NUMBER = [102, 103, 98, 3, 102, 103, 98, 1];
+var FlatGeobufWorkerLoader = {
+  id: "flatgeobuf",
+  name: "FlatGeobuf",
+  module: "flatgeobuf",
+  version: VERSION,
+  worker: true,
+  extensions: ["fgb"],
+  mimeTypes: ["application/octet-stream"],
+  category: "geometry",
+  tests: [new Uint8Array(FGB_MAGIC_NUMBER).buffer],
+  options: {
+    flatgeobuf: {
+      shape: "geojson-table"
+    },
+    gis: {
+      reproject: false
+    }
+  }
+};
+var FlatGeobufLoader = {
+  ...FlatGeobufWorkerLoader,
   parse: async (arrayBuffer, options) => parseFlatGeobuf(arrayBuffer, options),
   parseSync: parseFlatGeobuf,
   // @ts-expect-error this is a stream parser not an async iterator parser