@math.gl/dggs 5.0.0-alpha.10

package/dist/index.cjs

@@ -0,0 +1,863 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// dist/index.js
+var index_exports = {};
+__export(index_exports, {
+  A5Decoder: () => A5Decoder,
+  DGGS_DECODERS: () => DGGS_DECODERS,
+  GeohashDecoder: () => GeohashDecoder,
+  H3Decoder: () => H3Decoder,
+  PlusCodeDecoder: () => PlusCodeDecoder,
+  QuadkeyDecoder: () => QuadkeyDecoder,
+  S2Decoder: () => S2Decoder,
+  findDGGSCellColumn: () => findDGGSCellColumn,
+  getS2BoundaryFlat: () => getS2BoundaryFlat,
+  getS2Bounds: () => getS2Bounds,
+  getS2ChildIndex: () => getS2ChildIndex,
+  getS2DescendantIndex: () => getS2DescendantIndex,
+  getS2IndexFromCell: () => getS2IndexFromCell,
+  getS2IndexFromToken: () => getS2IndexFromToken,
+  getS2Level: () => getS2Level,
+  getS2LngLat: () => getS2LngLat,
+  getS2TokenFromIndex: () => getS2TokenFromIndex,
+  isS2IndexValid: () => isS2IndexValid,
+  isS2TokenValid: () => isS2TokenValid,
+  quadkeyToWorldBounds: () => quadkeyToWorldBounds,
+  unwrapDGGSBoundary: () => unwrapDGGSBoundary
+});
+module.exports = __toCommonJS(index_exports);
+
+// dist/a5-decoder.js
+var import_a5_js = require("a5-js");
+
+// dist/unwrap-dggs-boundary.js
+function unwrapDGGSBoundary(boundary, referenceLongitude) {
+  const result = boundary.map(([longitude, latitude]) => [longitude, latitude]);
+  if (result.length === 0) {
+    return result;
+  }
+  let west = Infinity;
+  let east = -Infinity;
+  for (const [longitude] of boundary) {
+    west = Math.min(west, longitude);
+    east = Math.max(east, longitude);
+  }
+  if (east - west >= 360) {
+    return result;
+  }
+  let previous = referenceLongitude ?? result[0][0];
+  for (const point of result) {
+    const delta = point[0] - previous;
+    if (delta > 180) {
+      point[0] -= 360 * Math.ceil((delta - 180) / 360);
+    } else if (delta < -180) {
+      point[0] += 360 * Math.ceil((-delta - 180) / 360);
+    }
+    previous = point[0];
+  }
+  const first = boundary[0];
+  const last = boundary[boundary.length - 1];
+  if (first[0] === last[0] && first[1] === last[1]) {
+    if (Math.abs(result[result.length - 1][0] - result[0][0]) > 180) {
+      return boundary.map(([longitude, latitude]) => [longitude, latitude]);
+    }
+    result[result.length - 1] = [...result[0]];
+  }
+  return result;
+}
+
+// dist/dggs-decoder.js
+function getDGGSCellToken(cell, gridName) {
+  if (typeof cell !== "string") {
+    throw new Error(`${gridName} cell identifiers must be strings`);
+  }
+  return cell;
+}
+function getDGGSCellBounds(boundary) {
+  let west = Infinity;
+  let south = Infinity;
+  let east = -Infinity;
+  let north = -Infinity;
+  for (const [longitude, latitude] of boundary) {
+    west = Math.min(west, longitude);
+    south = Math.min(south, latitude);
+    east = Math.max(east, longitude);
+    north = Math.max(north, latitude);
+  }
+  return [
+    [west, south],
+    [east, north]
+  ];
+}
+function withDGGSBoundaryOptions(decoder) {
+  const cellToBoundary3 = (cell, options) => {
+    const boundary = decoder.cellToBoundary(cell);
+    return (options == null ? void 0 : options.unwrap) ? unwrapDGGSBoundary(boundary, options.referenceLongitude) : boundary;
+  };
+  return {
+    ...decoder,
+    cellToBoundary: cellToBoundary3,
+    cellToBoundaryFlat: (cell, options) => (options == null ? void 0 : options.unwrap) ? cellToBoundary3(cell, options).flat() : decoder.cellToBoundaryFlat(cell),
+    cellToBounds: (cell, options) => {
+      const bounds = decoder.cellToBounds(cell);
+      if (!(options == null ? void 0 : options.unwrap) || bounds[1][0] - bounds[0][0] >= 360) {
+        return bounds;
+      }
+      const unwrapped = getDGGSCellBounds(cellToBoundary3(cell, options));
+      unwrapped[0][1] = bounds[0][1];
+      unwrapped[1][1] = bounds[1][1];
+      return unwrapped;
+    }
+  };
+}
+
+// dist/a5-decoder.js
+var A5Decoder = withDGGSBoundaryOptions({
+  name: "a5",
+  hasNumericRepresentation: true,
+  cellColumnNames: [
+    "a5",
+    "a5Token",
+    "a5_token",
+    "a5Cell",
+    "a5_cell",
+    "a5CellId",
+    "a5_cell_id",
+    "pentagon"
+  ],
+  tokenToCell: (token) => (0, import_a5_js.hexToU64)(removeHexPrefix(token)),
+  cellToToken: (cell) => typeof cell === "string" ? removeHexPrefix(cell) : (0, import_a5_js.u64ToHex)(cell),
+  cellToLngLat: (cell) => (0, import_a5_js.cellToLonLat)(getA5CellIndex(cell)),
+  cellToBoundary: (cell) => getA5Boundary(cell),
+  cellToBoundaryFlat: (cell) => getA5Boundary(cell).flat(),
+  cellToBounds: (cell) => getDGGSCellBounds(getA5Boundary(cell))
+});
+function getA5CellIndex(cell) {
+  return typeof cell === "bigint" ? cell : (0, import_a5_js.hexToU64)(removeHexPrefix(cell));
+}
+function getA5Boundary(cell) {
+  return (0, import_a5_js.cellToBoundary)(getA5CellIndex(cell)).map(([longitude, latitude]) => [longitude, latitude]);
+}
+function removeHexPrefix(token) {
+  return token.startsWith("0x") || token.startsWith("0X") ? token.slice(2) : token;
+}
+
+// dist/geohash-decoder.js
+var GeohashDecoder = withDGGSBoundaryOptions({
+  name: "geohash",
+  hasNumericRepresentation: false,
+  cellColumnNames: ["geohash", "geohashId", "geohash_id"],
+  cellToLngLat: (cell) => getGeohashLngLat(getDGGSCellToken(cell, "GeoHash")),
+  cellToBoundary: (cell) => getGeohashBoundary(getDGGSCellToken(cell, "GeoHash")),
+  cellToBoundaryFlat: (cell) => getGeohashBoundaryFlat(getDGGSCellToken(cell, "GeoHash")),
+  cellToBounds: (cell) => getGeohashBounds(getDGGSCellToken(cell, "GeoHash"))
+});
+var BASE32_CODES = "0123456789bcdefghjkmnpqrstuvwxyz";
+var BASE32_CODES_DICT = {};
+for (let i = 0; i < BASE32_CODES.length; i++) {
+  BASE32_CODES_DICT[BASE32_CODES.charAt(i)] = i;
+}
+var MIN_LAT = -90;
+var MAX_LAT = 90;
+var MIN_LON = -180;
+var MAX_LON = 180;
+function getGeohashLngLat(geohash) {
+  const [[w, s], [e, n]] = getGeohashBounds(geohash);
+  return [(e + w) / 2, (n + s) / 2];
+}
+function getGeohashBoundary(geohash) {
+  const [[w, s], [e, n]] = getGeohashBounds(geohash);
+  return [
+    [e, n],
+    [e, s],
+    [w, s],
+    [w, n],
+    [e, n]
+  ];
+}
+function getGeohashBoundaryFlat(geohash) {
+  const [[w, s], [e, n]] = getGeohashBounds(geohash);
+  return [e, n, e, s, w, s, w, n, e, n];
+}
+function getGeohashBounds(geohash) {
+  let isLon = true;
+  let maxLat = MAX_LAT;
+  let minLat = MIN_LAT;
+  let maxLon = MAX_LON;
+  let minLon = MIN_LON;
+  let mid;
+  let hashValue = 0;
+  for (let i = 0, l = geohash.length; i < l; i++) {
+    const code = geohash[i].toLowerCase();
+    hashValue = BASE32_CODES_DICT[code];
+    for (let bits = 4; bits >= 0; bits--) {
+      const bit = hashValue >> bits & 1;
+      if (isLon) {
+        mid = (maxLon + minLon) / 2;
+        if (bit === 1) {
+          minLon = mid;
+        } else {
+          maxLon = mid;
+        }
+      } else {
+        mid = (maxLat + minLat) / 2;
+        if (bit === 1) {
+          minLat = mid;
+        } else {
+          maxLat = mid;
+        }
+      }
+      isLon = !isLon;
+    }
+  }
+  return [
+    [minLon, minLat],
+    [maxLon, maxLat]
+  ];
+}
+
+// dist/h3-decoder.js
+var import_h3_js = require("h3-js");
+var H3Decoder = withDGGSBoundaryOptions({
+  name: "h3",
+  hasNumericRepresentation: true,
+  cellColumnNames: [
+    "h3",
+    "h3Index",
+    "h3_index",
+    "h3Cell",
+    "h3_cell",
+    "h3CellId",
+    "h3_cell_id",
+    "hexagon"
+  ],
+  tokenToCell: (token) => getBigIntFromHexToken(token),
+  cellToToken: (cell) => getH3Token(cell),
+  cellToLngLat: (cell) => getH3LngLat(cell),
+  cellToBoundary: (cell) => getH3Boundary(cell),
+  cellToBoundaryFlat: (cell) => getH3Boundary(cell).flat(),
+  cellToBounds: (cell) => getDGGSCellBounds(getH3Boundary(cell))
+});
+function getH3Token(cell) {
+  return typeof cell === "bigint" ? cell.toString(16) : removeHexPrefix2(cell);
+}
+function getH3LngLat(cell) {
+  const [latitude, longitude] = (0, import_h3_js.cellToLatLng)(getH3Token(cell));
+  return [longitude, latitude];
+}
+function getH3Boundary(cell) {
+  return (0, import_h3_js.cellToBoundary)(getH3Token(cell), true).map(([longitude, latitude]) => [
+    longitude,
+    latitude
+  ]);
+}
+function getBigIntFromHexToken(token) {
+  return BigInt(`0x${removeHexPrefix2(token)}`);
+}
+function removeHexPrefix2(token) {
+  return token.startsWith("0x") || token.startsWith("0X") ? token.slice(2) : token;
+}
+
+// dist/plus-code-decoder.js
+var import_open_location_code = __toESM(require("open-location-code"), 1);
+var openLocationCode = new import_open_location_code.default.OpenLocationCode();
+var PlusCodeDecoder = withDGGSBoundaryOptions({
+  name: "plus-code",
+  hasNumericRepresentation: false,
+  cellColumnNames: ["plusCode", "plus_code", "openLocationCode", "open_location_code", "olc"],
+  cellToLngLat: (cell) => getPlusCodeLngLat(cell),
+  cellToBoundary: (cell) => getPlusCodeBoundary(decodePlusCode(cell)),
+  cellToBoundaryFlat: (cell) => {
+    const area = decodePlusCode(cell);
+    return getPlusCodeBoundary(area).flat();
+  },
+  cellToBounds: (cell) => {
+    const area = decodePlusCode(cell);
+    return [
+      [area.longitudeLo, area.latitudeLo],
+      [area.longitudeHi, area.latitudeHi]
+    ];
+  }
+});
+function getPlusCodeLngLat(cell) {
+  const area = decodePlusCode(cell);
+  return [area.longitudeCenter, area.latitudeCenter];
+}
+function decodePlusCode(cell) {
+  const code = getDGGSCellToken(cell, "Plus Code");
+  if (!openLocationCode.isFull(code)) {
+    throw new Error(`Plus Code decoder requires a full code: ${code}`);
+  }
+  return openLocationCode.decode(code);
+}
+function getPlusCodeBoundary(area) {
+  const { longitudeLo: west, latitudeLo: south, longitudeHi: east, latitudeHi: north } = area;
+  return [
+    [east, north],
+    [east, south],
+    [west, south],
+    [west, north],
+    [east, north]
+  ];
+}
+
+// dist/quadkey-decoder.js
+var TILE_SIZE = 512;
+var QuadkeyDecoder = withDGGSBoundaryOptions({
+  name: "quadkey",
+  hasNumericRepresentation: false,
+  cellColumnNames: ["quadkey", "quadkeyId", "quadkey_id"],
+  cellToLngLat: (cell) => getQuadkeyLngLat(getDGGSCellToken(cell, "Quadkey")),
+  cellToBoundary: (cell) => getQuadkeyBoundary(getDGGSCellToken(cell, "Quadkey")),
+  cellToBoundaryFlat: (cell) => getQuadkeyBoundaryFlat(getDGGSCellToken(cell, "Quadkey")),
+  cellToBounds: (cell) => getQuadkeyBounds(getDGGSCellToken(cell, "Quadkey"))
+});
+function getQuadkeyLngLat(quadkey) {
+  const [topLeft, bottomRight] = quadkeyToWorldBounds(quadkey);
+  const [w, n] = worldToLngLat(topLeft);
+  const [e, s] = worldToLngLat(bottomRight);
+  return [(e + w) / 2, (s + n) / 2];
+}
+function getQuadkeyBoundary(quadkey) {
+  const [topLeft, bottomRight] = quadkeyToWorldBounds(quadkey);
+  const [w, n] = worldToLngLat(topLeft);
+  const [e, s] = worldToLngLat(bottomRight);
+  return [
+    [e, n],
+    [e, s],
+    [w, s],
+    [w, n],
+    [e, n]
+  ];
+}
+function getQuadkeyBoundaryFlat(quadkey) {
+  const [topLeft, bottomRight] = quadkeyToWorldBounds(quadkey);
+  const [w, n] = worldToLngLat(topLeft);
+  const [e, s] = worldToLngLat(bottomRight);
+  return [e, n, e, s, w, s, w, n, e, n];
+}
+function getQuadkeyBounds(quadkey) {
+  const [topLeft, bottomRight] = quadkeyToWorldBounds(quadkey);
+  const [w, n] = worldToLngLat(topLeft);
+  const [e, s] = worldToLngLat(bottomRight);
+  return [
+    [w, s],
+    [e, n]
+  ];
+}
+function quadkeyToWorldBounds(quadkey) {
+  let x = 0;
+  let y = 0;
+  let mask = 1 << quadkey.length;
+  const scale = mask / TILE_SIZE;
+  for (let i = 0; i < quadkey.length; i++) {
+    mask >>= 1;
+    const q = parseInt(quadkey[i], 10);
+    if (q % 2)
+      x |= mask;
+    if (q > 1)
+      y |= mask;
+  }
+  return [
+    [x / scale, TILE_SIZE - y / scale],
+    [(x + 0.99) / scale, TILE_SIZE - (y + 0.99) / scale]
+  ];
+}
+var PI = Math.PI;
+var PI_4 = PI / 4;
+var RADIANS_TO_DEGREES = 180 / PI;
+function worldToLngLat(xy) {
+  const [x, y] = xy;
+  const lambda2 = x / TILE_SIZE * (2 * PI) - PI;
+  const phi2 = 2 * (Math.atan(Math.exp(y / TILE_SIZE * (2 * PI) - PI)) - PI_4);
+  return [lambda2 * RADIANS_TO_DEGREES, phi2 * RADIANS_TO_DEGREES];
+}
+
+// dist/s2-geometry/s2-token.js
+var MAXIMUM_TOKEN_LENGTH = 16;
+var MAXIMUM_S2_INDEX = (1n << 64n) - 1n;
+var VALID_LOWEST_ON_BITS = 0x1555555555555555n;
+var MAXIMUM_LEVEL = 30;
+function getS2IndexFromToken(token) {
+  if (token === "X") {
+    return 0n;
+  }
+  if (!isS2TokenValid(token)) {
+    throw new Error(`Invalid S2 token: ${token}`);
+  }
+  const paddedToken = token.padEnd(MAXIMUM_TOKEN_LENGTH, "0");
+  return BigInt(`0x${paddedToken}`);
+}
+function getS2TokenFromIndex(cellId) {
+  if (cellId === 0n) {
+    return "X";
+  }
+  if (!isS2IndexValid(cellId)) {
+    throw new Error(`Invalid S2 index: ${cellId}`);
+  }
+  let numZeroDigits = countTrailingZeros(cellId);
+  const remainder = numZeroDigits % 4;
+  numZeroDigits = (numZeroDigits - remainder) / 4;
+  const trailingZeroHexChars = numZeroDigits;
+  numZeroDigits *= 4;
+  const x = cellId >> BigInt(numZeroDigits);
+  const hexString = x.toString(16).replace(/0+$/, "");
+  const zeroString = Array(17 - trailingZeroHexChars - hexString.length).join("0");
+  return zeroString + hexString;
+}
+function isS2IndexValid(s2Index) {
+  if (typeof s2Index !== "bigint" || s2Index <= 0n || s2Index > MAXIMUM_S2_INDEX) {
+    return false;
+  }
+  const face = s2Index >> 61n;
+  const lowestOnBit = s2Index & -s2Index;
+  return face < 6n && (lowestOnBit & VALID_LOWEST_ON_BITS) !== 0n;
+}
+function isS2TokenValid(token) {
+  if (typeof token !== "string" || !/^[0-9a-fA-F]{1,16}$/.test(token) || token.endsWith("0")) {
+    return false;
+  }
+  const paddedToken = token.padEnd(MAXIMUM_TOKEN_LENGTH, "0");
+  return isS2IndexValid(BigInt(`0x${paddedToken}`));
+}
+function getS2Level(s2Index) {
+  if (!isS2IndexValid(s2Index)) {
+    throw new Error(`Invalid S2 index: ${s2Index}`);
+  }
+  return (60 - countTrailingZeros(s2Index)) / 2;
+}
+function getS2ChildIndex(s2Index, index) {
+  if (!isS2IndexValid(s2Index)) {
+    throw new Error(`Invalid S2 index: ${s2Index}`);
+  }
+  if (!Number.isInteger(index) || index < 0 || index > 3) {
+    throw new Error(`Invalid S2 child index: ${index}`);
+  }
+  if (getS2Level(s2Index) === MAXIMUM_LEVEL) {
+    throw new Error("Cannot subdivide an S2 leaf cell");
+  }
+  const newLsb = lsb(s2Index) >> 2n;
+  const childCellId = s2Index + BigInt(2 * index + 1 - 4) * newLsb;
+  return childCellId;
+}
+function lsb(cellId) {
+  return cellId & -cellId;
+}
+function countTrailingZeros(n) {
+  let count = 0;
+  while (n % 2n === 0n) {
+    n /= 2n;
+    count++;
+  }
+  return count;
+}
+
+// dist/s2-geometry/s2-geometry.js
+function getS2Cell(s2Index) {
+  if (!isS2IndexValid(s2Index)) {
+    throw new Error(`Invalid S2 index: ${s2Index}`);
+  }
+  const key = toHilbertQuadkey(s2Index);
+  const s2cell = fromHilbertQuadKey(key);
+  return s2cell;
+}
+var FACE_BITS = 3;
+var MAX_LEVEL = 30;
+var POS_BITS = 2 * MAX_LEVEL + 1;
+var RADIAN_TO_DEGREE = 180 / Math.PI;
+var HILBERT_MAP = {
+  a: [
+    [0, "d"],
+    [1, "a"],
+    [3, "b"],
+    [2, "a"]
+  ],
+  b: [
+    [2, "b"],
+    [1, "b"],
+    [3, "a"],
+    [0, "c"]
+  ],
+  c: [
+    [2, "c"],
+    [3, "d"],
+    [1, "c"],
+    [0, "b"]
+  ],
+  d: [
+    [0, "a"],
+    [3, "c"],
+    [1, "d"],
+    [2, "d"]
+  ]
+};
+function fromHilbertQuadKey(hilbertQuadkey) {
+  if (!/^[0-5]\/[0-3]{0,30}$/.test(hilbertQuadkey)) {
+    throw new Error(`Invalid S2 Hilbert quadkey: ${hilbertQuadkey}`);
+  }
+  const parts = hilbertQuadkey.split("/");
+  const face = parseInt(parts[0], 10);
+  const position = parts[1] || "";
+  const maxLevel = position.length;
+  let level = 0;
+  const point = [0, 0];
+  for (let i = maxLevel - 1; i >= 0; i--) {
+    level = maxLevel - i;
+    const bit = position[i];
+    let rx = 0;
+    let ry = 0;
+    if (bit === "1") {
+      ry = 1;
+    } else if (bit === "2") {
+      rx = 1;
+      ry = 1;
+    } else if (bit === "3") {
+      rx = 1;
+    }
+    const val = Math.pow(2, level - 1);
+    rotateAndFlipQuadrant(val, point, rx, ry);
+    point[0] += val * rx;
+    point[1] += val * ry;
+  }
+  if (face % 2 === 1) {
+    const t = point[0];
+    point[0] = point[1];
+    point[1] = t;
+  }
+  return { face, ij: point, level };
+}
+function toHilbertQuadkey(id) {
+  if (!isS2IndexValid(id)) {
+    throw new Error(`Invalid S2 index: ${id}`);
+  }
+  let bin = id.toString(2);
+  while (bin.length < FACE_BITS + POS_BITS) {
+    bin = "0" + bin;
+  }
+  const lsbIndex = bin.lastIndexOf("1");
+  const faceB = bin.substring(0, 3);
+  const posB = bin.substring(3, lsbIndex);
+  const levelN = posB.length / 2;
+  const faceS = BigInt(`0b${faceB}`).toString(10);
+  let posS = "";
+  if (levelN !== 0) {
+    posS = BigInt(`0b${posB}`).toString(4);
+    while (posS.length < levelN) {
+      posS = "0" + posS;
+    }
+  }
+  return `${faceS}/${posS}`;
+}
+function getS2IndexFromCell(s2Cell) {
+  const { face, ij, level } = s2Cell;
+  if (!Number.isInteger(face) || face < 0 || face > 5) {
+    throw new Error(`Invalid S2 face: ${face}`);
+  }
+  if (!Number.isInteger(level) || level < 0 || level > MAX_LEVEL) {
+    throw new Error(`Invalid S2 level: ${level}`);
+  }
+  const maximumCoordinate = 2 ** level;
+  if (!Number.isInteger(ij[0]) || !Number.isInteger(ij[1]) || ij[0] < 0 || ij[1] < 0 || ij[0] >= maximumCoordinate || ij[1] >= maximumCoordinate) {
+    throw new Error(`Invalid S2 IJ coordinates: ${ij[0]}, ${ij[1]}`);
+  }
+  const positions = getHilbertQuadList(ij[0], ij[1], level, face);
+  let s2Index = BigInt(face) << 61n;
+  for (let positionIndex = 0; positionIndex < positions.length; positionIndex++) {
+    const bitOffset = 59 - positionIndex * 2;
+    s2Index |= BigInt(positions[positionIndex]) << BigInt(bitOffset);
+  }
+  s2Index |= 1n << BigInt(60 - level * 2);
+  return s2Index;
+}
+function getS2DescendantIndex(rootIndex, relativeLevel, x, y) {
+  const rootCell = getS2Cell(rootIndex);
+  if (!Number.isInteger(relativeLevel) || relativeLevel < 0 || rootCell.level + relativeLevel > MAX_LEVEL) {
+    throw new Error(`Invalid S2 relative level: ${relativeLevel}`);
+  }
+  const divisionCount = 2 ** relativeLevel;
+  if (!Number.isInteger(x) || !Number.isInteger(y) || x < 0 || y < 0 || x >= divisionCount || y >= divisionCount) {
+    throw new Error(`Invalid S2 descendant coordinates: ${x}, ${y}`);
+  }
+  return getS2IndexFromCell({
+    face: rootCell.face,
+    ij: [rootCell.ij[0] * divisionCount + x, rootCell.ij[1] * divisionCount + y],
+    level: rootCell.level + relativeLevel
+  });
+}
+function IJToST(ij, order, offsets) {
+  const maxSize = 1 << order;
+  return [(ij[0] + offsets[0]) / maxSize, (ij[1] + offsets[1]) / maxSize];
+}
+function singleSTtoUV(st) {
+  if (st >= 0.5) {
+    return 1 / 3 * (4 * st * st - 1);
+  }
+  return 1 / 3 * (1 - 4 * (1 - st) * (1 - st));
+}
+function STToUV(st) {
+  return [singleSTtoUV(st[0]), singleSTtoUV(st[1])];
+}
+function FaceUVToXYZ(face, [u, v]) {
+  switch (face) {
+    case 0:
+      return [1, u, v];
+    case 1:
+      return [-u, 1, v];
+    case 2:
+      return [-u, -v, 1];
+    case 3:
+      return [-1, -v, -u];
+    case 4:
+      return [v, -1, -u];
+    case 5:
+      return [v, u, -1];
+    default:
+      throw new Error("Invalid face");
+  }
+}
+function XYZToLngLat([x, y, z]) {
+  const lat = Math.atan2(z, Math.sqrt(x * x + y * y));
+  const lng = Math.atan2(y, x);
+  return [lng * RADIAN_TO_DEGREE, lat * RADIAN_TO_DEGREE];
+}
+function rotateAndFlipQuadrant(n, point, rx, ry) {
+  if (ry === 0) {
+    if (rx === 1) {
+      point[0] = n - 1 - point[0];
+      point[1] = n - 1 - point[1];
+    }
+    const x = point[0];
+    point[0] = point[1];
+    point[1] = x;
+  }
+}
+function getHilbertQuadList(x, y, level, face) {
+  let orientation = face % 2 === 1 ? "d" : "a";
+  const positions = [];
+  for (let bit = level - 1; bit >= 0; bit--) {
+    const mask = 1 << bit;
+    const quadrantX = (x & mask) !== 0 ? 1 : 0;
+    const quadrantY = (y & mask) !== 0 ? 1 : 0;
+    const [position, nextOrientation] = HILBERT_MAP[orientation][quadrantX * 2 + quadrantY];
+    positions.push(position);
+    orientation = nextOrientation;
+  }
+  return positions;
+}
+
+// dist/s2-geometry/s2-to-boundary.js
+var MAX_RESOLUTION = 100;
+function getS2GeoBounds(s2Index) {
+  const s2Cell = getS2Cell(s2Index);
+  return getS2GeoBoundsFromCell(s2Cell);
+}
+function getS2GeoBoundsFromCell({ face, ij, level }) {
+  const offsets = [
+    [0, 0],
+    [0, 1],
+    [1, 1],
+    [1, 0],
+    [0, 0]
+  ];
+  const resolution = Math.max(1, Math.ceil(MAX_RESOLUTION * Math.pow(2, -level)));
+  const result = new Float64Array(4 * resolution * 2 + 2);
+  let ptIndex = 0;
+  let prevLng = 0;
+  for (let i = 0; i < 4; i++) {
+    const offset = offsets[i].slice(0);
+    const nextOffset = offsets[i + 1];
+    const stepI = (nextOffset[0] - offset[0]) / resolution;
+    const stepJ = (nextOffset[1] - offset[1]) / resolution;
+    for (let j = 0; j < resolution; j++) {
+      offset[0] += stepI;
+      offset[1] += stepJ;
+      const st = IJToST(ij, level, offset);
+      const uv = STToUV(st);
+      const xyz = FaceUVToXYZ(face, uv);
+      const lngLat = XYZToLngLat(xyz);
+      if (Math.abs(lngLat[1]) > 89.999) {
+        lngLat[0] = prevLng;
+      }
+      const deltaLng = lngLat[0] - prevLng;
+      lngLat[0] += deltaLng > 180 ? -360 : deltaLng < -180 ? 360 : 0;
+      result[ptIndex++] = lngLat[0];
+      result[ptIndex++] = lngLat[1];
+      prevLng = lngLat[0];
+    }
+  }
+  result[ptIndex++] = result[0];
+  result[ptIndex++] = result[1];
+  return result;
+}
+
+// dist/s2-decoder.js
+var S2Decoder = withDGGSBoundaryOptions({
+  name: "s2",
+  hasNumericRepresentation: true,
+  cellColumnNames: ["s2", "s2Token", "s2_token", "s2Cell", "s2_cell", "s2CellId", "s2_cell_id"],
+  tokenToCell: (s2Token) => getS2IndexFromToken(s2Token),
+  cellToToken: (cell) => getS2TokenFromIndex(getS2CellIndex(cell)),
+  cellToLngLat: (cell) => getS2LngLat(cell),
+  cellToBoundary: (cell) => getS2Boundary(cell),
+  cellToBoundaryFlat: (cell) => getS2BoundaryFlat(cell),
+  cellToBounds: (cell) => getS2Bounds(cell)
+});
+function getS2LngLat(cell) {
+  const s2Index = getS2CellIndex(cell);
+  const s2Cell = getS2Cell(s2Index);
+  const st = IJToST(s2Cell.ij, s2Cell.level, [0.5, 0.5]);
+  const uv = STToUV(st);
+  const xyz = FaceUVToXYZ(s2Cell.face, uv);
+  const lngLat = XYZToLngLat(xyz);
+  return lngLat;
+}
+function getS2BoundaryFlat(cell) {
+  const s2Index = getS2CellIndex(cell);
+  const float64Array = getS2GeoBounds(s2Index);
+  return Array.from(float64Array);
+}
+function getS2Boundary(cell) {
+  const flatBoundary = getS2BoundaryFlat(cell);
+  const boundary = [];
+  for (let i = 0; i < flatBoundary.length; i += 2) {
+    boundary.push([flatBoundary[i], flatBoundary[i + 1]]);
+  }
+  return boundary;
+}
+function getS2Bounds(cell) {
+  const s2Cell = getS2Cell(getS2CellIndex(cell));
+  if (s2Cell.level === 0) {
+    return getS2RootBounds(s2Cell.face);
+  }
+  const offsets = [
+    [0, 0],
+    [0, 1],
+    [1, 1],
+    [1, 0]
+  ];
+  let west = Infinity;
+  let south = Infinity;
+  let east = -Infinity;
+  let north = -Infinity;
+  let previousLongitude;
+  for (const offset of offsets) {
+    const st = IJToST(s2Cell.ij, s2Cell.level, offset);
+    const uv = STToUV(st);
+    const [x, y, z] = FaceUVToXYZ(s2Cell.face, uv);
+    let [longitude, latitude] = XYZToLngLat([x, y, z]);
+    if (x === 0 && y === 0 && previousLongitude !== void 0) {
+      longitude = previousLongitude;
+    }
+    if (previousLongitude !== void 0) {
+      const longitudeDelta = longitude - previousLongitude;
+      longitude += longitudeDelta > 180 ? -360 : longitudeDelta < -180 ? 360 : 0;
+    }
+    previousLongitude = longitude;
+    west = Math.min(west, longitude);
+    south = Math.min(south, latitude);
+    east = Math.max(east, longitude);
+    north = Math.max(north, latitude);
+  }
+  const angularEpsilon = 2 * Number.EPSILON * 180 / Math.PI;
+  return [
+    [west - angularEpsilon, Math.max(-90, south - angularEpsilon)],
+    [east + angularEpsilon, Math.min(90, north + angularEpsilon)]
+  ];
+}
+function getS2CellIndex(cell) {
+  return typeof cell === "bigint" ? cell : getS2IndexFromToken(cell);
+}
+function getS2RootBounds(face) {
+  const polarLatitude = Math.asin(Math.sqrt(1 / 3)) * 180 / Math.PI;
+  switch (face) {
+    case 0:
+      return [
+        [-45, -45],
+        [45, 45]
+      ];
+    case 1:
+      return [
+        [45, -45],
+        [135, 45]
+      ];
+    case 2:
+      return [
+        [-180, polarLatitude],
+        [180, 90]
+      ];
+    case 3:
+      return [
+        [135, -45],
+        [225, 45]
+      ];
+    case 4:
+      return [
+        [-135, -45],
+        [-45, 45]
+      ];
+    case 5:
+      return [
+        [-180, -90],
+        [180, -polarLatitude]
+      ];
+    default:
+      throw new Error(`Invalid S2 face: ${face}`);
+  }
+}
+
+// dist/index.js
+var DGGS_DECODERS = [
+  A5Decoder,
+  GeohashDecoder,
+  H3Decoder,
+  PlusCodeDecoder,
+  QuadkeyDecoder,
+  S2Decoder
+];
+function findDGGSCellColumn(columnNames, decoders = DGGS_DECODERS) {
+  const actualNames = /* @__PURE__ */ new Map();
+  for (const columnName of columnNames) {
+    actualNames.set(columnName.toLowerCase(), columnName);
+  }
+  let match = null;
+  for (const decoder of decoders) {
+    for (const candidate of decoder.cellColumnNames) {
+      const columnName = actualNames.get(candidate.toLowerCase());
+      if (!columnName) {
+        continue;
+      }
+      if (match && (match.decoder !== decoder || match.columnName !== columnName)) {
+        return null;
+      }
+      match = { columnName, decoder };
+    }
+  }
+  return match;
+}
+//# sourceMappingURL=index.cjs.map