@loaders.gl/gis 4.0.0-alpha.4 → 4.0.0-alpha.6

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

@@ -1,274 +1,233 @@
-export function binaryToGeojson(data, options) {
-  const 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);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.binaryToGeometry = exports.binaryToGeoJson = exports.binaryToGeojson = void 0;
+/**
+ * Convert binary geometry representation to GeoJSON
+ * @param data   geometry data in binary representation
+ * @param options
+ * @param options.type  Input data type: Point, LineString, or Polygon
+ * @param options.featureId  Global feature id. If specified, only a single feature is extracted
+ * @return GeoJSON objects
+ */
+function binaryToGeojson(data, options) {
+    const globalFeatureId = options?.globalFeatureId;
+    if (globalFeatureId !== undefined) {
+        return getSingleFeature(data, globalFeatureId);
+    }
+    return parseFeatures(data, options?.type);
 }
-export function binaryToGeoJson(data, type, format = 'feature') {
-  switch (format) {
-    case 'feature':
-      return parseFeatures(data, type);
-
-    case 'geometry':
-      return binaryToGeometry(data);
-
-    default:
-      throw new Error(format);
-  }
+exports.binaryToGeojson = binaryToGeojson;
+/** @deprecated use `binaryToGeojson` or `binaryToGeometry` instead */
+function binaryToGeoJson(data, type, format = 'feature') {
+    switch (format) {
+        case 'feature':
+            return parseFeatures(data, type);
+        case 'geometry':
+            return binaryToGeometry(data);
+        default:
+            throw new Error(format);
+    }
 }
-
+exports.binaryToGeoJson = binaryToGeoJson;
+/**
+ * Return a single feature from a binary geometry representation as GeoJSON
+ * @param data   geometry data in binary representation
+ * @return GeoJSON feature
+ */
 function getSingleFeature(data, globalFeatureId) {
-  const dataArray = normalizeInput(data);
-
-  for (const data of dataArray) {
-    let lastIndex = 0;
-    let lastValue = data.featureIds.value[0];
-
-    for (let i = 0; i < data.featureIds.value.length; i++) {
-      const 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);
+    const dataArray = normalizeInput(data);
+    for (const data of dataArray) {
+        let lastIndex = 0;
+        let lastValue = data.featureIds.value[0];
+        // Scan through data until we find matching feature
+        for (let i = 0; i < data.featureIds.value.length; i++) {
+            const currValue = data.featureIds.value[i];
+            if (currValue === lastValue) {
+                // eslint-disable-next-line no-continue
+                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"));
+    throw new Error(`featureId:${globalFeatureId} not found`);
 }
-
 function parseFeatures(data, type) {
-  const dataArray = normalizeInput(data, type);
-  return parseFeatureCollection(dataArray);
+    const dataArray = normalizeInput(data, type);
+    return parseFeatureCollection(dataArray);
 }
-
-export 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:
-      const unexpectedInput = data;
-      throw new Error("Unsupported geometry type: ".concat(unexpectedInput === null || unexpectedInput === void 0 ? void 0 : unexpectedInput.type));
-  }
+/** Parse input binary data and return a valid GeoJSON geometry object */
+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:
+            const unexpectedInput = data;
+            throw new Error(`Unsupported geometry type: ${unexpectedInput?.type}`);
+    }
 }
-
+exports.binaryToGeometry = binaryToGeometry;
+// Normalize features
+// Return an array of data objects, each of which have a type key
 function normalizeInput(data, type) {
-  const isHeterogeneousType = Boolean(data.points || data.lines || data.polygons);
-
-  if (!isHeterogeneousType) {
-    data.type = type || parseType(data);
-    return [data];
-  }
-
-  const 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;
+    const isHeterogeneousType = Boolean(data.points || data.lines || data.polygons);
+    if (!isHeterogeneousType) {
+        // @ts-expect-error This is a legacy check which allowed `data` to be an instance of the values
+        // here. Aka the new data.points, data.lines, or data.polygons.
+        data.type = type || parseType(data);
+        return [data];
+    }
+    const 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;
 }
-
+/** Parse input binary data and return an array of GeoJSON Features */
 function parseFeatureCollection(dataArray) {
-  const features = [];
-
-  for (const data of dataArray) {
-    if (data.featureIds.value.length === 0) {
-      continue;
-    }
-
-    let lastIndex = 0;
-    let lastValue = data.featureIds.value[0];
-
-    for (let i = 0; i < data.featureIds.value.length; i++) {
-      const currValue = data.featureIds.value[i];
-
-      if (currValue === lastValue) {
-        continue;
-      }
-
-      features.push(parseFeature(data, lastIndex, i));
-      lastIndex = i;
-      lastValue = currValue;
+    const features = [];
+    for (const data of dataArray) {
+        if (data.featureIds.value.length === 0) {
+            // eslint-disable-next-line no-continue
+            continue;
+        }
+        let lastIndex = 0;
+        let lastValue = data.featureIds.value[0];
+        // Need to deduce start, end indices of each feature
+        for (let i = 0; i < data.featureIds.value.length; i++) {
+            const currValue = data.featureIds.value[i];
+            if (currValue === lastValue) {
+                // eslint-disable-next-line no-continue
+                continue;
+            }
+            features.push(parseFeature(data, lastIndex, i));
+            lastIndex = i;
+            lastValue = currValue;
+        }
+        // Last feature
+        features.push(parseFeature(data, lastIndex, data.featureIds.value.length));
     }
-
-    features.push(parseFeature(data, lastIndex, data.featureIds.value.length));
-  }
-
-  return features;
+    return features;
 }
-
+/** Parse input binary data and return a single GeoJSON Feature */
 function parseFeature(data, startIndex, endIndex) {
-  const geometry = binaryToGeometry(data, startIndex, endIndex);
-  const properties = parseProperties(data, startIndex, endIndex);
-  const fields = parseFields(data, startIndex, endIndex);
-  return {
-    type: 'Feature',
-    geometry,
-    properties,
-    ...fields
-  };
+    const geometry = binaryToGeometry(data, startIndex, endIndex);
+    const properties = parseProperties(data, startIndex, endIndex);
+    const fields = parseFields(data, startIndex, endIndex);
+    return { type: 'Feature', geometry, properties, ...fields };
 }
-
+/** Parse input binary data and return an object of fields */
 function parseFields(data, startIndex = 0, endIndex) {
-  return data.fields && data.fields[data.featureIds.value[startIndex]];
+    return data.fields && data.fields[data.featureIds.value[startIndex]];
 }
-
+/** Parse input binary data and return an object of properties */
 function parseProperties(data, startIndex = 0, endIndex) {
-  const properties = Object.assign({}, data.properties[data.featureIds.value[startIndex]]);
-
-  for (const key in data.numericProps) {
-    properties[key] = data.numericProps[key].value[startIndex];
-  }
-
-  return properties;
+    const properties = Object.assign({}, data.properties[data.featureIds.value[startIndex]]);
+    for (const key in data.numericProps) {
+        properties[key] = data.numericProps[key].value[startIndex];
+    }
+    return properties;
 }
-
+/** Parse binary data of type Polygon */
 function polygonToGeoJson(data, startIndex = -Infinity, endIndex = Infinity) {
-  const {
-    positions
-  } = data;
-  const polygonIndices = data.polygonIndices.value.filter(x => x >= startIndex && x <= endIndex);
-  const primitivePolygonIndices = data.primitivePolygonIndices.value.filter(x => x >= startIndex && x <= endIndex);
-  const multi = polygonIndices.length > 2;
-
-  if (!multi) {
+    const { positions } = data;
+    const polygonIndices = data.polygonIndices.value.filter((x) => x >= startIndex && x <= endIndex);
+    const primitivePolygonIndices = data.primitivePolygonIndices.value.filter((x) => x >= startIndex && x <= endIndex);
+    const multi = polygonIndices.length > 2;
+    // Polygon
+    if (!multi) {
+        const coordinates = [];
+        for (let i = 0; i < primitivePolygonIndices.length - 1; i++) {
+            const startRingIndex = primitivePolygonIndices[i];
+            const endRingIndex = primitivePolygonIndices[i + 1];
+            const ringCoordinates = ringToGeoJson(positions, startRingIndex, endRingIndex);
+            coordinates.push(ringCoordinates);
+        }
+        return { type: 'Polygon', coordinates };
+    }
+    // MultiPolygon
     const coordinates = [];
-
-    for (let i = 0; i < primitivePolygonIndices.length - 1; i++) {
-      const startRingIndex = primitivePolygonIndices[i];
-      const endRingIndex = primitivePolygonIndices[i + 1];
-      const ringCoordinates = ringToGeoJson(positions, startRingIndex, endRingIndex);
-      coordinates.push(ringCoordinates);
+    for (let i = 0; i < polygonIndices.length - 1; i++) {
+        const startPolygonIndex = polygonIndices[i];
+        const endPolygonIndex = polygonIndices[i + 1];
+        const polygonCoordinates = polygonToGeoJson(data, startPolygonIndex, endPolygonIndex).coordinates;
+        coordinates.push(polygonCoordinates);
     }
-
-    return {
-      type: 'Polygon',
-      coordinates
-    };
-  }
-
-  const coordinates = [];
-
-  for (let i = 0; i < polygonIndices.length - 1; i++) {
-    const startPolygonIndex = polygonIndices[i];
-    const endPolygonIndex = polygonIndices[i + 1];
-    const polygonCoordinates = polygonToGeoJson(data, startPolygonIndex, endPolygonIndex).coordinates;
-    coordinates.push(polygonCoordinates);
-  }
-
-  return {
-    type: 'MultiPolygon',
-    coordinates
-  };
+    return { type: 'MultiPolygon', coordinates };
 }
-
+/** Parse binary data of type LineString */
 function lineStringToGeoJson(data, startIndex = -Infinity, endIndex = Infinity) {
-  const {
-    positions
-  } = data;
-  const pathIndices = data.pathIndices.value.filter(x => x >= startIndex && x <= endIndex);
-  const multi = pathIndices.length > 2;
-
-  if (!multi) {
-    const coordinates = ringToGeoJson(positions, pathIndices[0], pathIndices[1]);
-    return {
-      type: 'LineString',
-      coordinates
-    };
-  }
-
-  const coordinates = [];
-
-  for (let i = 0; i < pathIndices.length - 1; i++) {
-    const ringCoordinates = ringToGeoJson(positions, pathIndices[i], pathIndices[i + 1]);
-    coordinates.push(ringCoordinates);
-  }
-
-  return {
-    type: 'MultiLineString',
-    coordinates
-  };
+    const { positions } = data;
+    const pathIndices = data.pathIndices.value.filter((x) => x >= startIndex && x <= endIndex);
+    const multi = pathIndices.length > 2;
+    if (!multi) {
+        const coordinates = ringToGeoJson(positions, pathIndices[0], pathIndices[1]);
+        return { type: 'LineString', coordinates };
+    }
+    const coordinates = [];
+    for (let i = 0; i < pathIndices.length - 1; i++) {
+        const ringCoordinates = ringToGeoJson(positions, pathIndices[i], pathIndices[i + 1]);
+        coordinates.push(ringCoordinates);
+    }
+    return { type: 'MultiLineString', coordinates };
 }
-
+/** Parse binary data of type Point */
 function pointToGeoJson(data, startIndex, endIndex) {
-  const {
-    positions
-  } = data;
-  const coordinates = ringToGeoJson(positions, startIndex, endIndex);
-  const multi = coordinates.length > 1;
-
-  if (multi) {
-    return {
-      type: 'MultiPoint',
-      coordinates
-    };
-  }
-
-  return {
-    type: 'Point',
-    coordinates: coordinates[0]
-  };
+    const { positions } = data;
+    const coordinates = ringToGeoJson(positions, startIndex, endIndex);
+    const multi = coordinates.length > 1;
+    if (multi) {
+        return { type: 'MultiPoint', coordinates };
+    }
+    return { type: 'Point', coordinates: coordinates[0] };
 }
-
+/**
+ * Parse a linear ring of positions to a GeoJSON linear ring
+ *
+ * @param positions Positions TypedArray
+ * @param startIndex Start index to include in ring
+ * @param endIndex End index to include in ring
+ * @returns GeoJSON ring
+ */
 function ringToGeoJson(positions, startIndex, endIndex) {
-  startIndex = startIndex || 0;
-  endIndex = endIndex || positions.value.length / positions.size;
-  const ringCoordinates = [];
-
-  for (let j = startIndex; j < endIndex; j++) {
-    const coord = Array();
-
-    for (let k = j * positions.size; k < (j + 1) * positions.size; k++) {
-      coord.push(Number(positions.value[k]));
+    startIndex = startIndex || 0;
+    endIndex = endIndex || positions.value.length / positions.size;
+    const ringCoordinates = [];
+    for (let j = startIndex; j < endIndex; j++) {
+        const coord = Array();
+        for (let k = j * positions.size; k < (j + 1) * positions.size; k++) {
+            coord.push(Number(positions.value[k]));
+        }
+        ringCoordinates.push(coord);
     }
-
-    ringCoordinates.push(coord);
-  }
-
-  return ringCoordinates;
+    return ringCoordinates;
 }
-
+// Deduce geometry type of data object
 function parseType(data) {
-  if (data.pathIndices) {
-    return 'LineString';
-  }
-
-  if (data.polygonIndices) {
-    return 'Polygon';
-  }
-
-  return 'Point';
+    if (data.pathIndices) {
+        return 'LineString';
+    }
+    if (data.polygonIndices) {
+        return 'Polygon';
+    }
+    return 'Point';
 }
-//# sourceMappingURL=binary-to-geojson.js.map

package/dist/lib/extract-geometry-info.d.ts

@@ -0,0 +1,8 @@
+import { Feature, GeojsonGeometryInfo } from '@loaders.gl/schema';
+/**
+ *  Initial scan over GeoJSON features
+ *  Counts number of coordinates of each geometry type and
+ *  keeps track of the max coordinate dimensions
+ */
+export declare function extractGeometryInfo(features: Feature[]): GeojsonGeometryInfo;
+//# sourceMappingURL=extract-geometry-info.d.ts.map

package/dist/lib/extract-geometry-info.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract-geometry-info.d.ts","sourceRoot":"","sources":["../../src/lib/extract-geometry-info.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,OAAO,EAAE,mBAAmB,EAAC,MAAM,oBAAoB,CAAC;AAEhE;;;;GAIG;AAEH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,mBAAmB,CA4F5E"}

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

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractGeometryInfo = void 0;
+/**
+ *  Initial scan over GeoJSON features
+ *  Counts number of coordinates of each geometry type and
+ *  keeps track of the max coordinate dimensions
+ */
+// eslint-disable-next-line complexity, max-statements
+function extractGeometryInfo(features) {
+    // Counts the number of _positions_, so [x, y, z] counts as one
+    let pointPositionsCount = 0;
+    let pointFeaturesCount = 0;
+    let linePositionsCount = 0;
+    let linePathsCount = 0;
+    let lineFeaturesCount = 0;
+    let polygonPositionsCount = 0;
+    let polygonObjectsCount = 0;
+    let polygonRingsCount = 0;
+    let polygonFeaturesCount = 0;
+    const coordLengths = new Set();
+    for (const feature of features) {
+        const geometry = feature.geometry;
+        switch (geometry.type) {
+            case 'Point':
+                pointFeaturesCount++;
+                pointPositionsCount++;
+                coordLengths.add(geometry.coordinates.length);
+                break;
+            case 'MultiPoint':
+                pointFeaturesCount++;
+                pointPositionsCount += geometry.coordinates.length;
+                for (const point of geometry.coordinates) {
+                    coordLengths.add(point.length);
+                }
+                break;
+            case 'LineString':
+                lineFeaturesCount++;
+                linePositionsCount += geometry.coordinates.length;
+                linePathsCount++;
+                for (const coord of geometry.coordinates) {
+                    coordLengths.add(coord.length);
+                }
+                break;
+            case 'MultiLineString':
+                lineFeaturesCount++;
+                for (const line of geometry.coordinates) {
+                    linePositionsCount += line.length;
+                    linePathsCount++;
+                    // eslint-disable-next-line max-depth
+                    for (const coord of line) {
+                        coordLengths.add(coord.length);
+                    }
+                }
+                break;
+            case 'Polygon':
+                polygonFeaturesCount++;
+                polygonObjectsCount++;
+                polygonRingsCount += geometry.coordinates.length;
+                const flattened = geometry.coordinates.flat();
+                polygonPositionsCount += flattened.length;
+                for (const coord of flattened) {
+                    coordLengths.add(coord.length);
+                }
+                break;
+            case 'MultiPolygon':
+                polygonFeaturesCount++;
+                for (const polygon of geometry.coordinates) {
+                    polygonObjectsCount++;
+                    polygonRingsCount += polygon.length;
+                    const flattened = polygon.flat();
+                    polygonPositionsCount += flattened.length;
+                    // eslint-disable-next-line max-depth
+                    for (const coord of flattened) {
+                        coordLengths.add(coord.length);
+                    }
+                }
+                break;
+            default:
+                throw new Error(`Unsupported geometry type: ${geometry.type}`);
+        }
+    }
+    return {
+        coordLength: coordLengths.size > 0 ? Math.max(...coordLengths) : 2,
+        pointPositionsCount,
+        pointFeaturesCount,
+        linePositionsCount,
+        linePathsCount,
+        lineFeaturesCount,
+        polygonPositionsCount,
+        polygonObjectsCount,
+        polygonRingsCount,
+        polygonFeaturesCount
+    };
+}
+exports.extractGeometryInfo = extractGeometryInfo;

package/dist/lib/flat-geojson-to-binary-types.d.ts

@@ -0,0 +1,58 @@
+import type { TypedArray } from '@loaders.gl/schema';
+/**
+ * Permissable constructor for numeric props
+ */
+export type PropArrayConstructor = Float32ArrayConstructor | Float64ArrayConstructor | ArrayConstructor;
+/**
+ * Collection type for holding intermediate binary data before conversion to `BinaryPointGeometry`
+ */
+export type Points = {
+    type: 'Point';
+    positions: Float32Array | Float64Array;
+    globalFeatureIds: Uint16Array | Uint32Array;
+    featureIds: Uint16Array | Uint32Array;
+    numericProps: {
+        [key: string]: TypedArray;
+    };
+    properties: {}[];
+    fields: {
+        id?: string | number;
+    }[];
+};
+/**
+ * Collection type for holding intermediate binary data before conversion to `BinaryLineStringGeometry`
+ */
+export type Lines = {
+    type: 'LineString';
+    positions: Float32Array | Float64Array;
+    pathIndices: Uint16Array | Uint32Array;
+    globalFeatureIds: Uint16Array | Uint32Array;
+    featureIds: Uint16Array | Uint32Array;
+    numericProps: {
+        [key: string]: TypedArray;
+    };
+    properties: {}[];
+    fields: {
+        id?: string | number;
+    }[];
+};
+/**
+ * Collection type for holding intermediate binary data before conversion to `BinaryPolygonGeometry`
+ */
+export type Polygons = {
+    type: 'Polygon';
+    positions: Float32Array | Float64Array;
+    polygonIndices: Uint16Array | Uint32Array;
+    primitivePolygonIndices: Uint16Array | Uint32Array;
+    triangles: number[];
+    globalFeatureIds: Uint16Array | Uint32Array;
+    featureIds: Uint16Array | Uint32Array;
+    numericProps: {
+        [key: string]: TypedArray;
+    };
+    properties: {}[];
+    fields: {
+        id?: string | number;
+    }[];
+};
+//# sourceMappingURL=flat-geojson-to-binary-types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"flat-geojson-to-binary-types.d.ts","sourceRoot":"","sources":["../../src/lib/flat-geojson-to-binary-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,oBAAoB,CAAC;AAEnD;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAC5B,uBAAuB,GACvB,uBAAuB,GACvB,gBAAgB,CAAC;AAErB;;GAEG;AACH,MAAM,MAAM,MAAM,GAAG;IACnB,IAAI,EAAE,OAAO,CAAC;IACd,SAAS,EAAE,YAAY,GAAG,YAAY,CAAC;IACvC,gBAAgB,EAAE,WAAW,GAAG,WAAW,CAAC;IAC5C,UAAU,EAAE,WAAW,GAAG,WAAW,CAAC;IACtC,YAAY,EAAE;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAAA;KAAC,CAAC;IAC1C,UAAU,EAAE,EAAE,EAAE,CAAC;IACjB,MAAM,EAAE;QACN,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;KACtB,EAAE,CAAC;CACL,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,KAAK,GAAG;IAClB,IAAI,EAAE,YAAY,CAAC;IACnB,SAAS,EAAE,YAAY,GAAG,YAAY,CAAC;IACvC,WAAW,EAAE,WAAW,GAAG,WAAW,CAAC;IACvC,gBAAgB,EAAE,WAAW,GAAG,WAAW,CAAC;IAC5C,UAAU,EAAE,WAAW,GAAG,WAAW,CAAC;IACtC,YAAY,EAAE;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAAA;KAAC,CAAC;IAC1C,UAAU,EAAE,EAAE,EAAE,CAAC;IACjB,MAAM,EAAE;QACN,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;KACtB,EAAE,CAAC;CACL,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG;IACrB,IAAI,EAAE,SAAS,CAAC;IAChB,SAAS,EAAE,YAAY,GAAG,YAAY,CAAC;IACvC,cAAc,EAAE,WAAW,GAAG,WAAW,CAAC;IAC1C,uBAAuB,EAAE,WAAW,GAAG,WAAW,CAAC;IACnD,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,gBAAgB,EAAE,WAAW,GAAG,WAAW,CAAC;IAC5C,UAAU,EAAE,WAAW,GAAG,WAAW,CAAC;IACtC,YAAY,EAAE;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAAA;KAAC,CAAC;IAC1C,UAAU,EAAE,EAAE,EAAE,CAAC;IACjB,MAAM,EAAE;QACN,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;KACtB,EAAE,CAAC;CACL,CAAC"}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });