@loaders.gl/flatgeobuf 4.3.1 → 4.4.0-alpha.1

package/dist/dist.dev.js

@@ -53,11 +53,23 @@ var __exports__ = (() => {
   // bundle.ts
   var bundle_exports = {};
   __export(bundle_exports, {
+    FlatGeobufFormat: () => FlatGeobufFormat,
     FlatGeobufLoader: () => FlatGeobufLoader,
-    FlatGeobufWorkerLoader: () => FlatGeobufWorkerLoader
+    FlatGeobufWorkerLoader: () => FlatGeobufWorkerLoader,
+    _FlatGeobufSource: () => FlatGeobufSource
   });
   __reExport(bundle_exports, __toESM(require_core(), 1));
 
+  // src/flatgeobuf-format.ts
+  var FlatGeobufFormat = {
+    id: "flatgeobuf",
+    name: "FlatGeobuf",
+    module: "flatgeobuf",
+    extensions: ["fgb"],
+    mimeTypes: ["application/octet-stream"],
+    category: "geometry"
+  };
+
   // ../../node_modules/proj4/lib/global.js
   function global_default(defs2) {
     defs2("EPSG:4326", "+title=WGS 84 (long/lat) +proj=longlat +ellps=WGS84 +datum=WGS84 +units=degrees");
@@ -5411,7 +5423,7 @@ var __exports__ = (() => {
     }
   };
 
-  // ../gis/src/lib/binary-features/transform.ts
+  // ../gis/src/lib/binary-geometry-api/transform-coordinates.ts
   function transformGeoJsonCoords(features, fn) {
     for (const feature of features) {
       feature.geometry.coordinates = coordMap(feature.geometry.coordinates, fn);
@@ -5430,209 +5442,6 @@ var __exports__ = (() => {
     return Array.isArray(array) && Number.isFinite(array[0]) && Number.isFinite(array[1]);
   }
 
-  // src/lib/binary-geometries.ts
-  function fgbToBinaryGeometry(geometry, type) {
-    if (geometry === null) {
-      return null;
-    }
-    switch (type) {
-      case GeometryType.Point:
-      case GeometryType.MultiPoint:
-        return parsePoint(geometry);
-      case GeometryType.LineString:
-      case GeometryType.MultiLineString:
-        return parseLines(geometry);
-      case GeometryType.Polygon:
-        return parsePolygons(geometry);
-      case GeometryType.MultiPolygon:
-        return parseMultiPolygons(geometry);
-      default:
-        throw new Error(`Unimplemented geometry type: ${type}`);
-    }
-  }
-  function parsePoint(geometry) {
-    const xy = geometry.xyArray();
-    const z = geometry.zArray();
-    const positions = blitArrays(xy, z);
-    return { positions };
-  }
-  function parseLines(geometry) {
-    const xy = geometry.xyArray();
-    const z = geometry.zArray();
-    const positions = blitArrays(xy, z);
-    const ends = geometry.endsArray() && Array.from(geometry.endsArray()) || [xy.length / 2];
-    ends.unshift(0);
-    const pathIndices = { value: new Uint16Array(ends), size: 1 };
-    return {
-      positions,
-      pathIndices
-    };
-  }
-  function parsePolygons(geometry) {
-    const xy = geometry.xyArray();
-    const z = geometry.zArray();
-    const positions = blitArrays(xy, z);
-    const ends = geometry.endsArray() && Array.from(geometry.endsArray()) || [xy.length / 2];
-    ends.unshift(0);
-    const primitivePolygonIndices = { value: new Uint16Array(ends), size: 1 };
-    const polygonIndices = { value: new Uint16Array([0, xy.length / 2]), size: 1 };
-    return {
-      positions,
-      primitivePolygonIndices,
-      polygonIndices
-    };
-  }
-  function parseMultiPolygons(geometry) {
-    const parsedParts = [];
-    let nPositions = 0;
-    let nPrimitivePolygonIndices = 1;
-    let nPolygonIndices = 1;
-    for (let i = 0; i < geometry.partsLength(); i++) {
-      const part = geometry.parts(i);
-      const polygon = parsePolygons(part);
-      nPositions += polygon.positions.value.length;
-      nPrimitivePolygonIndices += polygon.primitivePolygonIndices.value.length - 1;
-      nPolygonIndices += polygon.polygonIndices.value.length - 1;
-      parsedParts.push(polygon);
-    }
-    const concatPositions = new Float64Array(nPositions);
-    const concatPrimitivePolygonIndices = new Uint32Array(nPrimitivePolygonIndices);
-    const concatPolygonIndices = new Uint32Array(nPolygonIndices);
-    let positionCounter = 0;
-    let primitivePolygonIndicesCounter = 1;
-    let polygonIndicesCounter = 1;
-    const positionSize = parsedParts[0].positions.size;
-    for (const parsedPart of parsedParts) {
-      concatPositions.set(parsedPart.positions.value, positionCounter * positionSize);
-      concatPrimitivePolygonIndices.set(
-        // eslint-disable-next-line
-        parsedPart.primitivePolygonIndices.value.subarray(1).map((x) => x + positionCounter),
-        primitivePolygonIndicesCounter
-      );
-      concatPolygonIndices.set(
-        // eslint-disable-next-line
-        parsedPart.polygonIndices.value.subarray(1).map((x) => x + positionCounter),
-        polygonIndicesCounter
-      );
-      positionCounter += parsedPart.positions.value.length / positionSize;
-      primitivePolygonIndicesCounter += parsedPart.primitivePolygonIndices.value.length - 1;
-      polygonIndicesCounter += parsedPart.polygonIndices.value.length - 1;
-    }
-    return {
-      positions: { value: concatPositions, size: positionSize },
-      primitivePolygonIndices: { value: concatPrimitivePolygonIndices, size: 1 },
-      polygonIndices: { value: concatPolygonIndices, size: 1 }
-    };
-  }
-  function blitArrays(xy, z) {
-    if (!z) {
-      return { value: xy, size: 2 };
-    }
-    if (z.length * 2 !== xy.length) {
-      throw new Error("Z array must be half XY array's length");
-    }
-    const totalLength = xy.length + z.length;
-    const xyz = new Float64Array(totalLength);
-    for (let i = 0; i < xy.length / 2; i++) {
-      xyz[i * 3 + 0] = xy[i * 2 + 0];
-      xyz[i * 3 + 1] = xy[i * 2 + 1];
-      xyz[i * 3 + 2] = z[i];
-    }
-    return { value: xyz, size: 3 };
-  }
-
-  // src/lib/get-schema-from-fgb-header.ts
-  function getSchemaFromFGBHeader(fgbHeader) {
-    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: fgbHeader.envelope?.join(",") || ""
-    };
-    const fields = fgbHeader.columns?.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 || {});
-
   // ../../node_modules/flatbuffers/mjs/constants.js
   var SIZEOF_INT = 4;
   var FILE_IDENTIFIER_LENGTH = 4;
@@ -5895,6 +5704,209 @@ var __exports__ = (() => {
     }
   };
 
+  // src/lib/binary-geometries.ts
+  function fgbToBinaryGeometry(geometry, type) {
+    if (geometry === null) {
+      return null;
+    }
+    switch (type) {
+      case GeometryType.Point:
+      case GeometryType.MultiPoint:
+        return parsePoint(geometry);
+      case GeometryType.LineString:
+      case GeometryType.MultiLineString:
+        return parseLines(geometry);
+      case GeometryType.Polygon:
+        return parsePolygons(geometry);
+      case GeometryType.MultiPolygon:
+        return parseMultiPolygons(geometry);
+      default:
+        throw new Error(`Unimplemented geometry type: ${type}`);
+    }
+  }
+  function parsePoint(geometry) {
+    const xy = geometry.xyArray();
+    const z = geometry.zArray();
+    const positions = blitArrays(xy, z);
+    return { positions };
+  }
+  function parseLines(geometry) {
+    const xy = geometry.xyArray();
+    const z = geometry.zArray();
+    const positions = blitArrays(xy, z);
+    const ends = geometry.endsArray() && Array.from(geometry.endsArray()) || [xy.length / 2];
+    ends.unshift(0);
+    const pathIndices = { value: new Uint16Array(ends), size: 1 };
+    return {
+      positions,
+      pathIndices
+    };
+  }
+  function parsePolygons(geometry) {
+    const xy = geometry.xyArray();
+    const z = geometry.zArray();
+    const positions = blitArrays(xy, z);
+    const ends = geometry.endsArray() && Array.from(geometry.endsArray()) || [xy.length / 2];
+    ends.unshift(0);
+    const primitivePolygonIndices = { value: new Uint16Array(ends), size: 1 };
+    const polygonIndices = { value: new Uint16Array([0, xy.length / 2]), size: 1 };
+    return {
+      positions,
+      primitivePolygonIndices,
+      polygonIndices
+    };
+  }
+  function parseMultiPolygons(geometry) {
+    const parsedParts = [];
+    let nPositions = 0;
+    let nPrimitivePolygonIndices = 1;
+    let nPolygonIndices = 1;
+    for (let i = 0; i < geometry.partsLength(); i++) {
+      const part = geometry.parts(i);
+      const polygon = parsePolygons(part);
+      nPositions += polygon.positions.value.length;
+      nPrimitivePolygonIndices += polygon.primitivePolygonIndices.value.length - 1;
+      nPolygonIndices += polygon.polygonIndices.value.length - 1;
+      parsedParts.push(polygon);
+    }
+    const concatPositions = new Float64Array(nPositions);
+    const concatPrimitivePolygonIndices = new Uint32Array(nPrimitivePolygonIndices);
+    const concatPolygonIndices = new Uint32Array(nPolygonIndices);
+    let positionCounter = 0;
+    let primitivePolygonIndicesCounter = 1;
+    let polygonIndicesCounter = 1;
+    const positionSize = parsedParts[0].positions.size;
+    for (const parsedPart of parsedParts) {
+      concatPositions.set(parsedPart.positions.value, positionCounter * positionSize);
+      concatPrimitivePolygonIndices.set(
+        // eslint-disable-next-line
+        parsedPart.primitivePolygonIndices.value.subarray(1).map((x) => x + positionCounter),
+        primitivePolygonIndicesCounter
+      );
+      concatPolygonIndices.set(
+        // eslint-disable-next-line
+        parsedPart.polygonIndices.value.subarray(1).map((x) => x + positionCounter),
+        polygonIndicesCounter
+      );
+      positionCounter += parsedPart.positions.value.length / positionSize;
+      primitivePolygonIndicesCounter += parsedPart.primitivePolygonIndices.value.length - 1;
+      polygonIndicesCounter += parsedPart.polygonIndices.value.length - 1;
+    }
+    return {
+      positions: { value: concatPositions, size: positionSize },
+      primitivePolygonIndices: { value: concatPrimitivePolygonIndices, size: 1 },
+      polygonIndices: { value: concatPolygonIndices, size: 1 }
+    };
+  }
+  function blitArrays(xy, z) {
+    if (!z) {
+      return { value: xy, size: 2 };
+    }
+    if (z.length * 2 !== xy.length) {
+      throw new Error("Z array must be half XY array's length");
+    }
+    const totalLength = xy.length + z.length;
+    const xyz = new Float64Array(totalLength);
+    for (let i = 0; i < xy.length / 2; i++) {
+      xyz[i * 3 + 0] = xy[i * 2 + 0];
+      xyz[i * 3 + 1] = xy[i * 2 + 1];
+      xyz[i * 3 + 2] = z[i];
+    }
+    return { value: xyz, size: 3 };
+  }
+
+  // src/lib/get-schema-from-fgb-header.ts
+  function getSchemaFromFGBHeader(fgbHeader) {
+    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: fgbHeader.envelope?.join(",") || ""
+    };
+    const fields = fgbHeader.columns?.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 Geometry = class {
     bb = null;
@@ -8681,16 +8693,11 @@ var __exports__ = (() => {
   var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
   var FGB_MAGIC_NUMBER = [102, 103, 98, 3, 102, 103, 98, 1];
   var FlatGeobufWorkerLoader = {
+    ...FlatGeobufFormat,
     dataType: null,
     batchType: null,
-    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: {
@@ -8728,6 +8735,147 @@ var __exports__ = (() => {
       reproject: options?.gis?.reproject || false
     };
   }
+
+  // ../loader-utils/src/lib/option-utils/merge-options.ts
+  function mergeOptions(baseOptions, newOptions) {
+    return mergeOptionsRecursively(baseOptions || {}, newOptions);
+  }
+  function mergeOptionsRecursively(baseOptions, newOptions, level = 0) {
+    if (level > 3) {
+      return newOptions;
+    }
+    const options = { ...baseOptions };
+    for (const [key, newValue] of Object.entries(newOptions)) {
+      if (newValue && typeof newValue === "object" && !Array.isArray(newValue)) {
+        options[key] = mergeOptionsRecursively(
+          options[key] || {},
+          newOptions[key],
+          level + 1
+        );
+      } else {
+        options[key] = newOptions[key];
+      }
+    }
+    return options;
+  }
+
+  // ../loader-utils/src/lib/path-utils/file-aliases.ts
+  var pathPrefix = "";
+  var fileAliases = {};
+  function resolvePath(filename) {
+    for (const alias in fileAliases) {
+      if (filename.startsWith(alias)) {
+        const replacement = fileAliases[alias];
+        filename = filename.replace(alias, replacement);
+      }
+    }
+    if (!filename.startsWith("http://") && !filename.startsWith("https://")) {
+      filename = `${pathPrefix}${filename}`;
+    }
+    return filename;
+  }
+
+  // ../loader-utils/src/lib/sources/data-source.ts
+  var _DataSource = class {
+    optionsType;
+    options;
+    data;
+    url;
+    /** The actual load options, if calling a loaders.gl loader */
+    loadOptions;
+    /** A resolved fetch function extracted from loadOptions prop */
+    fetch;
+    _needsRefresh = true;
+    constructor(data, options, defaultOptions) {
+      if (defaultOptions) {
+        this.options = mergeOptions({ ...defaultOptions, core: _DataSource.defaultOptions }, options);
+      } else {
+        this.options = { ...options };
+      }
+      this.data = data;
+      this.url = typeof data === "string" ? resolvePath(data) : "";
+      this.loadOptions = { ...this.options.core?.loadOptions };
+      this.fetch = getFetchFunction(this.loadOptions);
+    }
+    setProps(options) {
+      this.options = Object.assign(this.options, options);
+      this.setNeedsRefresh();
+    }
+    /** Mark this data source as needing a refresh (redraw) */
+    setNeedsRefresh() {
+      this._needsRefresh = true;
+    }
+    /**
+     * Does this data source need refreshing?
+     * @note The specifics of the refresh mechanism depends on type of data source
+     */
+    getNeedsRefresh(clear = true) {
+      const needsRefresh = this._needsRefresh;
+      if (clear) {
+        this._needsRefresh = false;
+      }
+      return needsRefresh;
+    }
+  };
+  var DataSource = _DataSource;
+  __publicField(DataSource, "defaultOptions", {
+    core: {
+      type: "auto",
+      attributions: [],
+      loadOptions: {},
+      loaders: []
+    }
+  });
+  function getFetchFunction(options) {
+    const fetchFunction = options?.fetch;
+    if (fetchFunction && typeof fetchFunction === "function") {
+      return (url, fetchOptions2) => fetchFunction(url, fetchOptions2);
+    }
+    const fetchOptions = options?.fetch;
+    if (fetchOptions && typeof fetchOptions !== "function") {
+      return (url) => fetch(url, fetchOptions);
+    }
+    return (url) => fetch(url);
+  }
+
+  // src/flatgeobuf-source.ts
+  var FlatGeobufSource = {
+    ...FlatGeobufFormat,
+    version: "0.0.0",
+    type: "flatgeobuf-server",
+    fromUrl: true,
+    fromBlob: false,
+    // TODO check if supported by library?
+    defaultOptions: {
+      flatgeobuf: {}
+    },
+    testURL: (url) => url.toLowerCase().includes("FeatureServer"),
+    createDataSource: (url, options) => new FlatGeobufVectorSource(url, options)
+  };
+  var FlatGeobufVectorSource = class extends DataSource {
+    formatSpecificMetadata = null;
+    constructor(data, options) {
+      super(data, options, FlatGeobufSource.defaultOptions);
+    }
+    /** TODO - not yet clear if we can find schema information in the FeatureServer metadata or if we need to request a feature */
+    async getSchema() {
+      await this.getMetadata({ formatSpecificMetadata: true });
+      return { metadata: {}, fields: [] };
+    }
+    async getMetadata(options) {
+      if (!this.formatSpecificMetadata) {
+      }
+      if (options.formatSpecificMetadata) {
+      }
+      return {};
+    }
+    async getFeatures(parameters) {
+      const response = await this.fetch(this.url);
+      const arrayBuffer = await response.arrayBuffer();
+      const table = await FlatGeobufLoader.parse(arrayBuffer, {});
+      return table;
+    }
+  };
   return __toCommonJS(bundle_exports);
 })();
 /*! Bundled license information: