@loaders.gl/wkt 4.2.0-alpha.4 → 4.2.0-alpha.6

package/dist/lib/encode-wkb.js

@@ -1,250 +1,286 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+// Forked from https://github.com/cschwarz/wkx under MIT license, Copyright (c) 2013 Christian Schwarz
+// Reference: https://www.ogc.org/standards/sfa
 import { BinaryWriter } from "./utils/binary-writer.js";
-export let WKB = function (WKB) {
-  WKB[WKB["Point"] = 1] = "Point";
-  WKB[WKB["LineString"] = 2] = "LineString";
-  WKB[WKB["Polygon"] = 3] = "Polygon";
-  WKB[WKB["MultiPoint"] = 4] = "MultiPoint";
-  WKB[WKB["MultiLineString"] = 5] = "MultiLineString";
-  WKB[WKB["MultiPolygon"] = 6] = "MultiPolygon";
-  WKB[WKB["GeometryCollection"] = 7] = "GeometryCollection";
-  return WKB;
-}({});
-export function encodeWKB(geometry) {
-  let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  if (geometry.type === 'Feature') {
-    geometry = geometry.geometry;
-  }
-  switch (geometry.type) {
-    case 'Point':
-      return encodePoint(geometry.coordinates, options);
-    case 'LineString':
-      return encodeLineString(geometry.coordinates, options);
-    case 'Polygon':
-      return encodePolygon(geometry.coordinates, options);
-    case 'MultiPoint':
-      return encodeMultiPoint(geometry, options);
-    case 'MultiPolygon':
-      return encodeMultiPolygon(geometry, options);
-    case 'MultiLineString':
-      return encodeMultiLineString(geometry, options);
-    case 'GeometryCollection':
-      return encodeGeometryCollection(geometry, options);
-    default:
-      const exhaustiveCheck = geometry;
-      throw new Error(`Unhandled case: ${exhaustiveCheck}`);
-  }
+/**
+ * Integer code for geometry type
+ * Reference: https://en.wikipedia.org/wiki/Well-known_text_representation_of_geometry#Well-known_binary
+ */
+export var WKB;
+(function (WKB) {
+    WKB[WKB["Point"] = 1] = "Point";
+    WKB[WKB["LineString"] = 2] = "LineString";
+    WKB[WKB["Polygon"] = 3] = "Polygon";
+    WKB[WKB["MultiPoint"] = 4] = "MultiPoint";
+    WKB[WKB["MultiLineString"] = 5] = "MultiLineString";
+    WKB[WKB["MultiPolygon"] = 6] = "MultiPolygon";
+    WKB[WKB["GeometryCollection"] = 7] = "GeometryCollection";
+})(WKB || (WKB = {}));
+/**
+ * Encodes a GeoJSON object into WKB
+ * @param geojson A GeoJSON Feature or Geometry
+ * @returns string
+ */
+export function encodeWKB(geometry, options = {}) {
+    if (geometry.type === 'Feature') {
+        geometry = geometry.geometry;
+    }
+    switch (geometry.type) {
+        case 'Point':
+            return encodePoint(geometry.coordinates, options);
+        case 'LineString':
+            return encodeLineString(geometry.coordinates, options);
+        case 'Polygon':
+            return encodePolygon(geometry.coordinates, options);
+        case 'MultiPoint':
+            return encodeMultiPoint(geometry, options);
+        case 'MultiPolygon':
+            return encodeMultiPolygon(geometry, options);
+        case 'MultiLineString':
+            return encodeMultiLineString(geometry, options);
+        case 'GeometryCollection':
+            return encodeGeometryCollection(geometry, options);
+        default:
+            const exhaustiveCheck = geometry;
+            throw new Error(`Unhandled case: ${exhaustiveCheck}`);
+    }
 }
+/** Calculate the binary size (in the WKB encoding) of a specific GeoJSON geometry */
 function getGeometrySize(geometry, options) {
-  switch (geometry.type) {
-    case 'Point':
-      return getPointSize(options);
-    case 'LineString':
-      return getLineStringSize(geometry.coordinates, options);
-    case 'Polygon':
-      return getPolygonSize(geometry.coordinates, options);
-    case 'MultiPoint':
-      return getMultiPointSize(geometry, options);
-    case 'MultiPolygon':
-      return getMultiPolygonSize(geometry, options);
-    case 'MultiLineString':
-      return getMultiLineStringSize(geometry, options);
-    case 'GeometryCollection':
-      return getGeometryCollectionSize(geometry, options);
-    default:
-      const exhaustiveCheck = geometry;
-      throw new Error(`Unhandled case: ${exhaustiveCheck}`);
-  }
+    switch (geometry.type) {
+        case 'Point':
+            return getPointSize(options);
+        case 'LineString':
+            return getLineStringSize(geometry.coordinates, options);
+        case 'Polygon':
+            return getPolygonSize(geometry.coordinates, options);
+        case 'MultiPoint':
+            return getMultiPointSize(geometry, options);
+        case 'MultiPolygon':
+            return getMultiPolygonSize(geometry, options);
+        case 'MultiLineString':
+            return getMultiLineStringSize(geometry, options);
+        case 'GeometryCollection':
+            return getGeometryCollectionSize(geometry, options);
+        default:
+            const exhaustiveCheck = geometry;
+            throw new Error(`Unhandled case: ${exhaustiveCheck}`);
+    }
 }
+/** Encode Point geometry as WKB ArrayBuffer */
 function encodePoint(coordinates, options) {
-  const writer = new BinaryWriter(getPointSize(options));
-  writer.writeInt8(1);
-  writeWkbType(writer, WKB.Point, options);
-  if (typeof coordinates[0] === 'undefined' && typeof coordinates[1] === 'undefined') {
-    writer.writeDoubleLE(NaN);
-    writer.writeDoubleLE(NaN);
-    if (options.hasZ) {
-      writer.writeDoubleLE(NaN);
+    const writer = new BinaryWriter(getPointSize(options));
+    writer.writeInt8(1);
+    writeWkbType(writer, WKB.Point, options);
+    // I believe this special case is to handle writing Point(NaN, NaN) correctly
+    if (typeof coordinates[0] === 'undefined' && typeof coordinates[1] === 'undefined') {
+        writer.writeDoubleLE(NaN);
+        writer.writeDoubleLE(NaN);
+        if (options.hasZ) {
+            writer.writeDoubleLE(NaN);
+        }
+        if (options.hasM) {
+            writer.writeDoubleLE(NaN);
+        }
     }
-    if (options.hasM) {
-      writer.writeDoubleLE(NaN);
+    else {
+        writeCoordinate(writer, coordinates, options);
     }
-  } else {
-    writeCoordinate(writer, coordinates, options);
-  }
-  return writer.arrayBuffer;
+    return writer.arrayBuffer;
 }
+/** Write coordinate to buffer */
 function writeCoordinate(writer, coordinate, options) {
-  writer.writeDoubleLE(coordinate[0]);
-  writer.writeDoubleLE(coordinate[1]);
-  if (options.hasZ) {
-    writer.writeDoubleLE(coordinate[2]);
-  }
-  if (options.hasM) {
-    writer.writeDoubleLE(coordinate[3]);
-  }
+    writer.writeDoubleLE(coordinate[0]);
+    writer.writeDoubleLE(coordinate[1]);
+    if (options.hasZ) {
+        writer.writeDoubleLE(coordinate[2]);
+    }
+    if (options.hasM) {
+        writer.writeDoubleLE(coordinate[3]);
+    }
 }
+/** Get encoded size of Point geometry */
 function getPointSize(options) {
-  const coordinateSize = getCoordinateSize(options);
-  return 1 + 4 + coordinateSize;
+    const coordinateSize = getCoordinateSize(options);
+    return 1 + 4 + coordinateSize;
 }
+/** Encode LineString geometry as WKB ArrayBuffer */
 function encodeLineString(coordinates, options) {
-  const size = getLineStringSize(coordinates, options);
-  const writer = new BinaryWriter(size);
-  writer.writeInt8(1);
-  writeWkbType(writer, WKB.LineString, options);
-  writer.writeUInt32LE(coordinates.length);
-  for (const coordinate of coordinates) {
-    writeCoordinate(writer, coordinate, options);
-  }
-  return writer.arrayBuffer;
+    const size = getLineStringSize(coordinates, options);
+    const writer = new BinaryWriter(size);
+    writer.writeInt8(1);
+    writeWkbType(writer, WKB.LineString, options);
+    writer.writeUInt32LE(coordinates.length);
+    for (const coordinate of coordinates) {
+        writeCoordinate(writer, coordinate, options);
+    }
+    return writer.arrayBuffer;
 }
+/** Get encoded size of LineString geometry */
 function getLineStringSize(coordinates, options) {
-  const coordinateSize = getCoordinateSize(options);
-  return 1 + 4 + 4 + coordinates.length * coordinateSize;
+    const coordinateSize = getCoordinateSize(options);
+    return 1 + 4 + 4 + coordinates.length * coordinateSize;
 }
+/** Encode Polygon geometry as WKB ArrayBuffer */
 function encodePolygon(coordinates, options) {
-  const writer = new BinaryWriter(getPolygonSize(coordinates, options));
-  writer.writeInt8(1);
-  writeWkbType(writer, WKB.Polygon, options);
-  const [exteriorRing, ...interiorRings] = coordinates;
-  if (exteriorRing.length > 0) {
-    writer.writeUInt32LE(1 + interiorRings.length);
-    writer.writeUInt32LE(exteriorRing.length);
-  } else {
-    writer.writeUInt32LE(0);
-  }
-  for (const coordinate of exteriorRing) {
-    writeCoordinate(writer, coordinate, options);
-  }
-  for (const interiorRing of interiorRings) {
-    writer.writeUInt32LE(interiorRing.length);
-    for (const coordinate of interiorRing) {
-      writeCoordinate(writer, coordinate, options);
-    }
-  }
-  return writer.arrayBuffer;
+    const writer = new BinaryWriter(getPolygonSize(coordinates, options));
+    writer.writeInt8(1);
+    writeWkbType(writer, WKB.Polygon, options);
+    const [exteriorRing, ...interiorRings] = coordinates;
+    if (exteriorRing.length > 0) {
+        writer.writeUInt32LE(1 + interiorRings.length);
+        writer.writeUInt32LE(exteriorRing.length);
+    }
+    else {
+        writer.writeUInt32LE(0);
+    }
+    for (const coordinate of exteriorRing) {
+        writeCoordinate(writer, coordinate, options);
+    }
+    for (const interiorRing of interiorRings) {
+        writer.writeUInt32LE(interiorRing.length);
+        for (const coordinate of interiorRing) {
+            writeCoordinate(writer, coordinate, options);
+        }
+    }
+    return writer.arrayBuffer;
 }
+/** Get encoded size of Polygon geometry */
 function getPolygonSize(coordinates, options) {
-  const coordinateSize = getCoordinateSize(options);
-  const [exteriorRing, ...interiorRings] = coordinates;
-  let size = 1 + 4 + 4;
-  if (exteriorRing.length > 0) {
-    size += 4 + exteriorRing.length * coordinateSize;
-  }
-  for (const interiorRing of interiorRings) {
-    size += 4 + interiorRing.length * coordinateSize;
-  }
-  return size;
+    const coordinateSize = getCoordinateSize(options);
+    const [exteriorRing, ...interiorRings] = coordinates;
+    let size = 1 + 4 + 4;
+    if (exteriorRing.length > 0) {
+        size += 4 + exteriorRing.length * coordinateSize;
+    }
+    for (const interiorRing of interiorRings) {
+        size += 4 + interiorRing.length * coordinateSize;
+    }
+    return size;
 }
+/** Encode MultiPoint geometry as WKB ArrayBufer */
 function encodeMultiPoint(multiPoint, options) {
-  const writer = new BinaryWriter(getMultiPointSize(multiPoint, options));
-  const points = multiPoint.coordinates;
-  writer.writeInt8(1);
-  writeWkbType(writer, WKB.MultiPoint, options);
-  writer.writeUInt32LE(points.length);
-  for (const point of points) {
-    const arrayBuffer = encodePoint(point, options);
-    writer.writeBuffer(arrayBuffer);
-  }
-  return writer.arrayBuffer;
+    const writer = new BinaryWriter(getMultiPointSize(multiPoint, options));
+    const points = multiPoint.coordinates;
+    writer.writeInt8(1);
+    writeWkbType(writer, WKB.MultiPoint, options);
+    writer.writeUInt32LE(points.length);
+    for (const point of points) {
+        // TODO: add srid to this options object? {srid: multiPoint.srid}
+        const arrayBuffer = encodePoint(point, options);
+        writer.writeBuffer(arrayBuffer);
+    }
+    return writer.arrayBuffer;
 }
+/** Get encoded size of MultiPoint geometry */
 function getMultiPointSize(multiPoint, options) {
-  let coordinateSize = getCoordinateSize(options);
-  const points = multiPoint.coordinates;
-  coordinateSize += 5;
-  return 1 + 4 + 4 + points.length * coordinateSize;
+    let coordinateSize = getCoordinateSize(options);
+    const points = multiPoint.coordinates;
+    // This is because each point has a 5-byte header?
+    coordinateSize += 5;
+    return 1 + 4 + 4 + points.length * coordinateSize;
 }
+/** Encode MultiLineString geometry as WKB ArrayBufer */
 function encodeMultiLineString(multiLineString, options) {
-  const writer = new BinaryWriter(getMultiLineStringSize(multiLineString, options));
-  const lineStrings = multiLineString.coordinates;
-  writer.writeInt8(1);
-  writeWkbType(writer, WKB.MultiLineString, options);
-  writer.writeUInt32LE(lineStrings.length);
-  for (const lineString of lineStrings) {
-    const encodedLineString = encodeLineString(lineString, options);
-    writer.writeBuffer(encodedLineString);
-  }
-  return writer.arrayBuffer;
+    const writer = new BinaryWriter(getMultiLineStringSize(multiLineString, options));
+    const lineStrings = multiLineString.coordinates;
+    writer.writeInt8(1);
+    writeWkbType(writer, WKB.MultiLineString, options);
+    writer.writeUInt32LE(lineStrings.length);
+    for (const lineString of lineStrings) {
+        // TODO: Handle srid?
+        const encodedLineString = encodeLineString(lineString, options);
+        writer.writeBuffer(encodedLineString);
+    }
+    return writer.arrayBuffer;
 }
+/** Get encoded size of MultiLineString geometry */
 function getMultiLineStringSize(multiLineString, options) {
-  let size = 1 + 4 + 4;
-  const lineStrings = multiLineString.coordinates;
-  for (const lineString of lineStrings) {
-    size += getLineStringSize(lineString, options);
-  }
-  return size;
+    let size = 1 + 4 + 4;
+    const lineStrings = multiLineString.coordinates;
+    for (const lineString of lineStrings) {
+        size += getLineStringSize(lineString, options);
+    }
+    return size;
 }
 function encodeMultiPolygon(multiPolygon, options) {
-  const writer = new BinaryWriter(getMultiPolygonSize(multiPolygon, options));
-  const polygons = multiPolygon.coordinates;
-  writer.writeInt8(1);
-  writeWkbType(writer, WKB.MultiPolygon, options);
-  writer.writeUInt32LE(polygons.length);
-  for (const polygon of polygons) {
-    const encodedPolygon = encodePolygon(polygon, options);
-    writer.writeBuffer(encodedPolygon);
-  }
-  return writer.arrayBuffer;
+    const writer = new BinaryWriter(getMultiPolygonSize(multiPolygon, options));
+    const polygons = multiPolygon.coordinates;
+    writer.writeInt8(1);
+    writeWkbType(writer, WKB.MultiPolygon, options);
+    writer.writeUInt32LE(polygons.length);
+    for (const polygon of polygons) {
+        const encodedPolygon = encodePolygon(polygon, options);
+        writer.writeBuffer(encodedPolygon);
+    }
+    return writer.arrayBuffer;
 }
 function getMultiPolygonSize(multiPolygon, options) {
-  let size = 1 + 4 + 4;
-  const polygons = multiPolygon.coordinates;
-  for (const polygon of polygons) {
-    size += getPolygonSize(polygon, options);
-  }
-  return size;
+    let size = 1 + 4 + 4;
+    const polygons = multiPolygon.coordinates;
+    for (const polygon of polygons) {
+        size += getPolygonSize(polygon, options);
+    }
+    return size;
 }
 function encodeGeometryCollection(collection, options) {
-  const writer = new BinaryWriter(getGeometryCollectionSize(collection, options));
-  writer.writeInt8(1);
-  writeWkbType(writer, WKB.GeometryCollection, options);
-  writer.writeUInt32LE(collection.geometries.length);
-  for (const geometry of collection.geometries) {
-    const arrayBuffer = encodeWKB(geometry, options);
-    writer.writeBuffer(arrayBuffer);
-  }
-  return writer.arrayBuffer;
+    const writer = new BinaryWriter(getGeometryCollectionSize(collection, options));
+    writer.writeInt8(1);
+    writeWkbType(writer, WKB.GeometryCollection, options);
+    writer.writeUInt32LE(collection.geometries.length);
+    for (const geometry of collection.geometries) {
+        // TODO: handle srid? {srid: collection.srid}
+        const arrayBuffer = encodeWKB(geometry, options);
+        writer.writeBuffer(arrayBuffer);
+    }
+    return writer.arrayBuffer;
 }
 function getGeometryCollectionSize(collection, options) {
-  let size = 1 + 4 + 4;
-  for (const geometry of collection.geometries) {
-    size += getGeometrySize(geometry, options);
-  }
-  return size;
+    let size = 1 + 4 + 4;
+    for (const geometry of collection.geometries) {
+        size += getGeometrySize(geometry, options);
+    }
+    return size;
 }
+// HELPERS
+/**
+ * Construct and write WKB integer code
+ * Reference: https://en.wikipedia.org/wiki/Well-known_text_representation_of_geometry#Well-known_binary
+ */
 function writeWkbType(writer, geometryType, options) {
-  const {
-    hasZ,
-    hasM,
-    srid
-  } = options;
-  let dimensionType = 0;
-  if (!srid) {
-    if (hasZ && hasM) {
-      dimensionType += 3000;
-    } else if (hasZ) {
-      dimensionType += 1000;
-    } else if (hasM) {
-      dimensionType += 2000;
-    }
-  } else {
-    if (hasZ) {
-      dimensionType |= 0x80000000;
-    }
-    if (hasM) {
-      dimensionType |= 0x40000000;
-    }
-  }
-  writer.writeUInt32LE(dimensionType + geometryType >>> 0);
+    const { hasZ, hasM, srid } = options;
+    let dimensionType = 0;
+    if (!srid) {
+        if (hasZ && hasM) {
+            dimensionType += 3000;
+        }
+        else if (hasZ) {
+            dimensionType += 1000;
+        }
+        else if (hasM) {
+            dimensionType += 2000;
+        }
+    }
+    else {
+        if (hasZ) {
+            dimensionType |= 0x80000000;
+        }
+        if (hasM) {
+            dimensionType |= 0x40000000;
+        }
+    }
+    writer.writeUInt32LE((dimensionType + geometryType) >>> 0);
 }
+/** Get coordinate size given Z/M dimensions */
 function getCoordinateSize(options) {
-  let coordinateSize = 16;
-  if (options.hasZ) {
-    coordinateSize += 8;
-  }
-  if (options.hasM) {
-    coordinateSize += 8;
-  }
-  return coordinateSize;
-}
-//# sourceMappingURL=encode-wkb.js.map
+    let coordinateSize = 16;
+    if (options.hasZ) {
+        coordinateSize += 8;
+    }
+    if (options.hasM) {
+        coordinateSize += 8;
+    }
+    return coordinateSize;
+}

package/dist/lib/encode-wkt-crs.d.ts

@@ -1,4 +1,4 @@
-import type { WKTCRS } from './parse-wkt-crs';
+import type { WKTCRS } from "./parse-wkt-crs.js";
 export type EncodeWKTCRSOptions = {
     debug?: boolean;
 };

package/dist/lib/encode-wkt-crs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"encode-wkt-crs.d.ts","sourceRoot":"","sources":["../../src/lib/encode-wkt-crs.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,iBAAiB,CAAC;AAE5C,MAAM,MAAM,mBAAmB,GAAG;IAChC,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,CAAC;AAEF;;;GAGG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,MAAM,CAyB/E"}
+{"version":3,"file":"encode-wkt-crs.d.ts","sourceRoot":"","sources":["../../src/lib/encode-wkt-crs.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAC,MAAM,EAAC,2BAAwB;AAE5C,MAAM,MAAM,mBAAmB,GAAG;IAChC,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,CAAC;AAEF;;;GAGG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,MAAM,CAyB/E"}

package/dist/lib/encode-wkt-crs.js

@@ -1,21 +1,35 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+// parse-wkt-crs was forked from https://github.com/DanielJDufour/wkt-crs under Creative Commons CC0 1.0 license.
+/**
+ * convert JSON representation of Well-Known Text
+ * back to standard Well-Known Text
+ */
 export function encodeWKTCRS(wkt, options) {
-  if (Array.isArray(wkt) && wkt.length === 1 && Array.isArray(wkt[0])) {
-    wkt = wkt[0];
-  }
-  const [kw, ...attrs] = wkt;
-  const str = `${kw}[${attrs.map(attr => {
-    if (Array.isArray(attr)) {
-      return encodeWKTCRS(attr, options);
-    } else if (typeof attr === 'number') {
-      return attr.toString();
-    } else if (typeof attr === 'string') {
-      if (attr.startsWith('raw:')) {
-        return attr.replace('raw:', '');
-      }
-      return `"${attr}"`;
+    if (Array.isArray(wkt) && wkt.length === 1 && Array.isArray(wkt[0])) {
+        wkt = wkt[0]; // ignore first extra wrapper array
     }
-    throw new Error(`[wktcrs] unexpected attribute "${attr}"`);
-  }).join(',')}]`;
-  return str;
+    const [kw, ...attrs] = wkt;
+    const str = `${kw}[${attrs
+        .map((attr) => {
+        if (Array.isArray(attr)) {
+            return encodeWKTCRS(attr, options);
+        }
+        else if (typeof attr === 'number') {
+            return attr.toString();
+        }
+        else if (typeof attr === 'string') {
+            // can't automatically convert all caps to varibale
+            // because EPSG is string in AUTHORITY["EPSG", ...]
+            if (attr.startsWith('raw:')) {
+                // convert "raw:NORTH" to NORTH
+                return attr.replace('raw:', '');
+            }
+            return `"${attr}"`;
+        }
+        throw new Error(`[wktcrs] unexpected attribute "${attr}"`);
+    })
+        .join(',')}]`;
+    return str;
 }
-//# sourceMappingURL=encode-wkt-crs.js.map

package/dist/lib/encode-wkt.js

@@ -1,39 +1,47 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+// Fork of https://github.com/mapbox/wellknown under ISC license (MIT/BSD-2-clause equivalent)
+/**
+ * Stringifies a GeoJSON object into WKT
+ * @param geojson
+ * @returns string
+ */
 export function encodeWKT(geometry) {
-  if (geometry.type === 'Feature') {
-    geometry = geometry.geometry;
-  }
-  switch (geometry.type) {
-    case 'Point':
-      return `POINT ${wrapParens(pairWKT(geometry.coordinates))}`;
-    case 'LineString':
-      return `LINESTRING ${wrapParens(ringWKT(geometry.coordinates))}`;
-    case 'Polygon':
-      return `POLYGON ${wrapParens(ringsWKT(geometry.coordinates))}`;
-    case 'MultiPoint':
-      return `MULTIPOINT ${wrapParens(ringWKT(geometry.coordinates))}`;
-    case 'MultiPolygon':
-      return `MULTIPOLYGON ${wrapParens(multiRingsWKT(geometry.coordinates))}`;
-    case 'MultiLineString':
-      return `MULTILINESTRING ${wrapParens(ringsWKT(geometry.coordinates))}`;
-    case 'GeometryCollection':
-      return `GEOMETRYCOLLECTION ${wrapParens(geometry.geometries.map(encodeWKT).join(', '))}`;
-    default:
-      throw new Error('stringify requires a valid GeoJSON Feature or geometry object as input');
-  }
+    if (geometry.type === 'Feature') {
+        geometry = geometry.geometry;
+    }
+    switch (geometry.type) {
+        case 'Point':
+            return `POINT ${wrapParens(pairWKT(geometry.coordinates))}`;
+        case 'LineString':
+            return `LINESTRING ${wrapParens(ringWKT(geometry.coordinates))}`;
+        case 'Polygon':
+            return `POLYGON ${wrapParens(ringsWKT(geometry.coordinates))}`;
+        case 'MultiPoint':
+            return `MULTIPOINT ${wrapParens(ringWKT(geometry.coordinates))}`;
+        case 'MultiPolygon':
+            return `MULTIPOLYGON ${wrapParens(multiRingsWKT(geometry.coordinates))}`;
+        case 'MultiLineString':
+            return `MULTILINESTRING ${wrapParens(ringsWKT(geometry.coordinates))}`;
+        case 'GeometryCollection':
+            return `GEOMETRYCOLLECTION ${wrapParens(geometry.geometries.map(encodeWKT).join(', '))}`;
+        default:
+            throw new Error('stringify requires a valid GeoJSON Feature or geometry object as input');
+    }
 }
 function pairWKT(c) {
-  return c.join(' ');
+    return c.join(' ');
 }
 function ringWKT(r) {
-  return r.map(pairWKT).join(', ');
+    return r.map(pairWKT).join(', ');
 }
 function ringsWKT(r) {
-  return r.map(ringWKT).map(wrapParens).join(', ');
+    return r.map(ringWKT).map(wrapParens).join(', ');
 }
 function multiRingsWKT(r) {
-  return r.map(ringsWKT).map(wrapParens).join(', ');
+    return r.map(ringsWKT).map(wrapParens).join(', ');
 }
 function wrapParens(s) {
-  return `(${s})`;
+    return `(${s})`;
 }
-//# sourceMappingURL=encode-wkt.js.map

package/dist/lib/parse-hex-wkb.js

@@ -1,2 +1 @@
-
-//# sourceMappingURL=parse-hex-wkb.js.map
+"use strict";