@loaders.gl/gis 4.0.0-beta.2 → 4.0.0-beta.3

package/dist/index.js

@@ -0,0 +1,6 @@
+export { flatGeojsonToBinary } from "./lib/flat-geojson-to-binary.js";
+export { geojsonToBinary } from "./lib/geojson-to-binary.js";
+export { geojsonToFlatGeojson } from "./lib/geojson-to-flat-geojson.js";
+export { binaryToGeojson, binaryToGeometry } from "./lib/binary-to-geojson.js";
+export { transformBinaryCoords, transformGeoJsonCoords } from "./lib/transform.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["flatGeojsonToBinary","geojsonToBinary","geojsonToFlatGeojson","binaryToGeojson","binaryToGeometry","transformBinaryCoords","transformGeoJsonCoords"],"sources":["../src/index.ts"],"sourcesContent":["// Types from `@loaders.gl/schema`\n\n// Functions\nexport {flatGeojsonToBinary} from './lib/flat-geojson-to-binary';\nexport {geojsonToBinary} from './lib/geojson-to-binary';\nexport {geojsonToFlatGeojson} from './lib/geojson-to-flat-geojson';\nexport {binaryToGeojson, binaryToGeometry} from './lib/binary-to-geojson';\nexport {transformBinaryCoords, transformGeoJsonCoords} from './lib/transform';\n"],"mappings":"SAGQA,mBAAmB;AAAA,SACnBC,eAAe;AAAA,SACfC,oBAAoB;AAAA,SACpBC,eAAe,EAAEC,gBAAgB;AAAA,SACjCC,qBAAqB,EAAEC,sBAAsB"}

package/dist/{esm/lib → lib}/binary-to-geojson.js

@@ -25,7 +25,7 @@ function getSingleFeature(data, globalFeatureId) {
       return parseFeature(data, lastIndex, data.featureIds.value.length);
     }
   }
-  throw new Error("featureId:".concat(globalFeatureId, " not found"));
+  throw new Error(`featureId:${globalFeatureId} not found`);
 }
 function parseFeatures(data, type) {
   const dataArray = normalizeInput(data, type);
@@ -41,7 +41,7 @@ export function binaryToGeometry(data, startIndex, endIndex) {
       return polygonToGeoJson(data, startIndex, endIndex);
     default:
       const unexpectedInput = data;
-      throw new Error("Unsupported geometry type: ".concat(unexpectedInput === null || unexpectedInput === void 0 ? void 0 : unexpectedInput.type));
+      throw new Error(`Unsupported geometry type: ${unexpectedInput === null || unexpectedInput === void 0 ? void 0 : unexpectedInput.type}`);
   }
 }
 function normalizeInput(data, type) {

package/dist/lib/binary-to-geojson.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"binary-to-geojson.js","names":["binaryToGeojson","data","options","globalFeatureId","undefined","getSingleFeature","parseFeatures","type","dataArray","normalizeInput","lastIndex","lastValue","featureIds","value","i","length","currValue","globalFeatureIds","parseFeature","Error","parseFeatureCollection","binaryToGeometry","startIndex","endIndex","pointToGeoJson","lineStringToGeoJson","polygonToGeoJson","unexpectedInput","features","points","push","lines","polygons","geometry","properties","parseProperties","fields","parseFields","arguments","Object","assign","key","numericProps","Infinity","positions","polygonIndices","filter","x","primitivePolygonIndices","multi","coordinates","startRingIndex","endRingIndex","ringCoordinates","ringToGeoJson","startPolygonIndex","endPolygonIndex","polygonCoordinates","pathIndices","size","j","coord","Array","k","Number"],"sources":["../../src/lib/binary-to-geojson.ts"],"sourcesContent":["// loaders.gl, MIT license\n\nimport type {\n  BinaryGeometry,\n  BinaryGeometryType,\n  BinaryPointGeometry,\n  BinaryLineGeometry,\n  BinaryPolygonGeometry,\n  BinaryFeatureCollection,\n  BinaryFeature,\n  // BinaryPointFeature,\n  // BinaryLineFeature,\n  // BinaryPolygonFeature,\n  BinaryAttribute\n} from '@loaders.gl/schema';\nimport type {Feature, Geometry, Position, GeoJsonProperties} from '@loaders.gl/schema';\nimport type {\n  Point,\n  MultiPoint,\n  LineString,\n  MultiLineString,\n  Polygon,\n  MultiPolygon\n} from '@loaders.gl/schema';\n\n// Note:L We do not handle GeometryCollection, define a limited Geometry type that always has coordinates.\n// type FeatureGeometry = Point | MultiPoint | LineString | MultiLineString | Polygon | MultiPolygon;\n\ntype BinaryToGeoJsonOptions = {\n  type?: BinaryGeometryType;\n  globalFeatureId?: number;\n};\n\n/**\n * Convert binary geometry representation to GeoJSON\n * @param data   geometry data in binary representation\n * @param options\n * @param options.type  Input data type: Point, LineString, or Polygon\n * @param options.featureId  Global feature id. If specified, only a single feature is extracted\n * @return GeoJSON objects\n */\nexport function binaryToGeojson(\n  data: BinaryFeatureCollection,\n  options?: BinaryToGeoJsonOptions\n): Feature[] | Feature {\n  const globalFeatureId = options?.globalFeatureId;\n  if (globalFeatureId !== undefined) {\n    return getSingleFeature(data, globalFeatureId);\n  }\n  return parseFeatures(data, options?.type);\n}\n\n/** @deprecated use `binaryToGeojson` or `binaryToGeometry` instead *\nexport function binaryToGeoJson(\n  data: BinaryGeometry | BinaryFeatureCollection,\n  type?: BinaryGeometryType,\n  format: 'feature' | 'geometry' = 'feature'\n): Geometry | Feature[] {\n  switch (format) {\n    case 'feature':\n      return parseFeatures(data as BinaryFeatureCollection, type);\n    case 'geometry':\n      return binaryToGeometry(data as any);\n    default:\n      throw new Error(format);\n  }\n}\n*/\n\n/**\n * Return a single feature from a binary geometry representation as GeoJSON\n * @param data   geometry data in binary representation\n * @return GeoJSON feature\n */\nfunction getSingleFeature(data: BinaryFeatureCollection, globalFeatureId: number): Feature {\n  const dataArray = normalizeInput(data);\n  for (const data of dataArray) {\n    let lastIndex = 0;\n    let lastValue = data.featureIds.value[0];\n\n    // Scan through data until we find matching feature\n    for (let i = 0; i < data.featureIds.value.length; i++) {\n      const currValue = data.featureIds.value[i];\n      if (currValue === lastValue) {\n        // eslint-disable-next-line no-continue\n        continue;\n      }\n      if (globalFeatureId === data.globalFeatureIds.value[lastIndex]) {\n        return parseFeature(data, lastIndex, i);\n      }\n      lastIndex = i;\n      lastValue = currValue;\n    }\n\n    if (globalFeatureId === data.globalFeatureIds.value[lastIndex]) {\n      return parseFeature(data, lastIndex, data.featureIds.value.length);\n    }\n  }\n\n  throw new Error(`featureId:${globalFeatureId} not found`);\n}\n\nfunction parseFeatures(data: BinaryFeatureCollection, type?: BinaryGeometryType): Feature[] {\n  const dataArray = normalizeInput(data, type);\n  return parseFeatureCollection(dataArray);\n}\n\n/** Parse input binary data and return a valid GeoJSON geometry object */\nexport function binaryToGeometry(\n  data: BinaryGeometry,\n  startIndex?: number,\n  endIndex?: number\n): Geometry {\n  switch (data.type) {\n    case 'Point':\n      return pointToGeoJson(data, startIndex, endIndex);\n    case 'LineString':\n      return lineStringToGeoJson(data, startIndex, endIndex);\n    case 'Polygon':\n      return polygonToGeoJson(data, startIndex, endIndex);\n    default:\n      const unexpectedInput: never = data;\n      throw new Error(`Unsupported geometry type: ${(unexpectedInput as any)?.type}`);\n  }\n}\n\n// Normalize features\n// Return an array of data objects, each of which have a type key\nfunction normalizeInput(data: BinaryFeatureCollection, type?: BinaryGeometryType): BinaryFeature[] {\n  const features: BinaryFeature[] = [];\n  if (data.points) {\n    data.points.type = 'Point';\n    features.push(data.points);\n  }\n  if (data.lines) {\n    data.lines.type = 'LineString';\n    features.push(data.lines);\n  }\n  if (data.polygons) {\n    data.polygons.type = 'Polygon';\n    features.push(data.polygons);\n  }\n\n  return features;\n}\n\n/** Parse input binary data and return an array of GeoJSON Features */\nfunction parseFeatureCollection(dataArray: BinaryFeature[]): Feature[] {\n  const features: Feature[] = [];\n  for (const data of dataArray) {\n    if (data.featureIds.value.length === 0) {\n      // eslint-disable-next-line no-continue\n      continue;\n    }\n    let lastIndex = 0;\n    let lastValue = data.featureIds.value[0];\n\n    // Need to deduce start, end indices of each feature\n    for (let i = 0; i < data.featureIds.value.length; i++) {\n      const currValue = data.featureIds.value[i];\n      if (currValue === lastValue) {\n        // eslint-disable-next-line no-continue\n        continue;\n      }\n\n      features.push(parseFeature(data, lastIndex, i));\n      lastIndex = i;\n      lastValue = currValue;\n    }\n\n    // Last feature\n    features.push(parseFeature(data, lastIndex, data.featureIds.value.length));\n  }\n  return features;\n}\n\n/** Parse input binary data and return a single GeoJSON Feature */\nfunction parseFeature(data: BinaryFeature, startIndex?: number, endIndex?: number): Feature {\n  const geometry = binaryToGeometry(data, startIndex, endIndex);\n  const properties = parseProperties(data, startIndex, endIndex);\n  const fields = parseFields(data, startIndex, endIndex);\n  return {type: 'Feature', geometry, properties, ...fields};\n}\n\n/** Parse input binary data and return an object of fields */\nfunction parseFields(data, startIndex: number = 0, endIndex?: number): GeoJsonProperties {\n  return data.fields && data.fields[data.featureIds.value[startIndex]];\n}\n\n/** Parse input binary data and return an object of properties */\nfunction parseProperties(data, startIndex: number = 0, endIndex?: number): GeoJsonProperties {\n  const properties = Object.assign({}, data.properties[data.featureIds.value[startIndex]]);\n  for (const key in data.numericProps) {\n    properties[key] = data.numericProps[key].value[startIndex];\n  }\n  return properties;\n}\n\n/** Parse binary data of type Polygon */\nfunction polygonToGeoJson(\n  data: BinaryPolygonGeometry,\n  startIndex: number = -Infinity,\n  endIndex: number = Infinity\n): Polygon | MultiPolygon {\n  const {positions} = data;\n  const polygonIndices = data.polygonIndices.value.filter((x) => x >= startIndex && x <= endIndex);\n  const primitivePolygonIndices = data.primitivePolygonIndices.value.filter(\n    (x) => x >= startIndex && x <= endIndex\n  );\n  const multi = polygonIndices.length > 2;\n\n  // Polygon\n  if (!multi) {\n    const coordinates: Position[][] = [];\n    for (let i = 0; i < primitivePolygonIndices.length - 1; i++) {\n      const startRingIndex = primitivePolygonIndices[i];\n      const endRingIndex = primitivePolygonIndices[i + 1];\n      const ringCoordinates = ringToGeoJson(positions, startRingIndex, endRingIndex);\n      coordinates.push(ringCoordinates);\n    }\n\n    return {type: 'Polygon', coordinates};\n  }\n\n  // MultiPolygon\n  const coordinates: Position[][][] = [];\n  for (let i = 0; i < polygonIndices.length - 1; i++) {\n    const startPolygonIndex = polygonIndices[i];\n    const endPolygonIndex = polygonIndices[i + 1];\n    const polygonCoordinates = polygonToGeoJson(\n      data,\n      startPolygonIndex,\n      endPolygonIndex\n    ).coordinates;\n    coordinates.push(polygonCoordinates as Position[][]);\n  }\n\n  return {type: 'MultiPolygon', coordinates};\n}\n\n/** Parse binary data of type LineString */\nfunction lineStringToGeoJson(\n  data: BinaryLineGeometry,\n  startIndex: number = -Infinity,\n  endIndex: number = Infinity\n): LineString | MultiLineString {\n  const {positions} = data;\n  const pathIndices = data.pathIndices.value.filter((x) => x >= startIndex && x <= endIndex);\n  const multi = pathIndices.length > 2;\n\n  if (!multi) {\n    const coordinates = ringToGeoJson(positions, pathIndices[0], pathIndices[1]);\n    return {type: 'LineString', coordinates};\n  }\n\n  const coordinates: Position[][] = [];\n  for (let i = 0; i < pathIndices.length - 1; i++) {\n    const ringCoordinates = ringToGeoJson(positions, pathIndices[i], pathIndices[i + 1]);\n    coordinates.push(ringCoordinates);\n  }\n\n  return {type: 'MultiLineString', coordinates};\n}\n\n/** Parse binary data of type Point */\nfunction pointToGeoJson(data: BinaryPointGeometry, startIndex, endIndex): Point | MultiPoint {\n  const {positions} = data;\n  const coordinates = ringToGeoJson(positions, startIndex, endIndex);\n  const multi = coordinates.length > 1;\n\n  if (multi) {\n    return {type: 'MultiPoint', coordinates};\n  }\n\n  return {type: 'Point', coordinates: coordinates[0]};\n}\n\n/**\n * Parse a linear ring of positions to a GeoJSON linear ring\n *\n * @param positions Positions TypedArray\n * @param startIndex Start index to include in ring\n * @param endIndex End index to include in ring\n * @returns GeoJSON ring\n */\nfunction ringToGeoJson(\n  positions: BinaryAttribute,\n  startIndex?: number,\n  endIndex?: number\n): Position[] {\n  startIndex = startIndex || 0;\n  endIndex = endIndex || positions.value.length / positions.size;\n\n  const ringCoordinates: Position[] = [];\n  for (let j = startIndex; j < endIndex; j++) {\n    const coord = Array<number>();\n    for (let k = j * positions.size; k < (j + 1) * positions.size; k++) {\n      coord.push(Number(positions.value[k]));\n    }\n    ringCoordinates.push(coord);\n  }\n  return ringCoordinates;\n}\n"],"mappings":"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"}

