@loaders.gl/flatgeobuf 3.1.0-beta.5 → 3.1.2

package/dist/es5/bundle.js

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

package/dist/es5/bundle.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/bundle.ts"],"names":["moduleExports","require","globalThis","loaders","module","exports","Object","assign"],"mappings":";;AACA,MAAMA,aAAa,GAAGC,OAAO,CAAC,SAAD,CAA7B;;AACAC,UAAU,CAACC,OAAX,GAAqBD,UAAU,CAACC,OAAX,IAAsB,EAA3C;AACAC,MAAM,CAACC,OAAP,GAAiBC,MAAM,CAACC,MAAP,CAAcL,UAAU,CAACC,OAAzB,EAAkCH,aAAlC,CAAjB","sourcesContent":["// @ts-nocheck\nconst moduleExports = require('./index');\nglobalThis.loaders = globalThis.loaders || {};\nmodule.exports = Object.assign(globalThis.loaders, moduleExports);\n"],"file":"bundle.js"}
+{"version":3,"sources":["../../src/bundle.ts"],"names":["moduleExports","require","globalThis","loaders","module","exports","Object","assign"],"mappings":";;AACA,IAAMA,aAAa,GAAGC,OAAO,CAAC,SAAD,CAA7B;;AACAC,UAAU,CAACC,OAAX,GAAqBD,UAAU,CAACC,OAAX,IAAsB,EAA3C;AACAC,MAAM,CAACC,OAAP,GAAiBC,MAAM,CAACC,MAAP,CAAcL,UAAU,CAACC,OAAzB,EAAkCH,aAAlC,CAAjB","sourcesContent":["// @ts-nocheck\nconst moduleExports = require('./index');\nglobalThis.loaders = globalThis.loaders || {};\nmodule.exports = Object.assign(globalThis.loaders, moduleExports);\n"],"file":"bundle.js"}

package/dist/es5/flatgeobuf-loader.js

@@ -4,8 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports._typecheckFlatGeobufLoader = exports.FlatGeobufLoader = void 0;
-const VERSION = typeof "3.1.0-beta.5" !== 'undefined' ? "3.1.0-beta.5" : 'latest';
-const FlatGeobufLoader = {
+var VERSION = typeof "3.1.2" !== 'undefined' ? "3.1.2" : 'latest';
+var FlatGeobufLoader = {
   id: 'flatgeobuf',
   name: 'FlatGeobuf',
   module: 'flatgeobuf',
@@ -19,6 +19,6 @@ const FlatGeobufLoader = {
   }
 };
 exports.FlatGeobufLoader = FlatGeobufLoader;
-const _typecheckFlatGeobufLoader = FlatGeobufLoader;
+var _typecheckFlatGeobufLoader = FlatGeobufLoader;
 exports._typecheckFlatGeobufLoader = _typecheckFlatGeobufLoader;
 //# sourceMappingURL=flatgeobuf-loader.js.map

package/dist/es5/flatgeobuf-loader.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/flatgeobuf-loader.ts"],"names":["VERSION","FlatGeobufLoader","id","name","module","version","worker","extensions","mimeTypes","category","options","flatgeobuf","_typecheckFlatGeobufLoader"],"mappings":";;;;;;AAIA,MAAMA,OAAO,GAAG,0BAAuB,WAAvB,oBAAmD,QAAnE;AAEO,MAAMC,gBAAgB,GAAG;AAC9BC,EAAAA,EAAE,EAAE,YAD0B;AAE9BC,EAAAA,IAAI,EAAE,YAFwB;AAG9BC,EAAAA,MAAM,EAAE,YAHsB;AAI9BC,EAAAA,OAAO,EAAEL,OAJqB;AAK9BM,EAAAA,MAAM,EAAE,IALsB;AAM9BC,EAAAA,UAAU,EAAE,CAAC,KAAD,CANkB;AAO9BC,EAAAA,SAAS,EAAE,CAAC,0BAAD,CAPmB;AAQ9BC,EAAAA,QAAQ,EAAE,UARoB;AAS9BC,EAAAA,OAAO,EAAE;AACPC,IAAAA,UAAU,EAAE;AADL;AATqB,CAAzB;;AAcA,MAAMC,0BAAkC,GAAGX,gBAA3C","sourcesContent":["import type {Loader} from '@loaders.gl/loader-utils';\n\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n\nexport const FlatGeobufLoader = {\n  id: 'flatgeobuf',\n  name: 'FlatGeobuf',\n  module: 'flatgeobuf',\n  version: VERSION,\n  worker: true,\n  extensions: ['fgb'],\n  mimeTypes: ['application/octet-stream'],\n  category: 'geometry',\n  options: {\n    flatgeobuf: {}\n  }\n};\n\nexport const _typecheckFlatGeobufLoader: Loader = FlatGeobufLoader;\n"],"file":"flatgeobuf-loader.js"}
+{"version":3,"sources":["../../src/flatgeobuf-loader.ts"],"names":["VERSION","FlatGeobufLoader","id","name","module","version","worker","extensions","mimeTypes","category","options","flatgeobuf","_typecheckFlatGeobufLoader"],"mappings":";;;;;;AAIA,IAAMA,OAAO,GAAG,mBAAuB,WAAvB,aAAmD,QAAnE;AAEO,IAAMC,gBAAgB,GAAG;AAC9BC,EAAAA,EAAE,EAAE,YAD0B;AAE9BC,EAAAA,IAAI,EAAE,YAFwB;AAG9BC,EAAAA,MAAM,EAAE,YAHsB;AAI9BC,EAAAA,OAAO,EAAEL,OAJqB;AAK9BM,EAAAA,MAAM,EAAE,IALsB;AAM9BC,EAAAA,UAAU,EAAE,CAAC,KAAD,CANkB;AAO9BC,EAAAA,SAAS,EAAE,CAAC,0BAAD,CAPmB;AAQ9BC,EAAAA,QAAQ,EAAE,UARoB;AAS9BC,EAAAA,OAAO,EAAE;AACPC,IAAAA,UAAU,EAAE;AADL;AATqB,CAAzB;;AAcA,IAAMC,0BAAkC,GAAGX,gBAA3C","sourcesContent":["import type {Loader} from '@loaders.gl/loader-utils';\n\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n\nexport const FlatGeobufLoader = {\n  id: 'flatgeobuf',\n  name: 'FlatGeobuf',\n  module: 'flatgeobuf',\n  version: VERSION,\n  worker: true,\n  extensions: ['fgb'],\n  mimeTypes: ['application/octet-stream'],\n  category: 'geometry',\n  options: {\n    flatgeobuf: {}\n  }\n};\n\nexport const _typecheckFlatGeobufLoader: Loader = FlatGeobufLoader;\n"],"file":"flatgeobuf-loader.js"}

package/dist/es5/index.js

@@ -1,31 +1,61 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 Object.defineProperty(exports, "FlatGeobufWorkerLoader", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _flatgeobufLoader.FlatGeobufLoader;
   }
 });
 exports._typecheckFlatGeobufLoader = exports.FlatGeobufLoader = void 0;
 
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
 var _flatgeobufLoader = require("./flatgeobuf-loader");
 
