@loaders.gl/wkt 4.0.0-alpha.24 → 4.0.0-alpha.25

package/dist/dist.min.js

@@ -21,47 +21,767 @@
     }
   });
 
+  // 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}'`);
+    }
+    let data;
+    try {
+      data = JSON.parse(wkt);
+    } catch (error) {
+      console.error(`[wktcrs] failed to parse '${wkt}'`);
+      throw error;
+    }
+    if (options?.debug) {
+      console.log(`[wktcrs] json parsed: '${wkt}'`);
+    }
+    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;
+    }
+    const result = process(data, [data]);
+    if (options?.debug) {
+      console.log("[wktcrs] parse returning", result);
+    }
+    if (options?.sort) {
+      sort(result, options);
+    }
+    return result;
+  }
+  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);
+        }
+      }
+    }
+    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;
+  }
+  var init_parse_wkt_crs = __esm({
+    "src/lib/parse-wkt-crs.ts"() {
+    }
+  });
+
+  // src/wkt-crs-loader.ts
+  var WKTCRSLoader;
+  var init_wkt_crs_loader = __esm({
+    "src/wkt-crs-loader.ts"() {
+      init_version();
+      init_parse_wkt_crs();
+      WKTCRSLoader = {
+        name: "WKT CRS (Well-Known Text Coordinate Reference System)",
+        id: "wkt-crs",
+        module: "wkt-crs",
+        version: VERSION,
+        worker: true,
+        extensions: [],
+        mimeTypes: ["text/plain"],
+        category: "json",
+        text: true,
+        options: {
+          "wkt-crs": {}
+        },
+        parse: async (arrayBuffer, options) => parseWKTCRS(new TextDecoder().decode(arrayBuffer), options?.["wkt-crs"]),
+        parseTextSync: (string, options) => parseWKTCRS(string, options?.["wkt-crs"])
+      };
+    }
+  });
+
+  // src/lib/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;
+  }
+  var init_encode_wkt_crs = __esm({
+    "src/lib/encode-wkt-crs.ts"() {
+    }
+  });
+
+  // src/wkt-crs-writer.ts
+  var WKTCRSWriter;
+  var init_wkt_crs_writer = __esm({
+    "src/wkt-crs-writer.ts"() {
+      init_version();
+      init_encode_wkt_crs();
+      WKTCRSWriter = {
+        name: "WKT CRS (Well-Known Text Coordinate Reference System)",
+        id: "wkt-crs",
+        module: "wkt-crs",
+        version: VERSION,
+        worker: true,
+        extensions: [],
+        mimeTypes: ["text/plain"],
+        text: true,
+        options: {
+          "wkt-crs": {}
+        },
+        encode: async (wktcrs, options) => new TextEncoder().encode(encodeWKTCRS(wktcrs, options?.["wkt-crs"])),
+        encodeSync: (wktcrs, options) => new TextEncoder().encode(encodeWKTCRS(wktcrs, options?.["wkt-crs"])),
+        encodeTextSync: (wktcrs, options) => encodeWKTCRS(wktcrs, options?.["wkt-crs"])
+      };
+    }
+  });
+
+  // src/lib/parse-wkt.ts
+  function isWKT(input) {
+    return WKT_MAGIC_STRINGS.some((magicString) => input.startsWith(magicString));
+  }
+  function parseWKT(input, options) {
+    return parseWKTToGeometry(input, options);
+  }
+  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 parseGeometry(state) {
+    return parsePoint(state) || parseLineString(state) || parsePolygon(state) || parseMultiPoint(state) || parseMultiLineString(state) || parseMultiPolygon(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 parsePoint(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 parseMultiPoint(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 parseLineString(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 parseMultiLineString(state) {
+    if (!$(/^(MULTILINESTRING)/i, state))
+      return null;
+    white(state);
+    const c = multicoords(state);
+    if (!c) {
+      return null;
+    }
+    white(state);
+    return {
+      type: "MultiLineString",
+      coordinates: c
+    };
+  }
+  function parsePolygon(state) {
+    if (!$(/^(POLYGON(\sz)?)/i, state)) {
+      return null;
+    }
+    white(state);
+    const c = multicoords(state);
+    if (!c) {
+      return null;
+    }
+    return {
+      type: "Polygon",
+      coordinates: c
+    };
+  }
+  function parseMultiPolygon(state) {
+    if (!$(/^(MULTIPOLYGON)/i, state)) {
+      return null;
+    }
+    white(state);
+    const c = multicoords(state);
+    if (!c) {
+      return null;
+    }
+    return {
+      type: "MultiPolygon",
+      coordinates: c
+    };
+  }
+  function parseGeometryCollection(state) {
+    const geometries = [];
+    let geometry;
+    if (!$(/^(GEOMETRYCOLLECTION)/i, state)) {
+      return null;
+    }
+    white(state);
+    if (!$(/^(\()/, state)) {
+      return null;
+    }
+    while (geometry = parseGeometry(state)) {
+      geometries.push(geometry);
+      white(state);
+      $(/^(,)/, state);
+      white(state);
+    }
+    if (!$(/^(\))/, state)) {
+      return null;
+    }
+    return {
+      type: "GeometryCollection",
+      geometries
+    };
+  }
+  function multicoords(state) {
+    white(state);
+    let depth = 0;
+    const rings = [];
+    const stack = [rings];
+    let pointer = rings;
+    let elem;
+    while (elem = $(/^(\()/, state) || $(/^(\))/, state) || $(/^(,)/, state) || $(tuples, state)) {
+      if (elem === "(") {
+        stack.push(pointer);
+        pointer = [];
+        stack[stack.length - 1].push(pointer);
+        depth++;
+      } else if (elem === ")") {
+        if (pointer.length === 0)
+          return null;
+        pointer = stack.pop();
+        if (!pointer)
+          return null;
+        depth--;
+        if (depth === 0)
+          break;
+      } else if (elem === ",") {
+        pointer = [];
+        stack[stack.length - 1].push(pointer);
+      } else if (!elem.split(/\s/g).some(isNaN)) {
+        Array.prototype.push.apply(pointer, elem.split(/\s/g).map(parseFloat));
+      } else {
+        return null;
+      }
+      white(state);
+    }
+    if (depth !== 0)
+      return null;
+    return rings;
+  }
+  function coords(state) {
+    const list = [];
+    let item;
+    let pt;
+    while (pt = $(tuples, state) || $(/^(,)/, state)) {
+      if (pt === ",") {
+        list.push(item);
+        item = [];
+      } else if (!pt.split(/\s/g).some(isNaN)) {
+        if (!item)
+          item = [];
+        Array.prototype.push.apply(item, pt.split(/\s/g).map(parseFloat));
+      }
+      white(state);
+    }
+    if (item)
+      list.push(item);
+    else
+      return null;
+    return list.length ? list : null;
+  }
+  function $(regexp, state) {
+    const match = state._?.substring(state.i).match(regexp);
+    if (!match)
+      return null;
+    else {
+      state.i += match[0].length;
+      return match[0];
+    }
+  }
+  function white(state) {
+    $(/^\s*/, state);
+  }
+  var numberRegexp, tuples, WKT_MAGIC_STRINGS;
+  var init_parse_wkt = __esm({
+    "src/lib/parse-wkt.ts"() {
+      numberRegexp = /[-+]?([0-9]*\.[0-9]+|[0-9]+)([eE][-+]?[0-9]+)?/;
+      tuples = new RegExp("^" + numberRegexp.source + "(\\s" + numberRegexp.source + "){1,}");
+      WKT_MAGIC_STRINGS = [
+        "POINT(",
+        "LINESTRING(",
+        "POLYGON(",
+        "MULTIPOINT(",
+        "MULTILINESTRING(",
+        "MULTIPOLYGON(",
+        "GEOMETRYCOLLECTION("
+      ];
+    }
+  });
+
+  // src/wkt-loader.ts
+  var WKTWorkerLoader, WKTLoader;
+  var init_wkt_loader = __esm({
+    "src/wkt-loader.ts"() {
+      init_version();
+      init_parse_wkt();
+      init_parse_wkt();
+      WKTWorkerLoader = {
+        name: "WKT (Well-Known Text)",
+        id: "wkt",
+        module: "wkt",
+        version: VERSION,
+        worker: true,
+        extensions: ["wkt"],
+        mimeTypes: ["text/plain"],
+        category: "geometry",
+        text: true,
+        tests: WKT_MAGIC_STRINGS,
+        testText: isWKT,
+        options: {
+          wkt: {
+            crs: true
+          }
+        }
+      };
+      WKTLoader = {
+        ...WKTWorkerLoader,
+        parse: async (arrayBuffer, options) => parseWKT(new TextDecoder().decode(arrayBuffer), options),
+        parseTextSync: parseWKT
+      };
+    }
+  });
+
+  // src/lib/encode-wkt.ts
+  function encodeWKT(geometry) {
+    if (geometry.type === "Feature") {
+      geometry = geometry.geometry;
+    }
+    switch (geometry.type) {
+      case "Point":
+        return `POINT ${wrapParens(pairWKT(geometry.coordinates))}`;
+      case "LineString":
+        return `LINESTRING ${wrapParens(ringWKT(geometry.coordinates))}`;
+      case "Polygon":
+        return `POLYGON ${wrapParens(ringsWKT(geometry.coordinates))}`;
+      case "MultiPoint":
+        return `MULTIPOINT ${wrapParens(ringWKT(geometry.coordinates))}`;
+      case "MultiPolygon":
+        return `MULTIPOLYGON ${wrapParens(multiRingsWKT(geometry.coordinates))}`;
+      case "MultiLineString":
+        return `MULTILINESTRING ${wrapParens(ringsWKT(geometry.coordinates))}`;
+      case "GeometryCollection":
+        return `GEOMETRYCOLLECTION ${wrapParens(geometry.geometries.map(encodeWKT).join(", "))}`;
+      default:
+        throw new Error("stringify requires a valid GeoJSON Feature or geometry object as input");
+    }
+  }
+  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 wrapParens(s) {
+    return `(${s})`;
+  }
+  var init_encode_wkt = __esm({
+    "src/lib/encode-wkt.ts"() {
+    }
+  });
+
+  // src/wkt-writer.ts
+  var WKTWriter;
+  var init_wkt_writer = __esm({
+    "src/wkt-writer.ts"() {
+      init_version();
+      init_encode_wkt();
+      WKTWriter = {
+        name: "WKT (Well Known Text)",
+        id: "wkt",
+        module: "wkt",
+        version: VERSION,
+        extensions: ["wkt"],
+        encodeSync: encodeWKT,
+        options: {
+          wkt: {}
+        }
+      };
+    }
+  });
+
+  // ../gis/src/lib/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 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 };
+    }
+    const coordinates = [];
+    for (let i = 0; i < polygonIndices.length - 1; i++) {
+      const startPolygonIndex = polygonIndices[i];
+      const endPolygonIndex = polygonIndices[i + 1];
+      const polygonCoordinates = polygonToGeoJson(data, startPolygonIndex, endPolygonIndex).coordinates;
+      coordinates.push(polygonCoordinates);
+    }
+    return { type: "MultiPolygon", coordinates };
+  }
+  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 coordinates = [];
+    for (let i = 0; i < pathIndices.length - 1; i++) {
+      const ringCoordinates = ringToGeoJson(positions, pathIndices[i], pathIndices[i + 1]);
+      coordinates.push(ringCoordinates);
+    }
+    return { type: "MultiLineString", coordinates };
+  }
+  function pointToGeoJson(data, startIndex, endIndex) {
+    const { positions } = data;
+    const coordinates = ringToGeoJson(positions, startIndex, endIndex);
+    const multi = coordinates.length > 1;
+    if (multi) {
+      return { type: "MultiPoint", coordinates };
+    }
+    return { type: "Point", coordinates: coordinates[0] };
+  }
+  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);
+    }
+    return ringCoordinates;
+  }
+  var init_binary_to_geojson = __esm({
+    "../gis/src/lib/binary-to-geojson.ts"() {
+    }
+  });
+
+  // ../gis/src/index.ts
+  var init_src = __esm({
+    "../gis/src/index.ts"() {
+      init_binary_to_geojson();
+    }
+  });
+
+  // src/lib/parse-wkb-header.ts
+  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;
+      }
+    }
+    return true;
+  }
+  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";
+    }
+    if (ewkbSRID) {
+      wkbHeader.type = "ewkb";
+      wkbHeader.srid = dataView.getUint32(wkbHeader.byteOffset, wkbHeader.littleEndian);
+      wkbHeader.byteOffset += 4;
+    }
+    return wkbHeader;
+  }
+  var EWKB_FLAG_Z, EWKB_FLAG_M, EWKB_FLAG_SRID, MAX_SRID, WKBGeometryType;
+  var init_parse_wkb_header = __esm({
+    "src/lib/parse-wkb-header.ts"() {
+      EWKB_FLAG_Z = 2147483648;
+      EWKB_FLAG_M = 1073741824;
+      EWKB_FLAG_SRID = 536870912;
+      MAX_SRID = 1e4;
+      (function(WKBGeometryType2) {
+        WKBGeometryType2[WKBGeometryType2["Point"] = 1] = "Point";
+        WKBGeometryType2[WKBGeometryType2["LineString"] = 2] = "LineString";
+        WKBGeometryType2[WKBGeometryType2["Polygon"] = 3] = "Polygon";
+        WKBGeometryType2[WKBGeometryType2["MultiPoint"] = 4] = "MultiPoint";
+        WKBGeometryType2[WKBGeometryType2["MultiLineString"] = 5] = "MultiLineString";
+        WKBGeometryType2[WKBGeometryType2["MultiPolygon"] = 6] = "MultiPolygon";
+        WKBGeometryType2[WKBGeometryType2["GeometryCollection"] = 7] = "GeometryCollection";
+      })(WKBGeometryType || (WKBGeometryType = {}));
+    }
+  });
+
   // src/lib/parse-wkb.ts