package/dist/{esm/lib → lib}/extract-geometry-info.js

@@ -65,7 +65,7 @@ export function extractGeometryInfo(features) {
         }
         break;
       default:
-        throw new Error("Unsupported geometry type: ".concat(geometry.type));
+        throw new Error(`Unsupported geometry type: ${geometry.type}`);
     }
   }
   return {

package/dist/lib/extract-geometry-info.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract-geometry-info.js","names":["extractGeometryInfo","features","pointPositionsCount","pointFeaturesCount","linePositionsCount","linePathsCount","lineFeaturesCount","polygonPositionsCount","polygonObjectsCount","polygonRingsCount","polygonFeaturesCount","coordLengths","Set","feature","geometry","type","add","coordinates","length","point","coord","line","flattened","flat","polygon","Error","coordLength","size","Math","max"],"sources":["../../src/lib/extract-geometry-info.ts"],"sourcesContent":["import {Feature, GeojsonGeometryInfo} from '@loaders.gl/schema';\n\n/**\n *  Initial scan over GeoJSON features\n *  Counts number of coordinates of each geometry type and\n *  keeps track of the max coordinate dimensions\n */\n// eslint-disable-next-line complexity, max-statements\nexport function extractGeometryInfo(features: Feature[]): GeojsonGeometryInfo {\n  // Counts the number of _positions_, so [x, y, z] counts as one\n  let pointPositionsCount = 0;\n  let pointFeaturesCount = 0;\n  let linePositionsCount = 0;\n  let linePathsCount = 0;\n  let lineFeaturesCount = 0;\n  let polygonPositionsCount = 0;\n  let polygonObjectsCount = 0;\n  let polygonRingsCount = 0;\n  let polygonFeaturesCount = 0;\n  const coordLengths = new Set<number>();\n\n  for (const feature of features) {\n    const geometry = feature.geometry;\n    switch (geometry.type) {\n      case 'Point':\n        pointFeaturesCount++;\n        pointPositionsCount++;\n        coordLengths.add(geometry.coordinates.length);\n        break;\n      case 'MultiPoint':\n        pointFeaturesCount++;\n        pointPositionsCount += geometry.coordinates.length;\n        for (const point of geometry.coordinates) {\n          coordLengths.add(point.length);\n        }\n        break;\n      case 'LineString':\n        lineFeaturesCount++;\n        linePositionsCount += geometry.coordinates.length;\n        linePathsCount++;\n\n        for (const coord of geometry.coordinates) {\n          coordLengths.add(coord.length);\n        }\n        break;\n      case 'MultiLineString':\n        lineFeaturesCount++;\n        for (const line of geometry.coordinates) {\n          linePositionsCount += line.length;\n          linePathsCount++;\n\n          // eslint-disable-next-line max-depth\n          for (const coord of line) {\n            coordLengths.add(coord.length);\n          }\n        }\n        break;\n      case 'Polygon':\n        polygonFeaturesCount++;\n        polygonObjectsCount++;\n        polygonRingsCount += geometry.coordinates.length;\n        const flattened = geometry.coordinates.flat();\n        polygonPositionsCount += flattened.length;\n\n        for (const coord of flattened) {\n          coordLengths.add(coord.length);\n        }\n        break;\n      case 'MultiPolygon':\n        polygonFeaturesCount++;\n        for (const polygon of geometry.coordinates) {\n          polygonObjectsCount++;\n          polygonRingsCount += polygon.length;\n          const flattened = polygon.flat();\n          polygonPositionsCount += flattened.length;\n\n          // eslint-disable-next-line max-depth\n          for (const coord of flattened) {\n            coordLengths.add(coord.length);\n          }\n        }\n        break;\n      default:\n        throw new Error(`Unsupported geometry type: ${geometry.type}`);\n    }\n  }\n\n  return {\n    coordLength: coordLengths.size > 0 ? Math.max(...coordLengths) : 2,\n\n    pointPositionsCount,\n    pointFeaturesCount,\n    linePositionsCount,\n    linePathsCount,\n    lineFeaturesCount,\n    polygonPositionsCount,\n    polygonObjectsCount,\n    polygonRingsCount,\n    polygonFeaturesCount\n  };\n}\n"],"mappings":"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"}

package/dist/lib/flat-geojson-to-binary-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flat-geojson-to-binary-types.js","names":[],"sources":["../../src/lib/flat-geojson-to-binary-types.ts"],"sourcesContent":["import type {TypedArray} from '@loaders.gl/schema';\n\n/**\n * Permissable constructor for numeric props\n */\nexport type PropArrayConstructor =\n  | Float32ArrayConstructor\n  | Float64ArrayConstructor\n  | ArrayConstructor;\n\n/**\n * Collection type for holding intermediate binary data before conversion to `BinaryPointGeometry`\n */\nexport type Points = {\n  type: 'Point';\n  positions: Float32Array | Float64Array;\n  globalFeatureIds: Uint16Array | Uint32Array;\n  featureIds: Uint16Array | Uint32Array;\n  numericProps: {[key: string]: TypedArray};\n  properties: {}[];\n  fields: {\n    id?: string | number;\n  }[];\n};\n\n/**\n * Collection type for holding intermediate binary data before conversion to `BinaryLineStringGeometry`\n */\nexport type Lines = {\n  type: 'LineString';\n  positions: Float32Array | Float64Array;\n  pathIndices: Uint16Array | Uint32Array;\n  globalFeatureIds: Uint16Array | Uint32Array;\n  featureIds: Uint16Array | Uint32Array;\n  numericProps: {[key: string]: TypedArray};\n  properties: {}[];\n  fields: {\n    id?: string | number;\n  }[];\n};\n\n/**\n * Collection type for holding intermediate binary data before conversion to `BinaryPolygonGeometry`\n */\nexport type Polygons = {\n  type: 'Polygon';\n  positions: Float32Array | Float64Array;\n  polygonIndices: Uint16Array | Uint32Array;\n  primitivePolygonIndices: Uint16Array | Uint32Array;\n  triangles?: number[];\n  globalFeatureIds: Uint16Array | Uint32Array;\n  featureIds: Uint16Array | Uint32Array;\n  numericProps: {[key: string]: TypedArray};\n  properties: {}[];\n  fields: {\n    id?: string | number;\n  }[];\n};\n"],"mappings":""}

package/dist/lib/flat-geojson-to-binary.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flat-geojson-to-binary.js","names":["earcut","flatGeojsonToBinary","features","geometryInfo","options","propArrayTypes","extractNumericPropTypes","numericPropKeys","Object","keys","filter","k","Array","fillArrays","PositionDataType","Float32Array","triangulate","TEST_EXPORTS","feature","properties","key","val","deduceArrayType","pointPositionsCount","pointFeaturesCount","linePositionsCount","linePathsCount","lineFeaturesCount","polygonPositionsCount","polygonObjectsCount","polygonRingsCount","polygonFeaturesCount","coordLength","hasGlobalId","GlobalFeatureIdsDataType","length","Uint32Array","Uint16Array","points","type","positions","globalFeatureIds","featureIds","numericProps","fields","lines","pathIndices","polygons","polygonIndices","primitivePolygonIndices","triangles","object","propName","T","indexMap","pointPosition","pointFeature","linePosition","linePath","lineFeature","polygonPosition","polygonObject","polygonRing","polygonFeature","geometry","handlePoint","push","keepStringProperties","id","handleLineString","handlePolygon","Error","makeAccessorObjects","set","data","nPositions","fillNumericProperties","fill","i","il","indices","start","end","l","ll","startPosition","areas","nextIndices","undefined","endPosition","triangulatePolygon","_ref","polygonPositions","subarray","offset","holes","slice","map","n","t","tl","wrapProps","obj","size","returnObj","value","binaryFeatures","index","numericPropName","numericKeys","props","includes","x","constructor","Number","isFinite","Float64Array","Math","fround"],"sources":["../../src/lib/flat-geojson-to-binary.ts"],"sourcesContent":["/* eslint-disable indent */\nimport {earcut} from '@math.gl/polygon';\nimport type {\n  BinaryAttribute,\n  BinaryFeatureCollection,\n  BinaryPolygonFeature,\n  FlatFeature,\n  FlatPoint,\n  FlatLineString,\n  FlatPolygon,\n  GeojsonGeometryInfo,\n  TypedArray\n} from '@loaders.gl/schema';\nimport {PropArrayConstructor, Lines, Points, Polygons} from './flat-geojson-to-binary-types';\n\n/**\n * Convert binary features to flat binary arrays. Similar to\n * `geojsonToBinary` helper function, except that it expects\n * a binary representation of the feature data, which enables\n * 2X-3X speed increase in parse speed, compared to using\n * geoJSON. See `binary-vector-tile/VectorTileFeature` for\n * data format detais\n *\n * @param features\n * @param geometryInfo\n * @param options\n * @returns filled arrays\n */\nexport function flatGeojsonToBinary(\n  features: FlatFeature[],\n  geometryInfo: GeojsonGeometryInfo,\n  options?: FlatGeojsonToBinaryOptions\n) {\n  const propArrayTypes = extractNumericPropTypes(features);\n  const numericPropKeys = Object.keys(propArrayTypes).filter((k) => propArrayTypes[k] !== Array);\n  return fillArrays(\n    features,\n    {\n      propArrayTypes,\n      ...geometryInfo\n    },\n    {\n      numericPropKeys: (options && options.numericPropKeys) || numericPropKeys,\n      PositionDataType: options ? options.PositionDataType : Float32Array,\n      triangulate: options ? options.triangulate : true\n    }\n  );\n}\n\n/**\n * Options for `flatGeojsonToBinary`\n */\nexport type FlatGeojsonToBinaryOptions = {\n  numericPropKeys?: string[];\n  PositionDataType?: Float32ArrayConstructor | Float64ArrayConstructor;\n  triangulate?: boolean;\n};\n\nexport const TEST_EXPORTS = {\n  extractNumericPropTypes\n};\n\n/**\n * Extracts properties that are always numeric\n *\n * @param features\n * @returns object with numeric types\n */\nfunction extractNumericPropTypes(features: FlatFeature[]): {\n  [key: string]: PropArrayConstructor;\n} {\n  const propArrayTypes = {};\n  for (const feature of features) {\n    if (feature.properties) {\n      for (const key in feature.properties) {\n        // If property has not been seen before, or if property has been numeric\n        // in all previous features, check if numeric in this feature\n        // If not numeric, Array is stored to prevent rechecking in the future\n        // Additionally, detects if 64 bit precision is required\n        const val = feature.properties[key];\n        propArrayTypes[key] = deduceArrayType(val, propArrayTypes[key]);\n      }\n    }\n  }\n\n  return propArrayTypes;\n}\n\n/**\n * Fills coordinates into pre-allocated typed arrays\n *\n * @param features\n * @param geometryInfo\n * @param options\n * @returns an accessor object with value and size keys\n */\n// eslint-disable-next-line complexity, max-statements\nfunction fillArrays(\n  features: FlatFeature[],\n  geometryInfo: GeojsonGeometryInfo & {\n    propArrayTypes: {[key: string]: PropArrayConstructor};\n  },\n  options: FlatGeojsonToBinaryOptions\n) {\n  const {\n    pointPositionsCount,\n    pointFeaturesCount,\n    linePositionsCount,\n    linePathsCount,\n    lineFeaturesCount,\n    polygonPositionsCount,\n    polygonObjectsCount,\n    polygonRingsCount,\n    polygonFeaturesCount,\n    propArrayTypes,\n    coordLength\n  } = geometryInfo;\n  const {numericPropKeys = [], PositionDataType = Float32Array, triangulate = true} = options;\n  const hasGlobalId = features[0] && 'id' in features[0];\n  const GlobalFeatureIdsDataType = features.length > 65535 ? Uint32Array : Uint16Array;\n  const points: Points = {\n    type: 'Point',\n    positions: new PositionDataType(pointPositionsCount * coordLength),\n    globalFeatureIds: new GlobalFeatureIdsDataType(pointPositionsCount),\n    featureIds:\n      pointFeaturesCount > 65535\n        ? new Uint32Array(pointPositionsCount)\n        : new Uint16Array(pointPositionsCount),\n    numericProps: {},\n    properties: [],\n    fields: []\n  };\n  const lines: Lines = {\n    type: 'LineString',\n    pathIndices:\n      linePositionsCount > 65535\n        ? new Uint32Array(linePathsCount + 1)\n        : new Uint16Array(linePathsCount + 1),\n    positions: new PositionDataType(linePositionsCount * coordLength),\n    globalFeatureIds: new GlobalFeatureIdsDataType(linePositionsCount),\n    featureIds:\n      lineFeaturesCount > 65535\n        ? new Uint32Array(linePositionsCount)\n        : new Uint16Array(linePositionsCount),\n    numericProps: {},\n    properties: [],\n    fields: []\n  };\n  const polygons: Polygons = {\n    type: 'Polygon',\n    polygonIndices:\n      polygonPositionsCount > 65535\n        ? new Uint32Array(polygonObjectsCount + 1)\n        : new Uint16Array(polygonObjectsCount + 1),\n    primitivePolygonIndices:\n      polygonPositionsCount > 65535\n        ? new Uint32Array(polygonRingsCount + 1)\n        : new Uint16Array(polygonRingsCount + 1),\n    positions: new PositionDataType(polygonPositionsCount * coordLength),\n    globalFeatureIds: new GlobalFeatureIdsDataType(polygonPositionsCount),\n    featureIds:\n      polygonFeaturesCount > 65535\n        ? new Uint32Array(polygonPositionsCount)\n        : new Uint16Array(polygonPositionsCount),\n    numericProps: {},\n    properties: [],\n    fields: []\n  };\n\n  if (triangulate) {\n    polygons.triangles = [];\n  }\n\n  // Instantiate numeric properties arrays; one value per vertex\n  for (const object of [points, lines, polygons]) {\n    for (const propName of numericPropKeys) {\n      // If property has been numeric in all previous features in which the property existed, check\n      // if numeric in this feature\n      const T = propArrayTypes[propName];\n      object.numericProps[propName] = new T(object.positions.length / coordLength) as TypedArray;\n    }\n  }\n\n  // Set last element of path/polygon indices as positions length\n  lines.pathIndices[linePathsCount] = linePositionsCount;\n  polygons.polygonIndices[polygonObjectsCount] = polygonPositionsCount;\n  polygons.primitivePolygonIndices[polygonRingsCount] = polygonPositionsCount;\n\n  const indexMap = {\n    pointPosition: 0,\n    pointFeature: 0,\n    linePosition: 0,\n    linePath: 0,\n    lineFeature: 0,\n    polygonPosition: 0,\n    polygonObject: 0,\n    polygonRing: 0,\n    polygonFeature: 0,\n    feature: 0\n  };\n\n  for (const feature of features) {\n    const geometry = feature.geometry;\n    const properties = feature.properties || {};\n\n    switch (geometry.type) {\n      case 'Point':\n        handlePoint(geometry, points, indexMap, coordLength, properties);\n        points.properties.push(keepStringProperties(properties, numericPropKeys));\n        if (hasGlobalId) {\n          points.fields.push({id: feature.id});\n        }\n        indexMap.pointFeature++;\n        break;\n      case 'LineString':\n        handleLineString(geometry, lines, indexMap, coordLength, properties);\n        lines.properties.push(keepStringProperties(properties, numericPropKeys));\n        if (hasGlobalId) {\n          lines.fields.push({id: feature.id});\n        }\n        indexMap.lineFeature++;\n        break;\n      case 'Polygon':\n        handlePolygon(geometry, polygons, indexMap, coordLength, properties);\n        polygons.properties.push(keepStringProperties(properties, numericPropKeys));\n        if (hasGlobalId) {\n          polygons.fields.push({id: feature.id});\n        }\n        indexMap.polygonFeature++;\n        break;\n      default:\n        throw new Error('Invalid geometry type');\n    }\n\n    indexMap.feature++;\n  }\n\n  // Wrap each array in an accessor object with value and size keys\n  return makeAccessorObjects(points, lines, polygons, coordLength);\n}\n\n/**\n * Fills (Multi)Point coordinates into points object of arrays\n *\n * @param geometry\n * @param points\n * @param indexMap\n * @param coordLength\n * @param properties\n */\nfunction handlePoint(\n  geometry: FlatPoint,\n  points: Points,\n  indexMap: {\n    pointPosition: number;\n    pointFeature: number;\n    linePosition?: number;\n    linePath?: number;\n    lineFeature?: number;\n    polygonPosition?: number;\n    polygonObject?: number;\n    polygonRing?: number;\n    polygonFeature?: number;\n    feature: number;\n  },\n  coordLength: number,\n  properties: {[x: string]: string | number | boolean | null}\n): void {\n  points.positions.set(geometry.data, indexMap.pointPosition * coordLength);\n\n  const nPositions = geometry.data.length / coordLength;\n  fillNumericProperties(points, properties, indexMap.pointPosition, nPositions);\n  points.globalFeatureIds.fill(\n    indexMap.feature,\n    indexMap.pointPosition,\n    indexMap.pointPosition + nPositions\n  );\n  points.featureIds.fill(\n    indexMap.pointFeature,\n    indexMap.pointPosition,\n    indexMap.pointPosition + nPositions\n  );\n\n  indexMap.pointPosition += nPositions;\n}\n\n/**\n * Fills (Multi)LineString coordinates into lines object of arrays\n *\n * @param geometry\n * @param lines\n * @param indexMap\n * @param coordLength\n * @param properties\n */\nfunction handleLineString(\n  geometry: FlatLineString,\n  lines: Lines,\n  indexMap: {\n    pointPosition?: number;\n    pointFeature?: number;\n    linePosition: number;\n    linePath: number;\n    lineFeature: number;\n    polygonPosition?: number;\n    polygonObject?: number;\n    polygonRing?: number;\n    polygonFeature?: number;\n    feature: number;\n  },\n  coordLength: number,\n  properties: {[x: string]: string | number | boolean | null}\n): void {\n  lines.positions.set(geometry.data, indexMap.linePosition * coordLength);\n\n  const nPositions = geometry.data.length / coordLength;\n  fillNumericProperties(lines, properties, indexMap.linePosition, nPositions);\n\n  lines.globalFeatureIds.fill(\n    indexMap.feature,\n    indexMap.linePosition,\n    indexMap.linePosition + nPositions\n  );\n  lines.featureIds.fill(\n    indexMap.lineFeature,\n    indexMap.linePosition,\n    indexMap.linePosition + nPositions\n  );\n\n  for (let i = 0, il = geometry.indices.length; i < il; ++i) {\n    // Extract range of data we are working with, defined by start\n    // and end indices (these index into the geometry.data array)\n    const start = geometry.indices[i];\n    const end =\n      i === il - 1\n        ? geometry.data.length // last line, so read to end of data\n        : geometry.indices[i + 1]; // start index for next line\n\n    lines.pathIndices[indexMap.linePath++] = indexMap.linePosition;\n    indexMap.linePosition += (end - start) / coordLength;\n  }\n}\n\n/**\n * Fills (Multi)Polygon coordinates into polygons object of arrays\n *\n * @param geometry\n * @param polygons\n * @param indexMap\n * @param coordLength\n * @param properties\n */\nfunction handlePolygon(\n  geometry: FlatPolygon,\n  polygons: Polygons,\n  indexMap: {\n    pointPosition?: number;\n    pointFeature?: number;\n    linePosition?: number;\n    linePath?: number;\n    lineFeature?: number;\n    polygonPosition: number;\n    polygonObject: number;\n    polygonRing: number;\n    polygonFeature: number;\n    feature: number;\n  },\n  coordLength: number,\n  properties: {[x: string]: string | number | boolean | null}\n): void {\n  polygons.positions.set(geometry.data, indexMap.polygonPosition * coordLength);\n\n  const nPositions = geometry.data.length / coordLength;\n  fillNumericProperties(polygons, properties, indexMap.polygonPosition, nPositions);\n  polygons.globalFeatureIds.fill(\n    indexMap.feature,\n    indexMap.polygonPosition,\n    indexMap.polygonPosition + nPositions\n  );\n  polygons.featureIds.fill(\n    indexMap.polygonFeature,\n    indexMap.polygonPosition,\n    indexMap.polygonPosition + nPositions\n  );\n\n  // Unlike Point & LineString geometry.indices is a 2D array\n  for (let l = 0, ll = geometry.indices.length; l < ll; ++l) {\n    const startPosition = indexMap.polygonPosition;\n    polygons.polygonIndices[indexMap.polygonObject++] = startPosition;\n\n    const areas = geometry.areas[l];\n    const indices = geometry.indices[l];\n    const nextIndices = geometry.indices[l + 1];\n\n    for (let i = 0, il = indices.length; i < il; ++i) {\n      const start = indices[i];\n      const end =\n        i === il - 1\n          ? // last line, so either read to:\n            nextIndices === undefined\n            ? geometry.data.length // end of data (no next indices)\n            : nextIndices[0] // start of first line in nextIndices\n          : indices[i + 1]; // start index for next line\n\n      polygons.primitivePolygonIndices[indexMap.polygonRing++] = indexMap.polygonPosition;\n      indexMap.polygonPosition += (end - start) / coordLength;\n    }\n\n    const endPosition = indexMap.polygonPosition;\n    triangulatePolygon(polygons, areas, indices, {startPosition, endPosition, coordLength});\n  }\n}\n\n/**\n * Triangulate polygon using earcut\n *\n * @param polygons\n * @param areas\n * @param indices\n * @param param3\n */\nfunction triangulatePolygon(\n  polygons: Polygons,\n  areas: number[],\n  indices: number[],\n  {\n    startPosition,\n    endPosition,\n    coordLength\n  }: {startPosition: number; endPosition: number; coordLength: number}\n): void {\n  if (!polygons.triangles) {\n    return;\n  }\n\n  const start = startPosition * coordLength;\n  const end = endPosition * coordLength;\n\n  // Extract positions and holes for just this polygon\n  const polygonPositions = polygons.positions.subarray(start, end);\n\n  // Holes are referenced relative to outer polygon\n  const offset = indices[0];\n  const holes = indices.slice(1).map((n: number) => (n - offset) / coordLength);\n\n  // Compute triangulation\n  const triangles = earcut(polygonPositions, holes, coordLength, areas);\n\n  // Indices returned by triangulation are relative to start\n  // of polygon, so we need to offset\n  for (let t = 0, tl = triangles.length; t < tl; ++t) {\n    polygons.triangles.push(startPosition + triangles[t]);\n  }\n}\n\n/**\n * Wraps an object containing array into accessors\n *\n * @param obj\n * @param size\n */\nfunction wrapProps(\n  obj: {[key: string]: TypedArray},\n  size: number\n): {[key: string]: BinaryAttribute} {\n  const returnObj = {};\n  for (const key in obj) {\n    returnObj[key] = {value: obj[key], size};\n  }\n  return returnObj;\n}\n\n/**\n * Wrap each array in an accessor object with value and size keys\n *\n * @param points\n * @param lines\n * @param polygons\n * @param coordLength\n * @returns object\n */\nfunction makeAccessorObjects(\n  points: Points,\n  lines: Lines,\n  polygons: Polygons,\n  coordLength: number\n): BinaryFeatureCollection {\n  const binaryFeatures: BinaryFeatureCollection = {\n    points: {\n      ...points,\n      positions: {value: points.positions, size: coordLength},\n      globalFeatureIds: {value: points.globalFeatureIds, size: 1},\n      featureIds: {value: points.featureIds, size: 1},\n      numericProps: wrapProps(points.numericProps, 1)\n    },\n    lines: {\n      ...lines,\n      positions: {value: lines.positions, size: coordLength},\n      pathIndices: {value: lines.pathIndices, size: 1},\n      globalFeatureIds: {value: lines.globalFeatureIds, size: 1},\n      featureIds: {value: lines.featureIds, size: 1},\n      numericProps: wrapProps(lines.numericProps, 1)\n    },\n    polygons: {\n      ...polygons,\n      positions: {value: polygons.positions, size: coordLength},\n      polygonIndices: {value: polygons.polygonIndices, size: 1},\n      primitivePolygonIndices: {value: polygons.primitivePolygonIndices, size: 1},\n      globalFeatureIds: {value: polygons.globalFeatureIds, size: 1},\n      featureIds: {value: polygons.featureIds, size: 1},\n      numericProps: wrapProps(polygons.numericProps, 1)\n    } as BinaryPolygonFeature // triangles not expected\n  };\n\n  if (binaryFeatures.polygons && polygons.triangles) {\n    binaryFeatures.polygons.triangles = {value: new Uint32Array(polygons.triangles), size: 1};\n  }\n\n  return binaryFeatures;\n}\n\n/**\n * Add numeric properties to object\n *\n * @param object\n * @param properties\n * @param index\n * @param length\n */\nfunction fillNumericProperties(\n  object: Points | Lines | Polygons,\n  properties: {[x: string]: string | number | boolean | null},\n  index: number,\n  length: number\n): void {\n  for (const numericPropName in object.numericProps) {\n    if (numericPropName in properties) {\n      const value = properties[numericPropName] as number;\n      object.numericProps[numericPropName].fill(value, index, index + length);\n    }\n  }\n}\n\n/**\n * Keep string properties in object\n *\n * @param properties\n * @param numericKeys\n * @returns object\n */\nfunction keepStringProperties(\n  properties: {[x: string]: string | number | boolean | null},\n  numericKeys: string[]\n) {\n  const props = {};\n  for (const key in properties) {\n    if (!numericKeys.includes(key)) {\n      props[key] = properties[key];\n    }\n  }\n  return props;\n}\n\n/**\n *\n * Deduce correct array constructor to use for a given value\n *\n * @param x value to test\n * @param constructor previous constructor deduced\n * @returns PropArrayConstructor\n */\nfunction deduceArrayType(x: any, constructor: PropArrayConstructor): PropArrayConstructor {\n  if (constructor === Array || !Number.isFinite(x)) {\n    return Array;\n  }\n\n  // If this or previous value required 64bits use Float64Array\n  return constructor === Float64Array || Math.fround(x) !== x ? Float64Array : Float32Array;\n}\n"],"mappings":"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"}

package/dist/{esm/lib → lib}/geojson-to-binary.js

@@ -1,6 +1,6 @@
-import { extractGeometryInfo } from './extract-geometry-info';
-import { geojsonToFlatGeojson } from './geojson-to-flat-geojson';
-import { flatGeojsonToBinary } from './flat-geojson-to-binary';
+import { extractGeometryInfo } from "./extract-geometry-info.js";
+import { geojsonToFlatGeojson } from "./geojson-to-flat-geojson.js";
+import { flatGeojsonToBinary } from "./flat-geojson-to-binary.js";
 export function geojsonToBinary(features) {
   let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
     fixRingWinding: true,

package/dist/lib/geojson-to-binary.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"geojson-to-binary.js","names":["extractGeometryInfo","geojsonToFlatGeojson","flatGeojsonToBinary","geojsonToBinary","features","options","arguments","length","undefined","fixRingWinding","triangulate","geometryInfo","coordLength","flatFeatures","numericPropKeys","PositionDataType","Float32Array"],"sources":["../../src/lib/geojson-to-binary.ts"],"sourcesContent":["import type {Feature} from '@loaders.gl/schema';\nimport type {BinaryFeatureCollection} from '@loaders.gl/schema';\n\nimport {extractGeometryInfo} from './extract-geometry-info';\nimport {geojsonToFlatGeojson} from './geojson-to-flat-geojson';\nimport {flatGeojsonToBinary} from './flat-geojson-to-binary';\n\n/**\n * Options for `geojsonToBinary`\n */\nexport type GeojsonToBinaryOptions = {\n  fixRingWinding: boolean;\n  numericPropKeys?: string[];\n  PositionDataType?: Float32ArrayConstructor | Float64ArrayConstructor;\n  triangulate?: boolean;\n};\n\n/**\n * Convert GeoJSON features to flat binary arrays\n *\n * @param features\n * @param options\n * @returns features in binary format, grouped by geometry type\n */\nexport function geojsonToBinary(\n  features: Feature[],\n  options: GeojsonToBinaryOptions = {fixRingWinding: true, triangulate: true}\n): BinaryFeatureCollection {\n  const geometryInfo = extractGeometryInfo(features);\n  const coordLength = geometryInfo.coordLength;\n  const {fixRingWinding} = options;\n  const flatFeatures = geojsonToFlatGeojson(features, {coordLength, fixRingWinding});\n  return flatGeojsonToBinary(flatFeatures, geometryInfo, {\n    numericPropKeys: options.numericPropKeys,\n    PositionDataType: options.PositionDataType || Float32Array,\n    triangulate: options.triangulate\n  });\n}\n"],"mappings":"SAGQA,mBAAmB;AAAA,SACnBC,oBAAoB;AAAA,SACpBC,mBAAmB;AAmB3B,OAAO,SAASC,eAAeA,CAC7BC,QAAmB,EAEM;EAAA,IADzBC,OAA+B,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG;IAACG,cAAc,EAAE,IAAI;IAAEC,WAAW,EAAE;EAAI,CAAC;EAE3E,MAAMC,YAAY,GAAGX,mBAAmB,CAACI,QAAQ,CAAC;EAClD,MAAMQ,WAAW,GAAGD,YAAY,CAACC,WAAW;EAC5C,MAAM;IAACH;EAAc,CAAC,GAAGJ,OAAO;EAChC,MAAMQ,YAAY,GAAGZ,oBAAoB,CAACG,QAAQ,EAAE;IAACQ,WAAW;IAAEH;EAAc,CAAC,CAAC;EAClF,OAAOP,mBAAmB,CAACW,YAAY,EAAEF,YAAY,EAAE;IACrDG,eAAe,EAAET,OAAO,CAACS,eAAe;IACxCC,gBAAgB,EAAEV,OAAO,CAACU,gBAAgB,IAAIC,YAAY;IAC1DN,WAAW,EAAEL,OAAO,CAACK;EACvB,CAAC,CAAC;AACJ"}

package/dist/{esm/lib → lib}/geojson-to-flat-geojson.js

@@ -82,7 +82,7 @@ function flattenFeature(feature, options) {
       geometry.coordinates.map(c => flattenPolygon(c, data, indices, areas, options));
       break;
     default:
-      throw new Error("Unknown type: ".concat(type));
+      throw new Error(`Unknown type: ${type}`);
   }
   return {
     ...feature,

package/dist/lib/geojson-to-flat-geojson.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"geojson-to-flat-geojson.js","names":["getPolygonSignedArea","geojsonToFlatGeojson","features","options","arguments","length","undefined","coordLength","fixRingWinding","map","feature","flattenFeature","flattenPoint","coordinates","data","indices","push","i","flattenLineString","c","flattenPolygon","areas","count","ringAreas","polygons","lineString","lineString2d","p","slice","area","flat","ccw","reverse","geometry","type","Error"],"sources":["../../src/lib/geojson-to-flat-geojson.ts"],"sourcesContent":["import {getPolygonSignedArea} from '@math.gl/polygon';\n\nimport {Feature, Position, FlatFeature} from '@loaders.gl/schema';\n\n/**\n * Options for `geojsonToFlatGeojson`\n */\nexport type GeojsonToFlatGeojsonOptions = {\n  coordLength: number;\n  fixRingWinding: boolean;\n};\n\n// Coordinates defining a Point\ntype PointCoordinates = Position;\n// Coordinates defining a LineString\ntype LineStringCoordinates = Position[];\n// Coordinates defining a Polygon\ntype PolygonCoordinates = Position[][];\n\n/**\n * Convert GeoJSON features to Flat GeoJSON features\n *\n * @param features\n * @param options\n * @returns an Array of Flat GeoJSON features\n */\nexport function geojsonToFlatGeojson(\n  features: Feature[],\n  options: GeojsonToFlatGeojsonOptions = {coordLength: 2, fixRingWinding: true}\n): FlatFeature[] {\n  return features.map((feature) => flattenFeature(feature, options));\n}\n\n/**\n * Helper function to copy Point values from `coordinates` into `data` & `indices`\n *\n * @param coordinates\n * @param data\n * @param indices\n * @param options\n */\nfunction flattenPoint(\n  coordinates: PointCoordinates,\n  data: number[],\n  indices: number[],\n  options: GeojsonToFlatGeojsonOptions\n) {\n  indices.push(data.length);\n  data.push(...coordinates);\n\n  // Pad up to coordLength\n  for (let i = coordinates.length; i < options.coordLength; i++) {\n    data.push(0);\n  }\n}\n\n/**\n * Helper function to copy LineString values from `coordinates` into `data` & `indices`\n *\n * @param coordinates\n * @param data\n * @param indices\n * @param options\n */\nfunction flattenLineString(\n  coordinates: LineStringCoordinates,\n  data: number[],\n  indices: number[],\n  options: GeojsonToFlatGeojsonOptions\n) {\n  indices.push(data.length);\n  for (const c of coordinates) {\n    data.push(...c);\n\n    // Pad up to coordLength\n    for (let i = c.length; i < options.coordLength; i++) {\n      data.push(0);\n    }\n  }\n}\n\n/**\n * Helper function to copy Polygon values from `coordinates` into `data` & `indices` & `areas`\n *\n * @param coordinates\n * @param data\n * @param indices\n * @param areas\n * @param options\n */\nfunction flattenPolygon(\n  coordinates: PolygonCoordinates,\n  data: number[],\n  indices: number[][],\n  areas: number[][],\n  options: GeojsonToFlatGeojsonOptions\n) {\n  let count = 0;\n  const ringAreas: number[] = [];\n  const polygons: number[] = [];\n  for (const lineString of coordinates) {\n    const lineString2d = lineString.map((p) => p.slice(0, 2));\n    let area = getPolygonSignedArea(lineString2d.flat());\n    const ccw = area < 0;\n\n    // Exterior ring must be CCW and interior rings CW\n    if (options.fixRingWinding && ((count === 0 && !ccw) || (count > 0 && ccw))) {\n      lineString.reverse();\n      area = -area;\n    }\n    ringAreas.push(area);\n    flattenLineString(lineString, data, polygons, options);\n    count++;\n  }\n\n  if (count > 0) {\n    areas.push(ringAreas);\n    indices.push(polygons);\n  }\n}\n\n/**\n * Flatten single GeoJSON feature into Flat GeoJSON\n *\n * @param feature\n * @param options\n * @returns A Flat GeoJSON feature\n */\nfunction flattenFeature(feature: Feature, options: GeojsonToFlatGeojsonOptions): FlatFeature {\n  const {geometry} = feature;\n  if (geometry.type === 'GeometryCollection') {\n    throw new Error('GeometryCollection type not supported');\n  }\n  const data = [];\n  const indices = [];\n  let areas;\n  let type;\n\n  switch (geometry.type) {\n    case 'Point':\n      type = 'Point';\n      flattenPoint(geometry.coordinates, data, indices, options);\n      break;\n    case 'MultiPoint':\n      type = 'Point';\n      geometry.coordinates.map((c) => flattenPoint(c, data, indices, options));\n      break;\n    case 'LineString':\n      type = 'LineString';\n      flattenLineString(geometry.coordinates, data, indices, options);\n      break;\n    case 'MultiLineString':\n      type = 'LineString';\n      geometry.coordinates.map((c) => flattenLineString(c, data, indices, options));\n      break;\n    case 'Polygon':\n      type = 'Polygon';\n      areas = [];\n      flattenPolygon(geometry.coordinates, data, indices, areas, options);\n      break;\n    case 'MultiPolygon':\n      type = 'Polygon';\n      areas = [];\n      geometry.coordinates.map((c) => flattenPolygon(c, data, indices, areas, options));\n      break;\n    default:\n      throw new Error(`Unknown type: ${type}`);\n  }\n\n  return {...feature, geometry: {type, indices, data, areas}};\n}\n"],"mappings":"AAAA,SAAQA,oBAAoB,QAAO,kBAAkB;AA0BrD,OAAO,SAASC,oBAAoBA,CAClCC,QAAmB,EAEJ;EAAA,IADfC,OAAoC,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG;IAACG,WAAW,EAAE,CAAC;IAAEC,cAAc,EAAE;EAAI,CAAC;EAE7E,OAAON,QAAQ,CAACO,GAAG,CAAEC,OAAO,IAAKC,cAAc,CAACD,OAAO,EAAEP,OAAO,CAAC,CAAC;AACpE;AAUA,SAASS,YAAYA,CACnBC,WAA6B,EAC7BC,IAAc,EACdC,OAAiB,EACjBZ,OAAoC,EACpC;EACAY,OAAO,CAACC,IAAI,CAACF,IAAI,CAACT,MAAM,CAAC;EACzBS,IAAI,CAACE,IAAI,CAAC,GAAGH,WAAW,CAAC;EAGzB,KAAK,IAAII,CAAC,GAAGJ,WAAW,CAACR,MAAM,EAAEY,CAAC,GAAGd,OAAO,CAACI,WAAW,EAAEU,CAAC,EAAE,EAAE;IAC7DH,IAAI,CAACE,IAAI,CAAC,CAAC,CAAC;EACd;AACF;AAUA,SAASE,iBAAiBA,CACxBL,WAAkC,EAClCC,IAAc,EACdC,OAAiB,EACjBZ,OAAoC,EACpC;EACAY,OAAO,CAACC,IAAI,CAACF,IAAI,CAACT,MAAM,CAAC;EACzB,KAAK,MAAMc,CAAC,IAAIN,WAAW,EAAE;IAC3BC,IAAI,CAACE,IAAI,CAAC,GAAGG,CAAC,CAAC;IAGf,KAAK,IAAIF,CAAC,GAAGE,CAAC,CAACd,MAAM,EAAEY,CAAC,GAAGd,OAAO,CAACI,WAAW,EAAEU,CAAC,EAAE,EAAE;MACnDH,IAAI,CAACE,IAAI,CAAC,CAAC,CAAC;IACd;EACF;AACF;AAWA,SAASI,cAAcA,CACrBP,WAA+B,EAC/BC,IAAc,EACdC,OAAmB,EACnBM,KAAiB,EACjBlB,OAAoC,EACpC;EACA,IAAImB,KAAK,GAAG,CAAC;EACb,MAAMC,SAAmB,GAAG,EAAE;EAC9B,MAAMC,QAAkB,GAAG,EAAE;EAC7B,KAAK,MAAMC,UAAU,IAAIZ,WAAW,EAAE;IACpC,MAAMa,YAAY,GAAGD,UAAU,CAAChB,GAAG,CAAEkB,CAAC,IAAKA,CAAC,CAACC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IACzD,IAAIC,IAAI,GAAG7B,oBAAoB,CAAC0B,YAAY,CAACI,IAAI,CAAC,CAAC,CAAC;IACpD,MAAMC,GAAG,GAAGF,IAAI,GAAG,CAAC;IAGpB,IAAI1B,OAAO,CAACK,cAAc,KAAMc,KAAK,KAAK,CAAC,IAAI,CAACS,GAAG,IAAMT,KAAK,GAAG,CAAC,IAAIS,GAAI,CAAC,EAAE;MAC3EN,UAAU,CAACO,OAAO,CAAC,CAAC;MACpBH,IAAI,GAAG,CAACA,IAAI;IACd;IACAN,SAAS,CAACP,IAAI,CAACa,IAAI,CAAC;IACpBX,iBAAiB,CAACO,UAAU,EAAEX,IAAI,EAAEU,QAAQ,EAAErB,OAAO,CAAC;IACtDmB,KAAK,EAAE;EACT;EAEA,IAAIA,KAAK,GAAG,CAAC,EAAE;IACbD,KAAK,CAACL,IAAI,CAACO,SAAS,CAAC;IACrBR,OAAO,CAACC,IAAI,CAACQ,QAAQ,CAAC;EACxB;AACF;AASA,SAASb,cAAcA,CAACD,OAAgB,EAAEP,OAAoC,EAAe;EAC3F,MAAM;IAAC8B;EAAQ,CAAC,GAAGvB,OAAO;EAC1B,IAAIuB,QAAQ,CAACC,IAAI,KAAK,oBAAoB,EAAE;IAC1C,MAAM,IAAIC,KAAK,CAAC,uCAAuC,CAAC;EAC1D;EACA,MAAMrB,IAAI,GAAG,EAAE;EACf,MAAMC,OAAO,GAAG,EAAE;EAClB,IAAIM,KAAK;EACT,IAAIa,IAAI;EAER,QAAQD,QAAQ,CAACC,IAAI;IACnB,KAAK,OAAO;MACVA,IAAI,GAAG,OAAO;MACdtB,YAAY,CAACqB,QAAQ,CAACpB,WAAW,EAAEC,IAAI,EAAEC,OAAO,EAAEZ,OAAO,CAAC;MAC1D;IACF,KAAK,YAAY;MACf+B,IAAI,GAAG,OAAO;MACdD,QAAQ,CAACpB,WAAW,CAACJ,GAAG,CAAEU,CAAC,IAAKP,YAAY,CAACO,CAAC,EAAEL,IAAI,EAAEC,OAAO,EAAEZ,OAAO,CAAC,CAAC;MACxE;IACF,KAAK,YAAY;MACf+B,IAAI,GAAG,YAAY;MACnBhB,iBAAiB,CAACe,QAAQ,CAACpB,WAAW,EAAEC,IAAI,EAAEC,OAAO,EAAEZ,OAAO,CAAC;MAC/D;IACF,KAAK,iBAAiB;MACpB+B,IAAI,GAAG,YAAY;MACnBD,QAAQ,CAACpB,WAAW,CAACJ,GAAG,CAAEU,CAAC,IAAKD,iBAAiB,CAACC,CAAC,EAAEL,IAAI,EAAEC,OAAO,EAAEZ,OAAO,CAAC,CAAC;MAC7E;IACF,KAAK,SAAS;MACZ+B,IAAI,GAAG,SAAS;MAChBb,KAAK,GAAG,EAAE;MACVD,cAAc,CAACa,QAAQ,CAACpB,WAAW,EAAEC,IAAI,EAAEC,OAAO,EAAEM,KAAK,EAAElB,OAAO,CAAC;MACnE;IACF,KAAK,cAAc;MACjB+B,IAAI,GAAG,SAAS;MAChBb,KAAK,GAAG,EAAE;MACVY,QAAQ,CAACpB,WAAW,CAACJ,GAAG,CAAEU,CAAC,IAAKC,cAAc,CAACD,CAAC,EAAEL,IAAI,EAAEC,OAAO,EAAEM,KAAK,EAAElB,OAAO,CAAC,CAAC;MACjF;IACF;MACE,MAAM,IAAIgC,KAAK,CAAE,iBAAgBD,IAAK,EAAC,CAAC;EAC5C;EAEA,OAAO;IAAC,GAAGxB,OAAO;IAAEuB,QAAQ,EAAE;MAACC,IAAI;MAAEnB,OAAO;MAAED,IAAI;MAAEO;IAAK;EAAC,CAAC;AAC7D"}

package/dist/lib/transform.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform.js","names":["transformBinaryCoords","binaryFeatures","transformCoordinate","points","transformBinaryGeometryPositions","lines","polygons","binaryGeometry","fn","positions","i","value","length","size","coord","Array","from","subarray","transformedCoord","set","transformGeoJsonCoords","features","feature","geometry","coordinates","coordMap","array","isCoord","map","item","isArray","Number","isFinite"],"sources":["../../src/lib/transform.ts"],"sourcesContent":["import type {BinaryFeatureCollection, BinaryGeometry, Feature} from '@loaders.gl/schema';\n\ntype TransformCoordinate = (coord: number[]) => number[];\n\n/**\n * Apply transformation to every coordinate of binary features\n * @param  binaryFeatures binary features\n * @param  transformCoordinate Function to call on each coordinate\n * @return Transformed binary features\n */\nexport function transformBinaryCoords(\n  binaryFeatures: BinaryFeatureCollection,\n  transformCoordinate: TransformCoordinate\n): BinaryFeatureCollection {\n  if (binaryFeatures.points) {\n    transformBinaryGeometryPositions(binaryFeatures.points, transformCoordinate);\n  }\n  if (binaryFeatures.lines) {\n    transformBinaryGeometryPositions(binaryFeatures.lines, transformCoordinate);\n  }\n  if (binaryFeatures.polygons) {\n    transformBinaryGeometryPositions(binaryFeatures.polygons, transformCoordinate);\n  }\n  return binaryFeatures;\n}\n\n/** Transform one binary geometry */\nfunction transformBinaryGeometryPositions(binaryGeometry: BinaryGeometry, fn: TransformCoordinate) {\n  const {positions} = binaryGeometry;\n  for (let i = 0; i < positions.value.length; i += positions.size) {\n    // @ts-ignore inclusion of bigint causes problems\n    const coord: Array<number> = Array.from(positions.value.subarray(i, i + positions.size));\n    const transformedCoord = fn(coord);\n    // @ts-ignore typescript typing for .set seems to require bigint?\n    positions.value.set(transformedCoord, i);\n  }\n}\n\n/**\n * Apply transformation to every coordinate of GeoJSON features\n *\n * @param  features Array of GeoJSON features\n * @param  fn       Function to call on each coordinate\n * @return          Transformed GeoJSON features\n */\nexport function transformGeoJsonCoords(\n  features: Feature[],\n  fn: (coord: number[]) => number[]\n): Feature[] {\n  for (const feature of features) {\n    // @ts-ignore\n    feature.geometry.coordinates = coordMap(feature.geometry.coordinates, fn);\n  }\n  return features;\n}\n\nfunction coordMap(array: unknown, fn: (coord: number[]) => number[]): unknown[] {\n  if (isCoord(array)) {\n    return fn(array as number[]);\n  }\n\n  return (array as unknown[]).map((item) => {\n    return coordMap(item, fn);\n  });\n}\n\nfunction isCoord(array: unknown) {\n  return Array.isArray(array) && Number.isFinite(array[0]) && Number.isFinite(array[1]);\n}\n"],"mappings":"AAUA,OAAO,SAASA,qBAAqBA,CACnCC,cAAuC,EACvCC,mBAAwC,EACf;EACzB,IAAID,cAAc,CAACE,MAAM,EAAE;IACzBC,gCAAgC,CAACH,cAAc,CAACE,MAAM,EAAED,mBAAmB,CAAC;EAC9E;EACA,IAAID,cAAc,CAACI,KAAK,EAAE;IACxBD,gCAAgC,CAACH,cAAc,CAACI,KAAK,EAAEH,mBAAmB,CAAC;EAC7E;EACA,IAAID,cAAc,CAACK,QAAQ,EAAE;IAC3BF,gCAAgC,CAACH,cAAc,CAACK,QAAQ,EAAEJ,mBAAmB,CAAC;EAChF;EACA,OAAOD,cAAc;AACvB;AAGA,SAASG,gCAAgCA,CAACG,cAA8B,EAAEC,EAAuB,EAAE;EACjG,MAAM;IAACC;EAAS,CAAC,GAAGF,cAAc;EAClC,KAAK,IAAIG,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGD,SAAS,CAACE,KAAK,CAACC,MAAM,EAAEF,CAAC,IAAID,SAAS,CAACI,IAAI,EAAE;IAE/D,MAAMC,KAAoB,GAAGC,KAAK,CAACC,IAAI,CAACP,SAAS,CAACE,KAAK,CAACM,QAAQ,CAACP,CAAC,EAAEA,CAAC,GAAGD,SAAS,CAACI,IAAI,CAAC,CAAC;IACxF,MAAMK,gBAAgB,GAAGV,EAAE,CAACM,KAAK,CAAC;IAElCL,SAAS,CAACE,KAAK,CAACQ,GAAG,CAACD,gBAAgB,EAAER,CAAC,CAAC;EAC1C;AACF;AASA,OAAO,SAASU,sBAAsBA,CACpCC,QAAmB,EACnBb,EAAiC,EACtB;EACX,KAAK,MAAMc,OAAO,IAAID,QAAQ,EAAE;IAE9BC,OAAO,CAACC,QAAQ,CAACC,WAAW,GAAGC,QAAQ,CAACH,OAAO,CAACC,QAAQ,CAACC,WAAW,EAAEhB,EAAE,CAAC;EAC3E;EACA,OAAOa,QAAQ;AACjB;AAEA,SAASI,QAAQA,CAACC,KAAc,EAAElB,EAAiC,EAAa;EAC9E,IAAImB,OAAO,CAACD,KAAK,CAAC,EAAE;IAClB,OAAOlB,EAAE,CAACkB,KAAiB,CAAC;EAC9B;EAEA,OAAQA,KAAK,CAAeE,GAAG,CAAEC,IAAI,IAAK;IACxC,OAAOJ,QAAQ,CAACI,IAAI,EAAErB,EAAE,CAAC;EAC3B,CAAC,CAAC;AACJ;AAEA,SAASmB,OAAOA,CAACD,KAAc,EAAE;EAC/B,OAAOX,KAAK,CAACe,OAAO,CAACJ,KAAK,CAAC,IAAIK,MAAM,CAACC,QAAQ,CAACN,KAAK,CAAC,CAAC,CAAC,CAAC,IAAIK,MAAM,CAACC,QAAQ,CAACN,KAAK,CAAC,CAAC,CAAC,CAAC;AACvF"}

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@loaders.gl/gis",
   "description": "Helpers for GIS category data",
-  "version": "4.0.0-beta.2",
+  "version": "4.0.0-beta.3",
   "license": "MIT",
+  "type": "module",
   "publishConfig": {
     "access": "public"
   },
@@ -15,8 +16,15 @@
     "GeoJSON"
   ],
   "types": "dist/index.d.ts",
-  "main": "dist/es5/index.js",
-  "module": "dist/esm/index.js",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
   "sideEffects": false,
   "files": [
     "src",
@@ -24,14 +32,14 @@
     "README.md"
   ],
   "dependencies": {
-    "@loaders.gl/loader-utils": "4.0.0-beta.2",
-    "@loaders.gl/schema": "4.0.0-beta.2",
+    "@loaders.gl/loader-utils": "4.0.0-beta.3",
+    "@loaders.gl/schema": "4.0.0-beta.3",
     "@mapbox/vector-tile": "^1.3.1",
-    "@math.gl/polygon": "^3.5.1",
+    "@math.gl/polygon": "^4.0.0",
     "pbf": "^3.2.1"
   },
   "devDependencies": {
-    "@math.gl/proj4": "^3.5.1"
+    "@math.gl/proj4": "^4.0.0"
   },
-  "gitHead": "79c2033f755e88e11bc30a04428e3666b177b8fc"
+  "gitHead": "7ba9621cc51c7a26c407086ac86171f35b8712af"
 }

package/src/lib/flat-geojson-to-binary.ts

@@ -444,7 +444,6 @@ function triangulatePolygon(
   const holes = indices.slice(1).map((n: number) => (n - offset) / coordLength);
 
   // Compute triangulation
-  // @ts-expect-error TODO can earcut handle binary arrays? Add tests?
   const triangles = earcut(polygonPositions, holes, coordLength, areas);
 
   // Indices returned by triangulation are relative to start

package/dist/bundle.d.ts

@@ -1,2 +0,0 @@
-declare const moduleExports: any;
-//# sourceMappingURL=bundle.d.ts.map

package/dist/bundle.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bundle.d.ts","sourceRoot":"","sources":["../src/bundle.ts"],"names":[],"mappings":"AACA,QAAA,MAAM,aAAa,KAAqB,CAAC"}

package/dist/es5/bundle.js

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

package/dist/es5/bundle.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"bundle.js","names":["moduleExports","require","globalThis","loaders","module","exports","Object","assign"],"sources":["../../src/bundle.ts"],"sourcesContent":["// @ts-nocheck\nconst moduleExports = require('./index');\nglobalThis.loaders = globalThis.loaders || {};\nmodule.exports = Object.assign(globalThis.loaders, moduleExports);\n"],"mappings":";;AACA,IAAMA,aAAa,GAAGC,OAAO,CAAC,SAAS,CAAC;AACxCC,UAAU,CAACC,OAAO,GAAGD,UAAU,CAACC,OAAO,IAAI,CAAC,CAAC;AAC7CC,MAAM,CAACC,OAAO,GAAGC,MAAM,CAACC,MAAM,CAACL,UAAU,CAACC,OAAO,EAAEH,aAAa,CAAC"}

package/dist/es5/index.js

@@ -1,53 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "binaryToGeojson", {
-  enumerable: true,
-  get: function get() {
-    return _binaryToGeojson.binaryToGeojson;
-  }
-});
-Object.defineProperty(exports, "binaryToGeometry", {
-  enumerable: true,
-  get: function get() {
-    return _binaryToGeojson.binaryToGeometry;
-  }
-});
-Object.defineProperty(exports, "flatGeojsonToBinary", {
-  enumerable: true,
-  get: function get() {
-    return _flatGeojsonToBinary.flatGeojsonToBinary;
-  }
-});
-Object.defineProperty(exports, "geojsonToBinary", {
-  enumerable: true,
-  get: function get() {
-    return _geojsonToBinary.geojsonToBinary;
-  }
-});
-Object.defineProperty(exports, "geojsonToFlatGeojson", {
-  enumerable: true,
-  get: function get() {
-    return _geojsonToFlatGeojson.geojsonToFlatGeojson;
-  }
-});
-Object.defineProperty(exports, "transformBinaryCoords", {
-  enumerable: true,
-  get: function get() {
-    return _transform.transformBinaryCoords;
-  }
-});
-Object.defineProperty(exports, "transformGeoJsonCoords", {
-  enumerable: true,
-  get: function get() {
-    return _transform.transformGeoJsonCoords;
-  }
-});
-var _flatGeojsonToBinary = require("./lib/flat-geojson-to-binary");
-var _geojsonToBinary = require("./lib/geojson-to-binary");
-var _geojsonToFlatGeojson = require("./lib/geojson-to-flat-geojson");
-var _binaryToGeojson = require("./lib/binary-to-geojson");
-var _transform = require("./lib/transform");
-//# sourceMappingURL=index.js.map

package/dist/es5/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","names":["_flatGeojsonToBinary","require","_geojsonToBinary","_geojsonToFlatGeojson","_binaryToGeojson","_transform"],"sources":["../../src/index.ts"],"sourcesContent":["// Types from `@loaders.gl/schema`\n\n// Functions\nexport {flatGeojsonToBinary} from './lib/flat-geojson-to-binary';\nexport {geojsonToBinary} from './lib/geojson-to-binary';\nexport {geojsonToFlatGeojson} from './lib/geojson-to-flat-geojson';\nexport {binaryToGeojson, binaryToGeometry} from './lib/binary-to-geojson';\nexport {transformBinaryCoords, transformGeoJsonCoords} from './lib/transform';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,IAAAA,oBAAA,GAAAC,OAAA;AACA,IAAAC,gBAAA,GAAAD,OAAA;AACA,IAAAE,qBAAA,GAAAF,OAAA;AACA,IAAAG,gBAAA,GAAAH,OAAA;AACA,IAAAI,UAAA,GAAAJ,OAAA"}

package/dist/es5/lib/binary-to-geojson.js

@@ -1,221 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.binaryToGeojson = binaryToGeojson;
-exports.binaryToGeometry = binaryToGeometry;
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
-function binaryToGeojson(data, options) {
-  var globalFeatureId = options === null || options === void 0 ? void 0 : options.globalFeatureId;
-  if (globalFeatureId !== undefined) {
-    return getSingleFeature(data, globalFeatureId);
-  }
-  return parseFeatures(data, options === null || options === void 0 ? void 0 : options.type);
-}
-function getSingleFeature(data, globalFeatureId) {
-  var dataArray = normalizeInput(data);
-  for (var _i = 0, _dataArray = dataArray; _i < _dataArray.length; _i++) {
-    var _data = _dataArray[_i];
-    var lastIndex = 0;
-    var lastValue = _data.featureIds.value[0];
-    for (var i = 0; i < _data.featureIds.value.length; i++) {
-      var currValue = _data.featureIds.value[i];
-      if (currValue === lastValue) {
-        continue;
-      }
-      if (globalFeatureId === _data.globalFeatureIds.value[lastIndex]) {
-        return parseFeature(_data, lastIndex, i);
-      }
-      lastIndex = i;
-      lastValue = currValue;
-    }
-    if (globalFeatureId === _data.globalFeatureIds.value[lastIndex]) {
-      return parseFeature(_data, lastIndex, _data.featureIds.value.length);
-    }
-  }
-  throw new Error("featureId:".concat(globalFeatureId, " not found"));
-}
-function parseFeatures(data, type) {
-  var dataArray = normalizeInput(data, type);
-  return parseFeatureCollection(dataArray);
-}
-function binaryToGeometry(data, startIndex, endIndex) {
-  switch (data.type) {
-    case 'Point':
-      return pointToGeoJson(data, startIndex, endIndex);
-    case 'LineString':
-      return lineStringToGeoJson(data, startIndex, endIndex);
-    case 'Polygon':
-      return polygonToGeoJson(data, startIndex, endIndex);
-    default:
-      var unexpectedInput = data;
-      throw new Error("Unsupported geometry type: ".concat(unexpectedInput === null || unexpectedInput === void 0 ? void 0 : unexpectedInput.type));
-  }
-}
-function normalizeInput(data, type) {
-  var features = [];
-  if (data.points) {
-    data.points.type = 'Point';
-    features.push(data.points);
-  }
-  if (data.lines) {
-    data.lines.type = 'LineString';
-    features.push(data.lines);
-  }
-  if (data.polygons) {
-    data.polygons.type = 'Polygon';
-    features.push(data.polygons);
-  }
-  return features;
-}
-function parseFeatureCollection(dataArray) {
-  var features = [];
-  var _iterator = _createForOfIteratorHelper(dataArray),
-    _step;
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var data = _step.value;
-      if (data.featureIds.value.length === 0) {
-        continue;
-      }
-      var lastIndex = 0;
-      var lastValue = data.featureIds.value[0];
-      for (var i = 0; i < data.featureIds.value.length; i++) {
-        var currValue = data.featureIds.value[i];
-        if (currValue === lastValue) {
-          continue;
-        }
-        features.push(parseFeature(data, lastIndex, i));
-        lastIndex = i;
-        lastValue = currValue;
-      }
-      features.push(parseFeature(data, lastIndex, data.featureIds.value.length));
-    }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
-  }
-  return features;
-}
-function parseFeature(data, startIndex, endIndex) {
-  var geometry = binaryToGeometry(data, startIndex, endIndex);
-  var properties = parseProperties(data, startIndex, endIndex);
-  var fields = parseFields(data, startIndex, endIndex);
-  return _objectSpread({
-    type: 'Feature',
-    geometry: geometry,
-    properties: properties
-  }, fields);
-}
-function parseFields(data) {
-  var startIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-  var endIndex = arguments.length > 2 ? arguments[2] : undefined;
-  return data.fields && data.fields[data.featureIds.value[startIndex]];
-}
-function parseProperties(data) {
-  var startIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-  var endIndex = arguments.length > 2 ? arguments[2] : undefined;
-  var properties = Object.assign({}, data.properties[data.featureIds.value[startIndex]]);
-  for (var key in data.numericProps) {
-    properties[key] = data.numericProps[key].value[startIndex];
-  }
-  return properties;
-}
-function polygonToGeoJson(data) {
-  var startIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : -Infinity;
-  var endIndex = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Infinity;
-  var positions = data.positions;
-  var polygonIndices = data.polygonIndices.value.filter(function (x) {
-    return x >= startIndex && x <= endIndex;
-  });
-  var primitivePolygonIndices = data.primitivePolygonIndices.value.filter(function (x) {
-    return x >= startIndex && x <= endIndex;
-  });
-  var multi = polygonIndices.length > 2;
-  if (!multi) {
-    var _coordinates = [];
-    for (var i = 0; i < primitivePolygonIndices.length - 1; i++) {
-      var startRingIndex = primitivePolygonIndices[i];
-      var endRingIndex = primitivePolygonIndices[i + 1];
-      var ringCoordinates = ringToGeoJson(positions, startRingIndex, endRingIndex);
-      _coordinates.push(ringCoordinates);
-    }
-    return {
-      type: 'Polygon',
-      coordinates: _coordinates
-    };
-  }
-  var coordinates = [];
-  for (var _i2 = 0; _i2 < polygonIndices.length - 1; _i2++) {
-    var startPolygonIndex = polygonIndices[_i2];
-    var endPolygonIndex = polygonIndices[_i2 + 1];
-    var polygonCoordinates = polygonToGeoJson(data, startPolygonIndex, endPolygonIndex).coordinates;
-    coordinates.push(polygonCoordinates);
-  }
-  return {
-    type: 'MultiPolygon',
-    coordinates: coordinates
-  };
-}
-function lineStringToGeoJson(data) {
-  var startIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : -Infinity;
-  var endIndex = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Infinity;
-  var positions = data.positions;
-  var pathIndices = data.pathIndices.value.filter(function (x) {
-    return x >= startIndex && x <= endIndex;
-  });
-  var multi = pathIndices.length > 2;
-  if (!multi) {
-    var _coordinates2 = ringToGeoJson(positions, pathIndices[0], pathIndices[1]);
-    return {
-      type: 'LineString',
-      coordinates: _coordinates2
-    };
-  }
-  var coordinates = [];
-  for (var i = 0; i < pathIndices.length - 1; i++) {
-    var ringCoordinates = ringToGeoJson(positions, pathIndices[i], pathIndices[i + 1]);
-    coordinates.push(ringCoordinates);
-  }
-  return {
-    type: 'MultiLineString',
-    coordinates: coordinates
-  };
-}
-function pointToGeoJson(data, startIndex, endIndex) {
-  var positions = data.positions;
-  var coordinates = ringToGeoJson(positions, startIndex, endIndex);
-  var multi = coordinates.length > 1;
-  if (multi) {
-    return {
-      type: 'MultiPoint',
-      coordinates: coordinates
-    };
-  }
-  return {
-    type: 'Point',
-    coordinates: coordinates[0]
-  };
-}
-function ringToGeoJson(positions, startIndex, endIndex) {
-  startIndex = startIndex || 0;
-  endIndex = endIndex || positions.value.length / positions.size;
-  var ringCoordinates = [];
-  for (var j = startIndex; j < endIndex; j++) {
-    var coord = Array();
-    for (var k = j * positions.size; k < (j + 1) * positions.size; k++) {
-      coord.push(Number(positions.value[k]));
-    }
-    ringCoordinates.push(coord);
-  }
-  return ringCoordinates;
-}
-//# sourceMappingURL=binary-to-geojson.js.map