-var _parseFlatgeobuf = _interopRequireWildcard(require("./lib/parse-flatgeobuf"));
+var _parseFlatgeobuf = require("./lib/parse-flatgeobuf");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
 
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+var FlatGeobufLoader = _objectSpread(_objectSpread({}, _flatgeobufLoader.FlatGeobufLoader), {}, {
+  parse: function () {
+    var _parse = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(arrayBuffer, options) {
+      return _regenerator.default.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              return _context.abrupt("return", (0, _parseFlatgeobuf.parseFlatGeobuf)(arrayBuffer, options));
 
-const FlatGeobufLoader = { ..._flatgeobufLoader.FlatGeobufLoader,
-  parse: async (arrayBuffer, options) => (0, _parseFlatgeobuf.default)(arrayBuffer, options),
-  parseSync: _parseFlatgeobuf.default,
+            case 1:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee);
+    }));
+
+    function parse(_x, _x2) {
+      return _parse.apply(this, arguments);
+    }
+
+    return parse;
+  }(),
+  parseSync: _parseFlatgeobuf.parseFlatGeobuf,
   parseInBatchesFromStream: _parseFlatgeobuf.parseFlatGeobufInBatches,
   binary: true
-};
+});
+
 exports.FlatGeobufLoader = FlatGeobufLoader;
-const _typecheckFlatGeobufLoader = FlatGeobufLoader;
+var _typecheckFlatGeobufLoader = FlatGeobufLoader;
 exports._typecheckFlatGeobufLoader = _typecheckFlatGeobufLoader;
 //# sourceMappingURL=index.js.map

package/dist/es5/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/index.ts"],"names":["FlatGeobufLoader","FlatGeobufWorkerLoader","parse","arrayBuffer","options","parseSync","parseFlatGeobuf","parseInBatchesFromStream","parseFlatGeobufInBatches","binary","_typecheckFlatGeobufLoader"],"mappings":";;;;;;;;;;;;;AACA;;AACA;;;;;;AAIO,MAAMA,gBAAgB,GAAG,EAC9B,GAAGC,kCAD2B;AAE9BC,EAAAA,KAAK,EAAE,OAAOC,WAAP,EAAoBC,OAApB,KAAgC,8BAAgBD,WAAhB,EAA6BC,OAA7B,CAFT;AAG9BC,EAAAA,SAAS,EAAEC,wBAHmB;AAI9BC,EAAAA,wBAAwB,EAAEC,yCAJI;AAK9BC,EAAAA,MAAM,EAAE;AALsB,CAAzB;;AAQA,MAAMC,0BAA4C,GAAGV,gBAArD","sourcesContent":["import type {LoaderWithParser} from '@loaders.gl/loader-utils';\nimport {FlatGeobufLoader as FlatGeobufWorkerLoader} from './flatgeobuf-loader';\nimport parseFlatGeobuf, {parseFlatGeobufInBatches} from './lib/parse-flatgeobuf';\n\nexport {FlatGeobufWorkerLoader};\n\nexport const FlatGeobufLoader = {\n  ...FlatGeobufWorkerLoader,\n  parse: async (arrayBuffer, options) => parseFlatGeobuf(arrayBuffer, options),\n  parseSync: parseFlatGeobuf,\n  parseInBatchesFromStream: parseFlatGeobufInBatches,\n  binary: true\n};\n\nexport const _typecheckFlatGeobufLoader: LoaderWithParser = FlatGeobufLoader;\n"],"file":"index.js"}
+{"version":3,"sources":["../../src/index.ts"],"names":["FlatGeobufLoader","FlatGeobufWorkerLoader","parse","arrayBuffer","options","parseSync","parseFlatGeobuf","parseInBatchesFromStream","parseFlatGeobufInBatches","binary","_typecheckFlatGeobufLoader"],"mappings":";;;;;;;;;;;;;;;;;;;;;AACA;;AACA;;;;;;AAIO,IAAMA,gBAAgB,mCACxBC,kCADwB;AAE3BC,EAAAA,KAAK;AAAA,2EAAE,iBAAOC,WAAP,EAAoBC,OAApB;AAAA;AAAA;AAAA;AAAA;AAAA,+CAAgC,sCAAgBD,WAAhB,EAA6BC,OAA7B,CAAhC;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,KAAF;;AAAA;AAAA;AAAA;;AAAA;AAAA,KAFsB;AAG3BC,EAAAA,SAAS,EAAEC,gCAHgB;AAI3BC,EAAAA,wBAAwB,EAAEC,yCAJC;AAK3BC,EAAAA,MAAM,EAAE;AALmB,EAAtB;;;AAQA,IAAMC,0BAA4C,GAAGV,gBAArD","sourcesContent":["import type {LoaderWithParser} from '@loaders.gl/loader-utils';\nimport {FlatGeobufLoader as FlatGeobufWorkerLoader} from './flatgeobuf-loader';\nimport {parseFlatGeobuf, parseFlatGeobufInBatches} from './lib/parse-flatgeobuf';\n\nexport {FlatGeobufWorkerLoader};\n\nexport const FlatGeobufLoader = {\n  ...FlatGeobufWorkerLoader,\n  parse: async (arrayBuffer, options) => parseFlatGeobuf(arrayBuffer, options),\n  parseSync: parseFlatGeobuf,\n  parseInBatchesFromStream: parseFlatGeobufInBatches,\n  binary: true\n};\n\nexport const _typecheckFlatGeobufLoader: LoaderWithParser = FlatGeobufLoader;\n"],"file":"index.js"}

