@loaders.gl/wkt 4.0.0-beta.2 → 4.0.0-beta.4

package/dist/{dist.min.js → dist.dev.js}

@@ -1,26 +1,54 @@
-(() => {
+(function webpackUniversalModuleDefinition(root, factory) {
+  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 () {
+"use strict";
+var __exports__ = (() => {
   var __defProp = Object.defineProperty;
-  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
-  var __esm = (fn, res) => function __init() {
-    return fn && (res = (0, fn[Object.keys(fn)[0]])(fn = 0)), res;
-  };
-  var __commonJS = (cb, mod) => function __require() {
-    return mod || (0, cb[Object.keys(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-  };
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
   var __export = (target, all) => {
-    __markAsModule(target);
     for (var name in all)
       __defProp(target, name, { get: all[name], enumerable: true });
   };
-
-  // src/lib/utils/version.ts
-  var VERSION;
-  var init_version = __esm({
-    "src/lib/utils/version.ts"() {
-      VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
     }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/index.ts
+  var src_exports = {};
+  __export(src_exports, {
+    HexWKBLoader: () => HexWKBLoader,
+    TWKBLoader: () => TWKBLoader,
+    TWKBWriter: () => TWKBWriter,
+    WKBLoader: () => WKBLoader,
+    WKBWorkerLoader: () => WKBWorkerLoader,
+    WKBWriter: () => WKBWriter,
+    WKTCRSLoader: () => WKTCRSLoader,
+    WKTCRSWriter: () => WKTCRSWriter,
+    WKTLoader: () => WKTLoader,
+    WKTWorkerLoader: () => WKTWorkerLoader,
+    WKTWriter: () => WKTWriter,
+    decodeHex: () => decodeHex,
+    encodeHex: () => encodeHex,
+    isTWKB: () => isTWKB,
+    isWKB: () => isWKB,
+    isWKT: () => isWKT,
+    parseWKBHeader: () => parseWKBHeader
   });
 
+  // src/lib/utils/version.ts
+  var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+
   // src/lib/parse-wkt-crs.ts
   function parseWKTCRS(wkt, options) {
     if (options?.debug) {
@@ -119,35 +147,24 @@
     });
     return data;
   }
-  var init_parse_wkt_crs = __esm({
-    "src/lib/parse-wkt-crs.ts"() {
-    }
-  });
 
   // src/wkt-crs-loader.ts
-  var WKTCRSLoader;
-  var init_wkt_crs_loader = __esm({
-    "src/wkt-crs-loader.ts"() {
-      init_version();
-      init_parse_wkt_crs();
-      WKTCRSLoader = {
-        name: "WKT CRS (Well-Known Text Coordinate Reference System)",
-        id: "wkt-crs",
-        module: "wkt-crs",
-        version: VERSION,
-        worker: true,
-        extensions: [],
-        mimeTypes: ["text/plain"],
-        category: "json",
-        text: true,
-        options: {
-          "wkt-crs": {}
-        },
-        parse: async (arrayBuffer, options) => parseWKTCRS(new TextDecoder().decode(arrayBuffer), options?.["wkt-crs"]),
-        parseTextSync: (string, options) => parseWKTCRS(string, options?.["wkt-crs"])
-      };
-    }
-  });
+  var WKTCRSLoader = {
+    name: "WKT CRS (Well-Known Text Coordinate Reference System)",
+    id: "wkt-crs",
+    module: "wkt-crs",
+    version: VERSION,
+    worker: true,
+    extensions: [],
+    mimeTypes: ["text/plain"],
+    category: "json",
+    text: true,
+    options: {
+      "wkt-crs": {}
+    },
+    parse: async (arrayBuffer, options) => parseWKTCRS(new TextDecoder().decode(arrayBuffer), options?.["wkt-crs"]),
+    parseTextSync: (string, options) => parseWKTCRS(string, options?.["wkt-crs"])
+  };
 
   // src/lib/encode-wkt-crs.ts
   function encodeWKTCRS(wkt, options) {
@@ -170,37 +187,29 @@
     }).join(",")}]`;
     return str;
   }
-  var init_encode_wkt_crs = __esm({
-    "src/lib/encode-wkt-crs.ts"() {
-    }
-  });
 
   // src/wkt-crs-writer.ts
-  var WKTCRSWriter;
-  var init_wkt_crs_writer = __esm({
-    "src/wkt-crs-writer.ts"() {
-      init_version();
-      init_encode_wkt_crs();
-      WKTCRSWriter = {
-        name: "WKT CRS (Well-Known Text Coordinate Reference System)",
-        id: "wkt-crs",
-        module: "wkt-crs",
-        version: VERSION,
-        worker: true,
-        extensions: [],
-        mimeTypes: ["text/plain"],
-        text: true,
-        options: {
-          "wkt-crs": {}
-        },
-        encode: async (wktcrs, options) => new TextEncoder().encode(encodeWKTCRS(wktcrs, options?.["wkt-crs"])),
-        encodeSync: (wktcrs, options) => new TextEncoder().encode(encodeWKTCRS(wktcrs, options?.["wkt-crs"])),
-        encodeTextSync: (wktcrs, options) => encodeWKTCRS(wktcrs, options?.["wkt-crs"])
-      };
-    }
-  });
+  var WKTCRSWriter = {
+    name: "WKT CRS (Well-Known Text Coordinate Reference System)",
+    id: "wkt-crs",
+    module: "wkt-crs",
+    version: VERSION,
+    worker: true,
+    extensions: [],
+    mimeTypes: ["text/plain"],
+    text: true,
+    options: {
+      "wkt-crs": {}
+    },
+    encode: async (wktcrs, options) => new TextEncoder().encode(encodeWKTCRS(wktcrs, options?.["wkt-crs"])),
+    encodeSync: (wktcrs, options) => new TextEncoder().encode(encodeWKTCRS(wktcrs, options?.["wkt-crs"])),
+    encodeTextSync: (wktcrs, options) => encodeWKTCRS(wktcrs, options?.["wkt-crs"])
+  };
 
   // 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("];
   function isWKT(input) {
     return WKT_MAGIC_STRINGS.some((magicString) => input.startsWith(magicString));
   }
@@ -211,7 +220,11 @@
     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;
   }
@@ -423,55 +436,31 @@
   function white(state) {
     $(/^\s*/, state);
   }
-  var numberRegexp, tuples, WKT_MAGIC_STRINGS;
-  var init_parse_wkt = __esm({
-    "src/lib/parse-wkt.ts"() {
-      numberRegexp = /[-+]?([0-9]*\.[0-9]+|[0-9]+)([eE][-+]?[0-9]+)?/;
-      tuples = new RegExp("^" + numberRegexp.source + "(\\s" + numberRegexp.source + "){1,}");
-      WKT_MAGIC_STRINGS = [
-        "POINT(",
-        "LINESTRING(",
-        "POLYGON(",
-        "MULTIPOINT(",
-        "MULTILINESTRING(",
-        "MULTIPOLYGON(",
-        "GEOMETRYCOLLECTION("
-      ];
-    }
-  });
 
   // src/wkt-loader.ts
-  var WKTWorkerLoader, WKTLoader;
-  var init_wkt_loader = __esm({
-    "src/wkt-loader.ts"() {
-      init_version();
-      init_parse_wkt();
-      init_parse_wkt();
-      WKTWorkerLoader = {
-        name: "WKT (Well-Known Text)",
-        id: "wkt",
-        module: "wkt",
-        version: VERSION,
-        worker: true,
-        extensions: ["wkt"],
-        mimeTypes: ["text/plain"],
-        category: "geometry",
-        text: true,
-        tests: WKT_MAGIC_STRINGS,
-        testText: isWKT,
-        options: {
-          wkt: {
-            crs: true
-          }
-        }
-      };
-      WKTLoader = {
-        ...WKTWorkerLoader,
-        parse: async (arrayBuffer, options) => parseWKT(new TextDecoder().decode(arrayBuffer), options),
-        parseTextSync: parseWKT
-      };
+  var WKTWorkerLoader = {
+    name: "WKT (Well-Known Text)",
+    id: "wkt",
+    module: "wkt",
+    version: VERSION,
+    worker: true,
+    extensions: ["wkt"],
+    mimeTypes: ["text/plain"],
+    category: "geometry",
+    text: true,
+    tests: WKT_MAGIC_STRINGS,
+    testText: isWKT,
+    options: {
+      wkt: {
+        crs: true
+      }
     }
-  });
+  };
+  var WKTLoader = {
+    ...WKTWorkerLoader,
+    parse: async (arrayBuffer, options) => parseWKT(new TextDecoder().decode(arrayBuffer), options),
+    parseTextSync: parseWKT
+  };
 
   // src/lib/encode-wkt.ts
   function encodeWKT(geometry) {
@@ -512,30 +501,19 @@
   function wrapParens(s) {
     return `(${s})`;
   }
-  var init_encode_wkt = __esm({
-    "src/lib/encode-wkt.ts"() {
-    }
-  });
 
   // src/wkt-writer.ts
-  var WKTWriter;
-  var init_wkt_writer = __esm({
-    "src/wkt-writer.ts"() {
-      init_version();
-      init_encode_wkt();
-      WKTWriter = {
-        name: "WKT (Well Known Text)",
-        id: "wkt",
-        module: "wkt",
-        version: VERSION,
-        extensions: ["wkt"],
-        encodeSync: encodeWKT,
-        options: {
-          wkt: {}
-        }
-      };
+  var WKTWriter = {
+    name: "WKT (Well Known Text)",
+    id: "wkt",
+    module: "wkt",
+    version: VERSION,
+    extensions: ["wkt"],
+    encodeSync: encodeWKT,
+    options: {
+      wkt: {}
     }
-  });
+  };
 
   // ../gis/src/lib/binary-to-geojson.ts
   function binaryToGeometry(data, startIndex, endIndex) {
@@ -552,7 +530,9 @@
     }
   }
   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 multi = polygonIndices.length > 2;
@@ -564,7 +544,10 @@
         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++) {
@@ -573,31 +556,50 @@
       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;
@@ -612,19 +614,22 @@
     }
     return ringCoordinates;
   }
-  var init_binary_to_geojson = __esm({
-    "../gis/src/lib/binary-to-geojson.ts"() {
-    }
-  });
-
-  // ../gis/src/index.ts
-  var init_src = __esm({
-    "../gis/src/index.ts"() {
-      init_binary_to_geojson();
-    }
-  });
 
   // src/lib/parse-wkb-header.ts
+  var EWKB_FLAG_Z = 2147483648;
+  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;
@@ -715,24 +720,6 @@
     }
     return wkbHeader;
   }
-  var EWKB_FLAG_Z, EWKB_FLAG_M, EWKB_FLAG_SRID, MAX_SRID, WKBGeometryType;
-  var init_parse_wkb_header = __esm({
-    "src/lib/parse-wkb-header.ts"() {
-      EWKB_FLAG_Z = 2147483648;
-      EWKB_FLAG_M = 1073741824;
-      EWKB_FLAG_SRID = 536870912;
-      MAX_SRID = 1e4;
-      (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";
-      })(WKBGeometryType || (WKBGeometryType = {}));
-    }
-  });
 
   // src/lib/parse-wkb.ts
   function parseWKB(arrayBuffer, options) {
@@ -750,7 +737,11 @@
   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:
@@ -785,7 +776,13 @@
       offset += 8;
     }
     return {
-      geometry: { type: "Point", positions: { value: positions, size: dimension } },
+      geometry: {
+        type: "Point",
+        positions: {
+          value: positions,
+          size: dimension
+        }
+      },
       offset
     };
   }
@@ -804,19 +801,28 @@
     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
     };
   }
+  var cumulativeSum = (sum) => (value) => sum += value;
   function parsePolygon2(dataView, offset, dimension, littleEndian) {
     const nRings = dataView.getUint32(offset, littleEndian);
     offset += 4;
     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);
     }
@@ -830,12 +836,18 @@
     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
     };
@@ -896,7 +908,10 @@
     const concatenatedPositions = new Float64Array(concatTypedArrays(positions).buffer);
     return {
       type: "Point",
-      positions: { value: concatenatedPositions, size: dimension }
+      positions: {
+        value: concatenatedPositions,
+        size: dimension
+      }
     };
   }
   function concatenateBinaryLineGeometries(binaryLineGeometries, dimension) {
@@ -906,15 +921,24 @@
     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);
     }
@@ -927,9 +951,18 @@
     }
     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) {
@@ -948,164 +981,153 @@
     }
     return buffer;
   }
-  var cumulativeSum;
-  var init_parse_wkb = __esm({
-    "src/lib/parse-wkb.ts"() {
-      init_src();
-      init_parse_wkb_header();
-      cumulativeSum = (sum) => (value) => sum += value;
-    }
-  });
 
   // src/wkb-loader.ts
-  var WKBWorkerLoader, WKBLoader;
-  var init_wkb_loader = __esm({
-    "src/wkb-loader.ts"() {
-      init_version();
-      init_parse_wkb();
-      init_parse_wkb_header();
-      WKBWorkerLoader = {
-        name: "WKB",
-        id: "wkb",
-        module: "wkt",
-        version: VERSION,
-        worker: true,
-        category: "geometry",
-        extensions: ["wkb"],
-        mimeTypes: [],
-        tests: [isWKB],
-        options: {
-          wkb: {
-            shape: "binary-geometry"
-          }
-        }
-      };
-      WKBLoader = {
-        ...WKBWorkerLoader,
-        parse: async (arrayBuffer) => parseWKB(arrayBuffer),
-        parseSync: parseWKB
-      };
+  var WKBWorkerLoader = {
+    name: "WKB",
+    id: "wkb",
+    module: "wkt",
+    version: VERSION,
+    worker: true,
+    category: "geometry",
+    extensions: ["wkb"],
+    mimeTypes: [],
+    tests: [isWKB],
+    options: {
+      wkb: {
+        shape: "binary-geometry"
+      }
     }
-  });
+  };
+  var WKBLoader = {
+    ...WKBWorkerLoader,
+    parse: async (arrayBuffer) => parseWKB(arrayBuffer),
+    parseSync: parseWKB
+  };
 
   // src/lib/utils/binary-writer.ts
-  var LE, BE, BinaryWriter;
-  var init_binary_writer = __esm({
-    "src/lib/utils/binary-writer.ts"() {
-      LE = true;
-      BE = false;
-      BinaryWriter = class {
-        constructor(size, allowResize) {
-          this.byteOffset = 0;
-          this.allowResize = false;
-          this.arrayBuffer = new ArrayBuffer(size);
-          this.dataView = new DataView(this.arrayBuffer);
-          this.byteOffset = 0;
-          this.allowResize = allowResize || false;
-        }
-        writeUInt8(value) {
-          this._ensureSize(1);
-          this.dataView.setUint8(this.byteOffset, value);
-          this.byteOffset += 1;
-        }
-        writeUInt16LE(value) {
-          this._ensureSize(2);
-          this.dataView.setUint16(this.byteOffset, value, LE);
-          this.byteOffset += 2;
-        }
-        writeUInt16BE(value) {
-          this._ensureSize(2);
-          this.dataView.setUint16(this.byteOffset, value, BE);
-          this.byteOffset += 2;
-        }
-        writeUInt32LE(value) {
-          this._ensureSize(4);
-          this.dataView.setUint32(this.byteOffset, value, LE);
-          this.byteOffset += 4;
-        }
-        writeUInt32BE(value) {
-          this._ensureSize(4);
-          this.dataView.setUint32(this.byteOffset, value, BE);
-          this.byteOffset += 4;
-        }
-        writeInt8(value) {
-          this._ensureSize(1);
-          this.dataView.setInt8(this.byteOffset, value);
-          this.byteOffset += 1;
-        }
-        writeInt16LE(value) {
-          this._ensureSize(2);
-          this.dataView.setInt16(this.byteOffset, value, LE);
-          this.byteOffset += 2;
-        }
-        writeInt16BE(value) {
-          this._ensureSize(2);
-          this.dataView.setInt16(this.byteOffset, value, BE);
-          this.byteOffset += 2;
-        }
-        writeInt32LE(value) {
-          this._ensureSize(4);
-          this.dataView.setInt32(this.byteOffset, value, LE);
-          this.byteOffset += 4;
-        }
-        writeInt32BE(value) {
-          this._ensureSize(4);
-          this.dataView.setInt32(this.byteOffset, value, BE);
-          this.byteOffset += 4;
-        }
-        writeFloatLE(value) {
-          this._ensureSize(4);
-          this.dataView.setFloat32(this.byteOffset, value, LE);
-          this.byteOffset += 4;
-        }
-        writeFloatBE(value) {
-          this._ensureSize(4);
-          this.dataView.setFloat32(this.byteOffset, value, BE);
-          this.byteOffset += 4;
-        }
-        writeDoubleLE(value) {
-          this._ensureSize(8);
-          this.dataView.setFloat64(this.byteOffset, value, LE);
-          this.byteOffset += 8;
-        }
-        writeDoubleBE(value) {
-          this._ensureSize(8);
-          this.dataView.setFloat64(this.byteOffset, value, BE);
-          this.byteOffset += 8;
-        }
-        writeVarInt(value) {
-          let length = 1;
-          while ((value & 4294967168) !== 0) {
-            this.writeUInt8(value & 127 | 128);
-            value >>>= 7;
-            length++;
-          }
-          this.writeUInt8(value & 127);
-          return length;
-        }
-        writeBuffer(arrayBuffer) {
-          this._ensureSize(arrayBuffer.byteLength);
-          const tempArray = new Uint8Array(this.arrayBuffer);
-          tempArray.set(new Uint8Array(arrayBuffer), this.byteOffset);
-          this.byteOffset += arrayBuffer.byteLength;
-        }
-        _ensureSize(size) {
-          if (this.arrayBuffer.byteLength < this.byteOffset + size) {
-            if (this.allowResize) {
-              const newArrayBuffer = new ArrayBuffer(this.byteOffset + size);
-              const tempArray = new Uint8Array(newArrayBuffer);
-              tempArray.set(new Uint8Array(this.arrayBuffer));
-              this.arrayBuffer = newArrayBuffer;
-            } else {
-              throw new Error("BinaryWriter overflow");
-            }
-          }
+  var LE = true;
+  var BE = false;
+  var BinaryWriter = class {
+    byteOffset = 0;
+    allowResize = false;
+    constructor(size, allowResize) {
+      this.arrayBuffer = new ArrayBuffer(size);
+      this.dataView = new DataView(this.arrayBuffer);
+      this.byteOffset = 0;
+      this.allowResize = allowResize || false;
+    }
+    writeUInt8(value) {
+      this._ensureSize(1);
+      this.dataView.setUint8(this.byteOffset, value);
+      this.byteOffset += 1;
+    }
+    writeUInt16LE(value) {
+      this._ensureSize(2);
+      this.dataView.setUint16(this.byteOffset, value, LE);
+      this.byteOffset += 2;
+    }
+    writeUInt16BE(value) {
+      this._ensureSize(2);
+      this.dataView.setUint16(this.byteOffset, value, BE);
+      this.byteOffset += 2;
+    }
+    writeUInt32LE(value) {
+      this._ensureSize(4);
+      this.dataView.setUint32(this.byteOffset, value, LE);
+      this.byteOffset += 4;
+    }
+    writeUInt32BE(value) {
+      this._ensureSize(4);
+      this.dataView.setUint32(this.byteOffset, value, BE);
+      this.byteOffset += 4;
+    }
+    writeInt8(value) {
+      this._ensureSize(1);
+      this.dataView.setInt8(this.byteOffset, value);
+      this.byteOffset += 1;
+    }
+    writeInt16LE(value) {
+      this._ensureSize(2);
+      this.dataView.setInt16(this.byteOffset, value, LE);
+      this.byteOffset += 2;
+    }
+    writeInt16BE(value) {
+      this._ensureSize(2);
+      this.dataView.setInt16(this.byteOffset, value, BE);
+      this.byteOffset += 2;
+    }
+    writeInt32LE(value) {
+      this._ensureSize(4);
+      this.dataView.setInt32(this.byteOffset, value, LE);
+      this.byteOffset += 4;
+    }
+    writeInt32BE(value) {
+      this._ensureSize(4);
+      this.dataView.setInt32(this.byteOffset, value, BE);
+      this.byteOffset += 4;
+    }
+    writeFloatLE(value) {
+      this._ensureSize(4);
+      this.dataView.setFloat32(this.byteOffset, value, LE);
+      this.byteOffset += 4;
+    }
+    writeFloatBE(value) {
+      this._ensureSize(4);
+      this.dataView.setFloat32(this.byteOffset, value, BE);
+      this.byteOffset += 4;
+    }
+    writeDoubleLE(value) {
+      this._ensureSize(8);
+      this.dataView.setFloat64(this.byteOffset, value, LE);
+      this.byteOffset += 8;
+    }
+    writeDoubleBE(value) {
+      this._ensureSize(8);
+      this.dataView.setFloat64(this.byteOffset, value, BE);
+      this.byteOffset += 8;
+    }
+    writeVarInt(value) {
+      let length = 1;
+      while ((value & 4294967168) !== 0) {
+        this.writeUInt8(value & 127 | 128);
+        value >>>= 7;
+        length++;
+      }
+      this.writeUInt8(value & 127);
+      return length;
+    }
+    writeBuffer(arrayBuffer) {
+      this._ensureSize(arrayBuffer.byteLength);
+      const tempArray = new Uint8Array(this.arrayBuffer);
+      tempArray.set(new Uint8Array(arrayBuffer), this.byteOffset);
+      this.byteOffset += arrayBuffer.byteLength;
+    }
+    _ensureSize(size) {
+      if (this.arrayBuffer.byteLength < this.byteOffset + size) {
+        if (this.allowResize) {
+          const newArrayBuffer = new ArrayBuffer(this.byteOffset + size);
+          const tempArray = new Uint8Array(newArrayBuffer);
+          tempArray.set(new Uint8Array(this.arrayBuffer));
+          this.arrayBuffer = newArrayBuffer;
+        } else {
+          throw new Error("BinaryWriter overflow");
         }
-      };
+      }
     }
-  });
+  };
 
   // 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;
@@ -1157,7 +1179,7 @@
   function encodePoint(coordinates, options) {
     const writer = new BinaryWriter(getPointSize(options));
     writer.writeInt8(1);
-    writeWkbType(writer, 1, options);
+    writeWkbType(writer, WKB.Point, options);
     if (typeof coordinates[0] === "undefined" && typeof coordinates[1] === "undefined") {
       writer.writeDoubleLE(NaN);
       writer.writeDoubleLE(NaN);
@@ -1190,7 +1212,7 @@
     const size = getLineStringSize(coordinates, options);
     const writer = new BinaryWriter(size);
     writer.writeInt8(1);
-    writeWkbType(writer, 2, options);
+    writeWkbType(writer, WKB.LineString, options);
     writer.writeUInt32LE(coordinates.length);
     for (const coordinate of coordinates) {
       writeCoordinate(writer, coordinate, options);
@@ -1204,7 +1226,7 @@
   function encodePolygon(coordinates, options) {
     const writer = new BinaryWriter(getPolygonSize(coordinates, options));
     writer.writeInt8(1);
-    writeWkbType(writer, 3, options);
+    writeWkbType(writer, WKB.Polygon, options);
     const [exteriorRing, ...interiorRings] = coordinates;
     if (exteriorRing.length > 0) {
       writer.writeUInt32LE(1 + interiorRings.length);
@@ -1239,7 +1261,7 @@
     const writer = new BinaryWriter(getMultiPointSize(multiPoint, options));
     const points = multiPoint.coordinates;
     writer.writeInt8(1);
-    writeWkbType(writer, 4, options);
+    writeWkbType(writer, WKB.MultiPoint, options);
     writer.writeUInt32LE(points.length);
     for (const point of points) {
       const arrayBuffer = encodePoint(point, options);
@@ -1257,7 +1279,7 @@
     const writer = new BinaryWriter(getMultiLineStringSize(multiLineString, options));
     const lineStrings = multiLineString.coordinates;
     writer.writeInt8(1);
-    writeWkbType(writer, 5, options);
+    writeWkbType(writer, WKB.MultiLineString, options);
     writer.writeUInt32LE(lineStrings.length);
     for (const lineString of lineStrings) {
       const encodedLineString = encodeLineString(lineString, options);
@@ -1277,7 +1299,7 @@
     const writer = new BinaryWriter(getMultiPolygonSize(multiPolygon, options));
     const polygons = multiPolygon.coordinates;
     writer.writeInt8(1);
-    writeWkbType(writer, 6, options);
+    writeWkbType(writer, WKB.MultiPolygon, options);
     writer.writeUInt32LE(polygons.length);
     for (const polygon of polygons) {
       const encodedPolygon = encodePolygon(polygon, options);
@@ -1296,7 +1318,7 @@
   function encodeGeometryCollection(collection, options) {
     const writer = new BinaryWriter(getGeometryCollectionSize(collection, options));
     writer.writeInt8(1);
-    writeWkbType(writer, 7, options);
+    writeWkbType(writer, WKB.GeometryCollection, options);
     writer.writeUInt32LE(collection.geometries.length);
     for (const geometry of collection.geometries) {
       const arrayBuffer = encodeWKB(geometry, options);
@@ -1312,7 +1334,11 @@
     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) {
@@ -1342,46 +1368,37 @@
     }
     return coordinateSize;
   }
-  var WKB;
-  var init_encode_wkb = __esm({
-    "src/lib/encode-wkb.ts"() {
-      init_binary_writer();
-      (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";
-      })(WKB || (WKB = {}));
-    }
-  });
 
   // src/wkb-writer.ts
-  var WKBWriter;
-  var init_wkb_writer = __esm({
-    "src/wkb-writer.ts"() {
-      init_version();
-      init_encode_wkb();
-      WKBWriter = {
-        name: "WKB (Well Known Binary)",
-        id: "wkb",
-        module: "wkt",
-        version: VERSION,
-        extensions: ["wkb"],
-        encodeSync: encodeWKB,
-        options: {
-          wkb: {
-            hasZ: false,
-            hasM: false
-          }
-        }
-      };
+  var WKBWriter = {
+    name: "WKB (Well Known Binary)",
+    id: "wkb",
+    module: "wkt",
+    version: VERSION,
+    extensions: ["wkb"],
+    encodeSync: encodeWKB,
+    options: {
+      wkb: {
+        hasZ: false,
+        hasM: false
+      }
     }
-  });
+  };
 
   // src/lib/utils/hex-transcoder.ts
+  var alphabet = "0123456789abcdef";
+  var encodeLookup = [];
+  var decodeLookup = [];
+  for (let i = 0; i < 256; i++) {
+    encodeLookup[i] = alphabet[i >> 4 & 15] + alphabet[i & 15];
+    if (i < 16) {
+      if (i < 10) {
+        decodeLookup[48 + i] = i;
+      } else {
+        decodeLookup[97 - 10 + i] = i;
+      }
+    }
+  }
   function encodeHex(array) {
     const length = array.length;
     let string = "";
@@ -1402,26 +1419,23 @@
     }
     return array;
   }
-  var alphabet, encodeLookup, decodeLookup;
-  var init_hex_transcoder = __esm({
-    "src/lib/utils/hex-transcoder.ts"() {
-      alphabet = "0123456789abcdef";
-      encodeLookup = [];
-      decodeLookup = [];
-      for (let i = 0; i < 256; i++) {
-        encodeLookup[i] = alphabet[i >> 4 & 15] + alphabet[i & 15];
-        if (i < 16) {
-          if (i < 10) {
-            decodeLookup[48 + i] = i;
-          } else {
-            decodeLookup[97 - 10 + i] = i;
-          }
-        }
-      }
-    }
-  });
 
   // src/hex-wkb-loader.ts
+  var HexWKBLoader = {
+    name: "Hexadecimal WKB",
+    id: "wkb",
+    module: "wkt",
+    version: VERSION,
+    worker: true,
+    category: "geometry",
+    extensions: ["wkb"],
+    mimeTypes: [],
+    options: WKBLoader.options,
+    text: true,
+    testText: isHexWKB,
+    parse: async (arrayBuffer) => parseHexWKB(new TextDecoder().decode(arrayBuffer)),
+    parseTextSync: parseHexWKB
+  };
   function parseHexWKB(text, options) {
     const uint8Array = decodeHex(text);
     const binaryGeometry = WKBLoader.parseSync?.(uint8Array.buffer, options);
@@ -1439,96 +1453,68 @@
     }
     return /^[0-9a-fA-F]+$/.test(string.slice(2));
   }
-  var HexWKBLoader;
-  var init_hex_wkb_loader = __esm({
-    "src/hex-wkb-loader.ts"() {
-      init_wkb_loader();
-      init_version();
-      init_hex_transcoder();
-      HexWKBLoader = {
-        name: "Hexadecimal WKB",
-        id: "wkb",
-        module: "wkt",
-        version: VERSION,
-        worker: true,
-        category: "geometry",
-        extensions: ["wkb"],
-        mimeTypes: [],
-        options: WKBLoader.options,
-        text: true,
-        testText: isHexWKB,
-        parse: async (arrayBuffer) => parseHexWKB(new TextDecoder().decode(arrayBuffer)),
-        parseTextSync: parseHexWKB
-      };
-    }
-  });
 
   // src/lib/utils/binary-reader.ts
-  var BinaryReader;
-  var init_binary_reader = __esm({
-    "src/lib/utils/binary-reader.ts"() {
-      BinaryReader = class {
-        constructor(arrayBuffer, isBigEndian = false) {
-          this.arrayBuffer = arrayBuffer;
-          this.dataView = new DataView(arrayBuffer);
-          this.byteOffset = 0;
-          this.littleEndian = !isBigEndian;
-        }
-        readUInt8() {
-          const value = this.dataView.getUint8(this.byteOffset);
-          this.byteOffset += 1;
-          return value;
-        }
-        readUInt16() {
-          const value = this.dataView.getUint16(this.byteOffset, this.littleEndian);
-          this.byteOffset += 2;
-          return value;
-        }
-        readUInt32() {
-          const value = this.dataView.getUint32(this.byteOffset, this.littleEndian);
-          this.byteOffset += 4;
-          return value;
-        }
-        readInt8() {
-          const value = this.dataView.getInt8(this.byteOffset);
-          this.byteOffset += 1;
-          return value;
-        }
-        readInt16() {
-          const value = this.dataView.getInt16(this.byteOffset, this.littleEndian);
-          this.byteOffset += 2;
-          return value;
-        }
-        readInt32() {
-          const value = this.dataView.getInt32(this.byteOffset, this.littleEndian);
-          this.byteOffset += 4;
-          return value;
-        }
-        readFloat() {
-          const value = this.dataView.getFloat32(this.byteOffset, this.littleEndian);
-          this.byteOffset += 4;
-          return value;
-        }
-        readDouble() {
-          const value = this.dataView.getFloat64(this.byteOffset, this.littleEndian);
-          this.byteOffset += 8;
-          return value;
-        }
-        readVarInt() {
-          let result = 0;
-          let bytesRead = 0;
-          let nextByte;
-          do {
-            nextByte = this.dataView.getUint8(this.byteOffset + bytesRead);
-            result += (nextByte & 127) << 7 * bytesRead;
-            bytesRead++;
-          } while (nextByte >= 128);
-          this.byteOffset += bytesRead;
-          return result;
-        }
-      };
+  var BinaryReader = class {
+    constructor(arrayBuffer, isBigEndian = false) {
+      this.arrayBuffer = arrayBuffer;
+      this.dataView = new DataView(arrayBuffer);
+      this.byteOffset = 0;
+      this.littleEndian = !isBigEndian;
+    }
+    readUInt8() {
+      const value = this.dataView.getUint8(this.byteOffset);
+      this.byteOffset += 1;
+      return value;
+    }
+    readUInt16() {
+      const value = this.dataView.getUint16(this.byteOffset, this.littleEndian);
+      this.byteOffset += 2;
+      return value;
+    }
+    readUInt32() {
+      const value = this.dataView.getUint32(this.byteOffset, this.littleEndian);
+      this.byteOffset += 4;
+      return value;
+    }
+    readInt8() {
+      const value = this.dataView.getInt8(this.byteOffset);
+      this.byteOffset += 1;
+      return value;
+    }
+    readInt16() {
+      const value = this.dataView.getInt16(this.byteOffset, this.littleEndian);
+      this.byteOffset += 2;
+      return value;
+    }
+    readInt32() {
+      const value = this.dataView.getInt32(this.byteOffset, this.littleEndian);
+      this.byteOffset += 4;
+      return value;
+    }
+    readFloat() {
+      const value = this.dataView.getFloat32(this.byteOffset, this.littleEndian);
+      this.byteOffset += 4;
+      return value;
+    }
+    readDouble() {
+      const value = this.dataView.getFloat64(this.byteOffset, this.littleEndian);
+      this.byteOffset += 8;
+      return value;
+    }
+    readVarInt() {
+      let result = 0;
+      let bytesRead = 0;
+      let nextByte;
+      do {
+        nextByte = this.dataView.getUint8(this.byteOffset + bytesRead);
+        result += (nextByte & 127) << 7 * bytesRead;
+        bytesRead++;
+      } while (nextByte >= 128);
+      this.byteOffset += bytesRead;
+      return result;
     }
-  });
+  };
 
   // src/lib/parse-twkb.ts
   function isTWKB(arrayBuffer) {
@@ -1621,13 +1607,22 @@
   }
   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);
@@ -1635,11 +1630,17 @@
     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);
@@ -1657,11 +1658,17 @@
       }
       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();
@@ -1669,11 +1676,17 @@
     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();
@@ -1686,11 +1699,17 @@
       }
       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();
@@ -1713,10 +1732,16 @@
       }
       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);
@@ -1745,42 +1770,29 @@
     }
     return previousPoint.slice();
   }
-  var init_parse_twkb = __esm({
-    "src/lib/parse-twkb.ts"() {
-      init_binary_reader();
-      init_parse_wkb_header();
-    }
-  });
 
   // src/twkb-loader.ts
-  var TWKBWorkerLoader, TWKBLoader;
-  var init_twkb_loader = __esm({
-    "src/twkb-loader.ts"() {
-      init_version();
-      init_parse_twkb();
-      TWKBWorkerLoader = {
-        name: "TWKB (Tiny Well-Known Binary)",
-        id: "twkb",
-        module: "wkt",
-        version: VERSION,
-        worker: true,
-        category: "geometry",
-        extensions: ["twkb"],
-        mimeTypes: [],
-        tests: [isTWKB],
-        options: {
-          wkb: {
-            shape: "binary-geometry"
-          }
-        }
-      };
-      TWKBLoader = {
-        ...TWKBWorkerLoader,
-        parse: async (arrayBuffer) => parseTWKBGeometry(arrayBuffer),
-        parseSync: parseTWKBGeometry
-      };
+  var TWKBWorkerLoader = {
+    name: "TWKB (Tiny Well-Known Binary)",
+    id: "twkb",
+    module: "wkt",
+    version: VERSION,
+    worker: true,
+    category: "geometry",
+    extensions: ["twkb"],
+    mimeTypes: [],
+    tests: [isTWKB],
+    options: {
+      wkb: {
+        shape: "binary-geometry"
+      }
     }
-  });
+  };
+  var TWKBLoader = {
+    ...TWKBWorkerLoader,
+    parse: async (arrayBuffer) => parseTWKBGeometry(arrayBuffer),
+    parseSync: parseTWKBGeometry
+  };
 
   // src/lib/encode-twkb.ts
   function encodeTWKB(geometry, options) {
@@ -1879,7 +1891,9 @@
     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);
     if (!isEmpty) {
@@ -1898,7 +1912,9 @@
     }
   }
   function encodeGeometryCollection2(writer, context, geometryCollection) {
-    const { geometries } = geometryCollection;
+    const {
+      geometries
+    } = geometryCollection;
     const isEmpty = geometries.length === 0;
     writeTwkbHeader(writer, context, WKBGeometryType.GeometryCollection, isEmpty);
     if (geometries.length > 0) {
@@ -1956,79 +1972,20 @@
       mFactor: Math.pow(10, mPrecision)
     };
   }
-  var init_encode_twkb = __esm({
-    "src/lib/encode-twkb.ts"() {
-      init_binary_writer();
-      init_parse_wkb_header();
-    }
-  });
 
   // src/twkb-writer.ts
-  var TWKBWriter;
-  var init_twkb_writer = __esm({
-    "src/twkb-writer.ts"() {
-      init_version();
-      init_encode_twkb();
-      TWKBWriter = {
-        name: "TWKB (Tiny Well Known Binary)",
-        id: "twkb",
-        module: "wkt",
-        version: VERSION,
-        extensions: ["twkb"],
-        encodeSync: async (data, options) => encodeTWKB,
-        options: {
-          twkb: {}
-        }
-      };
+  var TWKBWriter = {
+    name: "TWKB (Tiny Well Known Binary)",
+    id: "twkb",
+    module: "wkt",
+    version: VERSION,
+    extensions: ["twkb"],
+    encodeSync: async (data, options) => encodeTWKB,
+    options: {
+      twkb: {}
     }
-  });
-
-  // src/index.ts
-  var src_exports = {};
-  __export(src_exports, {
-    HexWKBLoader: () => HexWKBLoader,
-    TWKBLoader: () => TWKBLoader,
-    TWKBWriter: () => TWKBWriter,
-    WKBLoader: () => WKBLoader,
-    WKBWorkerLoader: () => WKBWorkerLoader,
-    WKBWriter: () => WKBWriter,
-    WKTCRSLoader: () => WKTCRSLoader,
-    WKTCRSWriter: () => WKTCRSWriter,
-    WKTLoader: () => WKTLoader,
-    WKTWorkerLoader: () => WKTWorkerLoader,
-    WKTWriter: () => WKTWriter,
-    decodeHex: () => decodeHex,
-    encodeHex: () => encodeHex,
-    isTWKB: () => isTWKB,
-    isWKB: () => isWKB,
-    isWKT: () => isWKT,
-    parseWKBHeader: () => parseWKBHeader
-  });
-  var init_src2 = __esm({
-    "src/index.ts"() {
-      init_wkt_crs_loader();
-      init_wkt_crs_writer();
-      init_wkt_loader();
-      init_wkt_writer();
-      init_wkb_loader();
-      init_wkb_writer();
-      init_hex_wkb_loader();
-      init_twkb_loader();
-      init_twkb_writer();
-      init_parse_wkt();
-      init_parse_wkb_header();
-      init_parse_twkb();
-      init_hex_transcoder();
-    }
-  });
-
-  // src/bundle.ts
-  var require_bundle = __commonJS({
-    "src/bundle.ts"(exports, module) {
-      var moduleExports = (init_src2(), src_exports);
-      globalThis.loaders = globalThis.loaders || {};
-      module.exports = Object.assign(globalThis.loaders, moduleExports);
-    }
-  });
-  require_bundle();
+  };
+  return __toCommonJS(src_exports);
 })();
+      return __exports__;
+      });