@loaders.gl/wkt 4.3.1 → 4.4.0-alpha.1

package/dist/dist.dev.js

@@ -58,328 +58,579 @@ var __exports__ = (() => {
     WKTCRSWriter: () => WKTCRSWriter,
     WKTLoader: () => WKTLoader,
     WKTWorkerLoader: () => WKTWorkerLoader,
-    WKTWriter: () => WKTWriter,
-    decodeHex: () => decodeHex,
-    encodeHex: () => encodeHex,
-    isTWKB: () => isTWKB,
-    isWKB: () => isWKB,
-    isWKT: () => isWKT,
-    parseWKBHeader: () => parseWKBHeader
+    WKTWriter: () => WKTWriter
   });
   __reExport(bundle_exports, __toESM(require_core(), 1));
 
-  // 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) {
-      console.log("[wktcrs] parse starting with\n", wkt);
-    }
-    wkt = wkt.replace(/[A-Z][A-Z\d_]+\[/gi, (match) => `["${match.substr(0, match.length - 1)}",`);
-    wkt = wkt.replace(/, ?([A-Z][A-Z\d_]+[,\]])/gi, (match, p1) => {
-      const varname = p1.substr(0, p1.length - 1);
-      return `,"${options?.raw ? "raw:" : ""}${varname}"${p1[p1.length - 1]}`;
-    });
-    if (options?.raw) {
-      wkt = wkt.replace(/, {0,2}(-?[\.\d]+)(?=,|\])/g, function(match, p1) {
-        return `,"${options?.raw ? "raw:" : ""}${p1}"`;
-      });
-    }
-    if (options?.debug) {
-      console.log(`[wktcrs] json'd wkt: '${wkt}'`);
+  // ../gis/src/lib/geometry-converters/convert-binary-geometry-to-geojson.ts
+  function convertBinaryGeometryToGeometry(data, startIndex, endIndex) {
+    switch (data.type) {
+      case "Point":
+        return pointToGeoJson(data, startIndex, endIndex);
+      case "LineString":
+        return lineStringToGeoJson(data, startIndex, endIndex);
+      case "Polygon":
+        return polygonToGeoJson(data, startIndex, endIndex);
+      default:
+        const unexpectedInput = data;
+        throw new Error(`Unsupported geometry type: ${unexpectedInput?.type}`);
     }
-    let data;
-    try {
-      data = JSON.parse(wkt);
-    } catch (error) {
-      console.error(`[wktcrs] failed to parse '${wkt}'`);
-      throw error;
+  }
+  function polygonToGeoJson(data, startIndex = -Infinity, endIndex = Infinity) {
+    const { positions } = data;
+    const polygonIndices = data.polygonIndices.value.filter((x) => x >= startIndex && x <= endIndex);
+    const primitivePolygonIndices = data.primitivePolygonIndices.value.filter(
+      (x) => x >= startIndex && x <= endIndex
+    );
+    const multi = polygonIndices.length > 2;
+    if (!multi) {
+      const coordinates2 = [];
+      for (let i = 0; i < primitivePolygonIndices.length - 1; i++) {
+        const startRingIndex = primitivePolygonIndices[i];
+        const endRingIndex = primitivePolygonIndices[i + 1];
+        const ringCoordinates = ringToGeoJson(positions, startRingIndex, endRingIndex);
+        coordinates2.push(ringCoordinates);
+      }
+      return { type: "Polygon", coordinates: coordinates2 };
     }
-    if (options?.debug) {
-      console.log(`[wktcrs] json parsed: '${wkt}'`);
+    const coordinates = [];
+    for (let i = 0; i < polygonIndices.length - 1; i++) {
+      const startPolygonIndex = polygonIndices[i];
+      const endPolygonIndex = polygonIndices[i + 1];
+      const polygonCoordinates = polygonToGeoJson(
+        data,
+        startPolygonIndex,
+        endPolygonIndex
+      ).coordinates;
+      coordinates.push(polygonCoordinates);
     }
-    function process(data2, parent) {
-      const kw = data2[0];
-      data2.forEach(function(it) {
-        if (Array.isArray(it)) {
-          process(it, data2);
-        }
-      });
-      const kwarr = `MULTIPLE_${kw}`;
-      if (kwarr in parent) {
-        parent[kwarr].push(data2);
-      } else if (kw in parent) {
-        parent[kwarr] = [parent[kw], data2];
-        delete parent[kw];
-      } else {
-        parent[kw] = data2;
-      }
-      return parent;
+    return { type: "MultiPolygon", coordinates };
+  }
+  function lineStringToGeoJson(data, startIndex = -Infinity, endIndex = Infinity) {
+    const { positions } = data;
+    const pathIndices = data.pathIndices.value.filter((x) => x >= startIndex && x <= endIndex);
+    const multi = pathIndices.length > 2;
+    if (!multi) {
+      const coordinates2 = ringToGeoJson(positions, pathIndices[0], pathIndices[1]);
+      return { type: "LineString", coordinates: coordinates2 };
     }
-    const result = process(data, [data]);
-    if (options?.debug) {
-      console.log("[wktcrs] parse returning", result);
+    const coordinates = [];
+    for (let i = 0; i < pathIndices.length - 1; i++) {
+      const ringCoordinates = ringToGeoJson(positions, pathIndices[i], pathIndices[i + 1]);
+      coordinates.push(ringCoordinates);
     }
-    if (options?.sort) {
-      sort(result, options);
+    return { type: "MultiLineString", coordinates };
+  }
+  function pointToGeoJson(data, startIndex, endIndex) {
+    const { positions } = data;
+    const coordinates = ringToGeoJson(positions, startIndex, endIndex);
+    const multi = coordinates.length > 1;
+    if (multi) {
+      return { type: "MultiPoint", coordinates };
     }
-    return result;
+    return { type: "Point", coordinates: coordinates[0] };
   }
-  function sort(data, options) {
-    const keys = Object.keys(data).filter((k) => !/\d+/.test(k));
-    const keywords = options?.keywords || [];
-    if (!options?.keywords) {
-      const counts = {};
-      if (Array.isArray(data)) {
-        data.forEach((it) => {
-          if (Array.isArray(it) && it.length >= 2 && typeof it[1] === "string") {
-            const k = it[0];
-            if (!counts[k])
-              counts[k] = 0;
-            counts[k]++;
-          }
-        });
-        for (const k in counts) {
-          if (counts[k] > 0)
-            keywords.push(k);
-        }
+  function ringToGeoJson(positions, startIndex, endIndex) {
+    startIndex = startIndex || 0;
+    endIndex = endIndex || positions.value.length / positions.size;
+    const ringCoordinates = [];
+    for (let j = startIndex; j < endIndex; j++) {
+      const coord = Array();
+      for (let k = j * positions.size; k < (j + 1) * positions.size; k++) {
+        coord.push(Number(positions.value[k]));
       }
+      ringCoordinates.push(coord);
     }
-    keys.forEach((key) => {
-      data[key] = sort(data[key]);
-    });
-    keywords.forEach((key) => {
-      const indices = [];
-      const params = [];
-      data.forEach((item, i) => {
-        if (Array.isArray(item) && item[0] === key) {
-          indices.push(i);
-          params.push(item);
-        }
-      });
-      params.sort((a, b) => {
-        a = a[1].toString();
-        b = b[1].toString();
-        return a < b ? -1 : a > b ? 1 : 0;
-      });
-      params.forEach((param, i) => {
-        data[indices[i]] = param;
-      });
-    });
-    return data;
+    return ringCoordinates;
   }
 
-  // src/wkt-crs-loader.ts
-  var WKTCRSLoader = {
-    dataType: null,
-    batchType: null,
-    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) {
-    if (Array.isArray(wkt) && wkt.length === 1 && Array.isArray(wkt[0])) {
-      wkt = wkt[0];
+  // ../gis/src/lib/utils/concat-typed-arrays.ts
+  function concatTypedArrays(arrays) {
+    let byteLength = 0;
+    for (let i = 0; i < arrays.length; ++i) {
+      byteLength += arrays[i].byteLength;
     }
-    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}"`;
+    const buffer = new Uint8Array(byteLength);
+    let byteOffset = 0;
+    for (let i = 0; i < arrays.length; ++i) {
+      const data = new Uint8Array(arrays[i].buffer);
+      byteLength = data.length;
+      for (let j = 0; j < byteLength; ++j) {
+        buffer[byteOffset++] = data[j];
       }
-      throw new Error(`[wktcrs] unexpected attribute "${attr}"`);
-    }).join(",")}]`;
-    return str;
+    }
+    return buffer;
   }
 
-  // src/wkt-crs-writer.ts
-  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"],
-    // category: 'json',
-    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("
-    // We only support this "geojson" subset of the OGC simple features standard
-  ];
-  function isWKT(input) {
-    return WKT_MAGIC_STRINGS.some((magicString) => input.startsWith(magicString));
+  // ../gis/src/lib/binary-geometry-api/concat-binary-geometry.ts
+  function concatenateBinaryPointGeometries(binaryPointGeometries, dimension) {
+    const positions = binaryPointGeometries.map((geometry) => geometry.positions.value);
+    const concatenatedPositions = new Float64Array(concatTypedArrays(positions).buffer);
+    return {
+      type: "Point",
+      positions: { value: concatenatedPositions, size: dimension }
+    };
   }
-  function parseWKT(input, options) {
-    return parseWKTToGeometry(input, options);
+  function concatenateBinaryLineGeometries(binaryLineGeometries, dimension) {
+    const lines = binaryLineGeometries.map((geometry) => geometry.positions.value);
+    const concatenatedPositions = new Float64Array(concatTypedArrays(lines).buffer);
+    const pathIndices = lines.map((line) => line.length / dimension).map(cumulativeSum(0));
+    pathIndices.unshift(0);
+    return {
+      type: "LineString",
+      positions: { value: concatenatedPositions, size: dimension },
+      pathIndices: { value: new Uint32Array(pathIndices), size: 1 }
+    };
   }
-  function parseWKTToGeometry(input, options) {
-    const parts = input.split(";");
-    let _ = parts.pop();
-    const srid = (parts.shift() || "").split("=").pop();
-    const state = { parts, _, i: 0 };
-    const geometry = parseGeometry(state);
-    return options?.wkt?.crs ? addCRS(geometry, srid) : geometry;
+  function concatenateBinaryPolygonGeometries(binaryPolygonGeometries, dimension) {
+    const polygons = [];
+    const primitivePolygons = [];
+    for (const binaryPolygon of binaryPolygonGeometries) {
+      const { positions, primitivePolygonIndices: primitivePolygonIndices2 } = binaryPolygon;
+      polygons.push(positions.value);
+      primitivePolygons.push(primitivePolygonIndices2.value);
+    }
+    const concatenatedPositions = new Float64Array(concatTypedArrays(polygons).buffer);
+    const polygonIndices = polygons.map((p) => p.length / dimension).map(cumulativeSum(0));
+    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])
+      );
+    }
+    return {
+      type: "Polygon",
+      positions: { value: concatenatedPositions, size: dimension },
+      polygonIndices: { value: new Uint32Array(polygonIndices), size: 1 },
+      primitivePolygonIndices: { value: new Uint32Array(primitivePolygonIndices), size: 1 }
+    };
   }
-  function parseGeometry(state) {
-    return parsePoint(state) || parseLineString(state) || parsePolygon(state) || parseMultiPoint(state) || parseMultiLineString(state) || parseMultiPolygon(state) || parseGeometryCollection(state);
+  var cumulativeSum = (sum) => (value) => sum += value;
+
+  // ../gis/src/lib/geometry-converters/wkb/helpers/wkb-types.ts
+  var EWKB_FLAG_Z = 2147483648;
+  var EWKB_FLAG_M = 1073741824;
+  var EWKB_FLAG_SRID = 536870912;
+  var MAX_SRID = 1e4;
+  var WKT_MAGIC_STRINGS = [
+    "POINT(",
+    "LINESTRING(",
+    "POLYGON(",
+    "MULTIPOINT(",
+    "MULTILINESTRING(",
+    "MULTIPOLYGON(",
+    "GEOMETRYCOLLECTION("
+  ];
+  var textEncoder = new TextEncoder();
+  var WKT_MAGIC_BYTES = WKT_MAGIC_STRINGS.map((string) => textEncoder.encode(string));
+
+  // ../gis/src/lib/geometry-converters/wkb/helpers/parse-wkb-header.ts
+  function isWKT(input) {
+    return getWKTGeometryType(input) !== null;
   }
-  function addCRS(obj, srid) {
-    if (obj && srid?.match(/\d+/)) {
-      const crs = {
-        type: "name",
-        properties: {
-          name: "urn:ogc:def:crs:EPSG::" + srid
-        }
-      };
-      obj.crs = crs;
+  function getWKTGeometryType(input) {
+    if (typeof input === "string") {
+      const index2 = WKT_MAGIC_STRINGS.findIndex((magicString) => input.startsWith(magicString));
+      return index2 >= 0 ? index2 + 1 : null;
     }
-    return obj;
+    const inputArray = new Uint8Array(input);
+    const index = WKT_MAGIC_BYTES.findIndex(
+      (magicBytes) => magicBytes.every((value, index2) => value === inputArray[index2])
+    );
+    return index >= 0 ? index + 1 : null;
   }
-  function parsePoint(state) {
-    if (!$(/^(POINT(\sz)?)/i, state)) {
-      return null;
+  function isTWKB(arrayBuffer) {
+    const dataView = new DataView(arrayBuffer);
+    const byteOffset = 0;
+    const type = dataView.getUint8(byteOffset);
+    const geometryType = type & 15;
+    if (geometryType < 1 || geometryType > 7) {
+      return false;
     }
-    white(state);
-    if (!$(/^(\()/, state)) {
-      return null;
+    return true;
+  }
+  function isWKB(arrayBuffer) {
+    const dataView = new DataView(arrayBuffer);
+    let byteOffset = 0;
+    const endianness = dataView.getUint8(byteOffset);
+    byteOffset += 1;
+    if (endianness > 1) {
+      return false;
     }
-    const c = coords(state);
-    if (!c) {
-      return null;
+    const littleEndian = endianness === 1;
+    const geometry = dataView.getUint32(byteOffset, littleEndian);
+    byteOffset += 4;
+    const geometryType = geometry & 7;
+    if (geometryType === 0 || geometryType > 7) {
+      return false;
     }
-    white(state);
-    if (!$(/^(\))/, state)) {
-      return null;
+    const geometryFlags = geometry - geometryType;
+    if (geometryFlags === 0 || geometryFlags === 1e3 || geometryFlags === 2e3 || geometryFlags === 3e3) {
+      return true;
     }
-    return {
-      type: "Point",
-      coordinates: c[0]
-    };
-  }
-  function parseMultiPoint(state) {
-    if (!$(/^(MULTIPOINT)/i, state)) {
-      return null;
+    if ((geometryFlags & ~(EWKB_FLAG_Z | EWKB_FLAG_M | EWKB_FLAG_SRID)) !== 0) {
+      return false;
     }
-    white(state);
-    const newCoordsFormat = state._?.substring(state._?.indexOf("(") + 1, state._.length - 1).replace(/\(/g, "").replace(/\)/g, "");
-    state._ = "MULTIPOINT (" + newCoordsFormat + ")";
-    const c = multicoords(state);
-    if (!c) {
-      return null;
+    if (geometryFlags & EWKB_FLAG_SRID) {
+      const srid = dataView.getUint32(byteOffset, littleEndian);
+      byteOffset += 4;
+      if (srid > MAX_SRID) {
+        return false;
+      }
     }
-    white(state);
-    return {
-      type: "MultiPoint",
-      coordinates: c
-    };
+    return true;
   }
-  function parseLineString(state) {
-    if (!$(/^(LINESTRING(\sz)?)/i, state)) {
-      return null;
+  function parseWKBHeader(dataView, target) {
+    const wkbHeader = Object.assign(target || {}, {
+      type: "wkb",
+      variant: "wkb",
+      geometryType: 1,
+      dimensions: 2,
+      coordinates: "xy",
+      littleEndian: true,
+      byteOffset: 0
+    });
+    if (isWKT(dataView.buffer)) {
+      throw new Error("WKB: Cannot parse WKT data");
     }
-    white(state);
-    if (!$(/^(\()/, state)) {
-      return null;
+    wkbHeader.littleEndian = dataView.getUint8(wkbHeader.byteOffset) === 1;
+    wkbHeader.byteOffset++;
+    const geometryCode = dataView.getUint32(wkbHeader.byteOffset, wkbHeader.littleEndian);
+    wkbHeader.byteOffset += 4;
+    wkbHeader.geometryType = geometryCode & 7;
+    const isoType = (geometryCode - wkbHeader.geometryType) / 1e3;
+    switch (isoType) {
+      case 0:
+        break;
+      case 1:
+        wkbHeader.variant = "iso-wkb";
+        wkbHeader.dimensions = 3;
+        wkbHeader.coordinates = "xyz";
+        break;
+      case 2:
+        wkbHeader.variant = "iso-wkb";
+        wkbHeader.dimensions = 3;
+        wkbHeader.coordinates = "xym";
+        break;
+      case 3:
+        wkbHeader.variant = "iso-wkb";
+        wkbHeader.dimensions = 4;
+        wkbHeader.coordinates = "xyzm";
+        break;
+      default:
+        throw new Error(`WKB: Unsupported iso-wkb type: ${isoType}`);
     }
-    const c = coords(state);
-    if (!c) {
-      return null;
+    const ewkbZ = geometryCode & EWKB_FLAG_Z;
+    const ewkbM = geometryCode & EWKB_FLAG_M;
+    const ewkbSRID = geometryCode & EWKB_FLAG_SRID;
+    if (ewkbZ && ewkbM) {
+      wkbHeader.variant = "ewkb";
+      wkbHeader.dimensions = 4;
+      wkbHeader.coordinates = "xyzm";
+    } else if (ewkbZ) {
+      wkbHeader.variant = "ewkb";
+      wkbHeader.dimensions = 3;
+      wkbHeader.coordinates = "xyz";
+    } else if (ewkbM) {
+      wkbHeader.variant = "ewkb";
+      wkbHeader.dimensions = 3;
+      wkbHeader.coordinates = "xym";
     }
-    if (!$(/^(\))/, state)) {
-      return null;
+    if (ewkbSRID) {
+      wkbHeader.variant = "ewkb";
+      wkbHeader.srid = dataView.getUint32(wkbHeader.byteOffset, wkbHeader.littleEndian);
+      wkbHeader.byteOffset += 4;
     }
-    return {
-      type: "LineString",
-      coordinates: c
-    };
+    return wkbHeader;
   }
-  function parseMultiLineString(state) {
-    if (!$(/^(MULTILINESTRING)/i, state))
-      return null;
-    white(state);
-    const c = multicoords(state);
-    if (!c) {
-      return null;
+
+  // ../gis/src/lib/geometry-converters/wkb/convert-wkb-to-binary-geometry.ts
+  function convertWKBToBinaryGeometry(arrayBuffer) {
+    const dataView = new DataView(arrayBuffer);
+    const wkbHeader = parseWKBHeader(dataView);
+    const { geometryType, dimensions, littleEndian } = wkbHeader;
+    const offset = wkbHeader.byteOffset;
+    switch (geometryType) {
+      case 1 /* Point */:
+        const point = parsePoint(dataView, offset, dimensions, littleEndian);
+        return point.geometry;
+      case 2 /* LineString */:
+        const line = parseLineString(dataView, offset, dimensions, littleEndian);
+        return line.geometry;
+      case 3 /* Polygon */:
+        const polygon = parsePolygon(dataView, offset, dimensions, littleEndian);
+        return polygon.geometry;
+      case 4 /* MultiPoint */:
+        const multiPoint = parseMultiPoint(dataView, offset, dimensions, littleEndian);
+        multiPoint.type = "Point";
+        return multiPoint;
+      case 5 /* MultiLineString */:
+        const multiLine = parseMultiLineString(dataView, offset, dimensions, littleEndian);
+        multiLine.type = "LineString";
+        return multiLine;
+      case 6 /* MultiPolygon */:
+        const multiPolygon = parseMultiPolygon(dataView, offset, dimensions, littleEndian);
+        multiPolygon.type = "Polygon";
+        return multiPolygon;
+      default:
+        throw new Error(`WKB: Unsupported geometry type: ${geometryType}`);
     }
-    white(state);
-    return {
-      // @ts-ignore
-      type: "MultiLineString",
-      // @ts-expect-error
-      coordinates: c
-    };
   }
-  function parsePolygon(state) {
-    if (!$(/^(POLYGON(\sz)?)/i, state)) {
-      return null;
-    }
-    white(state);
-    const c = multicoords(state);
-    if (!c) {
-      return null;
+  function parsePoint(dataView, offset, dimension, littleEndian) {
+    const positions = new Float64Array(dimension);
+    for (let i = 0; i < dimension; i++) {
+      positions[i] = dataView.getFloat64(offset, littleEndian);
+      offset += 8;
     }
     return {
-      // @ts-ignore
-      type: "Polygon",
-      // @ts-expect-error
-      coordinates: c
+      geometry: { type: "Point", positions: { value: positions, size: dimension } },
+      offset
     };
   }
-  function parseMultiPolygon(state) {
-    if (!$(/^(MULTIPOLYGON)/i, state)) {
-      return null;
+  function parseLineString(dataView, offset, dimension, littleEndian) {
+    const nPoints = dataView.getUint32(offset, littleEndian);
+    offset += 4;
+    const positions = new Float64Array(nPoints * dimension);
+    for (let i = 0; i < nPoints * dimension; i++) {
+      positions[i] = dataView.getFloat64(offset, littleEndian);
+      offset += 8;
     }
-    white(state);
-    const c = multicoords(state);
-    if (!c) {
-      return null;
+    const pathIndices = [0];
+    if (nPoints > 0) {
+      pathIndices.push(nPoints);
     }
     return {
-      type: "MultiPolygon",
-      // @ts-expect-error
-      coordinates: c
-    };
-  }
-  function parseGeometryCollection(state) {
-    const geometries = [];
+      geometry: {
+        type: "LineString",
+        positions: { value: positions, size: dimension },
+        pathIndices: { value: new Uint32Array(pathIndices), size: 1 }
+      },
+      offset
+    };
+  }
+  var cumulativeSum2 = (sum) => (value) => sum += value;
+  function parsePolygon(dataView, offset, dimension, littleEndian) {
+    const nRings = dataView.getUint32(offset, littleEndian);
+    offset += 4;
+    const rings = [];
+    for (let i = 0; i < nRings; i++) {
+      const parsed = parseLineString(dataView, offset, dimension, littleEndian);
+      const { positions } = parsed.geometry;
+      offset = parsed.offset;
+      rings.push(positions.value);
+    }
+    const concatenatedPositions = new Float64Array(concatTypedArrays(rings).buffer);
+    const polygonIndices = [0];
+    if (concatenatedPositions.length > 0) {
+      polygonIndices.push(concatenatedPositions.length / dimension);
+    }
+    const primitivePolygonIndices = rings.map((l) => l.length / dimension).map(cumulativeSum2(0));
+    primitivePolygonIndices.unshift(0);
+    return {
+      geometry: {
+        type: "Polygon",
+        positions: { value: concatenatedPositions, size: dimension },
+        polygonIndices: {
+          value: new Uint32Array(polygonIndices),
+          size: 1
+        },
+        primitivePolygonIndices: { value: new Uint32Array(primitivePolygonIndices), size: 1 }
+      },
+      offset
+    };
+  }
+  function parseMultiPoint(dataView, offset, dimension, littleEndian) {
+    const nPoints = dataView.getUint32(offset, littleEndian);
+    offset += 4;
+    const binaryPointGeometries = [];
+    for (let i = 0; i < nPoints; i++) {
+      const littleEndianPoint = dataView.getUint8(offset) === 1;
+      offset++;
+      if (dataView.getUint32(offset, littleEndianPoint) % 1e3 !== 1) {
+        throw new Error("WKB: Inner geometries of MultiPoint not of type Point");
+      }
+      offset += 4;
+      const parsed = parsePoint(dataView, offset, dimension, littleEndianPoint);
+      offset = parsed.offset;
+      binaryPointGeometries.push(parsed.geometry);
+    }
+    return concatenateBinaryPointGeometries(binaryPointGeometries, dimension);
+  }
+  function parseMultiLineString(dataView, offset, dimension, littleEndian) {
+    const nLines = dataView.getUint32(offset, littleEndian);
+    offset += 4;
+    const binaryLineGeometries = [];
+    for (let i = 0; i < nLines; i++) {
+      const littleEndianLine = dataView.getUint8(offset) === 1;
+      offset++;
+      if (dataView.getUint32(offset, littleEndianLine) % 1e3 !== 2) {
+        throw new Error("WKB: Inner geometries of MultiLineString not of type LineString");
+      }
+      offset += 4;
+      const parsed = parseLineString(dataView, offset, dimension, littleEndianLine);
+      offset = parsed.offset;
+      binaryLineGeometries.push(parsed.geometry);
+    }
+    return concatenateBinaryLineGeometries(binaryLineGeometries, dimension);
+  }
+  function parseMultiPolygon(dataView, offset, dimension, littleEndian) {
+    const nPolygons = dataView.getUint32(offset, littleEndian);
+    offset += 4;
+    const binaryPolygonGeometries = [];
+    for (let i = 0; i < nPolygons; i++) {
+      const littleEndianPolygon = dataView.getUint8(offset) === 1;
+      offset++;
+      if (dataView.getUint32(offset, littleEndianPolygon) % 1e3 !== 3) {
+        throw new Error("WKB: Inner geometries of MultiPolygon not of type Polygon");
+      }
+      offset += 4;
+      const parsed = parsePolygon(dataView, offset, dimension, littleEndianPolygon);
+      offset = parsed.offset;
+      binaryPolygonGeometries.push(parsed.geometry);
+    }
+    return concatenateBinaryPolygonGeometries(binaryPolygonGeometries, dimension);
+  }
+
+  // ../gis/src/lib/geometry-converters/wkb/convert-wkb-to-geometry.ts
+  function convertWKBToGeometry(arrayBuffer) {
+    const binaryGeometry = convertWKBToBinaryGeometry(arrayBuffer);
+    return convertBinaryGeometryToGeometry(binaryGeometry);
+  }
+
+  // ../gis/src/lib/geometry-converters/wkb/convert-wkt-to-geometry.ts
+  var numberRegexp = /[-+]?([0-9]*\.[0-9]+|[0-9]+)([eE][-+]?[0-9]+)?/;
+  var tuples = new RegExp("^" + numberRegexp.source + "(\\s" + numberRegexp.source + "){1,}");
+  function convertWKTToGeometry(input, options) {
+    const parts = input.split(";");
+    let _ = parts.pop();
+    const srid = (parts.shift() || "").split("=").pop();
+    const state = { parts, _, i: 0 };
+    const geometry = parseGeometry(state);
+    return options?.wkt?.crs ? addCRS(geometry, srid) : geometry;
+  }
+  function parseGeometry(state) {
+    return parsePoint2(state) || parseLineString2(state) || parsePolygon2(state) || parseMultiPoint2(state) || parseMultiLineString2(state) || parseMultiPolygon2(state) || parseGeometryCollection(state);
+  }
+  function addCRS(obj, srid) {
+    if (obj && srid?.match(/\d+/)) {
+      const crs = {
+        type: "name",
+        properties: {
+          name: "urn:ogc:def:crs:EPSG::" + srid
+        }
+      };
+      obj.crs = crs;
+    }
+    return obj;
+  }
+  function parsePoint2(state) {
+    if (!$(/^(POINT(\sz)?)/i, state)) {
+      return null;
+    }
+    white(state);
+    if (!$(/^(\()/, state)) {
+      return null;
+    }
+    const c = coords(state);
+    if (!c) {
+      return null;
+    }
+    white(state);
+    if (!$(/^(\))/, state)) {
+      return null;
+    }
+    return {
+      type: "Point",
+      coordinates: c[0]
+    };
+  }
+  function parseMultiPoint2(state) {
+    if (!$(/^(MULTIPOINT)/i, state)) {
+      return null;
+    }
+    white(state);
+    const newCoordsFormat = state._?.substring(state._?.indexOf("(") + 1, state._.length - 1).replace(/\(/g, "").replace(/\)/g, "");
+    state._ = "MULTIPOINT (" + newCoordsFormat + ")";
+    const c = multicoords(state);
+    if (!c) {
+      return null;
+    }
+    white(state);
+    return {
+      type: "MultiPoint",
+      coordinates: c
+    };
+  }
+  function parseLineString2(state) {
+    if (!$(/^(LINESTRING(\sz)?)/i, state)) {
+      return null;
+    }
+    white(state);
+    if (!$(/^(\()/, state)) {
+      return null;
+    }
+    const c = coords(state);
+    if (!c) {
+      return null;
+    }
+    if (!$(/^(\))/, state)) {
+      return null;
+    }
+    return {
+      type: "LineString",
+      coordinates: c
+    };
+  }
+  function parseMultiLineString2(state) {
+    if (!$(/^(MULTILINESTRING)/i, state))
+      return null;
+    white(state);
+    const c = multicoords(state);
+    if (!c) {
+      return null;
+    }
+    white(state);
+    return {
+      // @ts-ignore
+      type: "MultiLineString",
+      // @ts-expect-error
+      coordinates: c
+    };
+  }
+  function parsePolygon2(state) {
+    if (!$(/^(POLYGON(\sz)?)/i, state)) {
+      return null;
+    }
+    white(state);
+    const c = multicoords(state);
+    if (!c) {
+      return null;
+    }
+    return {
+      // @ts-ignore
+      type: "Polygon",
+      // @ts-expect-error
+      coordinates: c
+    };
+  }
+  function parseMultiPolygon2(state) {
+    if (!$(/^(MULTIPOLYGON)/i, state)) {
+      return null;
+    }
+    white(state);
+    const c = multicoords(state);
+    if (!c) {
+      return null;
+    }
+    return {
+      type: "MultiPolygon",
+      // @ts-expect-error
+      coordinates: c
+    };
+  }
+  function parseGeometryCollection(state) {
+    const geometries = [];
     let geometry;
     if (!$(/^(GEOMETRYCOLLECTION)/i, state)) {
       return null;
@@ -472,520 +723,319 @@ var __exports__ = (() => {
     $(/^\s*/, state);
   }
 
-  // src/wkt-loader.ts
-  var WKTWorkerLoader = {
-    dataType: null,
-    batchType: null,
-    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: {
-        shape: "geojson-geometry",
-        crs: true
-      }
+  // ../gis/src/lib/utils/binary-reader.ts
+  var BinaryReader = class {
+    arrayBuffer;
+    dataView;
+    byteOffset;
+    littleEndian;
+    constructor(arrayBuffer, isBigEndian = false) {
+      this.arrayBuffer = arrayBuffer;
+      this.dataView = new DataView(arrayBuffer);
+      this.byteOffset = 0;
+      this.littleEndian = !isBigEndian;
     }
-  };
-  var WKTLoader = {
-    ...WKTWorkerLoader,
-    parse: async (arrayBuffer, options) => parseWKT(new TextDecoder().decode(arrayBuffer), options),
-    parseTextSync: (string, options) => parseWKT(string, options)
-  };
-
-  // src/lib/encode-wkt.ts
-  function encodeWKT(geometry) {
-    if (geometry.type === "Feature") {
-      geometry = geometry.geometry;
+    readUInt8() {
+      const value = this.dataView.getUint8(this.byteOffset);
+      this.byteOffset += 1;
+      return value;
     }
-    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");
+    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;
+    }
+  };
+
+  // ../gis/src/lib/geometry-converters/wkb/convert-twkb-to-geometry.ts
+  function convertTWKBToGeometry(arrayBuffer) {
+    const binaryReader = new BinaryReader(arrayBuffer);
+    const context = parseTWKBHeader(binaryReader);
+    if (context.hasSizeAttribute) {
+      binaryReader.readVarInt();
+    }
+    if (context.hasBoundingBox) {
+      let dimensions = 2;
+      if (context.hasZ) {
+        dimensions++;
+      }
+      if (context.hasM) {
+        dimensions++;
+      }
+      for (let i = 0; i < dimensions; i++) {
+        binaryReader.readVarInt();
+        binaryReader.readVarInt();
+      }
+    }
+    return parseGeometry2(binaryReader, context, context.geometryType);
   }
-  function pairWKT(c) {
-    return c.join(" ");
-  }
-  function ringWKT(r) {
-    return r.map(pairWKT).join(", ");
-  }
-  function ringsWKT(r) {
-    return r.map(ringWKT).map(wrapParens).join(", ");
-  }
-  function multiRingsWKT(r) {
-    return r.map(ringsWKT).map(wrapParens).join(", ");
+  function parseTWKBHeader(binaryReader) {
+    const type = binaryReader.readUInt8();
+    const metadataHeader = binaryReader.readUInt8();
+    const geometryType = type & 15;
+    const precision = zigZagDecode(type >> 4);
+    const hasExtendedPrecision = Boolean(metadataHeader >> 3 & 1);
+    let hasZ = false;
+    let hasM = false;
+    let zPrecision = 0;
+    let zPrecisionFactor = 1;
+    let mPrecision = 0;
+    let mPrecisionFactor = 1;
+    if (hasExtendedPrecision) {
+      const extendedPrecision = binaryReader.readUInt8();
+      hasZ = (extendedPrecision & 1) === 1;
+      hasM = (extendedPrecision & 2) === 2;
+      zPrecision = zigZagDecode((extendedPrecision & 28) >> 2);
+      zPrecisionFactor = Math.pow(10, zPrecision);
+      mPrecision = zigZagDecode((extendedPrecision & 224) >> 5);
+      mPrecisionFactor = Math.pow(10, mPrecision);
+    }
+    return {
+      geometryType,
+      precision,
+      precisionFactor: Math.pow(10, precision),
+      hasBoundingBox: Boolean(metadataHeader >> 0 & 1),
+      hasSizeAttribute: Boolean(metadataHeader >> 1 & 1),
+      hasIdList: Boolean(metadataHeader >> 2 & 1),
+      hasExtendedPrecision,
+      isEmpty: Boolean(metadataHeader >> 4 & 1),
+      hasZ,
+      hasM,
+      zPrecision,
+      zPrecisionFactor,
+      mPrecision,
+      mPrecisionFactor
+    };
   }
-  function wrapParens(s) {
-    return `(${s})`;
+  function parseGeometry2(binaryReader, context, geometryType) {
+    switch (geometryType) {
+      case 1 /* Point */:
+        return parsePoint3(binaryReader, context);
+      case 2 /* LineString */:
+        return parseLineString3(binaryReader, context);
+      case 3 /* Polygon */:
+        return parsePolygon3(binaryReader, context);
+      case 4 /* MultiPoint */:
+        return parseMultiPoint3(binaryReader, context);
+      case 5 /* MultiLineString */:
+        return parseMultiLineString3(binaryReader, context);
+      case 6 /* MultiPolygon */:
+        return parseMultiPolygon3(binaryReader, context);
+      case 7 /* GeometryCollection */:
+        return parseGeometryCollection2(binaryReader, context);
+      default:
+        throw new Error(`GeometryType ${geometryType} not supported`);
+    }
   }
-
-  // src/wkt-writer.ts
-  var WKTWriter = {
-    name: "WKT (Well Known Text)",
-    id: "wkt",
-    module: "wkt",
-    version: VERSION,
-    extensions: ["wkt"],
-    text: true,
-    encode: async (geometry) => encodeWKTSync(geometry),
-    encodeSync: encodeWKTSync,
-    encodeTextSync: encodeWKT,
-    options: {
-      wkt: {}
+  function parsePoint3(reader, context) {
+    if (context.isEmpty) {
+      return { type: "Point", coordinates: [] };
     }
-  };
-  function encodeWKTSync(geometry) {
-    return new TextEncoder().encode(encodeWKT(geometry)).buffer;
+    return { type: "Point", coordinates: readFirstPoint(reader, context) };
   }
-
-  // ../gis/src/lib/binary-features/binary-to-geojson.ts
-  function binaryToGeometry(data, startIndex, endIndex) {
-    switch (data.type) {
-      case "Point":
-        return pointToGeoJson(data, startIndex, endIndex);
-      case "LineString":
-        return lineStringToGeoJson(data, startIndex, endIndex);
-      case "Polygon":
-        return polygonToGeoJson(data, startIndex, endIndex);
-      default:
-        const unexpectedInput = data;
-        throw new Error(`Unsupported geometry type: ${unexpectedInput?.type}`);
+  function parseLineString3(reader, context) {
+    if (context.isEmpty) {
+      return { type: "LineString", coordinates: [] };
+    }
+    const pointCount = reader.readVarInt();
+    const previousPoint = makePreviousPoint(context);
+    const points = [];
+    for (let i = 0; i < pointCount; i++) {
+      points.push(parseNextPoint(reader, context, previousPoint));
     }
+    return { type: "LineString", coordinates: points };
   }
-  function polygonToGeoJson(data, startIndex = -Infinity, endIndex = Infinity) {
-    const { positions } = data;
-    const polygonIndices = data.polygonIndices.value.filter((x) => x >= startIndex && x <= endIndex);
-    const primitivePolygonIndices = data.primitivePolygonIndices.value.filter(
-      (x) => x >= startIndex && x <= endIndex
-    );
-    const multi = polygonIndices.length > 2;
-    if (!multi) {
-      const coordinates2 = [];
-      for (let i = 0; i < primitivePolygonIndices.length - 1; i++) {
-        const startRingIndex = primitivePolygonIndices[i];
-        const endRingIndex = primitivePolygonIndices[i + 1];
-        const ringCoordinates = ringToGeoJson(positions, startRingIndex, endRingIndex);
-        coordinates2.push(ringCoordinates);
+  function parsePolygon3(reader, context) {
+    if (context.isEmpty) {
+      return { type: "Polygon", coordinates: [] };
+    }
+    const ringCount = reader.readVarInt();
+    const previousPoint = makePreviousPoint(context);
+    const exteriorRingLength = reader.readVarInt();
+    const exteriorRing = [];
+    for (let i = 0; i < exteriorRingLength; i++) {
+      exteriorRing.push(parseNextPoint(reader, context, previousPoint));
+    }
+    const polygon = [exteriorRing];
+    for (let i = 1; i < ringCount; i++) {
+      const interiorRingCount = reader.readVarInt();
+      const interiorRing = [];
+      for (let j = 0; j < interiorRingCount; j++) {
+        interiorRing.push(parseNextPoint(reader, context, previousPoint));
       }
-      return { type: "Polygon", coordinates: coordinates2 };
+      polygon.push(interiorRing);
+    }
+    return { type: "Polygon", coordinates: polygon };
+  }
+  function parseMultiPoint3(reader, context) {
+    if (context.isEmpty) {
+      return { type: "MultiPoint", coordinates: [] };
     }
+    const previousPoint = makePreviousPoint(context);
+    const pointCount = reader.readVarInt();
     const coordinates = [];
-    for (let i = 0; i < polygonIndices.length - 1; i++) {
-      const startPolygonIndex = polygonIndices[i];
-      const endPolygonIndex = polygonIndices[i + 1];
-      const polygonCoordinates = polygonToGeoJson(
-        data,
-        startPolygonIndex,
-        endPolygonIndex
-      ).coordinates;
-      coordinates.push(polygonCoordinates);
+    for (let i = 0; i < pointCount; i++) {
+      coordinates.push(parseNextPoint(reader, context, previousPoint));
     }
-    return { type: "MultiPolygon", coordinates };
+    return { type: "MultiPoint", coordinates };
   }
-  function lineStringToGeoJson(data, startIndex = -Infinity, endIndex = Infinity) {
-    const { positions } = data;
-    const pathIndices = data.pathIndices.value.filter((x) => x >= startIndex && x <= endIndex);
-    const multi = pathIndices.length > 2;
-    if (!multi) {
-      const coordinates2 = ringToGeoJson(positions, pathIndices[0], pathIndices[1]);
-      return { type: "LineString", coordinates: coordinates2 };
+  function parseMultiLineString3(reader, context) {
+    if (context.isEmpty) {
+      return { type: "MultiLineString", coordinates: [] };
     }
+    const previousPoint = makePreviousPoint(context);
+    const lineStringCount = reader.readVarInt();
     const coordinates = [];
-    for (let i = 0; i < pathIndices.length - 1; i++) {
-      const ringCoordinates = ringToGeoJson(positions, pathIndices[i], pathIndices[i + 1]);
-      coordinates.push(ringCoordinates);
+    for (let i = 0; i < lineStringCount; i++) {
+      const pointCount = reader.readVarInt();
+      const lineString = [];
+      for (let j = 0; j < pointCount; j++) {
+        lineString.push(parseNextPoint(reader, context, previousPoint));
+      }
+      coordinates.push(lineString);
     }
     return { type: "MultiLineString", coordinates };
   }
-  function pointToGeoJson(data, startIndex, endIndex) {
-    const { positions } = data;
-    const coordinates = ringToGeoJson(positions, startIndex, endIndex);
-    const multi = coordinates.length > 1;
-    if (multi) {
-      return { type: "MultiPoint", coordinates };
+  function parseMultiPolygon3(reader, context) {
+    if (context.isEmpty) {
+      return { type: "MultiPolygon", coordinates: [] };
     }
-    return { type: "Point", coordinates: coordinates[0] };
-  }
-  function ringToGeoJson(positions, startIndex, endIndex) {
-    startIndex = startIndex || 0;
-    endIndex = endIndex || positions.value.length / positions.size;
-    const ringCoordinates = [];
-    for (let j = startIndex; j < endIndex; j++) {
-      const coord = Array();
-      for (let k = j * positions.size; k < (j + 1) * positions.size; k++) {
-        coord.push(Number(positions.value[k]));
+    const previousPoint = makePreviousPoint(context);
+    const polygonCount = reader.readVarInt();
+    const polygons = [];
+    for (let i = 0; i < polygonCount; i++) {
+      const ringCount = reader.readVarInt();
+      const exteriorPointCount = reader.readVarInt();
+      const exteriorRing = [];
+      for (let j = 0; j < exteriorPointCount; j++) {
+        exteriorRing.push(parseNextPoint(reader, context, previousPoint));
       }
-      ringCoordinates.push(coord);
-    }
-    return ringCoordinates;
-  }
-
-  // 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;
-  function isWKB(arrayBuffer) {
-    const dataView = new DataView(arrayBuffer);
-    let byteOffset = 0;
-    const endianness = dataView.getUint8(byteOffset);
-    byteOffset += 1;
-    if (endianness > 1) {
-      return false;
-    }
-    const littleEndian = endianness === 1;
-    const geometry = dataView.getUint32(byteOffset, littleEndian);
-    byteOffset += 4;
-    const geometryType = geometry & 7;
-    if (geometryType === 0 || geometryType > 7) {
-      return false;
-    }
-    const geometryFlags = geometry - geometryType;
-    if (geometryFlags === 0 || geometryFlags === 1e3 || geometryFlags === 2e3 || geometryFlags === 3e3) {
-      return true;
-    }
-    if ((geometryFlags & ~(EWKB_FLAG_Z | EWKB_FLAG_M | EWKB_FLAG_SRID)) !== 0) {
-      return false;
-    }
-    if (geometryFlags & EWKB_FLAG_SRID) {
-      const srid = dataView.getUint32(byteOffset, littleEndian);
-      byteOffset += 4;
-      if (srid > MAX_SRID) {
-        return false;
+      const polygon = exteriorRing ? [exteriorRing] : [];
+      for (let j = 1; j < ringCount; j++) {
+        const interiorRing = [];
+        const interiorRingLength = reader.readVarInt();
+        for (let k = 0; k < interiorRingLength; k++) {
+          interiorRing.push(parseNextPoint(reader, context, previousPoint));
+        }
+        polygon.push(interiorRing);
       }
+      polygons.push(polygon);
     }
-    return true;
+    return { type: "MultiPolygon", coordinates: polygons };
   }
-  function parseWKBHeader(dataView, target) {
-    const wkbHeader = Object.assign(target || {}, {
-      type: "wkb",
-      geometryType: 1,
-      dimensions: 2,
-      coordinates: "xy",
-      littleEndian: true,
-      byteOffset: 0
-    });
-    wkbHeader.littleEndian = dataView.getUint8(wkbHeader.byteOffset) === 1;
-    wkbHeader.byteOffset++;
-    const geometryCode = dataView.getUint32(wkbHeader.byteOffset, wkbHeader.littleEndian);
-    wkbHeader.byteOffset += 4;
-    wkbHeader.geometryType = geometryCode & 7;
-    const isoType = (geometryCode - wkbHeader.geometryType) / 1e3;
-    switch (isoType) {
-      case 0:
-        break;
-      case 1:
-        wkbHeader.type = "iso-wkb";
-        wkbHeader.dimensions = 3;
-        wkbHeader.coordinates = "xyz";
-        break;
-      case 2:
-        wkbHeader.type = "iso-wkb";
-        wkbHeader.dimensions = 3;
-        wkbHeader.coordinates = "xym";
-        break;
-      case 3:
-        wkbHeader.type = "iso-wkb";
-        wkbHeader.dimensions = 4;
-        wkbHeader.coordinates = "xyzm";
-        break;
-      default:
-        throw new Error(`WKB: Unsupported iso-wkb type: ${isoType}`);
-    }
-    const ewkbZ = geometryCode & EWKB_FLAG_Z;
-    const ewkbM = geometryCode & EWKB_FLAG_M;
-    const ewkbSRID = geometryCode & EWKB_FLAG_SRID;
-    if (ewkbZ && ewkbM) {
-      wkbHeader.type = "ewkb";
-      wkbHeader.dimensions = 4;
-      wkbHeader.coordinates = "xyzm";
-    } else if (ewkbZ) {
-      wkbHeader.type = "ewkb";
-      wkbHeader.dimensions = 3;
-      wkbHeader.coordinates = "xyz";
-    } else if (ewkbM) {
-      wkbHeader.type = "ewkb";
-      wkbHeader.dimensions = 3;
-      wkbHeader.coordinates = "xym";
+  function parseGeometryCollection2(reader, context) {
+    return { type: "GeometryCollection", geometries: [] };
+  }
+  function zigZagDecode(value) {
+    return value >> 1 ^ -(value & 1);
+  }
+  function makePointCoordinates(x, y, z, m) {
+    return z !== void 0 ? m !== void 0 ? [x, y, z, m] : [x, y, z] : [x, y];
+  }
+  function makePreviousPoint(context) {
+    return makePointCoordinates(0, 0, context.hasZ ? 0 : void 0, context.hasM ? 0 : void 0);
+  }
+  function readFirstPoint(reader, context) {
+    const x = zigZagDecode(reader.readVarInt()) / context.precisionFactor;
+    const y = zigZagDecode(reader.readVarInt()) / context.precisionFactor;
+    const z = context.hasZ ? zigZagDecode(reader.readVarInt()) / context.zPrecisionFactor : void 0;
+    const m = context.hasM ? zigZagDecode(reader.readVarInt()) / context.mPrecisionFactor : void 0;
+    return makePointCoordinates(x, y, z, m);
+  }
+  function parseNextPoint(reader, context, previousPoint) {
+    previousPoint[0] += zigZagDecode(reader.readVarInt()) / context.precisionFactor;
+    previousPoint[1] += zigZagDecode(reader.readVarInt()) / context.precisionFactor;
+    if (context.hasZ) {
+      previousPoint[2] += zigZagDecode(reader.readVarInt()) / context.zPrecisionFactor;
     }
-    if (ewkbSRID) {
-      wkbHeader.type = "ewkb";
-      wkbHeader.srid = dataView.getUint32(wkbHeader.byteOffset, wkbHeader.littleEndian);
-      wkbHeader.byteOffset += 4;
+    if (context.hasM) {
+      previousPoint[3] += zigZagDecode(reader.readVarInt()) / context.mPrecisionFactor;
     }
-    return wkbHeader;
+    return previousPoint.slice();
   }
 
-  // src/lib/parse-wkb.ts
-  function parseWKB(arrayBuffer, options) {
-    const binaryGeometry = parseWKBToBinary(arrayBuffer, options);
-    const shape = options?.wkb?.shape || "binary-geometry";
-    switch (shape) {
-      case "binary-geometry":
-        return binaryGeometry;
-      case "geojson-geometry":
-        return binaryToGeometry(binaryGeometry);
-      case "geometry":
-        console.error('WKBLoader: "geometry" shape is deprecated, use "binary-geometry" instead');
-        return binaryToGeometry(binaryGeometry);
+  // ../gis/src/lib/geometry-converters/wkb/convert-geometry-to-wkt.ts
+  function convertGeometryToWKT(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(convertGeometryToWKT).join(", "))}`;
       default:
-        throw new Error(shape);
+        throw new Error(
+          "convertGeometryToWKT requires a valid GeoJSON Geometry (not Feature) as input"
+        );
     }
   }
-  function parseWKBToBinary(arrayBuffer, options) {
-    const dataView = new DataView(arrayBuffer);
-    const wkbHeader = parseWKBHeader(dataView);
-    const { geometryType, dimensions, littleEndian } = wkbHeader;
-    const offset = wkbHeader.byteOffset;
-    switch (geometryType) {
-      case 1 /* Point */:
-        const point = parsePoint2(dataView, offset, dimensions, littleEndian);
-        return point.geometry;
-      case 2 /* LineString */:
-        const line = parseLineString2(dataView, offset, dimensions, littleEndian);
-        return line.geometry;
-      case 3 /* Polygon */:
-        const polygon = parsePolygon2(dataView, offset, dimensions, littleEndian);
-        return polygon.geometry;
-      case 4 /* MultiPoint */:
-        const multiPoint = parseMultiPoint2(dataView, offset, dimensions, littleEndian);
-        multiPoint.type = "Point";
-        return multiPoint;
-      case 5 /* MultiLineString */:
-        const multiLine = parseMultiLineString2(dataView, offset, dimensions, littleEndian);
-        multiLine.type = "LineString";
-        return multiLine;
-      case 6 /* MultiPolygon */:
-        const multiPolygon = parseMultiPolygon2(dataView, offset, dimensions, littleEndian);
-        multiPolygon.type = "Polygon";
-        return multiPolygon;
-      default:
-        throw new Error(`WKB: Unsupported geometry type: ${geometryType}`);
-    }
+  function pairWKT(c) {
+    return c.join(" ");
   }
-  function parsePoint2(dataView, offset, dimension, littleEndian) {
-    const positions = new Float64Array(dimension);
-    for (let i = 0; i < dimension; i++) {
-      positions[i] = dataView.getFloat64(offset, littleEndian);
-      offset += 8;
-    }
-    return {
-      geometry: { type: "Point", positions: { value: positions, size: dimension } },
-      offset
-    };
+  function ringWKT(r) {
+    return r.map(pairWKT).join(", ");
   }
-  function parseLineString2(dataView, offset, dimension, littleEndian) {
-    const nPoints = dataView.getUint32(offset, littleEndian);
-    offset += 4;
-    const positions = new Float64Array(nPoints * dimension);
-    for (let i = 0; i < nPoints * dimension; i++) {
-      positions[i] = dataView.getFloat64(offset, littleEndian);
-      offset += 8;
-    }
-    const pathIndices = [0];
-    if (nPoints > 0) {
-      pathIndices.push(nPoints);
-    }
-    return {
-      geometry: {
-        type: "LineString",
-        positions: { value: positions, size: dimension },
-        pathIndices: { value: new Uint32Array(pathIndices), size: 1 }
-      },
-      offset
-    };
+  function ringsWKT(r) {
+    return r.map(ringWKT).map(wrapParens).join(", ");
   }
-  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;
-      offset = parsed.offset;
-      rings.push(positions.value);
-    }
-    const concatenatedPositions = new Float64Array(concatTypedArrays(rings).buffer);
-    const polygonIndices = [0];
-    if (concatenatedPositions.length > 0) {
-      polygonIndices.push(concatenatedPositions.length / dimension);
-    }
-    const primitivePolygonIndices = rings.map((l) => l.length / dimension).map(cumulativeSum(0));
-    primitivePolygonIndices.unshift(0);
-    return {
-      geometry: {
-        type: "Polygon",
-        positions: { value: concatenatedPositions, size: dimension },
-        polygonIndices: {
-          value: new Uint32Array(polygonIndices),
-          size: 1
-        },
-        primitivePolygonIndices: { value: new Uint32Array(primitivePolygonIndices), size: 1 }
-      },
-      offset
-    };
+  function multiRingsWKT(r) {
+    return r.map(ringsWKT).map(wrapParens).join(", ");
   }
-  function parseMultiPoint2(dataView, offset, dimension, littleEndian) {
-    const nPoints = dataView.getUint32(offset, littleEndian);
-    offset += 4;
-    const binaryPointGeometries = [];
-    for (let i = 0; i < nPoints; i++) {
-      const littleEndianPoint = dataView.getUint8(offset) === 1;
-      offset++;
-      if (dataView.getUint32(offset, littleEndianPoint) % 1e3 !== 1) {
-        throw new Error("WKB: Inner geometries of MultiPoint not of type Point");
-      }
-      offset += 4;
-      const parsed = parsePoint2(dataView, offset, dimension, littleEndianPoint);
-      offset = parsed.offset;
-      binaryPointGeometries.push(parsed.geometry);
-    }
-    return concatenateBinaryPointGeometries(binaryPointGeometries, dimension);
-  }
-  function parseMultiLineString2(dataView, offset, dimension, littleEndian) {
-    const nLines = dataView.getUint32(offset, littleEndian);
-    offset += 4;
-    const binaryLineGeometries = [];
-    for (let i = 0; i < nLines; i++) {
-      const littleEndianLine = dataView.getUint8(offset) === 1;
-      offset++;
-      if (dataView.getUint32(offset, littleEndianLine) % 1e3 !== 2) {
-        throw new Error("WKB: Inner geometries of MultiLineString not of type LineString");
-      }
-      offset += 4;
-      const parsed = parseLineString2(dataView, offset, dimension, littleEndianLine);
-      offset = parsed.offset;
-      binaryLineGeometries.push(parsed.geometry);
-    }
-    return concatenateBinaryLineGeometries(binaryLineGeometries, dimension);
-  }
-  function parseMultiPolygon2(dataView, offset, dimension, littleEndian) {
-    const nPolygons = dataView.getUint32(offset, littleEndian);
-    offset += 4;
-    const binaryPolygonGeometries = [];
-    for (let i = 0; i < nPolygons; i++) {
-      const littleEndianPolygon = dataView.getUint8(offset) === 1;
-      offset++;
-      if (dataView.getUint32(offset, littleEndianPolygon) % 1e3 !== 3) {
-        throw new Error("WKB: Inner geometries of MultiPolygon not of type Polygon");
-      }
-      offset += 4;
-      const parsed = parsePolygon2(dataView, offset, dimension, littleEndianPolygon);
-      offset = parsed.offset;
-      binaryPolygonGeometries.push(parsed.geometry);
-    }
-    return concatenateBinaryPolygonGeometries(binaryPolygonGeometries, dimension);
-  }
-  function concatenateBinaryPointGeometries(binaryPointGeometries, dimension) {
-    const positions = binaryPointGeometries.map((geometry) => geometry.positions.value);
-    const concatenatedPositions = new Float64Array(concatTypedArrays(positions).buffer);
-    return {
-      type: "Point",
-      positions: { value: concatenatedPositions, size: dimension }
-    };
-  }
-  function concatenateBinaryLineGeometries(binaryLineGeometries, dimension) {
-    const lines = binaryLineGeometries.map((geometry) => geometry.positions.value);
-    const concatenatedPositions = new Float64Array(concatTypedArrays(lines).buffer);
-    const pathIndices = lines.map((line) => line.length / dimension).map(cumulativeSum(0));
-    pathIndices.unshift(0);
-    return {
-      type: "LineString",
-      positions: { value: concatenatedPositions, size: dimension },
-      pathIndices: { value: new Uint32Array(pathIndices), size: 1 }
-    };
-  }
-  function concatenateBinaryPolygonGeometries(binaryPolygonGeometries, dimension) {
-    const polygons = [];
-    const primitivePolygons = [];
-    for (const binaryPolygon of binaryPolygonGeometries) {
-      const { positions, primitivePolygonIndices: primitivePolygonIndices2 } = binaryPolygon;
-      polygons.push(positions.value);
-      primitivePolygons.push(primitivePolygonIndices2.value);
-    }
-    const concatenatedPositions = new Float64Array(concatTypedArrays(polygons).buffer);
-    const polygonIndices = polygons.map((p) => p.length / dimension).map(cumulativeSum(0));
-    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])
-      );
-    }
-    return {
-      type: "Polygon",
-      positions: { value: concatenatedPositions, size: dimension },
-      polygonIndices: { value: new Uint32Array(polygonIndices), size: 1 },
-      primitivePolygonIndices: { value: new Uint32Array(primitivePolygonIndices), size: 1 }
-    };
-  }
-  function concatTypedArrays(arrays) {
-    let byteLength = 0;
-    for (let i = 0; i < arrays.length; ++i) {
-      byteLength += arrays[i].byteLength;
-    }
-    const buffer = new Uint8Array(byteLength);
-    let byteOffset = 0;
-    for (let i = 0; i < arrays.length; ++i) {
-      const data = new Uint8Array(arrays[i].buffer);
-      byteLength = data.length;
-      for (let j = 0; j < byteLength; ++j) {
-        buffer[byteOffset++] = data[j];
-      }
-    }
-    return buffer;
+  function wrapParens(s) {
+    return `(${s})`;
   }
 
-  // src/wkb-loader.ts
-  var WKBWorkerLoader = {
-    dataType: null,
-    batchType: null,
-    name: "WKB",
-    id: "wkb",
-    module: "wkt",
-    version: VERSION,
-    worker: true,
-    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'
-      }
-    }
-  };
-  var WKBLoader = {
-    ...WKBWorkerLoader,
-    parse: async (arrayBuffer) => parseWKB(arrayBuffer),
-    parseSync: parseWKB
-  };
-
-  // src/lib/utils/binary-writer.ts
+  // ../gis/src/lib/utils/binary-writer.ts
   var LE = true;
   var BE = false;
   var BinaryWriter = class {
@@ -1080,6 +1130,12 @@ var __exports__ = (() => {
       this.writeUInt8(value & 127);
       return length;
     }
+    writeTypedArray(typedArray) {
+      this._ensureSize(typedArray.byteLength);
+      const tempArray = new Uint8Array(this.arrayBuffer);
+      tempArray.set(typedArray, this.byteOffset);
+      this.byteOffset += typedArray.byteLength;
+    }
     /** Append another ArrayBuffer to this ArrayBuffer */
     writeBuffer(arrayBuffer) {
       this._ensureSize(arrayBuffer.byteLength);
@@ -1102,8 +1158,8 @@ var __exports__ = (() => {
     }
   };
 
-  // src/lib/encode-wkb.ts
-  function encodeWKB(geometry, options = {}) {
+  // ../gis/src/lib/geometry-converters/wkb/convert-geometry-to-wkb.ts
+  function convertGeometryToWKB(geometry, options = {}) {
     if (geometry.type === "Feature") {
       geometry = geometry.geometry;
     }
@@ -1199,7 +1255,7 @@ var __exports__ = (() => {
     const writer = new BinaryWriter(getPolygonSize(coordinates, options));
     writer.writeInt8(1);
     writeWkbType(writer, 3 /* Polygon */, options);
-    const [exteriorRing, ...interiorRings] = coordinates;
+    const [exteriorRing = [], ...interiorRings] = coordinates;
     if (exteriorRing.length > 0) {
       writer.writeUInt32LE(1 + interiorRings.length);
       writer.writeUInt32LE(exteriorRing.length);
@@ -1219,7 +1275,7 @@ var __exports__ = (() => {
   }
   function getPolygonSize(coordinates, options) {
     const coordinateSize = getCoordinateSize(options);
-    const [exteriorRing, ...interiorRings] = coordinates;
+    const [exteriorRing = [], ...interiorRings] = coordinates;
     let size = 1 + 4 + 4;
     if (exteriorRing.length > 0) {
       size += 4 + exteriorRing.length * coordinateSize;
@@ -1293,7 +1349,7 @@ var __exports__ = (() => {
     writeWkbType(writer, 7 /* GeometryCollection */, options);
     writer.writeUInt32LE(collection.geometries.length);
     for (const geometry of collection.geometries) {
-      const arrayBuffer = encodeWKB(geometry, options);
+      const arrayBuffer = convertGeometryToWKB(geometry, options);
       writer.writeBuffer(arrayBuffer);
     }
     return writer.arrayBuffer;
@@ -1337,379 +1393,512 @@ var __exports__ = (() => {
     return coordinateSize;
   }
 
-  // src/wkb-writer.ts
-  var WKBWriter = {
-    name: "WKB (Well Known Binary)",
-    id: "wkb",
-    module: "wkt",
-    version: VERSION,
-    extensions: ["wkb"],
-    options: {
-      wkb: {
-        hasZ: false,
-        hasM: false
+  // ../gis/src/lib/geometry-converters/wkb/convert-geometry-to-twkb.ts
+  function convertGeometryToTWKB(geometry, options) {
+    const writer = new BinaryWriter(0, true);
+    const context = {
+      ...getTwkbPrecision(5, 0, 0),
+      hasZ: options?.hasZ,
+      hasM: options?.hasM
+    };
+    encodeGeometry(writer, geometry, context);
+    return writer.arrayBuffer;
+  }
+  function encodeGeometry(writer, geometry, context) {
+    switch (geometry.type) {
+      case "Point":
+        return encodePoint2(writer, context, geometry);
+      case "LineString":
+        return encodeLineString2(writer, context, geometry);
+      case "Polygon":
+        return encodePolygon2(writer, context, geometry);
+      case "MultiPoint":
+        return encodeMultiPoint2(writer, context, geometry);
+      case "MultiLineString":
+        return encodeMultiLineString2(writer, context, geometry);
+      case "MultiPolygon":
+        return encodeMultiPolygon2(writer, context, geometry);
+      case "GeometryCollection":
+        return encodeGeometryCollection2(writer, context, geometry);
+      default:
+        throw new Error("unsupported geometry type");
+    }
+  }
+  function encodePoint2(writer, context, point) {
+    const isEmpty = point.coordinates.length === 0 || point[0] === "undefined" || point[1] === "undefined";
+    writeTwkbHeader(writer, context, 1 /* Point */, isEmpty);
+    if (!isEmpty) {
+      const previousPoint = [0, 0, 0, 0];
+      writeTwkbPoint(writer, context, point.coordinates, previousPoint);
+    }
+  }
+  function encodeLineString2(writer, context, lineString) {
+    const points = lineString.coordinates;
+    const isEmpty = points.length === 0;
+    writeTwkbHeader(writer, context, 2 /* LineString */, isEmpty);
+    if (!isEmpty) {
+      writer.writeVarInt(points.length);
+      const previousPoint = [0, 0, 0, 0];
+      for (const point of points) {
+        writeTwkbPoint(writer, context, point, previousPoint);
       }
-    },
-    async encode(data, options) {
-      return encodeWKB(data, options?.wkb);
-    },
-    encodeSync(data, options) {
-      return encodeWKB(data, options?.wkb);
     }
-  };
-
-  // 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;
+    return writer.arrayBuffer;
+  }
+  function encodePolygon2(writer, context, polygon) {
+    const polygonRings = polygon.coordinates;
+    const isEmpty = polygonRings.length === 0;
+    writeTwkbHeader(writer, context, 3 /* Polygon */, isEmpty);
+    if (!isEmpty) {
+      writer.writeVarInt(polygonRings.length);
+      const previousPoint = [0, 0, 0, 0];
+      for (const ring of polygonRings) {
+        writer.writeVarInt(ring.length);
+        for (const point of ring) {
+          writeTwkbPoint(writer, context, previousPoint, point);
+        }
       }
     }
+    return writer.arrayBuffer;
   }
-  function encodeHex(array) {
-    const length = array.length;
-    let string = "";
-    let i = 0;
-    while (i < length) {
-      string += encodeLookup[array[i++]];
+  function encodeMultiPoint2(writer, context, multiPoint) {
+    const points = multiPoint.coordinates;
+    const isEmpty = points.length === 0;
+    writeTwkbHeader(writer, context, 4 /* MultiPoint */, isEmpty);
+    if (!isEmpty) {
+      writer.writeVarInt(points.length);
+      const previousPoint = [0, 0, 0, 0];
+      for (let i = 0; i < points.length; i++) {
+        writeTwkbPoint(writer, context, previousPoint, points[i]);
+      }
     }
-    return string;
   }
-  function decodeHex(string) {
-    const sizeof = string.length >> 1;
-    const length = sizeof << 1;
-    const array = new Uint8Array(sizeof);
-    let n = 0;
-    let i = 0;
-    while (i < length) {
-      array[n++] = decodeLookup[string.charCodeAt(i++)] << 4 | decodeLookup[string.charCodeAt(i++)];
+  function encodeMultiLineString2(writer, context, multiLineStrings) {
+    const lineStrings = multiLineStrings.coordinates;
+    const isEmpty = lineStrings.length === 0;
+    writeTwkbHeader(writer, context, 5 /* MultiLineString */, isEmpty);
+    if (!isEmpty) {
+      writer.writeVarInt(lineStrings.length);
+      const previousPoint = [0, 0, 0, 0];
+      for (const lineString of lineStrings) {
+        writer.writeVarInt(lineString.length);
+        for (const point of lineString) {
+          writeTwkbPoint(writer, context, previousPoint, point);
+        }
+      }
     }
-    return array;
+    return writer.arrayBuffer;
   }
-
-  // src/hex-wkb-loader.ts
-  var HexWKBLoader = {
-    dataType: null,
-    batchType: null,
-    name: "Hexadecimal WKB",
-    id: "wkb",
-    module: "wkt",
-    version: VERSION,
-    worker: true,
-    category: "geometry",
-    extensions: ["wkb"],
-    mimeTypes: [],
-    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
-  };
-  function parseHexWKB(text, options) {
-    const uint8Array = decodeHex(text);
-    const binaryGeometry = WKBLoader.parseSync?.(uint8Array.buffer, options);
-    return binaryGeometry;
-  }
-  function isHexWKB(string) {
-    if (!string) {
-      return false;
-    }
-    if (string.length < 10 || string.length % 2 !== 0) {
-      return false;
+  function encodeMultiPolygon2(writer, context, multiPolygon) {
+    const { coordinates } = multiPolygon;
+    const isEmpty = coordinates.length === 0;
+    writeTwkbHeader(writer, context, 6 /* MultiPolygon */, isEmpty);
+    if (!isEmpty) {
+      const polygons = coordinates;
+      writer.writeVarInt(polygons.length);
+      const previousPoint = [0, 0, 0, 0];
+      for (const polygonRings of polygons) {
+        writer.writeVarInt(polygonRings.length);
+        for (const ring of polygonRings) {
+          writer.writeVarInt(ring.length);
+          for (const point of ring) {
+            writeTwkbPoint(writer, context, previousPoint, point);
+          }
+        }
+      }
     }
-    if (!string.startsWith("00") && !string.startsWith("01")) {
-      return false;
+  }
+  function encodeGeometryCollection2(writer, context, geometryCollection) {
+    const { geometries } = geometryCollection;
+    const isEmpty = geometries.length === 0;
+    writeTwkbHeader(writer, context, 7 /* GeometryCollection */, isEmpty);
+    if (geometries.length > 0) {
+      writer.writeVarInt(geometries.length);
+      for (const geometry of geometries) {
+        encodeGeometry(writer, geometry, context);
+      }
     }
-    return /^[0-9a-fA-F]+$/.test(string.slice(2));
   }
-
-  // src/lib/utils/binary-reader.ts
-  var BinaryReader = class {
-    arrayBuffer;
-    dataView;
-    byteOffset;
-    littleEndian;
-    constructor(arrayBuffer, isBigEndian = false) {
-      this.arrayBuffer = arrayBuffer;
-      this.dataView = new DataView(arrayBuffer);
-      this.byteOffset = 0;
-      this.littleEndian = !isBigEndian;
+  function writeTwkbHeader(writer, context, geometryType, isEmpty) {
+    const type = (zigZagEncode(context.xy) << 4) + geometryType;
+    let metadataHeader = context.hasZ || context.hasM ? 1 << 3 : 0;
+    metadataHeader += isEmpty ? 1 << 4 : 0;
+    writer.writeUInt8(type);
+    writer.writeUInt8(metadataHeader);
+    if (context.hasZ || context.hasM) {
+      let extendedPrecision = 0;
+      if (context.hasZ) {
+        extendedPrecision |= 1;
+      }
+      if (context.hasM) {
+        extendedPrecision |= 2;
+      }
+      writer.writeUInt8(extendedPrecision);
     }
-    readUInt8() {
-      const value = this.dataView.getUint8(this.byteOffset);
-      this.byteOffset += 1;
-      return value;
+  }
+  function writeTwkbPoint(writer, context, point, previousPoint) {
+    const x = point[0] * context.xyFactor;
+    const y = point[1] * context.xyFactor;
+    const z = point[2] * context.zFactor;
+    const m = point[3] * context.mFactor;
+    writer.writeVarInt(zigZagEncode(x - previousPoint[0]));
+    writer.writeVarInt(zigZagEncode(y - previousPoint[1]));
+    if (context.hasZ) {
+      writer.writeVarInt(zigZagEncode(z - previousPoint[2]));
     }
-    readUInt16() {
-      const value = this.dataView.getUint16(this.byteOffset, this.littleEndian);
-      this.byteOffset += 2;
-      return value;
+    if (context.hasM) {
+      writer.writeVarInt(zigZagEncode(m - previousPoint[3]));
     }
-    readUInt32() {
-      const value = this.dataView.getUint32(this.byteOffset, this.littleEndian);
-      this.byteOffset += 4;
-      return value;
+    previousPoint[0] = x;
+    previousPoint[1] = y;
+    previousPoint[2] = z;
+    previousPoint[3] = m;
+  }
+  function zigZagEncode(value) {
+    return value << 1 ^ value >> 31;
+  }
+  function getTwkbPrecision(xyPrecision, zPrecision, mPrecision) {
+    return {
+      xy: xyPrecision,
+      z: zPrecision,
+      m: mPrecision,
+      xyFactor: Math.pow(10, xyPrecision),
+      zFactor: Math.pow(10, zPrecision),
+      mFactor: Math.pow(10, mPrecision)
+    };
+  }
+
+  // ../gis/src/lib/wkt-crs/parse-wkt-crs.ts
+  function parseWKTCRS(wkt, options) {
+    if (options?.debug) {
+      console.log("[wktcrs] parse starting with\n", wkt);
     }
-    readInt8() {
-      const value = this.dataView.getInt8(this.byteOffset);
-      this.byteOffset += 1;
-      return value;
+    wkt = wkt.replace(/[A-Z][A-Z\d_]+\[/gi, (match) => `["${match.substr(0, match.length - 1)}",`);
+    wkt = wkt.replace(/, ?([A-Z][A-Z\d_]+[,\]])/gi, (match, p1) => {
+      const varname = p1.substr(0, p1.length - 1);
+      return `,"${options?.raw ? "raw:" : ""}${varname}"${p1[p1.length - 1]}`;
+    });
+    if (options?.raw) {
+      wkt = wkt.replace(/, {0,2}(-?[\.\d]+)(?=,|\])/g, function(match, p1) {
+        return `,"${options?.raw ? "raw:" : ""}${p1}"`;
+      });
     }
-    readInt16() {
-      const value = this.dataView.getInt16(this.byteOffset, this.littleEndian);
-      this.byteOffset += 2;
-      return value;
+    if (options?.debug) {
+      console.log(`[wktcrs] json'd wkt: '${wkt}'`);
     }
-    readInt32() {
-      const value = this.dataView.getInt32(this.byteOffset, this.littleEndian);
-      this.byteOffset += 4;
-      return value;
+    let data;
+    try {
+      data = JSON.parse(wkt);
+    } catch (error) {
+      console.error(`[wktcrs] failed to parse '${wkt}'`);
+      throw error;
     }
-    readFloat() {
-      const value = this.dataView.getFloat32(this.byteOffset, this.littleEndian);
-      this.byteOffset += 4;
-      return value;
+    if (options?.debug) {
+      console.log(`[wktcrs] json parsed: '${wkt}'`);
     }
-    readDouble() {
-      const value = this.dataView.getFloat64(this.byteOffset, this.littleEndian);
-      this.byteOffset += 8;
-      return value;
+    function process(data2, parent) {
+      const kw = data2[0];
+      data2.forEach(function(it) {
+        if (Array.isArray(it)) {
+          process(it, data2);
+        }
+      });
+      const kwarr = `MULTIPLE_${kw}`;
+      if (kwarr in parent) {
+        parent[kwarr].push(data2);
+      } else if (kw in parent) {
+        parent[kwarr] = [parent[kw], data2];
+        delete parent[kw];
+      } else {
+        parent[kw] = data2;
+      }
+      return parent;
     }
-    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;
+    const result = process(data, [data]);
+    if (options?.debug) {
+      console.log("[wktcrs] parse returning", result);
     }
-  };
-
-  // src/lib/parse-twkb.ts
-  function isTWKB(arrayBuffer) {
-    const binaryReader = new BinaryReader(arrayBuffer);
-    const type = binaryReader.readUInt8();
-    const geometryType = type & 15;
-    if (geometryType < 1 || geometryType > 7) {
-      return false;
+    if (options?.sort) {
+      sort(result, options);
     }
-    return true;
+    return result;
   }
-  function parseTWKBGeometry(arrayBuffer) {
-    const binaryReader = new BinaryReader(arrayBuffer);
-    const context = parseTWKBHeader(binaryReader);
-    if (context.hasSizeAttribute) {
-      binaryReader.readVarInt();
-    }
-    if (context.hasBoundingBox) {
-      let dimensions = 2;
-      if (context.hasZ) {
-        dimensions++;
-      }
-      if (context.hasM) {
-        dimensions++;
-      }
-      for (let i = 0; i < dimensions; i++) {
-        binaryReader.readVarInt();
-        binaryReader.readVarInt();
+  function sort(data, options) {
+    const keys = Object.keys(data).filter((k) => !/\d+/.test(k));
+    const keywords = options?.keywords || [];
+    if (!options?.keywords) {
+      const counts = {};
+      if (Array.isArray(data)) {
+        data.forEach((it) => {
+          if (Array.isArray(it) && it.length >= 2 && typeof it[1] === "string") {
+            const k = it[0];
+            if (!counts[k])
+              counts[k] = 0;
+            counts[k]++;
+          }
+        });
+        for (const k in counts) {
+          if (counts[k] > 0)
+            keywords.push(k);
+        }
       }
     }
-    return parseGeometry2(binaryReader, context, context.geometryType);
-  }
-  function parseTWKBHeader(binaryReader) {
-    const type = binaryReader.readUInt8();
-    const metadataHeader = binaryReader.readUInt8();
-    const geometryType = type & 15;
-    const precision = zigZagDecode(type >> 4);
-    const hasExtendedPrecision = Boolean(metadataHeader >> 3 & 1);
-    let hasZ = false;
-    let hasM = false;
-    let zPrecision = 0;
-    let zPrecisionFactor = 1;
-    let mPrecision = 0;
-    let mPrecisionFactor = 1;
-    if (hasExtendedPrecision) {
-      const extendedPrecision = binaryReader.readUInt8();
-      hasZ = (extendedPrecision & 1) === 1;
-      hasM = (extendedPrecision & 2) === 2;
-      zPrecision = zigZagDecode((extendedPrecision & 28) >> 2);
-      zPrecisionFactor = Math.pow(10, zPrecision);
-      mPrecision = zigZagDecode((extendedPrecision & 224) >> 5);
-      mPrecisionFactor = Math.pow(10, mPrecision);
-    }
-    return {
-      geometryType,
-      precision,
-      precisionFactor: Math.pow(10, precision),
-      hasBoundingBox: Boolean(metadataHeader >> 0 & 1),
-      hasSizeAttribute: Boolean(metadataHeader >> 1 & 1),
-      hasIdList: Boolean(metadataHeader >> 2 & 1),
-      hasExtendedPrecision,
-      isEmpty: Boolean(metadataHeader >> 4 & 1),
-      hasZ,
-      hasM,
-      zPrecision,
-      zPrecisionFactor,
-      mPrecision,
-      mPrecisionFactor
-    };
+    keys.forEach((key) => {
+      data[key] = sort(data[key]);
+    });
+    keywords.forEach((key) => {
+      const indices = [];
+      const params = [];
+      data.forEach((item, i) => {
+        if (Array.isArray(item) && item[0] === key) {
+          indices.push(i);
+          params.push(item);
+        }
+      });
+      params.sort((a, b) => {
+        a = a[1].toString();
+        b = b[1].toString();
+        return a < b ? -1 : a > b ? 1 : 0;
+      });
+      params.forEach((param, i) => {
+        data[indices[i]] = param;
+      });
+    });
+    return data;
   }
-  function parseGeometry2(binaryReader, context, geometryType) {
-    switch (geometryType) {
-      case 1 /* Point */:
-        return parsePoint3(binaryReader, context);
-      case 2 /* LineString */:
-        return parseLineString3(binaryReader, context);
-      case 3 /* Polygon */:
-        return parsePolygon3(binaryReader, context);
-      case 4 /* MultiPoint */:
-        return parseMultiPoint3(binaryReader, context);
-      case 5 /* MultiLineString */:
-        return parseMultiLineString3(binaryReader, context);
-      case 6 /* MultiPolygon */:
-        return parseMultiPolygon3(binaryReader, context);
-      case 7 /* GeometryCollection */:
-        return parseGeometryCollection2(binaryReader, context);
-      default:
-        throw new Error(`GeometryType ${geometryType} not supported`);
+
+  // ../gis/src/lib/wkt-crs/encode-wkt-crs.ts
+  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}"`;
+      }
+      throw new Error(`[wktcrs] unexpected attribute "${attr}"`);
+    }).join(",")}]`;
+    return str;
   }
-  function parsePoint3(reader, context) {
-    if (context.isEmpty) {
-      return { type: "Point", coordinates: [] };
+
+  // ../gis/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;
+      }
     }
-    return { type: "Point", coordinates: readFirstPoint(reader, context) };
   }
-  function parseLineString3(reader, context) {
-    if (context.isEmpty) {
-      return { type: "LineString", coordinates: [] };
-    }
-    const pointCount = reader.readVarInt();
-    const previousPoint = makePreviousPoint(context);
-    const points = [];
-    for (let i = 0; i < pointCount; i++) {
-      points.push(parseNextPoint(reader, context, previousPoint));
+  function decodeHex(string) {
+    const sizeof = string.length >> 1;
+    const length = sizeof << 1;
+    const array = new Uint8Array(sizeof);
+    let n = 0;
+    let i = 0;
+    while (i < length) {
+      array[n++] = decodeLookup[string.charCodeAt(i++)] << 4 | decodeLookup[string.charCodeAt(i++)];
     }
-    return { type: "LineString", coordinates: points };
+    return array;
   }
-  function parsePolygon3(reader, context) {
-    if (context.isEmpty) {
-      return { type: "Polygon", coordinates: [] };
-    }
-    const ringCount = reader.readVarInt();
-    const previousPoint = makePreviousPoint(context);
-    const exteriorRingLength = reader.readVarInt();
-    const exteriorRing = [];
-    for (let i = 0; i < exteriorRingLength; i++) {
-      exteriorRing.push(parseNextPoint(reader, context, previousPoint));
-    }
-    const polygon = [exteriorRing];
-    for (let i = 1; i < ringCount; i++) {
-      const interiorRingCount = reader.readVarInt();
-      const interiorRing = [];
-      for (let j = 0; j < interiorRingCount; j++) {
-        interiorRing.push(parseNextPoint(reader, context, previousPoint));
+
+  // src/lib/version.ts
+  var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+
+  // src/wkt-crs-loader.ts
+  var WKTCRSLoader = {
+    dataType: null,
+    batchType: null,
+    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/wkt-crs-writer.ts
+  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"],
+    // category: 'json',
+    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/wkt-loader.ts
+  var WKTWorkerLoader = {
+    dataType: null,
+    batchType: null,
+    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: {
+        shape: "geojson-geometry",
+        crs: true
       }
-      polygon.push(interiorRing);
     }
-    return { type: "Polygon", coordinates: polygon };
-  }
-  function parseMultiPoint3(reader, context) {
-    if (context.isEmpty) {
-      return { type: "MultiPoint", coordinates: [] };
-    }
-    const previousPoint = makePreviousPoint(context);
-    const pointCount = reader.readVarInt();
-    const coordinates = [];
-    for (let i = 0; i < pointCount; i++) {
-      coordinates.push(parseNextPoint(reader, context, previousPoint));
+  };
+  var WKTLoader = {
+    ...WKTWorkerLoader,
+    parse: async (arrayBuffer, options) => convertWKTToGeometry(new TextDecoder().decode(arrayBuffer), options),
+    parseTextSync: (string, options) => convertWKTToGeometry(string, options)
+  };
+
+  // src/wkt-writer.ts
+  var WKTWriter = {
+    name: "WKT (Well Known Text)",
+    id: "wkt",
+    module: "wkt",
+    version: VERSION,
+    extensions: ["wkt"],
+    mimeTypes: ["application/wkt", "text/plain"],
+    text: true,
+    encode: async (geometry) => convertGeometryToWKTSync(geometry),
+    encodeSync: convertGeometryToWKTSync,
+    encodeTextSync: convertGeometryToWKT,
+    options: {
+      wkt: {}
     }
-    return { type: "MultiPoint", coordinates };
+  };
+  function convertGeometryToWKTSync(geometry) {
+    const wktString = convertGeometryToWKT(geometry);
+    const wktTypedArray = new TextEncoder().encode(wktString);
+    return wktTypedArray.buffer;
   }
-  function parseMultiLineString3(reader, context) {
-    if (context.isEmpty) {
-      return { type: "MultiLineString", coordinates: [] };
-    }
-    const previousPoint = makePreviousPoint(context);
-    const lineStringCount = reader.readVarInt();
-    const coordinates = [];
-    for (let i = 0; i < lineStringCount; i++) {
-      const pointCount = reader.readVarInt();
-      const lineString = [];
-      for (let j = 0; j < pointCount; j++) {
-        lineString.push(parseNextPoint(reader, context, previousPoint));
+
+  // src/wkb-loader.ts
+  var WKBWorkerLoader = {
+    dataType: null,
+    batchType: null,
+    name: "WKB",
+    id: "wkb",
+    module: "wkt",
+    version: VERSION,
+    worker: true,
+    category: "geometry",
+    extensions: ["wkb"],
+    mimeTypes: [],
+    // TODO can we define static, serializable tests, eg. some binary strings?
+    tests: [isWKB],
+    options: {
+      wkb: {
+        shape: "geojson-geometry"
       }
-      coordinates.push(lineString);
-    }
-    return { type: "MultiLineString", coordinates };
-  }
-  function parseMultiPolygon3(reader, context) {
-    if (context.isEmpty) {
-      return { type: "MultiPolygon", coordinates: [] };
     }
-    const previousPoint = makePreviousPoint(context);
-    const polygonCount = reader.readVarInt();
-    const polygons = [];
-    for (let i = 0; i < polygonCount; i++) {
-      const ringCount = reader.readVarInt();
-      const exteriorPointCount = reader.readVarInt();
-      const exteriorRing = [];
-      for (let j = 0; j < exteriorPointCount; j++) {
-        exteriorRing.push(parseNextPoint(reader, context, previousPoint));
-      }
-      const polygon = exteriorRing ? [exteriorRing] : [];
-      for (let j = 1; j < ringCount; j++) {
-        const interiorRing = [];
-        const interiorRingLength = reader.readVarInt();
-        for (let k = 0; k < interiorRingLength; k++) {
-          interiorRing.push(parseNextPoint(reader, context, previousPoint));
-        }
-        polygon.push(interiorRing);
-      }
-      polygons.push(polygon);
+  };
+  var WKBLoader = {
+    ...WKBWorkerLoader,
+    parse: async (arrayBuffer, options) => parseWKB(arrayBuffer, options?.wkb),
+    parseSync: (arrayBuffer, options) => parseWKB(arrayBuffer, options?.wkb)
+  };
+  function parseWKB(arrayBuffer, options) {
+    const shape = options?.shape || "geojson-geometry";
+    switch (shape) {
+      case "geojson-geometry":
+        return convertWKBToGeometry(arrayBuffer);
+      default:
+        throw new Error(shape);
     }
-    return { type: "MultiPolygon", coordinates: polygons };
-  }
-  function parseGeometryCollection2(reader, context) {
-    return { type: "GeometryCollection", geometries: [] };
-  }
-  function zigZagDecode(value) {
-    return value >> 1 ^ -(value & 1);
-  }
-  function makePointCoordinates(x, y, z, m) {
-    return z !== void 0 ? m !== void 0 ? [x, y, z, m] : [x, y, z] : [x, y];
-  }
-  function makePreviousPoint(context) {
-    return makePointCoordinates(0, 0, context.hasZ ? 0 : void 0, context.hasM ? 0 : void 0);
   }
-  function readFirstPoint(reader, context) {
-    const x = zigZagDecode(reader.readVarInt()) / context.precisionFactor;
-    const y = zigZagDecode(reader.readVarInt()) / context.precisionFactor;
-    const z = context.hasZ ? zigZagDecode(reader.readVarInt()) / context.zPrecisionFactor : void 0;
-    const m = context.hasM ? zigZagDecode(reader.readVarInt()) / context.mPrecisionFactor : void 0;
-    return makePointCoordinates(x, y, z, m);
+
+  // src/wkb-writer.ts
+  var WKBWriter = {
+    name: "WKB (Well Known Binary)",
+    id: "wkb",
+    module: "wkt",
+    version: VERSION,
+    extensions: ["wkb"],
+    mimeTypes: ["application/wkb", "application/octet-stream"],
+    options: {
+      wkb: {
+        hasZ: false,
+        hasM: false
+      }
+    },
+    async encode(data, options) {
+      return convertGeometryToWKB(data);
+    },
+    encodeSync(data, options) {
+      return convertGeometryToWKB(data);
+    }
+  };
+
+  // src/hex-wkb-loader.ts
+  var HexWKBLoader = {
+    dataType: null,
+    batchType: null,
+    name: "Hexadecimal WKB",
+    id: "wkb",
+    module: "wkt",
+    version: VERSION,
+    worker: true,
+    category: "geometry",
+    extensions: ["wkb"],
+    mimeTypes: [],
+    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
+  };
+  function parseHexWKB(text, options) {
+    const uint8Array = decodeHex(text);
+    const binaryGeometry = convertWKBToGeometry(uint8Array.buffer);
+    return binaryGeometry;
   }
-  function parseNextPoint(reader, context, previousPoint) {
-    previousPoint[0] += zigZagDecode(reader.readVarInt()) / context.precisionFactor;
-    previousPoint[1] += zigZagDecode(reader.readVarInt()) / context.precisionFactor;
-    if (context.hasZ) {
-      previousPoint[2] += zigZagDecode(reader.readVarInt()) / context.zPrecisionFactor;
+  function isHexWKB(string) {
+    if (!string) {
+      return false;
     }
-    if (context.hasM) {
-      previousPoint[3] += zigZagDecode(reader.readVarInt()) / context.mPrecisionFactor;
+    if (string.length < 10 || string.length % 2 !== 0) {
+      return false;
     }
-    return previousPoint.slice();
+    if (!string.startsWith("00") && !string.startsWith("01")) {
+      return false;
+    }
+    return /^[0-9a-fA-F]+$/.test(string.slice(2));
   }
 
   // src/twkb-loader.ts
@@ -1735,185 +1924,10 @@ var __exports__ = (() => {
   };
   var TWKBLoader = {
     ...TWKBWorkerLoader,
-    parse: async (arrayBuffer) => parseTWKBGeometry(arrayBuffer),
-    parseSync: parseTWKBGeometry
+    parse: async (arrayBuffer) => convertTWKBToGeometry(arrayBuffer),
+    parseSync: convertTWKBToGeometry
   };
 
-  // src/lib/encode-twkb.ts
-  function encodeTWKB(geometry, options) {
-    const writer = new BinaryWriter(0, true);
-    const context = {
-      ...getTwkbPrecision(5, 0, 0),
-      hasZ: options?.hasZ,
-      hasM: options?.hasM
-    };
-    encodeGeometry(writer, geometry, context);
-    return writer.arrayBuffer;
-  }
-  function encodeGeometry(writer, geometry, context) {
-    switch (geometry.type) {
-      case "Point":
-        return encodePoint2(writer, context, geometry);
-      case "LineString":
-        return encodeLineString2(writer, context, geometry);
-      case "Polygon":
-        return encodePolygon2(writer, context, geometry);
-      case "MultiPoint":
-        return encodeMultiPoint2(writer, context, geometry);
-      case "MultiLineString":
-        return encodeMultiLineString2(writer, context, geometry);
-      case "MultiPolygon":
-        return encodeMultiPolygon2(writer, context, geometry);
-      case "GeometryCollection":
-        return encodeGeometryCollection2(writer, context, geometry);
-      default:
-        throw new Error("unsupported geometry type");
-    }
-  }
-  function encodePoint2(writer, context, point) {
-    const isEmpty = point.coordinates.length === 0 || point[0] === "undefined" || point[1] === "undefined";
-    writeTwkbHeader(writer, context, 1 /* Point */, isEmpty);
-    if (!isEmpty) {
-      const previousPoint = [0, 0, 0, 0];
-      writeTwkbPoint(writer, context, point.coordinates, previousPoint);
-    }
-  }
-  function encodeLineString2(writer, context, lineString) {
-    const points = lineString.coordinates;
-    const isEmpty = points.length === 0;
-    writeTwkbHeader(writer, context, 2 /* LineString */, isEmpty);
-    if (!isEmpty) {
-      writer.writeVarInt(points.length);
-      const previousPoint = [0, 0, 0, 0];
-      for (const point of points) {
-        writeTwkbPoint(writer, context, point, previousPoint);
-      }
-    }
-    return writer.arrayBuffer;
-  }
-  function encodePolygon2(writer, context, polygon) {
-    const polygonRings = polygon.coordinates;
-    const isEmpty = polygonRings.length === 0;
-    writeTwkbHeader(writer, context, 3 /* Polygon */, isEmpty);
-    if (!isEmpty) {
-      writer.writeVarInt(polygonRings.length);
-      const previousPoint = [0, 0, 0, 0];
-      for (const ring of polygonRings) {
-        writer.writeVarInt(ring.length);
-        for (const point of ring) {
-          writeTwkbPoint(writer, context, previousPoint, point);
-        }
-      }
-    }
-    return writer.arrayBuffer;
-  }
-  function encodeMultiPoint2(writer, context, multiPoint) {
-    const points = multiPoint.coordinates;
-    const isEmpty = points.length === 0;
-    writeTwkbHeader(writer, context, 4 /* MultiPoint */, isEmpty);
-    if (!isEmpty) {
-      writer.writeVarInt(points.length);
-      const previousPoint = [0, 0, 0, 0];
-      for (let i = 0; i < points.length; i++) {
-        writeTwkbPoint(writer, context, previousPoint, points[i]);
-      }
-    }
-  }
-  function encodeMultiLineString2(writer, context, multiLineStrings) {
-    const lineStrings = multiLineStrings.coordinates;
-    const isEmpty = lineStrings.length === 0;
-    writeTwkbHeader(writer, context, 5 /* MultiLineString */, isEmpty);
-    if (!isEmpty) {
-      writer.writeVarInt(lineStrings.length);
-      const previousPoint = [0, 0, 0, 0];
-      for (const lineString of lineStrings) {
-        writer.writeVarInt(lineString.length);
-        for (const point of lineString) {
-          writeTwkbPoint(writer, context, previousPoint, point);
-        }
-      }
-    }
-    return writer.arrayBuffer;
-  }
-  function encodeMultiPolygon2(writer, context, multiPolygon) {
-    const { coordinates } = multiPolygon;
-    const isEmpty = coordinates.length === 0;
-    writeTwkbHeader(writer, context, 6 /* MultiPolygon */, isEmpty);
-    if (!isEmpty) {
-      const polygons = coordinates;
-      writer.writeVarInt(polygons.length);
-      const previousPoint = [0, 0, 0, 0];
-      for (const polygonRings of polygons) {
-        writer.writeVarInt(polygonRings.length);
-        for (const ring of polygonRings) {
-          writer.writeVarInt(ring.length);
-          for (const point of ring) {
-            writeTwkbPoint(writer, context, previousPoint, point);
-          }
-        }
-      }
-    }
-  }
-  function encodeGeometryCollection2(writer, context, geometryCollection) {
-    const { geometries } = geometryCollection;
-    const isEmpty = geometries.length === 0;
-    writeTwkbHeader(writer, context, 7 /* GeometryCollection */, isEmpty);
-    if (geometries.length > 0) {
-      writer.writeVarInt(geometries.length);
-      for (const geometry of geometries) {
-        encodeGeometry(writer, geometry, context);
-      }
-    }
-  }
-  function writeTwkbHeader(writer, context, geometryType, isEmpty) {
-    const type = (zigZagEncode(context.xy) << 4) + geometryType;
-    let metadataHeader = context.hasZ || context.hasM ? 1 << 3 : 0;
-    metadataHeader += isEmpty ? 1 << 4 : 0;
-    writer.writeUInt8(type);
-    writer.writeUInt8(metadataHeader);
-    if (context.hasZ || context.hasM) {
-      let extendedPrecision = 0;
-      if (context.hasZ) {
-        extendedPrecision |= 1;
-      }
-      if (context.hasM) {
-        extendedPrecision |= 2;
-      }
-      writer.writeUInt8(extendedPrecision);
-    }
-  }
-  function writeTwkbPoint(writer, context, point, previousPoint) {
-    const x = point[0] * context.xyFactor;
-    const y = point[1] * context.xyFactor;
-    const z = point[2] * context.zFactor;
-    const m = point[3] * context.mFactor;
-    writer.writeVarInt(zigZagEncode(x - previousPoint[0]));
-    writer.writeVarInt(zigZagEncode(y - previousPoint[1]));
-    if (context.hasZ) {
-      writer.writeVarInt(zigZagEncode(z - previousPoint[2]));
-    }
-    if (context.hasM) {
-      writer.writeVarInt(zigZagEncode(m - previousPoint[3]));
-    }
-    previousPoint[0] = x;
-    previousPoint[1] = y;
-    previousPoint[2] = z;
-    previousPoint[3] = m;
-  }
-  function zigZagEncode(value) {
-    return value << 1 ^ value >> 31;
-  }
-  function getTwkbPrecision(xyPrecision, zPrecision, mPrecision) {
-    return {
-      xy: xyPrecision,
-      z: zPrecision,
-      m: mPrecision,
-      xyFactor: Math.pow(10, xyPrecision),
-      zFactor: Math.pow(10, zPrecision),
-      mFactor: Math.pow(10, mPrecision)
-    };
-  }
-
   // src/twkb-writer.ts
   var TWKBWriter = {
     name: "TWKB (Tiny Well Known Binary)",
@@ -1921,8 +1935,9 @@ var __exports__ = (() => {
     module: "wkt",
     version: VERSION,
     extensions: ["twkb"],
-    encode: async (geometry, options) => encodeTWKB(geometry, options?.twkb),
-    encodeSync: (geometry, options) => encodeTWKB(geometry, options?.twkb),
+    mimeTypes: ["application/text"],
+    encode: async (geometry, options) => convertGeometryToTWKB(geometry, options?.twkb),
+    encodeSync: (geometry, options) => convertGeometryToTWKB(geometry, options?.twkb),
     options: {
       twkb: {
         hasZ: false,