-  function parseWKB(arrayBuffer) {
-    const view = new DataView(arrayBuffer);
-    let offset = 0;
-    const littleEndian = view.getUint8(offset) === 1;
-    offset++;
-    const geometryCode = view.getUint32(offset, littleEndian);
-    offset += 4;
-    const geometryType = geometryCode % 1e3;
-    const type = (geometryCode - geometryType) / 1e3;
-    const dimension = NUM_DIMENSIONS[type];
+  function parseWKB(arrayBuffer, options) {
+    const binaryGeometry = parseWKBToBinary(arrayBuffer, options);
+    const shape = options?.wkb?.shape || "binary-geometry";
+    switch (shape) {
+      case "binary-geometry":
+        return binaryGeometry;
+      case "geometry":
+        return binaryToGeometry(binaryGeometry);
+      default:
+        throw new Error(shape);
+    }
+  }
+  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:
-        const point = parsePoint(view, offset, dimension, littleEndian);
+      case WKBGeometryType.Point:
+        const point = parsePoint2(dataView, offset, dimensions, littleEndian);
         return point.geometry;
-      case 2:
-        const line = parseLineString(view, offset, dimension, littleEndian);
+      case WKBGeometryType.LineString:
+        const line = parseLineString2(dataView, offset, dimensions, littleEndian);
         return line.geometry;
-      case 3:
-        const polygon = parsePolygon(view, offset, dimension, littleEndian);
+      case WKBGeometryType.Polygon:
+        const polygon = parsePolygon2(dataView, offset, dimensions, littleEndian);
         return polygon.geometry;
-      case 4:
-        const multiPoint = parseMultiPoint(view, offset, dimension, littleEndian);
+      case WKBGeometryType.MultiPoint:
+        const multiPoint = parseMultiPoint2(dataView, offset, dimensions, littleEndian);
         multiPoint.type = "Point";
         return multiPoint;
-      case 5:
-        const multiLine = parseMultiLineString(view, offset, dimension, littleEndian);
+      case WKBGeometryType.MultiLineString:
+        const multiLine = parseMultiLineString2(dataView, offset, dimensions, littleEndian);
         multiLine.type = "LineString";
         return multiLine;
-      case 6:
-        const multiPolygon = parseMultiPolygon(view, offset, dimension, littleEndian);
+      case WKBGeometryType.MultiPolygon:
+        const multiPolygon = parseMultiPolygon2(dataView, offset, dimensions, littleEndian);
         multiPolygon.type = "Polygon";
         return multiPolygon;
       default:
         throw new Error(`WKB: Unsupported geometry type: ${geometryType}`);
     }
   }
