@math.gl/geospatial 5.0.0-alpha.18 → 5.0.0-alpha.19

package/dist/wkb/index.cjs

@@ -0,0 +1,1050 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// dist/wkb/index.js
+var index_exports = {};
+__export(index_exports, {
+  WKBBuilder: () => WKBBuilder,
+  formatWKT: () => formatWKT,
+  getWellKnownDimensionSize: () => getWellKnownDimensionSize,
+  inferWellKnownGeometryDimension: () => inferWellKnownGeometryDimension,
+  inspectWKBHeader: () => inspectWKBHeader,
+  parseWKB: () => parseWKB,
+  parseWKT: () => parseWKT,
+  parseWKTWithMetadata: () => parseWKTWithMetadata,
+  scanWKB: () => scanWKB,
+  visitWKB: () => visitWKB,
+  writeWKB: () => writeWKB
+});
+module.exports = __toCommonJS(index_exports);
+
+// dist/wkb/types.js
+function getWellKnownDimensionSize(dimension) {
+  switch (dimension) {
+    case "xy":
+      return 2;
+    case "xyz":
+    case "xym":
+      return 3;
+    case "xyzm":
+      return 4;
+  }
+}
+function inferWellKnownGeometryDimension(geometry) {
+  const size = getGeometryDimensionSize(geometry);
+  return size >= 4 ? "xyzm" : size === 3 ? "xyz" : "xy";
+}
+function getGeometryDimensionSize(geometry) {
+  if (geometry.type === "GeometryCollection") {
+    return Math.max(2, ...geometry.geometries.map(getGeometryDimensionSize));
+  }
+  return getCoordinateDimension(geometry.coordinates);
+}
+function getCoordinateDimension(value) {
+  if (value.length === 0)
+    return 2;
+  if (typeof value[0] === "number")
+    return value.length;
+  return Math.max(2, ...value.map((child) => getCoordinateDimension(child)));
+}
+
+// dist/wkb/wkb-reader.js
+var GEOMETRY_TYPES = [
+  "Point",
+  "LineString",
+  "Polygon",
+  "MultiPoint",
+  "MultiLineString",
+  "MultiPolygon",
+  "GeometryCollection"
+];
+function inspectWKBHeader(input, byteOffset = 0) {
+  return inspectWKBHeaderView(getDataView(input), byteOffset);
+}
+function visitWKB(input, visitor, options = {}) {
+  const view = getDataView(input);
+  const state = {
+    maximumDepth: validateLimit(options.maximumDepth, 64, "maximumDepth"),
+    maximumElements: validateLimit(options.maximumElements, 1e8, "maximumElements"),
+    elementCount: 0,
+    visitor
+  };
+  const byteLength = visitGeometry(view, 0, state, 0).byteOffset;
+  if (byteLength !== view.byteLength)
+    throw new Error("WKB contains trailing bytes");
+  return byteLength;
+}
+function scanWKB(input, options = {}) {
+  const header = inspectWKBHeader(input);
+  const geometryCounts = {
+    Point: 0,
+    LineString: 0,
+    Polygon: 0,
+    MultiPoint: 0,
+    MultiLineString: 0,
+    MultiPolygon: 0,
+    GeometryCollection: 0
+  };
+  const geometryTypes = /* @__PURE__ */ new Set();
+  const bounds = {};
+  let coordinateCount = 0;
+  let ringCount = 0;
+  let geometryCount = 0;
+  let maximumDepth = 0;
+  const byteLength = visitWKB(input, {
+    geometry: (geometryHeader, _count, depth) => {
+      geometryCounts[geometryHeader.geometryType]++;
+      geometryTypes.add(geometryHeader.geometryType);
+      geometryCount++;
+      maximumDepth = Math.max(maximumDepth, depth);
+    },
+    ring: () => ringCount++,
+    coordinate: (x, y, z, m) => {
+      coordinateCount++;
+      updateBounds(bounds, "x", x);
+      updateBounds(bounds, "y", y);
+      if (z !== void 0)
+        updateBounds(bounds, "z", z);
+      if (m !== void 0)
+        updateBounds(bounds, "m", m);
+    }
+  }, options);
+  const concreteBounds = makeBounds(bounds);
+  return {
+    header,
+    byteLength,
+    coordinateCount,
+    ringCount,
+    geometryCount,
+    maximumDepth,
+    geometryTypes: GEOMETRY_TYPES.filter((type) => geometryTypes.has(type)),
+    geometryCounts,
+    ...concreteBounds ? { bounds: concreteBounds } : {}
+  };
+}
+function visitGeometry(view, byteOffset, state, depth, expectedType) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+  if (depth > state.maximumDepth)
+    throw new Error("WKB geometry nesting exceeds maximumDepth");
+  const header = inspectWKBHeaderView(view, byteOffset);
+  if (expectedType && header.geometryType !== expectedType) {
+    throw new Error(`WKB ${expectedType} collection contains a ${header.geometryType} child`);
+  }
+  byteOffset = header.bodyByteOffset;
+  switch (header.geometryType) {
+    case "Point":
+      (_b = (_a = state.visitor).geometry) == null ? void 0 : _b.call(_a, header, void 0, depth);
+      byteOffset = visitCoordinate(view, byteOffset, header, state.visitor, depth);
+      break;
+    case "LineString": {
+      const pointCount = readCount(view, byteOffset, header.littleEndian, state);
+      byteOffset += 4;
+      (_d = (_c = state.visitor).geometry) == null ? void 0 : _d.call(_c, header, pointCount, depth);
+      byteOffset = visitCoordinateSequence(view, byteOffset, pointCount, header, state, depth);
+      break;
+    }
+    case "Polygon": {
+      const ringCount = readCount(view, byteOffset, header.littleEndian, state);
+      byteOffset += 4;
+      (_f = (_e = state.visitor).geometry) == null ? void 0 : _f.call(_e, header, ringCount, depth);
+      for (let ringIndex = 0; ringIndex < ringCount; ringIndex++) {
+        const pointCount = readCount(view, byteOffset, header.littleEndian, state);
+        byteOffset += 4;
+        (_h = (_g = state.visitor).ring) == null ? void 0 : _h.call(_g, pointCount, ringIndex, depth);
+        byteOffset = visitCoordinateSequence(view, byteOffset, pointCount, header, state, depth);
+      }
+      break;
+    }
+    case "MultiPoint":
+    case "MultiLineString":
+    case "MultiPolygon":
+    case "GeometryCollection": {
+      const childCount = readCount(view, byteOffset, header.littleEndian, state);
+      byteOffset += 4;
+      (_j = (_i = state.visitor).geometry) == null ? void 0 : _j.call(_i, header, childCount, depth);
+      const childType = header.geometryType === "MultiPoint" ? "Point" : header.geometryType === "MultiLineString" ? "LineString" : header.geometryType === "MultiPolygon" ? "Polygon" : void 0;
+      for (let childIndex = 0; childIndex < childCount; childIndex++) {
+        byteOffset = visitGeometry(view, byteOffset, state, depth + 1, childType).byteOffset;
+      }
+      break;
+    }
+  }
+  return { byteOffset, header };
+}
+function visitCoordinateSequence(view, byteOffset, pointCount, header, state, depth) {
+  for (let pointIndex = 0; pointIndex < pointCount; pointIndex++) {
+    byteOffset = visitCoordinate(view, byteOffset, header, state.visitor, depth);
+  }
+  return byteOffset;
+}
+function visitCoordinate(view, byteOffset, header, visitor, depth) {
+  var _a;
+  const coordinateByteLength = getWellKnownDimensionSize(header.dimension) * 8;
+  assertRemaining(view, byteOffset, coordinateByteLength);
+  if (!visitor.coordinate)
+    return byteOffset + coordinateByteLength;
+  const x = view.getFloat64(byteOffset, header.littleEndian);
+  const y = view.getFloat64(byteOffset + 8, header.littleEndian);
+  const third = header.dimension === "xy" ? void 0 : view.getFloat64(byteOffset + 16, header.littleEndian);
+  const fourth = header.dimension === "xyzm" ? view.getFloat64(byteOffset + 24, header.littleEndian) : void 0;
+  const z = header.dimension === "xyz" || header.dimension === "xyzm" ? third : void 0;
+  const m = header.dimension === "xym" ? third : fourth;
+  (_a = visitor.coordinate) == null ? void 0 : _a.call(visitor, x, y, z, m, header.dimension, byteOffset, depth);
+  return byteOffset + coordinateByteLength;
+}
+function inspectWKBHeaderView(view, byteOffset) {
+  const startByteOffset = byteOffset;
+  assertRemaining(view, byteOffset, 5);
+  const byteOrder = view.getUint8(byteOffset++);
+  if (byteOrder !== 0 && byteOrder !== 1)
+    throw new Error("Invalid WKB byte order");
+  const littleEndian = byteOrder === 1;
+  const typeCode = view.getUint32(byteOffset, littleEndian);
+  byteOffset += 4;
+  const hasZ = Boolean(typeCode & 2147483648);
+  const hasM = Boolean(typeCode & 1073741824);
+  const hasSrid = Boolean(typeCode & 536870912);
+  let geometryCode = typeCode & 536870911;
+  let dimension;
+  if (geometryCode >= 3e3 && geometryCode < 4e3) {
+    dimension = "xyzm";
+    geometryCode -= 3e3;
+  } else if (geometryCode >= 2e3 && geometryCode < 3e3) {
+    dimension = "xym";
+    geometryCode -= 2e3;
+  } else if (geometryCode >= 1e3 && geometryCode < 2e3) {
+    dimension = "xyz";
+    geometryCode -= 1e3;
+  } else {
+    dimension = hasZ && hasM ? "xyzm" : hasZ ? "xyz" : hasM ? "xym" : "xy";
+  }
+  const geometryType = GEOMETRY_TYPES[geometryCode - 1];
+  if (!geometryType)
+    throw new Error(`Unsupported WKB geometry type ${geometryCode}`);
+  let srid;
+  if (hasSrid) {
+    assertRemaining(view, byteOffset, 4);
+    srid = view.getUint32(byteOffset, littleEndian);
+    byteOffset += 4;
+  }
+  const dialect = hasZ || hasM || hasSrid ? "ewkb" : dimension === "xy" ? "wkb" : "iso-wkb";
+  return {
+    geometryType,
+    dimension,
+    dialect,
+    littleEndian,
+    byteOffset: startByteOffset,
+    bodyByteOffset: byteOffset,
+    byteLength: byteOffset - startByteOffset,
+    ...srid === void 0 ? {} : { srid }
+  };
+}
+function readCount(view, byteOffset, littleEndian, state) {
+  assertRemaining(view, byteOffset, 4);
+  const count = view.getUint32(byteOffset, littleEndian);
+  state.elementCount += count;
+  if (state.elementCount > state.maximumElements) {
+    throw new Error("WKB element count exceeds maximumElements");
+  }
+  return count;
+}
+function updateBounds(bounds, axis, value) {
+  if (!Number.isFinite(value))
+    return;
+  const minimum = `${axis}min`;
+  const maximum = `${axis}max`;
+  bounds[minimum] = bounds[minimum] === void 0 ? value : Math.min(bounds[minimum], value);
+  bounds[maximum] = bounds[maximum] === void 0 ? value : Math.max(bounds[maximum], value);
+}
+function makeBounds(bounds) {
+  if (bounds.xmin === void 0 || bounds.ymin === void 0 || bounds.xmax === void 0 || bounds.ymax === void 0) {
+    return void 0;
+  }
+  return bounds;
+}
+function getDataView(input) {
+  return ArrayBuffer.isView(input) ? new DataView(input.buffer, input.byteOffset, input.byteLength) : new DataView(input);
+}
+function assertRemaining(view, byteOffset, byteLength) {
+  if (byteOffset < 0 || byteOffset + byteLength > view.byteLength) {
+    throw new Error("Unexpected end of WKB");
+  }
+}
+function validateLimit(value, fallback, name) {
+  const limit = value ?? fallback;
+  if (!Number.isSafeInteger(limit) || limit < 0) {
+    throw new Error(`${name} must be a non-negative safe integer`);
+  }
+  return limit;
+}
+
+// dist/wkb/wkb.js
+function parseWKB(bytes, options = {}) {
+  const state = {
+    maximumDepth: validateLimit2(options.maximumDepth, 64, "maximumDepth"),
+    maximumElements: validateLimit2(options.maximumElements, 1e8, "maximumElements"),
+    elementCount: 0
+  };
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const result = readWKBGeometry(view, 0, state, 0);
+  if (result.offset !== bytes.byteLength)
+    throw new Error("WKB contains trailing bytes");
+  return {
+    geometry: result.geometry,
+    byteLength: result.offset,
+    dimension: result.dimension,
+    ...result.srid === void 0 ? {} : { srid: result.srid }
+  };
+}
+function writeWKB(geometry, dimension = inferWellKnownGeometryDimension(geometry)) {
+  const bytes = [];
+  writeWKBGeometry(bytes, geometry, dimension);
+  return Uint8Array.from(bytes);
+}
+function readWKBGeometry(view, startOffset, state, depth) {
+  if (depth > state.maximumDepth)
+    throw new Error("WKB geometry nesting exceeds maximumDepth");
+  const header = inspectWKBHeader(view, startOffset);
+  let offset = header.bodyByteOffset;
+  const { dimension, geometryType, littleEndian, srid } = header;
+  const dimensions = getWellKnownDimensionSize(dimension);
+  const readCoordinate = () => {
+    assertRemaining2(view, offset, dimensions * 8);
+    const coordinate = new Array(dimensions);
+    for (let index = 0; index < dimensions; index++) {
+      coordinate[index] = view.getFloat64(offset, littleEndian);
+      offset += 8;
+    }
+    return coordinate;
+  };
+  const readCount2 = () => {
+    assertRemaining2(view, offset, 4);
+    const count = view.getUint32(offset, littleEndian);
+    offset += 4;
+    state.elementCount += count;
+    if (state.elementCount > state.maximumElements) {
+      throw new Error("WKB element count exceeds maximumElements");
+    }
+    return count;
+  };
+  const readCoordinates = () => {
+    const count = readCount2();
+    return Array.from({ length: count }, readCoordinate);
+  };
+  let geometry;
+  switch (geometryType) {
+    case "Point":
+      geometry = { type: "Point", coordinates: readCoordinate() };
+      break;
+    case "LineString":
+      geometry = { type: "LineString", coordinates: readCoordinates() };
+      break;
+    case "Polygon":
+      geometry = { type: "Polygon", coordinates: Array.from({ length: readCount2() }, readCoordinates) };
+      break;
+    case "MultiPoint":
+    case "MultiLineString":
+    case "MultiPolygon":
+    case "GeometryCollection": {
+      const children = [];
+      for (let index = 0, count = readCount2(); index < count; index++) {
+        const child = readWKBGeometry(view, offset, state, depth + 1);
+        children.push(child.geometry);
+        offset = child.offset;
+      }
+      if (geometryType === "MultiPoint") {
+        geometry = {
+          type: "MultiPoint",
+          coordinates: children.map(assertPoint).map((point) => point.coordinates)
+        };
+      } else if (geometryType === "MultiLineString") {
+        geometry = {
+          type: "MultiLineString",
+          coordinates: children.map(assertLineString).map((line) => line.coordinates)
+        };
+      } else if (geometryType === "MultiPolygon") {
+        geometry = {
+          type: "MultiPolygon",
+          coordinates: children.map(assertPolygon).map((polygon) => polygon.coordinates)
+        };
+      } else {
+        geometry = { type: "GeometryCollection", geometries: children };
+      }
+      break;
+    }
+  }
+  return { geometry, offset, dimension, ...srid === void 0 ? {} : { srid } };
+}
+function writeWKBGeometry(bytes, geometry, dimension) {
+  bytes.push(1);
+  const size = getWellKnownDimensionSize(dimension);
+  const dimensionOffset = dimension === "xyz" ? 1e3 : dimension === "xym" ? 2e3 : dimension === "xyzm" ? 3e3 : 0;
+  writeUint32(bytes, getWKBType(geometry.type) + dimensionOffset);
+  const writeCoordinate = (coordinate) => {
+    for (let index = 0; index < size; index++)
+      writeFloat64(bytes, coordinate[index] ?? 0);
+  };
+  const writeCoordinates = (coordinates) => {
+    writeUint32(bytes, coordinates.length);
+    for (const coordinate of coordinates)
+      writeCoordinate(coordinate);
+  };
+  switch (geometry.type) {
+    case "Point":
+      writeCoordinate(geometry.coordinates.length === 0 ? new Array(size).fill(Number.NaN) : geometry.coordinates);
+      break;
+    case "LineString":
+      writeCoordinates(geometry.coordinates);
+      break;
+    case "Polygon":
+      writeUint32(bytes, geometry.coordinates.length);
+      for (const ring of geometry.coordinates)
+        writeCoordinates(ring);
+      break;
+    case "MultiPoint":
+      writeUint32(bytes, geometry.coordinates.length);
+      for (const coordinate of geometry.coordinates) {
+        writeWKBGeometry(bytes, { type: "Point", coordinates: coordinate }, dimension);
+      }
+      break;
+    case "MultiLineString":
+      writeUint32(bytes, geometry.coordinates.length);
+      for (const coordinates of geometry.coordinates) {
+        writeWKBGeometry(bytes, { type: "LineString", coordinates }, dimension);
+      }
+      break;
+    case "MultiPolygon":
+      writeUint32(bytes, geometry.coordinates.length);
+      for (const coordinates of geometry.coordinates) {
+        writeWKBGeometry(bytes, { type: "Polygon", coordinates }, dimension);
+      }
+      break;
+    case "GeometryCollection":
+      writeUint32(bytes, geometry.geometries.length);
+      for (const child of geometry.geometries)
+        writeWKBGeometry(bytes, child, dimension);
+      break;
+  }
+}
+function getWKBType(type) {
+  return [
+    "Point",
+    "LineString",
+    "Polygon",
+    "MultiPoint",
+    "MultiLineString",
+    "MultiPolygon",
+    "GeometryCollection"
+  ].indexOf(type) + 1;
+}
+function writeUint32(bytes, value) {
+  bytes.push(value & 255, value >>> 8 & 255, value >>> 16 & 255, value >>> 24 & 255);
+}
+function writeFloat64(bytes, value) {
+  const buffer = new ArrayBuffer(8);
+  new DataView(buffer).setFloat64(0, value, true);
+  bytes.push(...new Uint8Array(buffer));
+}
+function assertRemaining2(view, offset, length) {
+  if (offset + length > view.byteLength)
+    throw new Error("Unexpected end of WKB");
+}
+function assertPoint(value) {
+  if (value.type !== "Point")
+    throw new Error("WKB MultiPoint contains a non-Point child");
+  return value;
+}
+function assertLineString(value) {
+  if (value.type !== "LineString") {
+    throw new Error("WKB MultiLineString contains a non-LineString child");
+  }
+  return value;
+}
+function assertPolygon(value) {
+  if (value.type !== "Polygon")
+    throw new Error("WKB MultiPolygon contains a non-Polygon child");
+  return value;
+}
+function validateLimit2(value, fallback, name) {
+  const limit = value ?? fallback;
+  if (!Number.isSafeInteger(limit) || limit < 0) {
+    throw new Error(`${name} must be a non-negative safe integer`);
+  }
+  return limit;
+}
+
+// dist/wkb/wkb-builder.js
+var GEOMETRY_TYPE_CODES = {
+  Point: 1,
+  LineString: 2,
+  Polygon: 3,
+  MultiPoint: 4,
+  MultiLineString: 5,
+  MultiPolygon: 6,
+  GeometryCollection: 7
+};
+var WKBBuilder = class _WKBBuilder {
+  constructor(options) {
+    this.mode = options.mode;
+    this.dimension = options.dimension ?? "xy";
+    this.littleEndian = options.byteOrder !== "big-endian";
+    this.srid = options.srid;
+    this.transform = options.transform;
+    validateSrid(this.srid);
+    if (options.mode === "write") {
+      const dataView = getTargetDataView(options.target);
+      const byteOffset = options.byteOffset ?? 0;
+      if (!Number.isSafeInteger(byteOffset) || byteOffset < 0 || byteOffset > dataView.byteLength) {
+        throw new Error("WKBBuilder byteOffset is outside the target");
+      }
+      this.dataView = dataView;
+      this.startByteOffset = byteOffset;
+      this.endByteOffset = dataView.byteLength;
+      this.byteOffset = byteOffset;
+    } else {
+      this.dataView = null;
+      this.startByteOffset = 0;
+      this.endByteOffset = Number.POSITIVE_INFINITY;
+      this.byteOffset = 0;
+    }
+  }
+  /** Begins a geometry and writes its count field when required. */
+  beginGeometry(type, count) {
+    switch (type) {
+      case "Point":
+        this.beginPoint();
+        break;
+      case "LineString":
+        this.beginLineString(count ?? 0);
+        break;
+      case "Polygon":
+        this.beginPolygon(count ?? 0);
+        break;
+      case "MultiPoint":
+        this.beginMultiPoint(count ?? 0);
+        break;
+      case "MultiLineString":
+        this.beginMultiLineString(count ?? 0);
+        break;
+      case "MultiPolygon":
+        this.beginMultiPolygon(count ?? 0);
+        break;
+      case "GeometryCollection":
+        this.writeHeader("GeometryCollection");
+        this.writeUint32(count ?? 0);
+        break;
+    }
+  }
+  /** Begins one point geometry. */
+  beginPoint() {
+    this.writeHeader("Point");
+  }
+  /** Begins one linestring geometry. */
+  beginLineString(pointCount) {
+    this.writeHeader("LineString");
+    this.writeUint32(pointCount);
+  }
+  /** Begins one polygon geometry. */
+  beginPolygon(ringCount) {
+    this.writeHeader("Polygon");
+    this.writeUint32(ringCount);
+  }
+  /** Begins one linear ring inside a polygon. */
+  beginLinearRing(pointCount) {
+    this.writeUint32(pointCount);
+  }
+  /** Begins one multipoint geometry. */
+  beginMultiPoint(pointCount) {
+    this.writeHeader("MultiPoint");
+    this.writeUint32(pointCount);
+  }
+  /** Begins one multilinestring geometry. */
+  beginMultiLineString(lineCount) {
+    this.writeHeader("MultiLineString");
+    this.writeUint32(lineCount);
+  }
+  /** Begins one multipolygon geometry. */
+  beginMultiPolygon(polygonCount) {
+    this.writeHeader("MultiPolygon");
+    this.writeUint32(polygonCount);
+  }
+  /** Writes one coordinate using the builder's semantic dimension. */
+  writeCoordinate(x, y, z, m) {
+    let coordinate = makeCoordinate(this.dimension, x, y, z, m);
+    if (this.transform)
+      coordinate = this.transform(coordinate, this.dimension);
+    const coordinateSize = getDimensionSize(this.dimension);
+    for (let index = 0; index < coordinateSize; index++) {
+      this.writeFloat64(coordinate[index] ?? Number.NaN);
+    }
+  }
+  /** Temporarily changes the semantic dimension for a nested geometry. */
+  withDimension(dimension, callback) {
+    const previous = this.dimension;
+    this.dimension = dimension;
+    try {
+      return callback();
+    } finally {
+      this.dimension = previous;
+    }
+  }
+  /** Returns the number of bytes measured or written. */
+  finishGeometry() {
+    return this.byteOffset - this.startByteOffset;
+  }
+  /** Measures geometry callbacks and returns contiguous Binary offsets. */
+  static measureGeometryArray(geometryWriters, options = {}) {
+    var _a;
+    const valueOffsets = new Int32Array(geometryWriters.length + 1);
+    for (let geometryIndex = 0; geometryIndex < geometryWriters.length; geometryIndex++) {
+      const geometryWriter = geometryWriters[geometryIndex];
+      const byteLength = geometryWriter ? measureGeometry(geometryWriter, {
+        ...options,
+        dimension: ((_a = options.dimensionResolver) == null ? void 0 : _a.call(options, geometryIndex)) ?? options.dimension
+      }) : 0;
+      const nextOffset = valueOffsets[geometryIndex] + byteLength;
+      if (nextOffset > 2147483647)
+        throw new Error("WKB geometry array exceeds Int32 offsets");
+      valueOffsets[geometryIndex + 1] = nextOffset;
+    }
+    return valueOffsets;
+  }
+  /** Writes geometry callbacks into an existing contiguous values buffer. */
+  static writeGeometryArray(geometryWriters, valueOffsets, values, options = {}) {
+    var _a;
+    if (valueOffsets.length !== geometryWriters.length + 1) {
+      throw new Error("WKB valueOffsets length must equal geometry count plus one");
+    }
+    if (valueOffsets[valueOffsets.length - 1] > values.byteLength) {
+      throw new Error("WKB values buffer is smaller than its final offset");
+    }
+    for (let geometryIndex = 0; geometryIndex < geometryWriters.length; geometryIndex++) {
+      const geometryWriter = geometryWriters[geometryIndex];
+      if (!geometryWriter)
+        continue;
+      const builder = new _WKBBuilder({
+        mode: "write",
+        target: values,
+        byteOffset: valueOffsets[geometryIndex],
+        ...options,
+        dimension: ((_a = options.dimensionResolver) == null ? void 0 : _a.call(options, geometryIndex)) ?? options.dimension
+      });
+      geometryWriter(builder);
+      const byteLength = builder.finishGeometry();
+      if (valueOffsets[geometryIndex] + byteLength !== valueOffsets[geometryIndex + 1]) {
+        throw new Error("WKB measure and write passes produced different byte lengths");
+      }
+    }
+    return values;
+  }
+  /** Builds plain offsets, values, and validity buffers in two passes. */
+  static buildGeometryArray(geometryWriters, options = {}) {
+    const valueOffsets = _WKBBuilder.measureGeometryArray(geometryWriters, options);
+    const values = new Uint8Array(valueOffsets[valueOffsets.length - 1]);
+    _WKBBuilder.writeGeometryArray(geometryWriters, valueOffsets, values, options);
+    const { nullBitmap, nullCount } = makeNullBitmap(geometryWriters);
+    return {
+      valueOffsets,
+      values,
+      ...nullCount > 0 ? { nullBitmap } : {},
+      nullCount
+    };
+  }
+  writeHeader(geometryType) {
+    this.writeUint8(this.littleEndian ? 1 : 0);
+    this.writeUint32(getWKBTypeCode(geometryType, this.dimension, this.srid !== void 0));
+    if (this.srid !== void 0)
+      this.writeUint32(this.srid);
+  }
+  writeUint8(value) {
+    var _a;
+    this.ensureSize(1);
+    (_a = this.dataView) == null ? void 0 : _a.setUint8(this.byteOffset, value);
+    this.byteOffset++;
+  }
+  writeUint32(value) {
+    var _a;
+    if (!Number.isSafeInteger(value) || value < 0 || value > 4294967295) {
+      throw new Error("WKB count must be an unsigned 32-bit integer");
+    }
+    this.ensureSize(4);
+    (_a = this.dataView) == null ? void 0 : _a.setUint32(this.byteOffset, value, this.littleEndian);
+    this.byteOffset += 4;
+  }
+  writeFloat64(value) {
+    var _a;
+    this.ensureSize(8);
+    (_a = this.dataView) == null ? void 0 : _a.setFloat64(this.byteOffset, value, this.littleEndian);
+    this.byteOffset += 8;
+  }
+  ensureSize(byteLength) {
+    if (this.byteOffset + byteLength > this.endByteOffset) {
+      throw new Error("WKBBuilder target buffer overflow");
+    }
+  }
+};
+function measureGeometry(geometryWriter, options) {
+  const builder = new WKBBuilder({ mode: "measure", ...options });
+  geometryWriter(builder);
+  return builder.finishGeometry();
+}
+function getTargetDataView(target) {
+  return ArrayBuffer.isView(target) ? new DataView(target.buffer, target.byteOffset, target.byteLength) : new DataView(target);
+}
+function getWKBTypeCode(geometryType, dimension, hasSrid) {
+  const geometryCode = GEOMETRY_TYPE_CODES[geometryType];
+  if (hasSrid) {
+    const dimensionFlags = dimension === "xyz" ? 2147483648 : dimension === "xym" ? 1073741824 : dimension === "xyzm" ? 3221225472 : 0;
+    return (geometryCode | dimensionFlags | 536870912) >>> 0;
+  }
+  const dimensionOffset = dimension === "xyz" ? 1e3 : dimension === "xym" ? 2e3 : dimension === "xyzm" ? 3e3 : 0;
+  return geometryCode + dimensionOffset;
+}
+function makeCoordinate(dimension, x, y, z, m) {
+  switch (dimension) {
+    case "xy":
+      return [x, y];
+    case "xyz":
+      return [x, y, z ?? Number.NaN];
+    case "xym":
+      return [x, y, m ?? Number.NaN];
+    case "xyzm":
+      return [x, y, z ?? Number.NaN, m ?? Number.NaN];
+  }
+}
+function getDimensionSize(dimension) {
+  return dimension === "xy" ? 2 : dimension === "xyzm" ? 4 : 3;
+}
+function validateSrid(srid) {
+  if (srid !== void 0 && (!Number.isSafeInteger(srid) || srid < 0 || srid > 4294967295)) {
+    throw new Error("WKBBuilder srid must be an unsigned 32-bit integer");
+  }
+}
+function makeNullBitmap(geometryWriters) {
+  const nullBitmap = new Uint8Array(Math.ceil(geometryWriters.length / 8));
+  let nullCount = 0;
+  for (let geometryIndex = 0; geometryIndex < geometryWriters.length; geometryIndex++) {
+    if (geometryWriters[geometryIndex]) {
+      nullBitmap[geometryIndex >> 3] |= 1 << (geometryIndex & 7);
+    } else {
+      nullCount++;
+    }
+  }
+  return { nullBitmap, nullCount };
+}
+
+// dist/wkb/wkt.js
+function parseWKT(text, options) {
+  const parser = new WKTParser(text);
+  const result = parser.parseGeometry("xy", options ?? {}, false);
+  parser.assertComplete();
+  return result.geometry;
+}
+function parseWKTWithMetadata(text, options = {}) {
+  const parser = new WKTParser(text);
+  const result = parser.parseGeometry("xy", options, true);
+  parser.assertComplete();
+  return result;
+}
+function formatWKT(geometry, dimension) {
+  if (isWKTParseResult(geometry)) {
+    return dimension === void 0 ? formatWKTResult(geometry) : formatWKTGeometry(geometry.geometry, dimension);
+  }
+  return formatWKTGeometry(geometry, dimension ?? inferWellKnownGeometryDimension(geometry));
+}
+function formatWKTResult(result) {
+  return formatWKTGeometry(result.geometry, result.dimension, result.children);
+}
+function formatWKTGeometry(geometry, dimension, children) {
+  const dimensionToken = dimension === "xy" ? "" : " " + dimension.slice(2).toUpperCase();
+  if (geometry.type === "GeometryCollection") {
+    if (geometry.geometries.length === 0)
+      return "GEOMETRYCOLLECTION" + dimensionToken + " EMPTY";
+    const formattedChildren = children ? children.map(formatWKTResult) : geometry.geometries.map((child) => formatWKTGeometry(child, dimension));
+    return "GEOMETRYCOLLECTION" + dimensionToken + " (" + formattedChildren.join(", ") + ")";
+  }
+  const type = geometry.type.toUpperCase();
+  const isEmpty = geometry.type === "MultiPoint" ? geometry.coordinates.length === 0 : isEmptyCoordinates(geometry.coordinates);
+  if (isEmpty)
+    return type + dimensionToken + " EMPTY";
+  return type + dimensionToken + " " + formatCoordinateNesting(geometry.coordinates, getGeometryDepth(geometry.type), geometry.type === "MultiPoint");
+}
+function isWKTParseResult(value) {
+  return "geometry" in value && "dimension" in value;
+}
+var WKTParser = class {
+  constructor(text) {
+    this.index = 0;
+    this.tokens = tokenizeWKT(text);
+  }
+  parseGeometry(inheritedDimension, options, validateInheritedDimensions) {
+    const type = this.takeWord().toUpperCase();
+    let dimension = inheritedDimension;
+    let hasExplicitDimension = false;
+    if (["Z", "M", "ZM"].includes(this.peek().toUpperCase())) {
+      const token = this.take().toUpperCase();
+      dimension = token === "Z" ? "xyz" : token === "M" ? "xym" : "xyzm";
+      hasExplicitDimension = true;
+    }
+    const dimensionSize = getWellKnownDimensionSize(dimension);
+    if (this.peek().toUpperCase() === "EMPTY") {
+      this.take();
+      return { geometry: makeEmptyGeometry(type, dimensionSize), dimension };
+    }
+    if (type === "GEOMETRYCOLLECTION") {
+      this.expect("(");
+      const children = [];
+      if (this.peek() !== ")") {
+        do
+          children.push(this.parseGeometry(dimension, options, validateInheritedDimensions));
+        while (this.takeIf(","));
+      }
+      this.expect(")");
+      return {
+        geometry: { type: "GeometryCollection", geometries: children.map((child) => child.geometry) },
+        dimension,
+        children
+      };
+    }
+    const inferDimension = Boolean(options.inferDimensions && !hasExplicitDimension && inheritedDimension === "xy");
+    const coordinates = this.parseCoordinateNesting(getWKTDepth(type), inferDimension ? null : dimensionSize, type === "MULTIPOINT");
+    const coordinateValues = coordinates;
+    if (inferDimension) {
+      const inferredSize = inferCoordinateSize(coordinateValues);
+      if (inferredSize !== null)
+        dimension = getDimensionForSize(inferredSize);
+    } else if (hasExplicitDimension || validateInheritedDimensions) {
+      assertCoordinateSize(coordinateValues, dimensionSize);
+    }
+    return { geometry: makeGeometry(type, coordinates), dimension };
+  }
+  assertComplete() {
+    if (this.index !== this.tokens.length)
+      throw new Error(`Unexpected WKT token ${this.peek()}`);
+  }
+  parseCoordinateNesting(depth, dimensionSize, allowEmptyPoints = false) {
+    this.expect("(");
+    if (depth === 0) {
+      const coordinate = this.readCoordinate(dimensionSize);
+      this.expect(")");
+      return coordinate;
+    }
+    const values = [];
+    if (this.peek() !== ")") {
+      do {
+        if (allowEmptyPoints && depth === 1 && this.peek().toUpperCase() === "EMPTY") {
+          this.take();
+          values.push([]);
+        } else if (depth === 1 && this.peek() !== "(") {
+          values.push(this.readCoordinate(dimensionSize));
+        } else {
+          values.push(this.parseCoordinateNesting(depth - 1, dimensionSize));
+        }
+      } while (this.takeIf(","));
+    }
+    this.expect(")");
+    return values;
+  }
+  readCoordinate(dimensionSize) {
+    const values = [];
+    while ((dimensionSize === null || values.length < dimensionSize) && isNumberToken(this.peek())) {
+      values.push(Number(this.take()));
+    }
+    if (values.length < 2)
+      throw new Error("WKT coordinate requires at least two numbers");
+    if (values.length > 4)
+      throw new Error("WKT coordinates cannot contain more than four numbers");
+    return values;
+  }
+  peek() {
+    return this.tokens[this.index] || "";
+  }
+  take() {
+    if (this.index >= this.tokens.length)
+      throw new Error("Unexpected end of WKT");
+    return this.tokens[this.index++];
+  }
+  takeWord() {
+    const token = this.take();
+    if (!/^[A-Za-z_]+$/.test(token))
+      throw new Error(`Expected WKT geometry type, found ${token}`);
+    return token;
+  }
+  takeIf(token) {
+    if (this.peek() !== token)
+      return false;
+    this.index++;
+    return true;
+  }
+  expect(token) {
+    const actual = this.take();
+    if (actual !== token)
+      throw new Error(`Expected WKT token ${token}, found ${actual}`);
+  }
+};
+function inferCoordinateSize(value) {
+  let coordinateSize = null;
+  const visit = (coordinates) => {
+    if (coordinates.length === 0)
+      return;
+    if (typeof coordinates[0] === "number") {
+      if (coordinates.length < 2 || coordinates.length > 4) {
+        throw new Error("WKT coordinates must contain between two and four numbers");
+      }
+      if (coordinateSize !== null && coordinateSize !== coordinates.length) {
+        throw new Error("WKT geometry contains inconsistent coordinate dimensions");
+      }
+      coordinateSize = coordinates.length;
+      return;
+    }
+    for (const child of coordinates)
+      visit(child);
+  };
+  visit(value);
+  return coordinateSize;
+}
+function assertCoordinateSize(value, expectedSize) {
+  const actualSize = inferCoordinateSize(value);
+  if (actualSize !== null && actualSize !== expectedSize) {
+    throw new Error("WKT coordinate dimension does not match declared dimension " + expectedSize);
+  }
+}
+function getDimensionForSize(size) {
+  switch (size) {
+    case 2:
+      return "xy";
+    case 3:
+      return "xyz";
+    case 4:
+      return "xyzm";
+    default:
+      throw new Error("Unsupported WKT coordinate dimension " + size);
+  }
+}
+function tokenizeWKT(text) {
+  const tokens = [];
+  const tokenPattern = /[A-Za-z_]+|[(),]|[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?/gy;
+  let index = 0;
+  while (index < text.length) {
+    while (index < text.length && /\s/.test(text[index]))
+      index++;
+    if (index === text.length)
+      break;
+    tokenPattern.lastIndex = index;
+    const match = tokenPattern.exec(text);
+    if (!match) {
+      throw new Error(`Unexpected WKT character ${JSON.stringify(text[index])} at ${index}`);
+    }
+    tokens.push(match[0]);
+    index = tokenPattern.lastIndex;
+  }
+  return tokens;
+}
+function formatCoordinateNesting(value, depth, allowEmptyPoints = false) {
+  if (depth === 0)
+    return `(${value.map(formatNumber).join(" ")})`;
+  return `(${value.map((child) => {
+    if (depth === 1) {
+      const coordinate = child;
+      if (allowEmptyPoints && isEmptyCoordinates(coordinate))
+        return "EMPTY";
+      return coordinate.map(formatNumber).join(" ");
+    }
+    return formatCoordinateNesting(child, depth - 1);
+  }).join(", ")})`;
+}
+function formatNumber(value) {
+  if (!Number.isFinite(value))
+    return "NaN";
+  return String(value);
+}
+function getGeometryDepth(type) {
+  switch (type) {
+    case "Point":
+      return 0;
+    case "LineString":
+    case "MultiPoint":
+      return 1;
+    case "Polygon":
+    case "MultiLineString":
+      return 2;
+    case "MultiPolygon":
+      return 3;
+  }
+}
+function getWKTDepth(type) {
+  switch (type) {
+    case "POINT":
+      return 0;
+    case "LINESTRING":
+      return 1;
+    case "POLYGON":
+      return 2;
+    case "MULTIPOINT":
+      return 1;
+    case "MULTILINESTRING":
+      return 2;
+    case "MULTIPOLYGON":
+      return 3;
+    default:
+      throw new Error(`Unsupported WKT geometry type ${type}`);
+  }
+}
+function makeGeometry(type, coordinates) {
+  const canonical = type[0] + type.slice(1).toLowerCase();
+  const names = {
+    Point: "Point",
+    Linestring: "LineString",
+    Polygon: "Polygon",
+    Multipoint: "MultiPoint",
+    Multilinestring: "MultiLineString",
+    Multipolygon: "MultiPolygon"
+  };
+  const geometryType = names[canonical];
+  if (!geometryType)
+    throw new Error(`Unsupported WKT geometry type ${type}`);
+  return { type: geometryType, coordinates };
+}
+function makeEmptyGeometry(type, dimensionSize) {
+  if (type === "GEOMETRYCOLLECTION")
+    return { type: "GeometryCollection", geometries: [] };
+  if (type === "POINT") {
+    return {
+      type: "Point",
+      coordinates: new Array(getValidDimensionSize(dimensionSize)).fill(Number.NaN)
+    };
+  }
+  return makeGeometry(type, []);
+}
+function getValidDimensionSize(size) {
+  if (size === 2 || size === 3 || size === 4)
+    return size;
+  return getWellKnownDimensionSize("xy");
+}
+function isEmptyCoordinates(value) {
+  if (value.length === 0)
+    return true;
+  if (typeof value[0] === "number") {
+    return value.every((component) => !Number.isFinite(component));
+  }
+  return value.every((child) => isEmptyCoordinates(child));
+}
+function isNumberToken(token) {
+  return token !== "" && Number.isFinite(Number(token));
+}
+//# sourceMappingURL=index.cjs.map