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

package/dist/dist.dev.js

@@ -2,14 +2,19 @@
   if (typeof exports === 'object' && typeof module === 'object')
     module.exports = factory();
   else if (typeof define === 'function' && define.amd) define([], factory);
-        else if (typeof exports === 'object') exports['loader'] = factory();
-  else root['loader'] = factory();})(globalThis, function () {
+        else if (typeof exports === 'object') exports['loaders'] = factory();
+  else root['loaders'] = factory();})(globalThis, function () {
 "use strict";
 var __exports__ = (() => {
+  var __create = Object.create;
   var __defProp = Object.defineProperty;
   var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
   var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
   var __export = (target, all) => {
     for (var name in all)
       __defProp(target, name, { get: all[name], enumerable: true });
@@ -22,11 +27,27 @@ var __exports__ = (() => {
     }
     return to;
   };
+  var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-  // src/index.ts
-  var src_exports = {};
-  __export(src_exports, {
+  // external-global-plugin:@loaders.gl/core
+  var require_core = __commonJS({
+    "external-global-plugin:@loaders.gl/core"(exports, module) {
+      module.exports = globalThis.loaders;
+    }
+  });
+
+  // bundle.ts
+  var bundle_exports = {};
+  __export(bundle_exports, {
     HexWKBLoader: () => HexWKBLoader,
     TWKBLoader: () => TWKBLoader,
     TWKBWriter: () => TWKBWriter,
@@ -45,9 +66,10 @@ var __exports__ = (() => {
     isWKT: () => isWKT,
     parseWKBHeader: () => parseWKBHeader
   });
+  __reExport(bundle_exports, __toESM(require_core(), 1));
 
   // src/lib/utils/version.ts
-  var VERSION = true ? "4.2.0-alpha.4" : "latest";
+  var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
 
   // src/lib/parse-wkt-crs.ts
   function parseWKTCRS(wkt, options) {
@@ -197,6 +219,7 @@ var __exports__ = (() => {
     worker: true,
     extensions: [],
     mimeTypes: ["text/plain"],
+    // category: 'json',
     text: true,
     options: {
       "wkt-crs": {}
@@ -209,7 +232,16 @@ var __exports__ = (() => {
   // src/lib/parse-wkt.ts
   var numberRegexp = /[-+]?([0-9]*\.[0-9]+|[0-9]+)([eE][-+]?[0-9]+)?/;
   var tuples = new RegExp("^" + numberRegexp.source + "(\\s" + numberRegexp.source + "){1,}");
-  var WKT_MAGIC_STRINGS = ["POINT(", "LINESTRING(", "POLYGON(", "MULTIPOINT(", "MULTILINESTRING(", "MULTIPOLYGON(", "GEOMETRYCOLLECTION("];
+  var WKT_MAGIC_STRINGS = [
+    "POINT(",
+    "LINESTRING(",
+    "POLYGON(",
+    "MULTIPOINT(",
+    "MULTILINESTRING(",
+    "MULTIPOLYGON(",
+    "GEOMETRYCOLLECTION("
+    // We only support this "geojson" subset of the OGC simple features standard
+  ];
   function isWKT(input) {
     return WKT_MAGIC_STRINGS.some((magicString) => input.startsWith(magicString));
   }
@@ -220,11 +252,7 @@ var __exports__ = (() => {
     const parts = input.split(";");
     let _ = parts.pop();
     const srid = (parts.shift() || "").split("=").pop();
-    const state = {
-      parts,
-      _,
-      i: 0
-    };
+    const state = { parts, _, i: 0 };
     const geometry = parseGeometry(state);
     return options?.wkt?.crs ? addCRS(geometry, srid) : geometry;
   }
@@ -311,7 +339,9 @@ var __exports__ = (() => {
     }
     white(state);
     return {
+      // @ts-ignore
       type: "MultiLineString",
+      // @ts-expect-error
       coordinates: c
     };
   }
@@ -325,7 +355,9 @@ var __exports__ = (() => {
       return null;
     }
     return {
+      // @ts-ignore
       type: "Polygon",
+      // @ts-expect-error
       coordinates: c
     };
   }
@@ -340,6 +372,7 @@ var __exports__ = (() => {
     }
     return {
       type: "MultiPolygon",
+      // @ts-expect-error
       coordinates: c
     };
   }
@@ -537,11 +570,11 @@ var __exports__ = (() => {
     }
   }
   function polygonToGeoJson(data, startIndex = -Infinity, endIndex = Infinity) {
-    const {
-      positions
-    } = data;
+    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 primitivePolygonIndices = data.primitivePolygonIndices.value.filter(
+      (x) => x >= startIndex && x <= endIndex
+    );
     const multi = polygonIndices.length > 2;
     if (!multi) {
       const coordinates2 = [];
@@ -551,62 +584,44 @@ var __exports__ = (() => {
         const ringCoordinates = ringToGeoJson(positions, startRingIndex, endRingIndex);
         coordinates2.push(ringCoordinates);
       }
-      return {
-        type: "Polygon",
-        coordinates: coordinates2
-      };
+      return { type: "Polygon", coordinates: coordinates2 };
     }
     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;
+      const polygonCoordinates = polygonToGeoJson(
+        data,
+        startPolygonIndex,
+        endPolygonIndex
+      ).coordinates;
       coordinates.push(polygonCoordinates);
     }
-    return {
-      type: "MultiPolygon",
-      coordinates
-    };
+    return { type: "MultiPolygon", coordinates };
   }
   function lineStringToGeoJson(data, startIndex = -Infinity, endIndex = Infinity) {
-    const {
-      positions
-    } = data;
+    const { positions } = data;
     const pathIndices = data.pathIndices.value.filter((x) => x >= startIndex && x <= endIndex);
     const multi = pathIndices.length > 2;
     if (!multi) {
       const coordinates2 = ringToGeoJson(positions, pathIndices[0], pathIndices[1]);
-      return {
-        type: "LineString",
-        coordinates: coordinates2
-      };
+      return { type: "LineString", coordinates: coordinates2 };
     }
     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
-    };
+    return { type: "MultiLineString", coordinates };
   }
   function pointToGeoJson(data, startIndex, endIndex) {
-    const {
-      positions
-    } = data;
+    const { positions } = data;
     const coordinates = ringToGeoJson(positions, startIndex, endIndex);
     const multi = coordinates.length > 1;
     if (multi) {
-      return {
-        type: "MultiPoint",
-        coordinates
-      };
+      return { type: "MultiPoint", coordinates };
     }
-    return {
-      type: "Point",
-      coordinates: coordinates[0]
-    };
+    return { type: "Point", coordinates: coordinates[0] };
   }
   function ringToGeoJson(positions, startIndex, endIndex) {
     startIndex = startIndex || 0;
@@ -627,16 +642,6 @@ var __exports__ = (() => {
   var EWKB_FLAG_M = 1073741824;
   var EWKB_FLAG_SRID = 536870912;
   var MAX_SRID = 1e4;
-  var WKBGeometryType = function(WKBGeometryType2) {
-    WKBGeometryType2[WKBGeometryType2["Point"] = 1] = "Point";
-    WKBGeometryType2[WKBGeometryType2["LineString"] = 2] = "LineString";
-    WKBGeometryType2[WKBGeometryType2["Polygon"] = 3] = "Polygon";
-    WKBGeometryType2[WKBGeometryType2["MultiPoint"] = 4] = "MultiPoint";
-    WKBGeometryType2[WKBGeometryType2["MultiLineString"] = 5] = "MultiLineString";
-    WKBGeometryType2[WKBGeometryType2["MultiPolygon"] = 6] = "MultiPolygon";
-    WKBGeometryType2[WKBGeometryType2["GeometryCollection"] = 7] = "GeometryCollection";
-    return WKBGeometryType2;
-  }({});
   function isWKB(arrayBuffer) {
     const dataView = new DataView(arrayBuffer);
     let byteOffset = 0;
@@ -747,31 +752,27 @@ var __exports__ = (() => {
   function parseWKBToBinary(arrayBuffer, options) {
     const dataView = new DataView(arrayBuffer);
     const wkbHeader = parseWKBHeader(dataView);
-    const {
-      geometryType,
-      dimensions,
-      littleEndian
-    } = wkbHeader;
+    const { geometryType, dimensions, littleEndian } = wkbHeader;
     const offset = wkbHeader.byteOffset;
     switch (geometryType) {
-      case WKBGeometryType.Point:
+      case 1 /* Point */:
         const point = parsePoint2(dataView, offset, dimensions, littleEndian);
         return point.geometry;
-      case WKBGeometryType.LineString:
+      case 2 /* LineString */:
         const line = parseLineString2(dataView, offset, dimensions, littleEndian);
         return line.geometry;
-      case WKBGeometryType.Polygon:
+      case 3 /* Polygon */:
         const polygon = parsePolygon2(dataView, offset, dimensions, littleEndian);
         return polygon.geometry;
-      case WKBGeometryType.MultiPoint:
+      case 4 /* MultiPoint */:
         const multiPoint = parseMultiPoint2(dataView, offset, dimensions, littleEndian);
         multiPoint.type = "Point";
         return multiPoint;
-      case WKBGeometryType.MultiLineString:
+      case 5 /* MultiLineString */:
         const multiLine = parseMultiLineString2(dataView, offset, dimensions, littleEndian);
         multiLine.type = "LineString";
         return multiLine;
-      case WKBGeometryType.MultiPolygon:
+      case 6 /* MultiPolygon */:
         const multiPolygon = parseMultiPolygon2(dataView, offset, dimensions, littleEndian);
         multiPolygon.type = "Polygon";
         return multiPolygon;
@@ -786,13 +787,7 @@ var __exports__ = (() => {
       offset += 8;
     }
     return {
-      geometry: {
-        type: "Point",
-        positions: {
-          value: positions,
-          size: dimension
-        }
-      },
+      geometry: { type: "Point", positions: { value: positions, size: dimension } },
       offset
     };
   }
@@ -811,14 +806,8 @@ var __exports__ = (() => {
     return {
       geometry: {
         type: "LineString",
-        positions: {
-          value: positions,
-          size: dimension
-        },
-        pathIndices: {
-          value: new Uint16Array(pathIndices),
-          size: 1
-        }
+        positions: { value: positions, size: dimension },
+        pathIndices: { value: new Uint16Array(pathIndices), size: 1 }
       },
       offset
     };
@@ -830,9 +819,7 @@ var __exports__ = (() => {
     const rings = [];
     for (let i = 0; i < nRings; i++) {
       const parsed = parseLineString2(dataView, offset, dimension, littleEndian);
-      const {
-        positions
-      } = parsed.geometry;
+      const { positions } = parsed.geometry;
       offset = parsed.offset;
       rings.push(positions.value);
     }
@@ -846,18 +833,12 @@ var __exports__ = (() => {
     return {
       geometry: {
         type: "Polygon",
-        positions: {
-          value: concatenatedPositions,
-          size: dimension
-        },
+        positions: { value: concatenatedPositions, size: dimension },
         polygonIndices: {
           value: new Uint16Array(polygonIndices),
           size: 1
         },
-        primitivePolygonIndices: {
-          value: new Uint16Array(primitivePolygonIndices),
-          size: 1
-        }
+        primitivePolygonIndices: { value: new Uint16Array(primitivePolygonIndices), size: 1 }
       },
       offset
     };
@@ -918,10 +899,7 @@ var __exports__ = (() => {
     const concatenatedPositions = new Float64Array(concatTypedArrays(positions).buffer);
     return {
       type: "Point",
-      positions: {
-        value: concatenatedPositions,
-        size: dimension
-      }
+      positions: { value: concatenatedPositions, size: dimension }
     };
   }
   function concatenateBinaryLineGeometries(binaryLineGeometries, dimension) {
@@ -931,24 +909,15 @@ var __exports__ = (() => {
     pathIndices.unshift(0);
     return {
       type: "LineString",
-      positions: {
-        value: concatenatedPositions,
-        size: dimension
-      },
-      pathIndices: {
-        value: new Uint16Array(pathIndices),
-        size: 1
-      }
+      positions: { value: concatenatedPositions, size: dimension },
+      pathIndices: { value: new Uint16Array(pathIndices), size: 1 }
     };
   }
   function concatenateBinaryPolygonGeometries(binaryPolygonGeometries, dimension) {
     const polygons = [];
     const primitivePolygons = [];
     for (const binaryPolygon of binaryPolygonGeometries) {
-      const {
-        positions,
-        primitivePolygonIndices: primitivePolygonIndices2
-      } = binaryPolygon;
+      const { positions, primitivePolygonIndices: primitivePolygonIndices2 } = binaryPolygon;
       polygons.push(positions.value);
       primitivePolygons.push(primitivePolygonIndices2.value);
     }
@@ -957,22 +926,15 @@ var __exports__ = (() => {
     polygonIndices.unshift(0);
     const primitivePolygonIndices = [0];
     for (const primitivePolygon of primitivePolygons) {
-      primitivePolygonIndices.push(...primitivePolygon.filter((x) => x > 0).map((x) => x + primitivePolygonIndices[primitivePolygonIndices.length - 1]));
+      primitivePolygonIndices.push(
+        ...primitivePolygon.filter((x) => x > 0).map((x) => x + primitivePolygonIndices[primitivePolygonIndices.length - 1])
+      );
     }
     return {
       type: "Polygon",
-      positions: {
-        value: concatenatedPositions,
-        size: dimension
-      },
-      polygonIndices: {
-        value: new Uint16Array(polygonIndices),
-        size: 1
-      },
-      primitivePolygonIndices: {
-        value: new Uint16Array(primitivePolygonIndices),
-        size: 1
-      }
+      positions: { value: concatenatedPositions, size: dimension },
+      polygonIndices: { value: new Uint16Array(polygonIndices), size: 1 },
+      primitivePolygonIndices: { value: new Uint16Array(primitivePolygonIndices), size: 1 }
     };
   }
   function concatTypedArrays(arrays) {
@@ -1002,10 +964,12 @@ var __exports__ = (() => {
     category: "geometry",
     extensions: ["wkb"],
     mimeTypes: [],
+    // TODO can we define static, serializable tests, eg. some binary strings?
     tests: [isWKB],
     options: {
       wkb: {
         shape: "binary-geometry"
+        // 'geojson-geometry'
       }
     }
   };
@@ -1019,9 +983,9 @@ var __exports__ = (() => {
   var LE = true;
   var BE = false;
   var BinaryWriter = class {
-    byteOffset = 0;
-    allowResize = false;
     constructor(size, allowResize) {
+      this.byteOffset = 0;
+      this.allowResize = false;
       this.arrayBuffer = new ArrayBuffer(size);
       this.dataView = new DataView(this.arrayBuffer);
       this.byteOffset = 0;
@@ -1097,6 +1061,7 @@ var __exports__ = (() => {
       this.dataView.setFloat64(this.byteOffset, value, BE);
       this.byteOffset += 8;
     }
+    /** A varint uses a variable number of bytes */
     writeVarInt(value) {
       let length = 1;
       while ((value & 4294967168) !== 0) {
@@ -1107,12 +1072,14 @@ var __exports__ = (() => {
       this.writeUInt8(value & 127);
       return length;
     }
+    /** Append another ArrayBuffer to this ArrayBuffer */
     writeBuffer(arrayBuffer) {
       this._ensureSize(arrayBuffer.byteLength);
       const tempArray = new Uint8Array(this.arrayBuffer);
       tempArray.set(new Uint8Array(arrayBuffer), this.byteOffset);
       this.byteOffset += arrayBuffer.byteLength;
     }
+    /** Resizes this.arrayBuffer if not enough space */
     _ensureSize(size) {
       if (this.arrayBuffer.byteLength < this.byteOffset + size) {
         if (this.allowResize) {
@@ -1128,16 +1095,6 @@ var __exports__ = (() => {
   };
 
   // src/lib/encode-wkb.ts
-  var WKB = function(WKB2) {
-    WKB2[WKB2["Point"] = 1] = "Point";
-    WKB2[WKB2["LineString"] = 2] = "LineString";
-    WKB2[WKB2["Polygon"] = 3] = "Polygon";
-    WKB2[WKB2["MultiPoint"] = 4] = "MultiPoint";
-    WKB2[WKB2["MultiLineString"] = 5] = "MultiLineString";
-    WKB2[WKB2["MultiPolygon"] = 6] = "MultiPolygon";
-    WKB2[WKB2["GeometryCollection"] = 7] = "GeometryCollection";
-    return WKB2;
-  }({});
   function encodeWKB(geometry, options = {}) {
     if (geometry.type === "Feature") {
       geometry = geometry.geometry;
@@ -1186,7 +1143,7 @@ var __exports__ = (() => {
   function encodePoint(coordinates, options) {
     const writer = new BinaryWriter(getPointSize(options));
     writer.writeInt8(1);
-    writeWkbType(writer, WKB.Point, options);
+    writeWkbType(writer, 1 /* Point */, options);
     if (typeof coordinates[0] === "undefined" && typeof coordinates[1] === "undefined") {
       writer.writeDoubleLE(NaN);
       writer.writeDoubleLE(NaN);
@@ -1219,7 +1176,7 @@ var __exports__ = (() => {
     const size = getLineStringSize(coordinates, options);
     const writer = new BinaryWriter(size);
     writer.writeInt8(1);
-    writeWkbType(writer, WKB.LineString, options);
+    writeWkbType(writer, 2 /* LineString */, options);
     writer.writeUInt32LE(coordinates.length);
     for (const coordinate of coordinates) {
       writeCoordinate(writer, coordinate, options);
@@ -1233,7 +1190,7 @@ var __exports__ = (() => {
   function encodePolygon(coordinates, options) {
     const writer = new BinaryWriter(getPolygonSize(coordinates, options));
     writer.writeInt8(1);
-    writeWkbType(writer, WKB.Polygon, options);
+    writeWkbType(writer, 3 /* Polygon */, options);
     const [exteriorRing, ...interiorRings] = coordinates;
     if (exteriorRing.length > 0) {
       writer.writeUInt32LE(1 + interiorRings.length);
@@ -1268,7 +1225,7 @@ var __exports__ = (() => {
     const writer = new BinaryWriter(getMultiPointSize(multiPoint, options));
     const points = multiPoint.coordinates;
     writer.writeInt8(1);
-    writeWkbType(writer, WKB.MultiPoint, options);
+    writeWkbType(writer, 4 /* MultiPoint */, options);
     writer.writeUInt32LE(points.length);
     for (const point of points) {
       const arrayBuffer = encodePoint(point, options);
@@ -1286,7 +1243,7 @@ var __exports__ = (() => {
     const writer = new BinaryWriter(getMultiLineStringSize(multiLineString, options));
     const lineStrings = multiLineString.coordinates;
     writer.writeInt8(1);
-    writeWkbType(writer, WKB.MultiLineString, options);
+    writeWkbType(writer, 5 /* MultiLineString */, options);
     writer.writeUInt32LE(lineStrings.length);
     for (const lineString of lineStrings) {
       const encodedLineString = encodeLineString(lineString, options);
@@ -1306,7 +1263,7 @@ var __exports__ = (() => {
     const writer = new BinaryWriter(getMultiPolygonSize(multiPolygon, options));
     const polygons = multiPolygon.coordinates;
     writer.writeInt8(1);
-    writeWkbType(writer, WKB.MultiPolygon, options);
+    writeWkbType(writer, 6 /* MultiPolygon */, options);
     writer.writeUInt32LE(polygons.length);
     for (const polygon of polygons) {
       const encodedPolygon = encodePolygon(polygon, options);
@@ -1325,7 +1282,7 @@ var __exports__ = (() => {
   function encodeGeometryCollection(collection, options) {
     const writer = new BinaryWriter(getGeometryCollectionSize(collection, options));
     writer.writeInt8(1);
-    writeWkbType(writer, WKB.GeometryCollection, options);
+    writeWkbType(writer, 7 /* GeometryCollection */, options);
     writer.writeUInt32LE(collection.geometries.length);
     for (const geometry of collection.geometries) {
       const arrayBuffer = encodeWKB(geometry, options);
@@ -1341,11 +1298,7 @@ var __exports__ = (() => {
     return size;
   }
   function writeWkbType(writer, geometryType, options) {
-    const {
-      hasZ,
-      hasM,
-      srid
-    } = options;
+    const { hasZ, hasM, srid } = options;
     let dimensionType = 0;
     if (!srid) {
       if (hasZ && hasM) {
@@ -1445,6 +1398,7 @@ var __exports__ = (() => {
     options: WKBLoader.options,
     text: true,
     testText: isHexWKB,
+    // TODO - encoding here seems wasteful - extend hex transcoder?
     parse: async (arrayBuffer) => parseHexWKB(new TextDecoder().decode(arrayBuffer)),
     parseTextSync: parseHexWKB
   };
@@ -1599,19 +1553,19 @@ var __exports__ = (() => {
   }
   function parseGeometry2(binaryReader, context, geometryType) {
     switch (geometryType) {
-      case WKBGeometryType.Point:
+      case 1 /* Point */:
         return parsePoint3(binaryReader, context);
-      case WKBGeometryType.LineString:
+      case 2 /* LineString */:
         return parseLineString3(binaryReader, context);
-      case WKBGeometryType.Polygon:
+      case 3 /* Polygon */:
         return parsePolygon3(binaryReader, context);
-      case WKBGeometryType.MultiPoint:
+      case 4 /* MultiPoint */:
         return parseMultiPoint3(binaryReader, context);
-      case WKBGeometryType.MultiLineString:
+      case 5 /* MultiLineString */:
         return parseMultiLineString3(binaryReader, context);
-      case WKBGeometryType.MultiPolygon:
+      case 6 /* MultiPolygon */:
         return parseMultiPolygon3(binaryReader, context);
-      case WKBGeometryType.GeometryCollection:
+      case 7 /* GeometryCollection */:
         return parseGeometryCollection2(binaryReader, context);
       default:
         throw new Error(`GeometryType ${geometryType} not supported`);
@@ -1619,22 +1573,13 @@ var __exports__ = (() => {
   }
   function parsePoint3(reader, context) {
     if (context.isEmpty) {
-      return {
-        type: "Point",
-        coordinates: []
-      };
+      return { type: "Point", coordinates: [] };
     }
-    return {
-      type: "Point",
-      coordinates: readFirstPoint(reader, context)
-    };
+    return { type: "Point", coordinates: readFirstPoint(reader, context) };
   }
   function parseLineString3(reader, context) {
     if (context.isEmpty) {
-      return {
-        type: "LineString",
-        coordinates: []
-      };
+      return { type: "LineString", coordinates: [] };
     }
     const pointCount = reader.readVarInt();
     const previousPoint = makePreviousPoint(context);
@@ -1642,17 +1587,11 @@ var __exports__ = (() => {
     for (let i = 0; i < pointCount; i++) {
       points.push(parseNextPoint(reader, context, previousPoint));
     }
-    return {
-      type: "LineString",
-      coordinates: points
-    };
+    return { type: "LineString", coordinates: points };
   }
   function parsePolygon3(reader, context) {
     if (context.isEmpty) {
-      return {
-        type: "Polygon",
-        coordinates: []
-      };
+      return { type: "Polygon", coordinates: [] };
     }
     const ringCount = reader.readVarInt();
     const previousPoint = makePreviousPoint(context);
@@ -1670,17 +1609,11 @@ var __exports__ = (() => {
       }
       polygon.push(interiorRing);
     }
-    return {
-      type: "Polygon",
-      coordinates: polygon
-    };
+    return { type: "Polygon", coordinates: polygon };
   }
   function parseMultiPoint3(reader, context) {
     if (context.isEmpty) {
-      return {
-        type: "MultiPoint",
-        coordinates: []
-      };
+      return { type: "MultiPoint", coordinates: [] };
     }
     const previousPoint = makePreviousPoint(context);
     const pointCount = reader.readVarInt();
@@ -1688,17 +1621,11 @@ var __exports__ = (() => {
     for (let i = 0; i < pointCount; i++) {
       coordinates.push(parseNextPoint(reader, context, previousPoint));
     }
-    return {
-      type: "MultiPoint",
-      coordinates
-    };
+    return { type: "MultiPoint", coordinates };
   }
   function parseMultiLineString3(reader, context) {
     if (context.isEmpty) {
-      return {
-        type: "MultiLineString",
-        coordinates: []
-      };
+      return { type: "MultiLineString", coordinates: [] };
     }
     const previousPoint = makePreviousPoint(context);
     const lineStringCount = reader.readVarInt();
@@ -1711,17 +1638,11 @@ var __exports__ = (() => {
       }
       coordinates.push(lineString);
     }
-    return {
-      type: "MultiLineString",
-      coordinates
-    };
+    return { type: "MultiLineString", coordinates };
   }
   function parseMultiPolygon3(reader, context) {
     if (context.isEmpty) {
-      return {
-        type: "MultiPolygon",
-        coordinates: []
-      };
+      return { type: "MultiPolygon", coordinates: [] };
     }
     const previousPoint = makePreviousPoint(context);
     const polygonCount = reader.readVarInt();
@@ -1744,16 +1665,10 @@ var __exports__ = (() => {
       }
       polygons.push(polygon);
     }
-    return {
-      type: "MultiPolygon",
-      coordinates: polygons
-    };
+    return { type: "MultiPolygon", coordinates: polygons };
   }
   function parseGeometryCollection2(reader, context) {
-    return {
-      type: "GeometryCollection",
-      geometries: []
-    };
+    return { type: "GeometryCollection", geometries: [] };
   }
   function zigZagDecode(value) {
     return value >> 1 ^ -(value & 1);
@@ -1793,10 +1708,12 @@ var __exports__ = (() => {
     category: "geometry",
     extensions: ["twkb"],
     mimeTypes: [],
+    // TODO can we define static, serializable tests, eg. some binary strings?
     tests: [isTWKB],
     options: {
       wkb: {
         shape: "binary-geometry"
+        // 'geojson-geometry'
       }
     }
   };
@@ -1839,7 +1756,7 @@ var __exports__ = (() => {
   }
   function encodePoint2(writer, context, point) {
     const isEmpty = point.coordinates.length === 0 || point[0] === "undefined" || point[1] === "undefined";
-    writeTwkbHeader(writer, context, WKBGeometryType.Point, isEmpty);
+    writeTwkbHeader(writer, context, 1 /* Point */, isEmpty);
     if (!isEmpty) {
       const previousPoint = [0, 0, 0, 0];
       writeTwkbPoint(writer, context, point.coordinates, previousPoint);
@@ -1848,7 +1765,7 @@ var __exports__ = (() => {
   function encodeLineString2(writer, context, lineString) {
     const points = lineString.coordinates;
     const isEmpty = points.length === 0;
-    writeTwkbHeader(writer, context, WKBGeometryType.LineString, isEmpty);
+    writeTwkbHeader(writer, context, 2 /* LineString */, isEmpty);
     if (!isEmpty) {
       writer.writeVarInt(points.length);
       const previousPoint = [0, 0, 0, 0];
@@ -1861,7 +1778,7 @@ var __exports__ = (() => {
   function encodePolygon2(writer, context, polygon) {
     const polygonRings = polygon.coordinates;
     const isEmpty = polygonRings.length === 0;
-    writeTwkbHeader(writer, context, WKBGeometryType.Polygon, isEmpty);
+    writeTwkbHeader(writer, context, 3 /* Polygon */, isEmpty);
     if (!isEmpty) {
       writer.writeVarInt(polygonRings.length);
       const previousPoint = [0, 0, 0, 0];
@@ -1877,7 +1794,7 @@ var __exports__ = (() => {
   function encodeMultiPoint2(writer, context, multiPoint) {
     const points = multiPoint.coordinates;
     const isEmpty = points.length === 0;
-    writeTwkbHeader(writer, context, WKBGeometryType.MultiPoint, isEmpty);
+    writeTwkbHeader(writer, context, 4 /* MultiPoint */, isEmpty);
     if (!isEmpty) {
       writer.writeVarInt(points.length);
       const previousPoint = [0, 0, 0, 0];
@@ -1889,7 +1806,7 @@ var __exports__ = (() => {
   function encodeMultiLineString2(writer, context, multiLineStrings) {
     const lineStrings = multiLineStrings.coordinates;
     const isEmpty = lineStrings.length === 0;
-    writeTwkbHeader(writer, context, WKBGeometryType.MultiLineString, isEmpty);
+    writeTwkbHeader(writer, context, 5 /* MultiLineString */, isEmpty);
     if (!isEmpty) {
       writer.writeVarInt(lineStrings.length);
       const previousPoint = [0, 0, 0, 0];
@@ -1903,11 +1820,9 @@ var __exports__ = (() => {
     return writer.arrayBuffer;
   }
   function encodeMultiPolygon2(writer, context, multiPolygon) {
-    const {
-      coordinates
-    } = multiPolygon;
+    const { coordinates } = multiPolygon;
     const isEmpty = coordinates.length === 0;
-    writeTwkbHeader(writer, context, WKBGeometryType.MultiPolygon, isEmpty);
+    writeTwkbHeader(writer, context, 6 /* MultiPolygon */, isEmpty);
     if (!isEmpty) {
       const polygons = coordinates;
       writer.writeVarInt(polygons.length);
@@ -1924,11 +1839,9 @@ var __exports__ = (() => {
     }
   }
   function encodeGeometryCollection2(writer, context, geometryCollection) {
-    const {
-      geometries
-    } = geometryCollection;
+    const { geometries } = geometryCollection;
     const isEmpty = geometries.length === 0;
-    writeTwkbHeader(writer, context, WKBGeometryType.GeometryCollection, isEmpty);
+    writeTwkbHeader(writer, context, 7 /* GeometryCollection */, isEmpty);
     if (geometries.length > 0) {
       writer.writeVarInt(geometries.length);
       for (const geometry of geometries) {
@@ -2001,7 +1914,7 @@ var __exports__ = (() => {
       }
     }
   };
-  return __toCommonJS(src_exports);
+  return __toCommonJS(bundle_exports);
 })();
       return __exports__;
       });