-  function parsePoint(view, offset, dimension, littleEndian) {
+  function parsePoint2(dataView, offset, dimension, littleEndian) {
     const positions = new Float64Array(dimension);
     for (let i = 0; i < dimension; i++) {
-      positions[i] = view.getFloat64(offset, littleEndian);
+      positions[i] = dataView.getFloat64(offset, littleEndian);
       offset += 8;
     }
     return {
@@ -69,12 +789,12 @@
       offset
     };
   }
-  function parseLineString(view, offset, dimension, littleEndian) {
-    const nPoints = view.getUint32(offset, littleEndian);
+  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] = view.getFloat64(offset, littleEndian);
+      positions[i] = dataView.getFloat64(offset, littleEndian);
       offset += 8;
     }
     const pathIndices = [0];
@@ -90,12 +810,12 @@
       offset
     };
   }
-  function parsePolygon(view, offset, dimension, littleEndian) {
-    const nRings = view.getUint32(offset, littleEndian);
+  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 = parseLineString(view, offset, dimension, littleEndian);
+      const parsed = parseLineString2(dataView, offset, dimension, littleEndian);
       const { positions } = parsed.geometry;
       offset = parsed.offset;
       rings.push(positions.value);
@@ -120,52 +840,52 @@
       offset
     };
   }
