@loaders.gl/flatgeobuf 4.0.0-alpha.8 → 4.0.0-beta.1

package/dist/flatgeobuf-worker.js

@@ -3336,7 +3336,7 @@
               options,
               context: {
                 ...context,
-                parse: parseOnMainThread
+                _parse: parseOnMainThread
               }
             });
             WorkerBody.postMessage("done", { result });
@@ -3349,7 +3349,7 @@
       }
     };
   }
-  function parseOnMainThread(arrayBuffer, options) {
+  function parseOnMainThread(arrayBuffer, loader, options, context) {
     return new Promise((resolve, reject) => {
       const id = requestId++;
       const onMessage = (type, payload2) => {
@@ -3373,7 +3373,12 @@
       WorkerBody.postMessage("process", payload);
     });
   }
-  async function parseData({ loader, arrayBuffer, options, context }) {
+  async function parseData({
+    loader,
+    arrayBuffer,
+    options,
+    context
+  }) {
     let data;
     let parser;
     if (loader.parseSync || loader.parse) {
@@ -3441,7 +3446,7 @@
   }
 
   // src/flatgeobuf-loader.ts
-  var VERSION = true ? "4.0.0-alpha.8" : "latest";
+  var VERSION = true ? "4.0.0-beta.1" : "latest";
   var FlatGeobufLoader = {
     id: "flatgeobuf",
     name: "FlatGeobuf",
@@ -3453,7 +3458,10 @@
     category: "geometry",
     options: {
       flatgeobuf: {
-        shape: "geojson"
+        shape: "geojson-table"
+      },
+      gis: {
+        reproject: false
       }
     }
   };
@@ -8826,7 +8834,7 @@
     });
   }
   function isCoord(array) {
-    return Number.isFinite(array[0]) && Number.isFinite(array[1]);
+    return Array.isArray(array) && Number.isFinite(array[0]) && Number.isFinite(array[1]);
   }
 
   // src/lib/parse-flatgeobuf.ts
@@ -8946,35 +8954,37 @@
   function parseFlatGeobuf(arrayBuffer, options) {
     const shape = options?.gis?.format || options?.flatgeobuf?.shape;
     switch (shape) {
-      case "geojson-row-table": {
+      case "geojson":
+      case "geojson-table": {
+        const features = parseFlatGeobufToGeoJSON(arrayBuffer, options);
         const table = {
-          shape: "geojson-row-table",
-          data: parseFlatGeobufToGeoJSON(arrayBuffer, options)
+          shape: "geojson-table",
+          type: "FeatureCollection",
+          features
         };
         return table;
       }
       case "columnar-table":
-        return { shape: "columnar-table", data: parseFlatGeobufToBinary(arrayBuffer, options) };
-      case "geojson":
-        return parseFlatGeobufToGeoJSON(arrayBuffer, options);
+        const binary = parseFlatGeobufToBinary(arrayBuffer, options);
+        return { shape: "columnar-table", data: binary };
       case "binary":
         return parseFlatGeobufToBinary(arrayBuffer, options);
       default:
         throw new Error(shape);
     }
   }
-  function parseFlatGeobufToBinary(arrayBuffer, options) {
+  function parseFlatGeobufToBinary(arrayBuffer, options = {}) {
     const array = new Uint8Array(arrayBuffer);
     return (0, import_generic.deserialize)(array, binaryFromFeature);
   }
-  function parseFlatGeobufToGeoJSON(arrayBuffer, options) {
+  function parseFlatGeobufToGeoJSON(arrayBuffer, options = {}) {
     if (arrayBuffer.byteLength === 0) {
       return [];
     }
     const { reproject = false, _targetCrs = "WGS84" } = options && options.gis || {};
     const arr = new Uint8Array(arrayBuffer);
     let headerMeta;
-    const { features } = (0, import_geojson.deserialize)(arr, false, (header) => {
+    const { features } = (0, import_geojson.deserialize)(arr, void 0, (header) => {
       headerMeta = header;
     });
     const crs = headerMeta && headerMeta.crs;
@@ -9003,7 +9013,7 @@
   async function* parseFlatGeobufInBatchesToGeoJSON(stream, options) {
     const { reproject = false, _targetCrs = "WGS84" } = options && options.gis || {};
     let headerMeta;
-    const iterator = (0, import_geojson.deserialize)(stream, false, (header) => {
+    const iterator = (0, import_geojson.deserialize)(stream, void 0, (header) => {
       headerMeta = header;
     });
     let projection;

package/dist/index.d.ts

@@ -1,28 +1,6 @@
 import type { LoaderWithParser } from '@loaders.gl/loader-utils';
+import type { FlatGeobufLoaderOptions } from './flatgeobuf-loader';
 import { FlatGeobufLoader as FlatGeobufWorkerLoader } from './flatgeobuf-loader';
-import { parseFlatGeobuf, parseFlatGeobufInBatches } from './lib/parse-flatgeobuf';
 export { FlatGeobufWorkerLoader };
-export declare const FlatGeobufLoader: {
-    parse: (arrayBuffer: any, options: any) => Promise<any[] | import("@loaders.gl/schema").GeoJSONRowTable | AsyncGenerator<import("flatgeobuf/lib/cjs/generic/feature").IFeature, any, unknown> | {
-        shape: string;
-        data: any[] | AsyncGenerator<import("flatgeobuf/lib/cjs/generic/feature").IFeature, any, unknown>;
-    }>;
-    parseSync: typeof parseFlatGeobuf;
-    parseInBatchesFromStream: typeof parseFlatGeobufInBatches;
-    binary: boolean;
-    id: string;
-    name: string;
-    module: string;
-    version: any;
-    worker: boolean;
-    extensions: string[];
-    mimeTypes: string[];
-    category: string;
-    options: {
-        flatgeobuf: {
-            shape: string;
-        };
-    };
-};
-export declare const _typecheckFlatGeobufLoader: LoaderWithParser;
+export declare const FlatGeobufLoader: LoaderWithParser<any, any, FlatGeobufLoaderOptions>;
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAC/D,OAAO,EAAC,gBAAgB,IAAI,sBAAsB,EAAC,MAAM,qBAAqB,CAAC;AAC/E,OAAO,EAAC,eAAe,EAAE,wBAAwB,EAAC,MAAM,wBAAwB,CAAC;AAEjF,OAAO,EAAC,sBAAsB,EAAC,CAAC;AAEhC,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;CAM5B,CAAC;AAEF,eAAO,MAAM,0BAA0B,EAAE,gBAAmC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAC/D,OAAO,KAAK,EAAC,uBAAuB,EAAC,MAAM,qBAAqB,CAAC;AACjE,OAAO,EAAC,gBAAgB,IAAI,sBAAsB,EAAC,MAAM,qBAAqB,CAAC;AAG/E,OAAO,EAAC,sBAAsB,EAAC,CAAC;AAEhC,eAAO,MAAM,gBAAgB,EAAE,gBAAgB,CAAC,GAAG,EAAE,GAAG,EAAE,uBAAuB,CAOhF,CAAC"}

package/dist/lib/parse-flatgeobuf.d.ts

@@ -1,8 +1,5 @@
-import { FlatGeobufLoaderOptions } from './types';
-import { GeoJSONRowTable } from '@loaders.gl/schema';
-export declare function parseFlatGeobuf(arrayBuffer: ArrayBuffer, options?: FlatGeobufLoaderOptions): any[] | GeoJSONRowTable | AsyncGenerator<import("flatgeobuf/lib/cjs/generic/feature").IFeature, any, unknown> | {
-    shape: string;
-    data: any[] | AsyncGenerator<import("flatgeobuf/lib/cjs/generic/feature").IFeature, any, unknown>;
-};
+import type { FlatGeobufLoaderOptions } from '../flatgeobuf-loader';
+import type { Table } from '@loaders.gl/schema';
+export declare function parseFlatGeobuf(arrayBuffer: ArrayBuffer, options?: FlatGeobufLoaderOptions): Table;
 export declare function parseFlatGeobufInBatches(stream: any, options: FlatGeobufLoaderOptions): any[] | AsyncGenerator<import("flatgeobuf/lib/cjs/generic/feature").IFeature, any, unknown> | AsyncGenerator<any, void, unknown>;
 //# sourceMappingURL=parse-flatgeobuf.d.ts.map

package/dist/lib/parse-flatgeobuf.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse-flatgeobuf.d.ts","sourceRoot":"","sources":["../../src/lib/parse-flatgeobuf.ts"],"names":[],"mappings":"AASA,OAAO,EAAC,uBAAuB,EAAC,MAAM,SAAS,CAAC;AAChD,OAAO,EAAC,eAAe,EAAU,MAAM,oBAAoB,CAAC;AAwB5D,wBAAgB,eAAe,CAAC,WAAW,EAAE,WAAW,EAAE,OAAO,CAAC,EAAE,uBAAuB;;;EAoB1F;AAoDD,wBAAgB,wBAAwB,CAAC,MAAM,KAAA,EAAE,OAAO,EAAE,uBAAuB,oIAMhF"}
+{"version":3,"file":"parse-flatgeobuf.d.ts","sourceRoot":"","sources":["../../src/lib/parse-flatgeobuf.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAC,uBAAuB,EAAC,MAAM,sBAAsB,CAAC;AAClE,OAAO,KAAK,EAAwB,KAAK,EAAC,MAAM,oBAAoB,CAAC;AA2BrE,wBAAgB,eAAe,CAC7B,WAAW,EAAE,WAAW,EACxB,OAAO,CAAC,EAAE,uBAAuB,GAChC,KAAK,CA2BP;AAsDD,wBAAgB,wBAAwB,CAAC,MAAM,KAAA,EAAE,OAAO,EAAE,uBAAuB,oIAMhF"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@loaders.gl/flatgeobuf",
   "description": "Loader for FlatGeobuf",
-  "version": "4.0.0-alpha.8",
+  "version": "4.0.0-beta.1",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
@@ -32,10 +32,10 @@
     "build-worker": "esbuild src/workers/flatgeobuf-worker.ts --bundle --outfile=dist/flatgeobuf-worker.js --define:__VERSION__=\\\"$npm_package_version\\\""
   },
   "dependencies": {
-    "@loaders.gl/gis": "4.0.0-alpha.8",
-    "@loaders.gl/loader-utils": "4.0.0-alpha.8",
+    "@loaders.gl/gis": "4.0.0-beta.1",
+    "@loaders.gl/loader-utils": "4.0.0-beta.1",
     "@math.gl/proj4": "^3.3.1",
     "flatgeobuf": "3.6.5"
   },
-  "gitHead": "c35d6640c8d26deab99e277a8e698b5174233789"
+  "gitHead": "35c625e67132b0784e597d9ddabae8aefea29ff2"
 }

package/src/flatgeobuf-loader.ts

@@ -1,10 +1,22 @@
-import type {Loader} from '@loaders.gl/loader-utils';
+import type {Loader, LoaderOptions} from '@loaders.gl/loader-utils';
 
 // __VERSION__ is injected by babel-plugin-version-inline
 // @ts-ignore TS2304: Cannot find name '__VERSION__'.
 const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
 
-export const FlatGeobufLoader = {
+export type FlatGeobufLoaderOptions = LoaderOptions & {
+  flatgeobuf?: {
+    shape?: 'geojson-table' | 'columnar-table' | 'geojson-table' | 'geojson' | 'binary';
+  };
+  gis?: {
+    reproject?: boolean;
+    _targetCrs?: string;
+    /** @deprecated Use options.flatgeobuf.shape */
+    format?: never;
+  };
+};
+
+export const FlatGeobufLoader: Loader<any, any, FlatGeobufLoaderOptions> = {
   id: 'flatgeobuf',
   name: 'FlatGeobuf',
   module: 'flatgeobuf',
@@ -15,10 +27,10 @@ export const FlatGeobufLoader = {
   category: 'geometry',
   options: {
     flatgeobuf: {
-      // Set to GeoJSON for backwards compatibility
-      shape: 'geojson'
+      shape: 'geojson-table'
+    },
+    gis: {
+      reproject: false
     }
   }
 };
-
-export const _typecheckFlatGeobufLoader: Loader = FlatGeobufLoader;

package/src/index.ts

@@ -1,15 +1,15 @@
 import type {LoaderWithParser} from '@loaders.gl/loader-utils';
+import type {FlatGeobufLoaderOptions} from './flatgeobuf-loader';
 import {FlatGeobufLoader as FlatGeobufWorkerLoader} from './flatgeobuf-loader';
 import {parseFlatGeobuf, parseFlatGeobufInBatches} from './lib/parse-flatgeobuf';
 
 export {FlatGeobufWorkerLoader};
 
-export const FlatGeobufLoader = {
+export const FlatGeobufLoader: LoaderWithParser<any, any, FlatGeobufLoaderOptions> = {
   ...FlatGeobufWorkerLoader,
   parse: async (arrayBuffer, options) => parseFlatGeobuf(arrayBuffer, options),
   parseSync: parseFlatGeobuf,
+  // @ts-expect-error this is a stream parser not an async iterator parser
   parseInBatchesFromStream: parseFlatGeobufInBatches,
   binary: true
 };
-
-export const _typecheckFlatGeobufLoader: LoaderWithParser = FlatGeobufLoader;

package/src/lib/parse-flatgeobuf.ts

@@ -1,4 +1,3 @@
-// @ts-nocheck
 import {Proj4Projection} from '@math.gl/proj4';
 import {transformGeoJsonCoords} from '@loaders.gl/gis';
 
@@ -6,9 +5,10 @@ import {deserialize as deserializeGeoJson} from 'flatgeobuf/lib/cjs/geojson';
 import {deserialize as deserializeGeneric} from 'flatgeobuf/lib/cjs/generic';
 import {parseProperties as parsePropertiesBinary} from 'flatgeobuf/lib/cjs/generic/feature';
 
+import type {FlatGeobufLoaderOptions} from '../flatgeobuf-loader';
+import type {GeoJSONTable, Feature, Table} from '@loaders.gl/schema';
 import {fromGeometry as binaryFromGeometry} from './binary-geometries';
-import {FlatGeobufLoaderOptions} from './types';
-import {GeoJSONRowTable, Feature} from '@loaders.gl/schema';
+// import {Feature} from 'flatgeobuf/lib/cjs/feature_generated';
 
 // TODO: reproject binary features
 function binaryFromFeature(feature, header) {
@@ -20,6 +20,7 @@ function binaryFromFeature(feature, header) {
   // known in the header?
   const geometryType = header.geometryType || geometry.type();
   const parsedGeometry = binaryFromGeometry(geometry, geometryType);
+  // @ts-expect-error this looks wrong
   parsedGeometry.properties = parsePropertiesBinary(feature, header.columns);
 
   // TODO: wrap binary data either in points, lines, or polygons key
@@ -32,39 +33,50 @@ function binaryFromFeature(feature, header) {
  * @param arrayBuffer  A FlatGeobuf arrayBuffer
  * @return A GeoJSON geometry object
  */
-export function parseFlatGeobuf(arrayBuffer: ArrayBuffer, options?: FlatGeobufLoaderOptions) {
+export function parseFlatGeobuf(
+  arrayBuffer: ArrayBuffer,
+  options?: FlatGeobufLoaderOptions
+): Table {
   const shape = options?.gis?.format || options?.flatgeobuf?.shape;
 
   switch (shape) {
-    case 'geojson-row-table': {
-      const table: GeoJSONRowTable = {
-        shape: 'geojson-row-table',
-        data: parseFlatGeobufToGeoJSON(arrayBuffer, options)
+    case 'geojson':
+    case 'geojson-table': {
+      const features = parseFlatGeobufToGeoJSON(arrayBuffer, options);
+      const table: GeoJSONTable = {
+        shape: 'geojson-table',
+        type: 'FeatureCollection',
+        features
       };
       return table;
     }
+
     case 'columnar-table': // binary + some JS arrays
-      return {shape: 'columnar-table', data: parseFlatGeobufToBinary(arrayBuffer, options)};
-    case 'geojson':
-      return parseFlatGeobufToGeoJSON(arrayBuffer, options);
+      const binary = parseFlatGeobufToBinary(arrayBuffer, options);
+      // @ts-expect-error
+      return {shape: 'columnar-table', data: binary};
+
     case 'binary':
+      // @ts-expect-error
       return parseFlatGeobufToBinary(arrayBuffer, options);
+
     default:
       throw new Error(shape);
   }
 }
 
-function parseFlatGeobufToBinary(arrayBuffer: ArrayBuffer, options: FlatGeobufLoaderOptions) {
+function parseFlatGeobufToBinary(arrayBuffer: ArrayBuffer, options: FlatGeobufLoaderOptions = {}) {
   // TODO: reproject binary features
   // const {reproject = false, _targetCrs = 'WGS84'} = (options && options.gis) || {};
 
   const array = new Uint8Array(arrayBuffer);
+  // @ts-expect-error this looks wrong
   return deserializeGeneric(array, binaryFromFeature);
 }
 
 function parseFlatGeobufToGeoJSON(
   arrayBuffer: ArrayBuffer,
-  options: FlatGeobufLoaderOptions
+  options: FlatGeobufLoaderOptions = {}
 ): Feature[] {
   if (arrayBuffer.byteLength === 0) {
     return [];
@@ -75,7 +87,8 @@ function parseFlatGeobufToGeoJSON(
   const arr = new Uint8Array(arrayBuffer);
 
   let headerMeta;
-  const {features} = deserializeGeoJson(arr, false, (header) => {
+  // @ts-expect-error this looks wrong
+  const {features} = deserializeGeoJson(arr, undefined, (header) => {
     headerMeta = header;
   });
 
@@ -116,6 +129,7 @@ function parseFlatGeobufInBatchesToBinary(stream, options: FlatGeobufLoaderOptio
   // TODO: reproject binary streaming features
   // const {reproject = false, _targetCrs = 'WGS84'} = (options && options.gis) || {};
 
+  // @ts-expect-error
   const iterator = deserializeGeneric(stream, binaryFromFeature);
   return iterator;
 }
@@ -125,12 +139,13 @@ async function* parseFlatGeobufInBatchesToGeoJSON(stream, options: FlatGeobufLoa
   const {reproject = false, _targetCrs = 'WGS84'} = (options && options.gis) || {};
 
   let headerMeta;
-  const iterator = deserializeGeoJson(stream, false, (header) => {
+  const iterator = deserializeGeoJson(stream, undefined, (header) => {
     headerMeta = header;
   });
 
   let projection;
   let firstRecord = true;
+  // @ts-expect-error this looks wrong
   for await (const feature of iterator) {
     if (firstRecord) {
       const crs = headerMeta && headerMeta.crs;

package/dist/bundle.js

@@ -1,5 +0,0 @@
-"use strict";
-// @ts-nocheck
-const moduleExports = require('./index');
-globalThis.loaders = globalThis.loaders || {};
-module.exports = Object.assign(globalThis.loaders, moduleExports);

package/dist/es5/lib/types.js

@@ -1,2 +0,0 @@
-"use strict";
-//# sourceMappingURL=types.js.map

package/dist/es5/lib/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","names":[],"sources":["../../../src/lib/types.ts"],"sourcesContent":["import type {LoaderOptions} from '@loaders.gl/loader-utils';\n\nexport type FlatGeobufLoaderOptions = LoaderOptions & {\n  flatgeobuf?: {\n    shape?: 'geojson-row-table' | 'columnar-table' | 'geojson' | 'binary';\n  };\n  gis?: {\n    reproject?: boolean;\n    _targetCrs?: string;\n    /** @deprecated Use options.flatgeobuf.shape */\n    format?: 'geojson-row-table' | 'columnar-table' | 'geojson' | 'binary';\n  };\n};\n"],"mappings":""}

package/dist/esm/lib/types.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=types.js.map

package/dist/esm/lib/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","names":[],"sources":["../../../src/lib/types.ts"],"sourcesContent":["import type {LoaderOptions} from '@loaders.gl/loader-utils';\n\nexport type FlatGeobufLoaderOptions = LoaderOptions & {\n  flatgeobuf?: {\n    shape?: 'geojson-row-table' | 'columnar-table' | 'geojson' | 'binary';\n  };\n  gis?: {\n    reproject?: boolean;\n    _targetCrs?: string;\n    /** @deprecated Use options.flatgeobuf.shape */\n    format?: 'geojson-row-table' | 'columnar-table' | 'geojson' | 'binary';\n  };\n};\n"],"mappings":""}

package/dist/flatgeobuf-loader.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._typecheckFlatGeobufLoader = exports.FlatGeobufLoader = void 0;
-// __VERSION__ is injected by babel-plugin-version-inline
-// @ts-ignore TS2304: Cannot find name '__VERSION__'.
-const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
-exports.FlatGeobufLoader = {
-    id: 'flatgeobuf',
-    name: 'FlatGeobuf',
-    module: 'flatgeobuf',
-    version: VERSION,
-    worker: true,
-    extensions: ['fgb'],
-    mimeTypes: ['application/octet-stream'],
-    category: 'geometry',
-    options: {
-        flatgeobuf: {
-            // Set to GeoJSON for backwards compatibility
-            shape: 'geojson'
-        }
-    }
-};
-exports._typecheckFlatGeobufLoader = exports.FlatGeobufLoader;

package/dist/index.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._typecheckFlatGeobufLoader = exports.FlatGeobufLoader = exports.FlatGeobufWorkerLoader = void 0;
-const flatgeobuf_loader_1 = require("./flatgeobuf-loader");
-Object.defineProperty(exports, "FlatGeobufWorkerLoader", { enumerable: true, get: function () { return flatgeobuf_loader_1.FlatGeobufLoader; } });
-const parse_flatgeobuf_1 = require("./lib/parse-flatgeobuf");
-exports.FlatGeobufLoader = {
-    ...flatgeobuf_loader_1.FlatGeobufLoader,
-    parse: async (arrayBuffer, options) => (0, parse_flatgeobuf_1.parseFlatGeobuf)(arrayBuffer, options),
-    parseSync: parse_flatgeobuf_1.parseFlatGeobuf,
-    parseInBatchesFromStream: parse_flatgeobuf_1.parseFlatGeobufInBatches,
-    binary: true
-};
-exports._typecheckFlatGeobufLoader = exports.FlatGeobufLoader;

package/dist/lib/binary-geometries.js

@@ -1,120 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fromGeometry = void 0;
-const header_generated_1 = require("flatgeobuf/lib/cjs/header_generated");
-// Parse Point to flat array
-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);
-    // If endsArray is null, a single LineString. Otherwise, contains the end
-    // indices of each part of the MultiLineString. geometry.endsArray() omits the
-    // initial 0 that we have in our internal format.
-    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);
-    // If endsArray is null, a simple Polygon with no inner rings. Otherwise,
-    // contains the end indices of each ring of the Polygon. geometry.endsArray()
-    // omits the initial 0 that we have in our internal format.
-    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
-    };
-}
-// eslint-disable-next-line max-statements
-function parseMultiPolygons(geometry) {
-    // Create arrays for each geometry part, then concatenate
-    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;
-    // Assumes all parts of the multipolygon have the same size
-    const positionSize = parsedParts[0].positions.size;
-    for (const parsedPart of parsedParts) {
-        concatPositions.set(parsedPart.positions.value, positionCounter * positionSize);
-        // For indices, need to add positionCounter so that position indices are
-        // correct in the concatenated positions
-        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 }
-    };
-}
-// Combine xy and z arrays
-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 };
-}
-function fromGeometry(geometry, type) {
-    switch (type) {
-        case header_generated_1.GeometryType.Point:
-        case header_generated_1.GeometryType.MultiPoint:
-            return parsePoint(geometry);
-        case header_generated_1.GeometryType.LineString:
-        case header_generated_1.GeometryType.MultiLineString:
-            return parseLines(geometry);
-        case header_generated_1.GeometryType.Polygon:
-            return parsePolygons(geometry);
-        case header_generated_1.GeometryType.MultiPolygon:
-            return parseMultiPolygons(geometry);
-        default:
-            throw new Error(`Unimplemented geometry type: ${type}`);
-    }
-}
-exports.fromGeometry = fromGeometry;