package/dist/es5/lib/binary-geometries.js

@@ -0,0 +1,156 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.fromGeometry = fromGeometry;
+
+var _header_generated = require("flatgeobuf/lib/cjs/header_generated");
+
+function parsePoint(geometry) {
+  var xy = geometry.xyArray();
+  var z = geometry.zArray();
+  var positions = blitArrays(xy, z);
+  return {
+    positions: positions
+  };
+}
+
+function parseLines(geometry) {
+  var xy = geometry.xyArray();
+  var z = geometry.zArray();
+  var positions = blitArrays(xy, z);
+  var ends = geometry.endsArray() && Array.from(geometry.endsArray()) || [xy.length / 2];
+  ends.unshift(0);
+  var pathIndices = {
+    value: new Uint16Array(ends),
+    size: 1
+  };
+  return {
+    positions: positions,
+    pathIndices: pathIndices
+  };
+}
+
+function parsePolygons(geometry) {
+  var xy = geometry.xyArray();
+  var z = geometry.zArray();
+  var positions = blitArrays(xy, z);
+  var ends = geometry.endsArray() && Array.from(geometry.endsArray()) || [xy.length / 2];
+  ends.unshift(0);
+  var primitivePolygonIndices = {
+    value: new Uint16Array(ends),
+    size: 1
+  };
+  var polygonIndices = {
+    value: new Uint16Array([0, xy.length / 2]),
+    size: 1
+  };
+  return {
+    positions: positions,
+    primitivePolygonIndices: primitivePolygonIndices,
+    polygonIndices: polygonIndices
+  };
+}
+
+function parseMultiPolygons(geometry) {
+  var parsedParts = [];
+  var nPositions = 0;
+  var nPrimitivePolygonIndices = 1;
+  var nPolygonIndices = 1;
+
+  for (var i = 0; i < geometry.partsLength(); i++) {
+    var part = geometry.parts(i);
+    var polygon = parsePolygons(part);
+    nPositions += polygon.positions.value.length;
+    nPrimitivePolygonIndices += polygon.primitivePolygonIndices.value.length - 1;
+    nPolygonIndices += polygon.polygonIndices.value.length - 1;
+    parsedParts.push(polygon);
+  }
+
+  var concatPositions = new Float64Array(nPositions);
+  var concatPrimitivePolygonIndices = new Uint32Array(nPrimitivePolygonIndices);
+  var concatPolygonIndices = new Uint32Array(nPolygonIndices);
+  var positionCounter = 0;
+  var primitivePolygonIndicesCounter = 1;
+  var polygonIndicesCounter = 1;
+  var positionSize = parsedParts[0].positions.size;
+
+  for (var _i = 0, _parsedParts = parsedParts; _i < _parsedParts.length; _i++) {
+    var parsedPart = _parsedParts[_i];
+    concatPositions.set(parsedPart.positions.value, positionCounter * positionSize);
+    concatPrimitivePolygonIndices.set(parsedPart.primitivePolygonIndices.value.subarray(1).map(function (x) {
+      return x + positionCounter;
+    }), primitivePolygonIndicesCounter);
+    concatPolygonIndices.set(parsedPart.polygonIndices.value.subarray(1).map(function (x) {
+      return 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');
+  }
+
+  var totalLength = xy.length + z.length;
+  var xyz = new Float64Array(totalLength);
+
+  for (var 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.GeometryType.Point:
+    case _header_generated.GeometryType.MultiPoint:
+      return parsePoint(geometry);
+
+    case _header_generated.GeometryType.LineString:
+    case _header_generated.GeometryType.MultiLineString:
+      return parseLines(geometry);
+
+    case _header_generated.GeometryType.Polygon:
+      return parsePolygons(geometry);
+
+    case _header_generated.GeometryType.MultiPolygon:
+      return parseMultiPolygons(geometry);
+
+    default:
+      throw new Error("Unimplemented geometry type: ".concat(type));
+  }
+}
+//# sourceMappingURL=binary-geometries.js.map

package/dist/es5/lib/binary-geometries.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/binary-geometries.ts"],"names":["parsePoint","geometry","xy","xyArray","z","zArray","positions","blitArrays","parseLines","ends","endsArray","Array","from","length","unshift","pathIndices","value","Uint16Array","size","parsePolygons","primitivePolygonIndices","polygonIndices","parseMultiPolygons","parsedParts","nPositions","nPrimitivePolygonIndices","nPolygonIndices","i","partsLength","part","parts","polygon","push","concatPositions","Float64Array","concatPrimitivePolygonIndices","Uint32Array","concatPolygonIndices","positionCounter","primitivePolygonIndicesCounter","polygonIndicesCounter","positionSize","parsedPart","set","subarray","map","x","Error","totalLength","xyz","fromGeometry","type","GeometryType","Point","MultiPoint","LineString","MultiLineString","Polygon","MultiPolygon"],"mappings":"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","sourcesContent":["import {GeometryType} from 'flatgeobuf/lib/cjs/header_generated';\n\n// Parse Point to flat array\nfunction parsePoint(geometry) {\n  const xy = geometry.xyArray();\n  const z = geometry.zArray();\n  const positions = blitArrays(xy, z);\n  return {positions};\n}\n\nfunction parseLines(geometry) {\n  const xy = geometry.xyArray();\n  const z = geometry.zArray();\n  const positions = blitArrays(xy, z);\n\n  // If endsArray is null, a single LineString. Otherwise, contains the end\n  // indices of each part of the MultiLineString. geometry.endsArray() omits the\n  // initial 0 that we have in our internal format.\n  const ends = (geometry.endsArray() && Array.from(geometry.endsArray())) || [xy.length / 2];\n  ends.unshift(0);\n\n  const pathIndices = {value: new Uint16Array(ends), size: 1};\n\n  return {\n    positions,\n    pathIndices\n  };\n}\n\nfunction parsePolygons(geometry) {\n  const xy = geometry.xyArray();\n  const z = geometry.zArray();\n  const positions = blitArrays(xy, z);\n\n  // If endsArray is null, a simple Polygon with no inner rings. Otherwise,\n  // contains the end indices of each ring of the Polygon. geometry.endsArray()\n  // omits the initial 0 that we have in our internal format.\n  const ends = (geometry.endsArray() && Array.from(geometry.endsArray())) || [xy.length / 2];\n  ends.unshift(0);\n\n  const primitivePolygonIndices = {value: new Uint16Array(ends), size: 1};\n  const polygonIndices = {value: new Uint16Array([0, xy.length / 2]), size: 1};\n\n  return {\n    positions,\n    primitivePolygonIndices,\n    polygonIndices\n  };\n}\n\n// eslint-disable-next-line max-statements\nfunction parseMultiPolygons(geometry) {\n  // Create arrays for each geometry part, then concatenate\n  const parsedParts: any[] = [];\n  let nPositions = 0;\n  let nPrimitivePolygonIndices = 1;\n  let nPolygonIndices = 1;\n\n  for (let i = 0; i < geometry.partsLength(); i++) {\n    const part = geometry.parts(i);\n    const polygon = parsePolygons(part);\n\n    nPositions += polygon.positions.value.length;\n    nPrimitivePolygonIndices += polygon.primitivePolygonIndices.value.length - 1;\n    nPolygonIndices += polygon.polygonIndices.value.length - 1;\n\n    parsedParts.push(polygon);\n  }\n\n  const concatPositions = new Float64Array(nPositions);\n  const concatPrimitivePolygonIndices = new Uint32Array(nPrimitivePolygonIndices);\n  const concatPolygonIndices = new Uint32Array(nPolygonIndices);\n\n  let positionCounter = 0;\n  let primitivePolygonIndicesCounter = 1;\n  let polygonIndicesCounter = 1;\n\n  // Assumes all parts of the multipolygon have the same size\n  const positionSize = parsedParts[0].positions.size;\n\n  for (const parsedPart of parsedParts) {\n    concatPositions.set(parsedPart.positions.value, positionCounter * positionSize);\n\n    // For indices, need to add positionCounter so that position indices are\n    // correct in the concatenated positions\n    concatPrimitivePolygonIndices.set(\n      // eslint-disable-next-line\n      parsedPart.primitivePolygonIndices.value.subarray(1).map((x) => x + positionCounter),\n      primitivePolygonIndicesCounter\n    );\n    concatPolygonIndices.set(\n      // eslint-disable-next-line\n      parsedPart.polygonIndices.value.subarray(1).map((x) => x + positionCounter),\n      polygonIndicesCounter\n    );\n\n    positionCounter += parsedPart.positions.value.length / positionSize;\n    primitivePolygonIndicesCounter += parsedPart.primitivePolygonIndices.value.length - 1;\n    polygonIndicesCounter += parsedPart.polygonIndices.value.length - 1;\n  }\n\n  return {\n    positions: {value: concatPositions, size: positionSize},\n    primitivePolygonIndices: {value: concatPrimitivePolygonIndices, size: 1},\n    polygonIndices: {value: concatPolygonIndices, size: 1}\n  };\n}\n\n// Combine xy and z arrays\nfunction blitArrays(xy, z) {\n  if (!z) {\n    return {value: xy, size: 2};\n  }\n\n  if (z.length * 2 !== xy.length) {\n    throw new Error('Z array must be half XY array\\'s length');\n  }\n  const totalLength = xy.length + z.length;\n\n  const xyz = new Float64Array(totalLength);\n  for (let i = 0; i < xy.length / 2; i++) {\n    xyz[i * 3 + 0] = xy[i * 2 + 0];\n    xyz[i * 3 + 1] = xy[i * 2 + 1];\n    xyz[i * 3 + 2] = z[i];\n  }\n  return {value: xyz, size: 3};\n}\n\nexport function fromGeometry(geometry, type) {\n  switch (type) {\n    case GeometryType.Point:\n    case GeometryType.MultiPoint:\n      return parsePoint(geometry);\n    case GeometryType.LineString:\n    case GeometryType.MultiLineString:\n      return parseLines(geometry);\n    case GeometryType.Polygon:\n      return parsePolygons(geometry);\n    case GeometryType.MultiPolygon:\n      return parseMultiPolygons(geometry);\n    default:\n      throw new Error(`Unimplemented geometry type: ${type}`);\n  }\n}\n"],"file":"binary-geometries.js"}

package/dist/es5/lib/parse-flatgeobuf.js

@@ -1,27 +1,230 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = parseFlatGeobuf;
+exports.parseFlatGeobuf = parseFlatGeobuf;
 exports.parseFlatGeobufInBatches = parseFlatGeobufInBatches;
 
-var _flatgeobufGeojson = require("flatgeobuf/dist/flatgeobuf-geojson.min");
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _awaitAsyncGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/awaitAsyncGenerator"));
+
+var _wrapAsyncGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/wrapAsyncGenerator"));
+
+var _asyncIterator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncIterator"));
+
+var _proj = require("@math.gl/proj4");
+
+var _gis = require("@loaders.gl/gis");
+
+var _geojson = require("flatgeobuf/lib/cjs/geojson");
+
+var _generic = require("flatgeobuf/lib/cjs/generic");
 
-function parseFlatGeobuf(input, options) {
-  if (input.byteLength === 0) {
+var _feature = require("flatgeobuf/lib/cjs/generic/feature");
+
+var _binaryGeometries = require("./binary-geometries");
+
+function binaryFromFeature(feature, header) {
+  var geometry = feature.geometry();
+  var geometryType = header.geometryType || geometry.type();
+  var parsedGeometry = (0, _binaryGeometries.fromGeometry)(geometry, geometryType);
+  parsedGeometry.properties = (0, _feature.parseProperties)(feature, header.columns);
+  return parsedGeometry;
+}
+
+function parseFlatGeobuf(arrayBuffer, options) {
+  if (arrayBuffer.byteLength === 0) {
     return [];
   }
 
-  const arr = new Uint8Array(input);
-  const {
-    features
-  } = (0, _flatgeobufGeojson.deserialize)(arr);
+  if (options && options.gis && options.gis.format === 'binary') {
+    return parseFlatGeobufToBinary(arrayBuffer, options);
+  }
+
+  return parseFlatGeobufToGeoJSON(arrayBuffer, options);
+}
+
+function parseFlatGeobufToBinary(arrayBuffer, options) {
+  var arr = new Uint8Array(arrayBuffer);
+  return (0, _generic.deserialize)(arr, binaryFromFeature);
+}
+
+function parseFlatGeobufToGeoJSON(arrayBuffer, options) {
+  var _ref = options && options.gis || {},
+      _ref$reproject = _ref.reproject,
+      reproject = _ref$reproject === void 0 ? false : _ref$reproject,
+      _ref$_targetCrs = _ref._targetCrs,
+      _targetCrs = _ref$_targetCrs === void 0 ? 'WGS84' : _ref$_targetCrs;
+
+  var arr = new Uint8Array(arrayBuffer);
+  var headerMeta;
+
+  var _deserializeGeoJson = (0, _geojson.deserialize)(arr, false, function (header) {
+    headerMeta = header;
+  }),
+      features = _deserializeGeoJson.features;
+
+  var crs = headerMeta && headerMeta.crs;
+  var projection;
+
+  if (reproject && crs) {
+    try {
+      projection = new _proj.Proj4Projection({
+        from: crs.wkt,
+        to: _targetCrs
+      });
+    } catch (e) {}
+  }
+
+  if (projection) {
+    return (0, _gis.transformGeoJsonCoords)(features, function (coords) {
+      return projection.project(coords);
+    });
+  }
+
   return features;
 }
 
 function parseFlatGeobufInBatches(stream, options) {
-  const iterator = (0, _flatgeobufGeojson.deserializeStream)(stream);
+  if (options && options.gis && options.gis.format === 'binary') {
+    return parseFlatGeobufInBatchesToBinary(stream, options);
+  }
+
+  return parseFlatGeobufInBatchesToGeoJSON(stream, options);
+}
+
+function parseFlatGeobufInBatchesToBinary(stream, options) {
+  var iterator = (0, _generic.deserialize)(stream, binaryFromFeature);
   return iterator;
 }
+
+function parseFlatGeobufInBatchesToGeoJSON(_x, _x2) {
+  return _parseFlatGeobufInBatchesToGeoJSON.apply(this, arguments);
+}
+
+function _parseFlatGeobufInBatchesToGeoJSON() {
+  _parseFlatGeobufInBatchesToGeoJSON = (0, _wrapAsyncGenerator2.default)(_regenerator.default.mark(function _callee(stream, options) {
+    var _ref2, _ref2$reproject, reproject, _ref2$_targetCrs, _targetCrs, headerMeta, iterator, projection, firstRecord, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, feature, crs;
+
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            _ref2 = options && options.gis || {}, _ref2$reproject = _ref2.reproject, reproject = _ref2$reproject === void 0 ? false : _ref2$reproject, _ref2$_targetCrs = _ref2._targetCrs, _targetCrs = _ref2$_targetCrs === void 0 ? 'WGS84' : _ref2$_targetCrs;
+            iterator = (0, _geojson.deserialize)(stream, false, function (header) {
+              headerMeta = header;
+            });
+            firstRecord = true;
+            _iteratorNormalCompletion = true;
+            _didIteratorError = false;
+            _context.prev = 5;
+            _iterator = (0, _asyncIterator2.default)(iterator);
+
+          case 7:
+            _context.next = 9;
+            return (0, _awaitAsyncGenerator2.default)(_iterator.next());
+
+          case 9:
+            _step = _context.sent;
+            _iteratorNormalCompletion = _step.done;
+            _context.next = 13;
+            return (0, _awaitAsyncGenerator2.default)(_step.value);
+
+          case 13:
+            _value = _context.sent;
+
+            if (_iteratorNormalCompletion) {
+              _context.next = 27;
+              break;
+            }
+
+            feature = _value;
+
+            if (firstRecord) {
+              crs = headerMeta && headerMeta.crs;
+
+              if (reproject && crs) {
+                projection = new _proj.Proj4Projection({
+                  from: crs.wkt,
+                  to: _targetCrs
+                });
+              }
+
+              firstRecord = false;
+            }
+
+            if (!(reproject && projection)) {
+              _context.next = 22;
+              break;
+            }
+
+            _context.next = 20;
+            return (0, _gis.transformGeoJsonCoords)([feature], function (coords) {
+              return projection.project(coords);
+            });
+
+          case 20:
+            _context.next = 24;
+            break;
+
+          case 22:
+            _context.next = 24;
+            return feature;
+
+          case 24:
+            _iteratorNormalCompletion = true;
+            _context.next = 7;
+            break;
+
+          case 27:
+            _context.next = 33;
+            break;
+
+          case 29:
+            _context.prev = 29;
+            _context.t0 = _context["catch"](5);
+            _didIteratorError = true;
+            _iteratorError = _context.t0;
+
+          case 33:
+            _context.prev = 33;
+            _context.prev = 34;
+
+            if (!(!_iteratorNormalCompletion && _iterator.return != null)) {
+              _context.next = 38;
+              break;
+            }
+
+            _context.next = 38;
+            return (0, _awaitAsyncGenerator2.default)(_iterator.return());
+
+          case 38:
+            _context.prev = 38;
+
+            if (!_didIteratorError) {
+              _context.next = 41;
+              break;
+            }
+
+            throw _iteratorError;
+
+          case 41:
+            return _context.finish(38);
+
+          case 42:
+            return _context.finish(33);
+
+          case 43:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee, null, [[5, 29, 33, 43], [34,, 38, 42]]);
+  }));
+  return _parseFlatGeobufInBatchesToGeoJSON.apply(this, arguments);
+}
 //# sourceMappingURL=parse-flatgeobuf.js.map

package/dist/es5/lib/parse-flatgeobuf.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/lib/parse-flatgeobuf.ts"],"names":["parseFlatGeobuf","input","options","byteLength","arr","Uint8Array","features","parseFlatGeobufInBatches","stream","iterator"],"mappings":";;;;;;;;AACA;;AAQe,SAASA,eAAT,CAAyBC,KAAzB,EAAgCC,OAAhC,EAAyC;AACtD,MAAID,KAAK,CAACE,UAAN,KAAqB,CAAzB,EAA4B;AAC1B,WAAO,EAAP;AACD;;AAED,QAAMC,GAAG,GAAG,IAAIC,UAAJ,CAAeJ,KAAf,CAAZ;AACA,QAAM;AAACK,IAAAA;AAAD,MAAa,oCAAYF,GAAZ,CAAnB;AACA,SAAOE,QAAP;AACD;;AAQM,SAASC,wBAAT,CAAkCC,MAAlC,EAA0CN,OAA1C,EAAmD;AACxD,QAAMO,QAAQ,GAAG,0CAAkBD,MAAlB,CAAjB;AACA,SAAOC,QAAP;AACD","sourcesContent":["// import {deserialize} from 'flatgeobuf/lib/geojson/featurecollection';\nimport {deserialize, deserializeStream} from 'flatgeobuf/dist/flatgeobuf-geojson.min';\n\n/*\n * Parse FlatGeobuf arrayBuffer and return GeoJSON.\n *\n * @param {arrayBuffer} _ A FlatGeobuf arrayBuffer\n * @return {?Object} A GeoJSON geometry object\n */\nexport default function parseFlatGeobuf(input, options) {\n  if (input.byteLength === 0) {\n    return [];\n  }\n\n  const arr = new Uint8Array(input);\n  const {features} = deserialize(arr);\n  return features;\n}\n\n/*\n * Parse FlatGeobuf arrayBuffer and return GeoJSON.\n *\n * @param {ReadableStream} _ A FlatGeobuf arrayBuffer\n * @return  A GeoJSON geometry object iterator\n */\nexport function parseFlatGeobufInBatches(stream, options) {\n  const iterator = deserializeStream(stream);\n  return iterator;\n}\n"],"file":"parse-flatgeobuf.js"}
+{"version":3,"sources":["../../../src/lib/parse-flatgeobuf.ts"],"names":["binaryFromFeature","feature","header","geometry","geometryType","type","parsedGeometry","properties","columns","parseFlatGeobuf","arrayBuffer","options","byteLength","gis","format","parseFlatGeobufToBinary","parseFlatGeobufToGeoJSON","arr","Uint8Array","reproject","_targetCrs","headerMeta","features","crs","projection","Proj4Projection","from","wkt","to","e","coords","project","parseFlatGeobufInBatches","stream","parseFlatGeobufInBatchesToBinary","parseFlatGeobufInBatchesToGeoJSON","iterator","firstRecord"],"mappings":"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","sourcesContent":["// @ts-nocheck\nimport {Proj4Projection} from '@math.gl/proj4';\nimport {transformGeoJsonCoords} from '@loaders.gl/gis';\n\nimport {deserialize as deserializeGeoJson} from 'flatgeobuf/lib/cjs/geojson';\nimport {deserialize as deserializeGeneric} from 'flatgeobuf/lib/cjs/generic';\nimport {parseProperties as parsePropertiesBinary} from 'flatgeobuf/lib/cjs/generic/feature';\n\nimport {fromGeometry as binaryFromGeometry} from './binary-geometries';\n\n// TODO: reproject binary features\nfunction binaryFromFeature(feature, header) {\n  const geometry = feature.geometry();\n\n  // FlatGeobuf files can only hold a single geometry type per file, otherwise\n  // GeometryType is GeometryCollection\n  // I believe geometry.type() is null (0) except when the geometry type isn't\n  // known in the header?\n  const geometryType = header.geometryType || geometry.type();\n  const parsedGeometry = binaryFromGeometry(geometry, geometryType);\n  parsedGeometry.properties = parsePropertiesBinary(feature, header.columns);\n\n  // TODO: wrap binary data either in points, lines, or polygons key\n  return parsedGeometry;\n}\n\n/*\n * Parse FlatGeobuf arrayBuffer and return GeoJSON.\n *\n * @param arrayBuffer  A FlatGeobuf arrayBuffer\n * @return A GeoJSON geometry object\n */\nexport function parseFlatGeobuf(arrayBuffer, options) {\n  if (arrayBuffer.byteLength === 0) {\n    return [];\n  }\n\n  if (options && options.gis && options.gis.format === 'binary') {\n    return parseFlatGeobufToBinary(arrayBuffer, options);\n  }\n\n  return parseFlatGeobufToGeoJSON(arrayBuffer, options);\n}\n\nfunction parseFlatGeobufToBinary(arrayBuffer, options) {\n  // TODO: reproject binary features\n  // const {reproject = false, _targetCrs = 'WGS84'} = (options && options.gis) || {};\n\n  const arr = new Uint8Array(arrayBuffer);\n  return deserializeGeneric(arr, binaryFromFeature);\n}\n\nfunction parseFlatGeobufToGeoJSON(arrayBuffer, options) {\n  const {reproject = false, _targetCrs = 'WGS84'} = (options && options.gis) || {};\n\n  const arr = new Uint8Array(arrayBuffer);\n\n  let headerMeta;\n  const {features} = deserializeGeoJson(arr, false, (header) => {\n    headerMeta = header;\n  });\n\n  const crs = headerMeta && headerMeta.crs;\n  let projection;\n  if (reproject && crs) {\n    // Constructing the projection may fail for some invalid WKT strings\n    try {\n      projection = new Proj4Projection({from: crs.wkt, to: _targetCrs});\n    } catch (e) {\n      // no op\n    }\n  }\n\n  if (projection) {\n    return transformGeoJsonCoords(features, (coords) => projection.project(coords));\n  }\n\n  return features;\n}\n\n/*\n * Parse FlatGeobuf arrayBuffer and return GeoJSON.\n *\n * @param {ReadableStream} _ A FlatGeobuf arrayBuffer\n * @return  A GeoJSON geometry object iterator\n */\n// eslint-disable-next-line complexity\nexport function parseFlatGeobufInBatches(stream, options) {\n  if (options && options.gis && options.gis.format === 'binary') {\n    return parseFlatGeobufInBatchesToBinary(stream, options);\n  }\n\n  return parseFlatGeobufInBatchesToGeoJSON(stream, options);\n}\n\nfunction parseFlatGeobufInBatchesToBinary(stream, options) {\n  // TODO: reproject binary streaming features\n  // const {reproject = false, _targetCrs = 'WGS84'} = (options && options.gis) || {};\n\n  const iterator = deserializeGeneric(stream, binaryFromFeature);\n  return iterator;\n}\n\n// eslint-disable-next-line complexity\nasync function* parseFlatGeobufInBatchesToGeoJSON(stream, options) {\n  const {reproject = false, _targetCrs = 'WGS84'} = (options && options.gis) || {};\n\n  let headerMeta;\n  const iterator = deserializeGeoJson(stream, false, (header) => {\n    headerMeta = header;\n  });\n\n  let projection;\n  let firstRecord = true;\n  for await (const feature of iterator) {\n    if (firstRecord) {\n      const crs = headerMeta && headerMeta.crs;\n      if (reproject && crs) {\n        projection = new Proj4Projection({from: crs.wkt, to: _targetCrs});\n      }\n\n      firstRecord = false;\n    }\n\n    if (reproject && projection) {\n      // eslint-disable-next-line\n      yield transformGeoJsonCoords([feature], (coords) => projection.project(coords));\n    } else {\n      yield feature;\n    }\n  }\n}\n"],"file":"parse-flatgeobuf.js"}

package/dist/esm/flatgeobuf-loader.js

@@ -1,4 +1,4 @@
-const VERSION = typeof "3.1.0-beta.5" !== 'undefined' ? "3.1.0-beta.5" : 'latest';
+const VERSION = typeof "3.1.2" !== 'undefined' ? "3.1.2" : 'latest';
 export const FlatGeobufLoader = {
   id: 'flatgeobuf',
   name: 'FlatGeobuf',

package/dist/esm/flatgeobuf-loader.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/flatgeobuf-loader.ts"],"names":["VERSION","FlatGeobufLoader","id","name","module","version","worker","extensions","mimeTypes","category","options","flatgeobuf","_typecheckFlatGeobufLoader"],"mappings":"AAIA,MAAMA,OAAO,GAAG,0BAAuB,WAAvB,oBAAmD,QAAnE;AAEA,OAAO,MAAMC,gBAAgB,GAAG;AAC9BC,EAAAA,EAAE,EAAE,YAD0B;AAE9BC,EAAAA,IAAI,EAAE,YAFwB;AAG9BC,EAAAA,MAAM,EAAE,YAHsB;AAI9BC,EAAAA,OAAO,EAAEL,OAJqB;AAK9BM,EAAAA,MAAM,EAAE,IALsB;AAM9BC,EAAAA,UAAU,EAAE,CAAC,KAAD,CANkB;AAO9BC,EAAAA,SAAS,EAAE,CAAC,0BAAD,CAPmB;AAQ9BC,EAAAA,QAAQ,EAAE,UARoB;AAS9BC,EAAAA,OAAO,EAAE;AACPC,IAAAA,UAAU,EAAE;AADL;AATqB,CAAzB;AAcP,OAAO,MAAMC,0BAAkC,GAAGX,gBAA3C","sourcesContent":["import type {Loader} from '@loaders.gl/loader-utils';\n\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n\nexport const FlatGeobufLoader = {\n  id: 'flatgeobuf',\n  name: 'FlatGeobuf',\n  module: 'flatgeobuf',\n  version: VERSION,\n  worker: true,\n  extensions: ['fgb'],\n  mimeTypes: ['application/octet-stream'],\n  category: 'geometry',\n  options: {\n    flatgeobuf: {}\n  }\n};\n\nexport const _typecheckFlatGeobufLoader: Loader = FlatGeobufLoader;\n"],"file":"flatgeobuf-loader.js"}
+{"version":3,"sources":["../../src/flatgeobuf-loader.ts"],"names":["VERSION","FlatGeobufLoader","id","name","module","version","worker","extensions","mimeTypes","category","options","flatgeobuf","_typecheckFlatGeobufLoader"],"mappings":"AAIA,MAAMA,OAAO,GAAG,mBAAuB,WAAvB,aAAmD,QAAnE;AAEA,OAAO,MAAMC,gBAAgB,GAAG;AAC9BC,EAAAA,EAAE,EAAE,YAD0B;AAE9BC,EAAAA,IAAI,EAAE,YAFwB;AAG9BC,EAAAA,MAAM,EAAE,YAHsB;AAI9BC,EAAAA,OAAO,EAAEL,OAJqB;AAK9BM,EAAAA,MAAM,EAAE,IALsB;AAM9BC,EAAAA,UAAU,EAAE,CAAC,KAAD,CANkB;AAO9BC,EAAAA,SAAS,EAAE,CAAC,0BAAD,CAPmB;AAQ9BC,EAAAA,QAAQ,EAAE,UARoB;AAS9BC,EAAAA,OAAO,EAAE;AACPC,IAAAA,UAAU,EAAE;AADL;AATqB,CAAzB;AAcP,OAAO,MAAMC,0BAAkC,GAAGX,gBAA3C","sourcesContent":["import type {Loader} from '@loaders.gl/loader-utils';\n\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n\nexport const FlatGeobufLoader = {\n  id: 'flatgeobuf',\n  name: 'FlatGeobuf',\n  module: 'flatgeobuf',\n  version: VERSION,\n  worker: true,\n  extensions: ['fgb'],\n  mimeTypes: ['application/octet-stream'],\n  category: 'geometry',\n  options: {\n    flatgeobuf: {}\n  }\n};\n\nexport const _typecheckFlatGeobufLoader: Loader = FlatGeobufLoader;\n"],"file":"flatgeobuf-loader.js"}

package/dist/esm/index.js

@@ -1,5 +1,5 @@
 import { FlatGeobufLoader as FlatGeobufWorkerLoader } from './flatgeobuf-loader';
-import parseFlatGeobuf, { parseFlatGeobufInBatches } from './lib/parse-flatgeobuf';
+import { parseFlatGeobuf, parseFlatGeobufInBatches } from './lib/parse-flatgeobuf';
 export { FlatGeobufWorkerLoader };
 export const FlatGeobufLoader = { ...FlatGeobufWorkerLoader,
   parse: async (arrayBuffer, options) => parseFlatGeobuf(arrayBuffer, options),

package/dist/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/index.ts"],"names":["FlatGeobufLoader","FlatGeobufWorkerLoader","parseFlatGeobuf","parseFlatGeobufInBatches","parse","arrayBuffer","options","parseSync","parseInBatchesFromStream","binary","_typecheckFlatGeobufLoader"],"mappings":"AACA,SAAQA,gBAAgB,IAAIC,sBAA5B,QAAyD,qBAAzD;AACA,OAAOC,eAAP,IAAyBC,wBAAzB,QAAwD,wBAAxD;AAEA,SAAQF,sBAAR;AAEA,OAAO,MAAMD,gBAAgB,GAAG,EAC9B,GAAGC,sBAD2B;AAE9BG,EAAAA,KAAK,EAAE,OAAOC,WAAP,EAAoBC,OAApB,KAAgCJ,eAAe,CAACG,WAAD,EAAcC,OAAd,CAFxB;AAG9BC,EAAAA,SAAS,EAAEL,eAHmB;AAI9BM,EAAAA,wBAAwB,EAAEL,wBAJI;AAK9BM,EAAAA,MAAM,EAAE;AALsB,CAAzB;AAQP,OAAO,MAAMC,0BAA4C,GAAGV,gBAArD","sourcesContent":["import type {LoaderWithParser} from '@loaders.gl/loader-utils';\nimport {FlatGeobufLoader as FlatGeobufWorkerLoader} from './flatgeobuf-loader';\nimport parseFlatGeobuf, {parseFlatGeobufInBatches} from './lib/parse-flatgeobuf';\n\nexport {FlatGeobufWorkerLoader};\n\nexport const FlatGeobufLoader = {\n  ...FlatGeobufWorkerLoader,\n  parse: async (arrayBuffer, options) => parseFlatGeobuf(arrayBuffer, options),\n  parseSync: parseFlatGeobuf,\n  parseInBatchesFromStream: parseFlatGeobufInBatches,\n  binary: true\n};\n\nexport const _typecheckFlatGeobufLoader: LoaderWithParser = FlatGeobufLoader;\n"],"file":"index.js"}
+{"version":3,"sources":["../../src/index.ts"],"names":["FlatGeobufLoader","FlatGeobufWorkerLoader","parseFlatGeobuf","parseFlatGeobufInBatches","parse","arrayBuffer","options","parseSync","parseInBatchesFromStream","binary","_typecheckFlatGeobufLoader"],"mappings":"AACA,SAAQA,gBAAgB,IAAIC,sBAA5B,QAAyD,qBAAzD;AACA,SAAQC,eAAR,EAAyBC,wBAAzB,QAAwD,wBAAxD;AAEA,SAAQF,sBAAR;AAEA,OAAO,MAAMD,gBAAgB,GAAG,EAC9B,GAAGC,sBAD2B;AAE9BG,EAAAA,KAAK,EAAE,OAAOC,WAAP,EAAoBC,OAApB,KAAgCJ,eAAe,CAACG,WAAD,EAAcC,OAAd,CAFxB;AAG9BC,EAAAA,SAAS,EAAEL,eAHmB;AAI9BM,EAAAA,wBAAwB,EAAEL,wBAJI;AAK9BM,EAAAA,MAAM,EAAE;AALsB,CAAzB;AAQP,OAAO,MAAMC,0BAA4C,GAAGV,gBAArD","sourcesContent":["import type {LoaderWithParser} from '@loaders.gl/loader-utils';\nimport {FlatGeobufLoader as FlatGeobufWorkerLoader} from './flatgeobuf-loader';\nimport {parseFlatGeobuf, parseFlatGeobufInBatches} from './lib/parse-flatgeobuf';\n\nexport {FlatGeobufWorkerLoader};\n\nexport const FlatGeobufLoader = {\n  ...FlatGeobufWorkerLoader,\n  parse: async (arrayBuffer, options) => parseFlatGeobuf(arrayBuffer, options),\n  parseSync: parseFlatGeobuf,\n  parseInBatchesFromStream: parseFlatGeobufInBatches,\n  binary: true\n};\n\nexport const _typecheckFlatGeobufLoader: LoaderWithParser = FlatGeobufLoader;\n"],"file":"index.js"}