-  function parseMultiPoint(view, offset, dimension, littleEndian) {
-    const nPoints = view.getUint32(offset, littleEndian);
+  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 = view.getUint8(offset) === 1;
+      const littleEndianPoint = dataView.getUint8(offset) === 1;
       offset++;
-      if (view.getUint32(offset, littleEndianPoint) % 1e3 !== 1) {
+      if (dataView.getUint32(offset, littleEndianPoint) % 1e3 !== 1) {
         throw new Error("WKB: Inner geometries of MultiPoint not of type Point");
       }
       offset += 4;
-      const parsed = parsePoint(view, offset, dimension, littleEndianPoint);
+      const parsed = parsePoint2(dataView, offset, dimension, littleEndianPoint);
       offset = parsed.offset;
       binaryPointGeometries.push(parsed.geometry);
     }
     return concatenateBinaryPointGeometries(binaryPointGeometries, dimension);
   }
-  function parseMultiLineString(view, offset, dimension, littleEndian) {
-    const nLines = view.getUint32(offset, littleEndian);
+  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 = view.getUint8(offset) === 1;
+      const littleEndianLine = dataView.getUint8(offset) === 1;
       offset++;
-      if (view.getUint32(offset, littleEndianLine) % 1e3 !== 2) {
+      if (dataView.getUint32(offset, littleEndianLine) % 1e3 !== 2) {
         throw new Error("WKB: Inner geometries of MultiLineString not of type LineString");
       }
       offset += 4;
-      const parsed = parseLineString(view, offset, dimension, littleEndianLine);
+      const parsed = parseLineString2(dataView, offset, dimension, littleEndianLine);
       offset = parsed.offset;
       binaryLineGeometries.push(parsed.geometry);
     }
     return concatenateBinaryLineGeometries(binaryLineGeometries, dimension);
   }
-  function parseMultiPolygon(view, offset, dimension, littleEndian) {
-    const nPolygons = view.getUint32(offset, littleEndian);
+  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 = view.getUint8(offset) === 1;
+      const littleEndianPolygon = dataView.getUint8(offset) === 1;
       offset++;
-      if (view.getUint32(offset, littleEndianPolygon) % 1e3 !== 3) {
+      if (dataView.getUint32(offset, littleEndianPolygon) % 1e3 !== 3) {
         throw new Error("WKB: Inner geometries of MultiPolygon not of type Polygon");
       }
       offset += 4;
-      const parsed = parsePolygon(view, offset, dimension, littleEndianPolygon);
+      const parsed = parsePolygon2(dataView, offset, dimension, littleEndianPolygon);
       offset = parsed.offset;
       binaryPolygonGeometries.push(parsed.geometry);
     }
@@ -194,374 +914,77 @@
     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 Uint16Array(polygonIndices), size: 1 },
-      primitivePolygonIndices: { value: new Uint16Array(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;
-  }
-  var NUM_DIMENSIONS, cumulativeSum;
-  var init_parse_wkb = __esm({
-    "src/lib/parse-wkb.ts"() {
-      NUM_DIMENSIONS = {
-        0: 2,
-        1: 3,
-        2: 3,
-        3: 4
-      };
-      cumulativeSum = (sum) => (value) => sum += value;
-    }
-  });
-
-  // src/wkb-loader.ts
-  var WKBWorkerLoader, WKBLoader;
-  var init_wkb_loader = __esm({
-    "src/wkb-loader.ts"() {
-      init_version();
-      init_parse_wkb();
-      WKBWorkerLoader = {
-        name: "WKB",
-        id: "wkb",
-        module: "wkt",
-        version: VERSION,
-        worker: true,
-        category: "geometry",
-        extensions: ["wkb"],
-        mimeTypes: [],
-        options: {
-          wkb: {}
-        }
-      };
-      WKBLoader = {
-        ...WKBWorkerLoader,
-        parse: async (arrayBuffer) => parseWKB(arrayBuffer),
-        parseSync: parseWKB
-      };
-    }
-  });
-
-  // src/lib/parse-wkt.ts
-  function parseWKT(input) {
-    const parts = input.split(";");
-    let _ = parts.pop();
-    const srid = (parts.shift() || "").split("=").pop();
-    let i = 0;
-    function $(re) {
-      const match = _.substring(i).match(re);
-      if (!match)
-        return null;
-      else {
-        i += match[0].length;
-        return match[0];
-      }
-    }
-    function crs(obj) {
-      if (obj && srid.match(/\d+/)) {
-        obj.crs = {
-          type: "name",
-          properties: {
-            name: "urn:ogc:def:crs:EPSG::" + srid
-          }
-        };
-      }
-      return obj;
-    }
-    function white() {
-      $(/^\s*/);
-    }
-    function multicoords() {
-      white();
-      let depth = 0;
-      const rings = [];
-      const stack = [rings];
-      let pointer = rings;
-      let elem;
-      while (elem = $(/^(\()/) || $(/^(\))/) || $(/^(,)/) || $(tuples)) {
-        if (elem === "(") {
-          stack.push(pointer);
-          pointer = [];
-          stack[stack.length - 1].push(pointer);
-          depth++;
-        } else if (elem === ")") {
-          if (pointer.length === 0)
-            return null;
-          pointer = stack.pop();
-          if (!pointer)
-            return null;
-          depth--;
-          if (depth === 0)
-            break;
-        } else if (elem === ",") {
-          pointer = [];
-          stack[stack.length - 1].push(pointer);
-        } else if (!elem.split(/\s/g).some(isNaN)) {
-          Array.prototype.push.apply(pointer, elem.split(/\s/g).map(parseFloat));
-        } else {
-          return null;
-        }
-        white();
-      }
-      if (depth !== 0)
-        return null;
-      return rings;
-    }
-    function coords() {
-      const list = [];
-      let item;
-      let pt;
-      while (pt = $(tuples) || $(/^(,)/)) {
-        if (pt === ",") {
-          list.push(item);
-          item = [];
-        } else if (!pt.split(/\s/g).some(isNaN)) {
-          if (!item)
-            item = [];
-          Array.prototype.push.apply(item, pt.split(/\s/g).map(parseFloat));
-        }
-        white();
-      }
-      if (item)
-        list.push(item);
-      else
-        return null;
-      return list.length ? list : null;
-    }
-    function point() {
-      if (!$(/^(point(\sz)?)/i))
-        return null;
-      white();
-      if (!$(/^(\()/))
-        return null;
-      const c = coords();
-      if (!c)
-        return null;
-      white();
-      if (!$(/^(\))/))
-        return null;
-      return {
-        type: "Point",
-        coordinates: c[0]
-      };
-    }
-    function multipoint() {
-      if (!$(/^(multipoint)/i))
-        return null;
-      white();
-      const newCoordsFormat = _.substring(_.indexOf("(") + 1, _.length - 1).replace(/\(/g, "").replace(/\)/g, "");
-      _ = "MULTIPOINT (" + newCoordsFormat + ")";
-      const c = multicoords();
-      if (!c)
-        return null;
-      white();
-      return {
-        type: "MultiPoint",
-        coordinates: c
-      };
-    }
-    function multilinestring() {
-      if (!$(/^(multilinestring)/i))
-        return null;
-      white();
-      const c = multicoords();
-      if (!c)
-        return null;
-      white();
-      return {
-        type: "MultiLineString",
-        coordinates: c
-      };
-    }
-    function linestring() {
-      if (!$(/^(linestring(\sz)?)/i))
-        return null;
-      white();
-      if (!$(/^(\()/))
-        return null;
-      const c = coords();
-      if (!c)
-        return null;
-      if (!$(/^(\))/))
-        return null;
-      return {
-        type: "LineString",
-        coordinates: c
-      };
-    }
-    function polygon() {
-      if (!$(/^(polygon(\sz)?)/i))
-        return null;
-      white();
-      const c = multicoords();
-      if (!c)
-        return null;
-      return {
-        type: "Polygon",
-        coordinates: c
-      };
-    }
-    function multipolygon() {
-      if (!$(/^(multipolygon)/i))
-        return null;
-      white();
-      const c = multicoords();
-      if (!c)
-        return null;
-      return {
-        type: "MultiPolygon",
-        coordinates: c
-      };
-    }
-    function geometrycollection() {
-      const geometries = [];
-      let geometry;
-      if (!$(/^(geometrycollection)/i))
-        return null;
-      white();
-      if (!$(/^(\()/))
-        return null;
-      while (geometry = root()) {
-        geometries.push(geometry);
-        white();
-        $(/^(,)/);
-        white();
-      }
-      if (!$(/^(\))/))
-        return null;
-      return {
-        type: "GeometryCollection",
-        geometries
-      };
-    }
-    function root() {
-      return point() || linestring() || polygon() || multipoint() || multilinestring() || multipolygon() || geometrycollection();
-    }
-    return crs(root());
-  }
-  var numberRegexp, tuples;
-  var init_parse_wkt = __esm({
-    "src/lib/parse-wkt.ts"() {
-      numberRegexp = /[-+]?([0-9]*\.[0-9]+|[0-9]+)([eE][-+]?[0-9]+)?/;
-      tuples = new RegExp("^" + numberRegexp.source + "(\\s" + numberRegexp.source + "){1,}");
-    }
-  });
-
-  // src/wkt-loader.ts
-  var WKTWorkerLoader, WKTLoader;
-  var init_wkt_loader = __esm({
-    "src/wkt-loader.ts"() {
-      init_version();
-      init_parse_wkt();
-      WKTWorkerLoader = {
-        name: "WKT (Well-Known Text)",
-        id: "wkt",
-        module: "wkt",
-        version: VERSION,
-        worker: true,
-        extensions: ["wkt"],
-        mimeTypes: ["text/plain"],
-        category: "geometry",
-        text: true,
-        options: {
-          wkt: {}
-        }
-      };
-      WKTLoader = {
-        ...WKTWorkerLoader,
-        parse: async (arrayBuffer) => parseWKT(new TextDecoder().decode(arrayBuffer)),
-        parseTextSync: parseWKT
-      };
-    }
-  });
-
-  // src/lib/encode-wkt.ts
-  function encodeWKT(geometry) {
-    if (geometry.type === "Feature") {
-      geometry = geometry.geometry;
-    }
-    switch (geometry.type) {
-      case "Point":
-        return `POINT ${wrapParens(pairWKT(geometry.coordinates))}`;
-      case "LineString":
-        return `LINESTRING ${wrapParens(ringWKT(geometry.coordinates))}`;
-      case "Polygon":
-        return `POLYGON ${wrapParens(ringsWKT(geometry.coordinates))}`;
-      case "MultiPoint":
-        return `MULTIPOINT ${wrapParens(ringWKT(geometry.coordinates))}`;
-      case "MultiPolygon":
-        return `MULTIPOLYGON ${wrapParens(multiRingsWKT(geometry.coordinates))}`;
-      case "MultiLineString":
-        return `MULTILINESTRING ${wrapParens(ringsWKT(geometry.coordinates))}`;
-      case "GeometryCollection":
-        return `GEOMETRYCOLLECTION ${wrapParens(geometry.geometries.map(encodeWKT).join(", "))}`;
-      default:
-        throw new Error("stringify requires a valid GeoJSON Feature or geometry object as input");
-    }
-  }
-  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(", ");
+      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 Uint16Array(polygonIndices), size: 1 },
+      primitivePolygonIndices: { value: new Uint16Array(primitivePolygonIndices), size: 1 }
+    };
   }
-  function wrapParens(s) {
-    return `(${s})`;
+  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;
   }
-  var init_encode_wkt = __esm({
-    "src/lib/encode-wkt.ts"() {
+  var cumulativeSum;
+  var init_parse_wkb = __esm({
+    "src/lib/parse-wkb.ts"() {
+      init_src();
+      init_parse_wkb_header();
+      cumulativeSum = (sum) => (value) => sum += value;
     }
   });
 
-  // src/wkt-writer.ts
-  var WKTWriter;
-  var init_wkt_writer = __esm({
-    "src/wkt-writer.ts"() {
+  // src/wkb-loader.ts
+  var WKBWorkerLoader, WKBLoader;
+  var init_wkb_loader = __esm({
+    "src/wkb-loader.ts"() {
       init_version();
-      init_encode_wkt();
-      WKTWriter = {
-        name: "WKT (Well Known Text)",
-        id: "wkt",
+      init_parse_wkb();
+      init_parse_wkb_header();
+      WKBWorkerLoader = {
+        name: "WKB",
+        id: "wkb",
         module: "wkt",
         version: VERSION,
-        extensions: ["wkt"],
-        encode: encodeWKT,
+        worker: true,
+        category: "geometry",
+        extensions: ["wkb"],
+        mimeTypes: [],
+        tests: [isWKB],
         options: {
-          wkt: {}
+          wkb: {
+            shape: "binary-geometry"
+          }
         }
       };
+      WKBLoader = {
+        ...WKBWorkerLoader,
+        parse: async (arrayBuffer) => parseWKB(arrayBuffer),
+        parseSync: parseWKB
+      };
     }
   });
 
@@ -958,29 +1381,647 @@
     }
   });
 
+  // src/lib/utils/hex-transcoder.ts
+  function encodeHex(array) {
+    const length = array.length;
+    let string = "";
+    let i = 0;
+    while (i < length) {
+      string += encodeLookup[array[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++)];
+    }
+    return array;
+  }
+  var alphabet, encodeLookup, decodeLookup;
+  var init_hex_transcoder = __esm({
+    "src/lib/utils/hex-transcoder.ts"() {
+      alphabet = "0123456789abcdef";
+      encodeLookup = [];
+      decodeLookup = [];
+      for (let i = 0; i < 256; i++) {
+        encodeLookup[i] = alphabet[i >> 4 & 15] + alphabet[i & 15];
+        if (i < 16) {
+          if (i < 10) {
+            decodeLookup[48 + i] = i;
+          } else {
+            decodeLookup[97 - 10 + i] = i;
+          }
+        }
+      }
+    }
+  });
+
+  // src/hex-wkb-loader.ts
+  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;
+    }
+    if (!string.startsWith("00") && !string.startsWith("01")) {
+      return false;
+    }
+    return /^[0-9a-fA-F]+$/.test(string.slice(2));
+  }
+  var HexWKBLoader;
+  var init_hex_wkb_loader = __esm({
+    "src/hex-wkb-loader.ts"() {
+      init_wkb_loader();
+      init_version();
+      init_hex_transcoder();
+      HexWKBLoader = {
+        name: "Hexadecimal WKB",
+        id: "wkb",
+        module: "wkt",
+        version: VERSION,
+        worker: true,
+        category: "geometry",
+        extensions: ["wkb"],
+        mimeTypes: [],
+        options: WKBLoader.options,
+        text: true,
+        testText: isHexWKB,
+        parse: async (arrayBuffer) => parseHexWKB(new TextDecoder().decode(arrayBuffer)),
+        parseTextSync: parseHexWKB
+      };
+    }
+  });
+
+  // src/lib/utils/binary-reader.ts
+  var BinaryReader;
+  var init_binary_reader = __esm({
+    "src/lib/utils/binary-reader.ts"() {
+      BinaryReader = class {
+        constructor(arrayBuffer, isBigEndian = false) {
+          this.arrayBuffer = arrayBuffer;
+          this.dataView = new DataView(arrayBuffer);
+          this.byteOffset = 0;
+          this.littleEndian = !isBigEndian;
+        }
+        readUInt8() {
+          const value = this.dataView.getUint8(this.byteOffset);
+          this.byteOffset += 1;
+          return value;
+        }
+        readUInt16() {
+          const value = this.dataView.getUint16(this.byteOffset, this.littleEndian);
+          this.byteOffset += 2;
+          return value;
+        }
+        readUInt32() {
+          const value = this.dataView.getUint32(this.byteOffset, this.littleEndian);
+          this.byteOffset += 4;
+          return value;
+        }
+        readInt8() {
+          const value = this.dataView.getInt8(this.byteOffset);
+          this.byteOffset += 1;
+          return value;
+        }
+        readInt16() {
+          const value = this.dataView.getInt16(this.byteOffset, this.littleEndian);
+          this.byteOffset += 2;
+          return value;
+        }
+        readInt32() {
+          const value = this.dataView.getInt32(this.byteOffset, this.littleEndian);
+          this.byteOffset += 4;
+          return value;
+        }
+        readFloat() {
+          const value = this.dataView.getFloat32(this.byteOffset, this.littleEndian);
+          this.byteOffset += 4;
+          return value;
+        }
+        readDouble() {
+          const value = this.dataView.getFloat64(this.byteOffset, this.littleEndian);
+          this.byteOffset += 8;
+          return value;
+        }
+        readVarInt() {
+          let result = 0;
+          let bytesRead = 0;
+          let nextByte;
+          do {
+            nextByte = this.dataView.getUint8(this.byteOffset + bytesRead);
+            result += (nextByte & 127) << 7 * bytesRead;
+            bytesRead++;
+          } while (nextByte >= 128);
+          this.byteOffset += bytesRead;
+          return result;
+        }
+      };
+    }
+  });
+
+  // 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;
+    }
+    return true;
+  }
+  function parseTWKBGeometry(arrayBuffer) {
+    const binaryReader = new BinaryReader(arrayBuffer);
+    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);
+    }
+    const context = {
+      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
+    };
+    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, geometryType);
+  }
+  function parseGeometry2(binaryReader, context, geometryType) {
+    switch (geometryType) {
+      case WKBGeometryType.Point:
+        return parsePoint3(binaryReader, context);
+      case WKBGeometryType.LineString:
+        return parseLineString3(binaryReader, context);
+      case WKBGeometryType.Polygon:
+        return parsePolygon3(binaryReader, context);
+      case WKBGeometryType.MultiPoint:
+        return parseMultiPoint3(binaryReader, context);
+      case WKBGeometryType.MultiLineString:
+        return parseMultiLineString3(binaryReader, context);
+      case WKBGeometryType.MultiPolygon:
+        return parseMultiPolygon3(binaryReader, context);
+      case WKBGeometryType.GeometryCollection:
+        return parseGeometryCollection2(binaryReader, context);
+      default:
+        throw new Error(`GeometryType ${geometryType} not supported`);
+    }
+  }
+  function parsePoint3(reader, context) {
+    if (context.isEmpty) {
+      return { type: "Point", coordinates: [] };
+    }
+    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));
+    }
+    return { type: "LineString", coordinates: points };
+  }
+  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));
+      }
+      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));
+    }
+    return { type: "MultiPoint", coordinates };
+  }
+  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));
+      }
+      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);
+    }
+    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);
+  }
+  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 (context.hasM) {
+      previousPoint[3] += zigZagDecode(reader.readVarInt()) / context.mPrecisionFactor;
+    }
+    return previousPoint.slice();
+  }
+  var init_parse_twkb = __esm({
+    "src/lib/parse-twkb.ts"() {
+      init_binary_reader();
+      init_parse_wkb_header();
+    }
+  });
+
+  // src/twkb-loader.ts
+  var TWKBWorkerLoader, TWKBLoader;
+  var init_twkb_loader = __esm({
+    "src/twkb-loader.ts"() {
+      init_version();
+      init_parse_twkb();
+      TWKBWorkerLoader = {
+        name: "TWKB (Tiny Well-Known Binary)",
+        id: "twkb",
+        module: "wkt",
+        version: VERSION,
+        worker: true,
+        category: "geometry",
+        extensions: ["twkb"],
+        mimeTypes: [],
+        tests: [isTWKB],
+        options: {
+          wkb: {
+            shape: "binary-geometry"
+          }
+        }
+      };
+      TWKBLoader = {
+        ...TWKBWorkerLoader,
+        parse: async (arrayBuffer) => parseTWKBGeometry(arrayBuffer),
+        parseSync: parseTWKBGeometry
+      };
+    }
+  });
+
+  // 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, WKBGeometryType.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, WKBGeometryType.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, WKBGeometryType.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, WKBGeometryType.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, WKBGeometryType.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, WKBGeometryType.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, WKBGeometryType.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)
+    };
+  }
+  var init_encode_twkb = __esm({
+    "src/lib/encode-twkb.ts"() {
+      init_binary_writer();
+      init_parse_wkb_header();
+    }
+  });
+
+  // src/twkb-writer.ts
+  var TWKBWriter;
+  var init_twkb_writer = __esm({
+    "src/twkb-writer.ts"() {
+      init_version();
+      init_encode_twkb();
+      TWKBWriter = {
+        name: "TWKB (Tiny Well Known Binary)",
+        id: "twkb",
+        module: "wkt",
+        version: VERSION,
+        extensions: ["twkb"],
+        encodeSync: async (data, options) => encodeTWKB,
+        options: {
+          twkb: {}
+        }
+      };
+    }
+  });
+
   // src/index.ts
   var src_exports = {};
   __export(src_exports, {
+    HexWKBLoader: () => HexWKBLoader,
+    TWKBLoader: () => TWKBLoader,
+    TWKBWriter: () => TWKBWriter,
     WKBLoader: () => WKBLoader,
     WKBWorkerLoader: () => WKBWorkerLoader,
     WKBWriter: () => WKBWriter,
+    WKTCRSLoader: () => WKTCRSLoader,
+    WKTCRSWriter: () => WKTCRSWriter,
     WKTLoader: () => WKTLoader,
     WKTWorkerLoader: () => WKTWorkerLoader,
-    WKTWriter: () => WKTWriter
+    WKTWriter: () => WKTWriter,
+    decodeHex: () => decodeHex,
+    encodeHex: () => encodeHex,
+    isTWKB: () => isTWKB,
+    isWKB: () => isWKB,
+    isWKT: () => isWKT,
+    parseWKBHeader: () => parseWKBHeader
   });
-  var init_src = __esm({
+  var init_src2 = __esm({
     "src/index.ts"() {
-      init_wkb_loader();
+      init_wkt_crs_loader();
+      init_wkt_crs_writer();
       init_wkt_loader();
       init_wkt_writer();
+      init_wkb_loader();
       init_wkb_writer();
+      init_hex_wkb_loader();
+      init_twkb_loader();
+      init_twkb_writer();
+      init_parse_wkt();
+      init_parse_wkb_header();
+      init_parse_twkb();
+      init_hex_transcoder();
     }
   });
 
   // src/bundle.ts
   var require_bundle = __commonJS({
     "src/bundle.ts"(exports, module) {
-      var moduleExports = (init_src(), src_exports);
+      var moduleExports = (init_src2(), src_exports);
       globalThis.loaders = globalThis.loaders || {};
       module.exports = Object.assign(globalThis.loaders, moduleExports);
     }