webdggrid 1.5.0 → 1.7.0

package/lib-esm/webdggrid.js

@@ -269,8 +269,10 @@ export class Webdggrid {
      * @returns Total number of cells at the given resolution.
      */
     nCells(resolution = DEFAULT_RESOLUTION) {
-        const { poleCoordinates: { lat, lng }, azimuth, topology, projection, aperture, } = this.dggs;
-        const cellCount = this._module.nCells(lng, lat, azimuth, aperture, resolution, topology, projection);
+        const { poleCoordinates: { lat, lng }, azimuth, topology, projection, aperture, apertureSequence, } = this.dggs;
+        const isApertureSequence = !!apertureSequence;
+        const apSeq = apertureSequence || "";
+        const cellCount = this._module.nCells(lng, lat, azimuth, aperture, resolution, topology, projection, isApertureSequence, apSeq);
         return cellCount;
     }
     /**
@@ -289,8 +291,10 @@ export class Webdggrid {
      * @returns Average cell area in km².
      */
     cellAreaKM(resolution = DEFAULT_RESOLUTION) {
-        const { poleCoordinates: { lat, lng }, azimuth, topology, projection, aperture, } = this.dggs;
-        const cellCount = this._module.cellAreaKM(lng, lat, azimuth, aperture, resolution, topology, projection);
+        const { poleCoordinates: { lat, lng }, azimuth, topology, projection, aperture, apertureSequence, } = this.dggs;
+        const isApertureSequence = !!apertureSequence;
+        const apSeq = apertureSequence || "";
+        const cellCount = this._module.cellAreaKM(lng, lat, azimuth, aperture, resolution, topology, projection, isApertureSequence, apSeq);
         return cellCount;
     }
     /**
@@ -309,8 +313,10 @@ export class Webdggrid {
      * @returns Average cell spacing in km.
      */
     cellDistKM(resolution = DEFAULT_RESOLUTION) {
-        const { poleCoordinates: { lat, lng }, azimuth, topology, projection, aperture, } = this.dggs;
-        const cellCount = this._module.cellDistKM(lng, lat, azimuth, aperture, resolution, topology, projection);
+        const { poleCoordinates: { lat, lng }, azimuth, topology, projection, aperture, apertureSequence, } = this.dggs;
+        const isApertureSequence = !!apertureSequence;
+        const apSeq = apertureSequence || "";
+        const cellCount = this._module.cellDistKM(lng, lat, azimuth, aperture, resolution, topology, projection, isApertureSequence, apSeq);
         return cellCount;
     }
     /**
@@ -330,8 +336,10 @@ export class Webdggrid {
      * @returns Grid CLS value.
      */
     gridStatCLS(resolution = DEFAULT_RESOLUTION) {
-        const { poleCoordinates: { lat, lng }, azimuth, topology, projection, aperture, } = this.dggs;
-        const cellCount = this._module.gridStatCLS(lng, lat, azimuth, aperture, resolution, topology, projection);
+        const { poleCoordinates: { lat, lng }, azimuth, topology, projection, aperture, apertureSequence, } = this.dggs;
+        const isApertureSequence = !!apertureSequence;
+        const apSeq = apertureSequence || "";
+        const cellCount = this._module.gridStatCLS(lng, lat, azimuth, aperture, resolution, topology, projection, isApertureSequence, apSeq);
         return cellCount;
     }
     /**
@@ -364,10 +372,12 @@ export class Webdggrid {
      *   in the same order.
      */
     geoToSequenceNum(coordinates, resolution = DEFAULT_RESOLUTION) {
-        const { poleCoordinates: { lat, lng }, azimuth, topology, projection, aperture, } = this.dggs;
+        const { poleCoordinates: { lat, lng }, azimuth, topology, projection, aperture, apertureSequence, } = this.dggs;
+        const isApertureSequence = !!apertureSequence;
+        const apSeq = apertureSequence || "";
         const xCoords = coordinates.map((coord) => coord[0]);
         const yCoords = coordinates.map((coord) => coord[1]);
-        const resultArray = this._module.DgGEO_to_SEQNUM(lng, lat, azimuth, aperture, resolution, topology, projection, xCoords, yCoords);
+        const resultArray = this._module.DgGEO_to_SEQNUM(lng, lat, azimuth, aperture, resolution, topology, projection, isApertureSequence, apSeq, xCoords, yCoords);
         return resultArray;
     }
     /**
@@ -389,8 +399,10 @@ export class Webdggrid {
      *   the same order.
      */
     sequenceNumToGeo(sequenceNum, resolution = DEFAULT_RESOLUTION) {
-        const { poleCoordinates: { lat, lng }, azimuth, topology, projection, aperture, } = this.dggs;
-        const resultArray = this._module.SEQNUM_to_GEO(lng, lat, azimuth, aperture, resolution, topology, projection, sequenceNum);
+        const { poleCoordinates: { lat, lng }, azimuth, topology, projection, aperture, apertureSequence, } = this.dggs;
+        const isApertureSequence = !!apertureSequence;
+        const apSeq = apertureSequence || "";
+        const resultArray = this._module.SEQNUM_to_GEO(lng, lat, azimuth, aperture, resolution, topology, projection, isApertureSequence, apSeq, sequenceNum);
         const size = resultArray.length / 2;
         const arrayOfArrays = [];
         for (let i = 0; i < size; i += 1) {
@@ -426,10 +438,12 @@ export class Webdggrid {
      *   coordinate, in the same order.
      */
     geoToGeo(coordinates, resolution = DEFAULT_RESOLUTION) {
-        const { poleCoordinates: { lat, lng }, azimuth, topology, projection, aperture, } = this.dggs;
+        const { poleCoordinates: { lat, lng }, azimuth, topology, projection, aperture, apertureSequence, } = this.dggs;
+        const isApertureSequence = !!apertureSequence;
+        const apSeq = apertureSequence || "";
         const xCoords = coordinates.map((coord) => coord[0]);
         const yCoords = coordinates.map((coord) => coord[1]);
-        const resultArray = this._module.GEO_to_GEO(lng, lat, azimuth, aperture, resolution, topology, projection, xCoords, yCoords);
+        const resultArray = this._module.GEO_to_GEO(lng, lat, azimuth, aperture, resolution, topology, projection, isApertureSequence, apSeq, xCoords, yCoords);
         const size = resultArray.length / 2;
         const arrayOfArrays = [];
         for (let i = 0; i < size; i += 1) {
@@ -461,11 +475,13 @@ export class Webdggrid {
      * @throws If the WASM module encounters an invalid cell ID.
      */
     sequenceNumToGrid(sequenceNum, resolution = DEFAULT_RESOLUTION) {
-        const { poleCoordinates: { lat, lng }, azimuth, topology, projection, aperture, } = this.dggs;
+        const { poleCoordinates: { lat, lng }, azimuth, topology, projection, aperture, apertureSequence, } = this.dggs;
+        const isApertureSequence = !!apertureSequence;
+        const apSeq = apertureSequence || "";
         const inputSize = sequenceNum.length;
         let resultArray = [];
         try {
-            resultArray = this._module.SeqNumGrid(lng, lat, azimuth, aperture, resolution, topology, projection, sequenceNum);
+            resultArray = this._module.SeqNumGrid(lng, lat, azimuth, aperture, resolution, topology, projection, isApertureSequence, apSeq, sequenceNum);
         }
         catch (e) {
             console.error(this._module.getExceptionMessage(e).toString());
@@ -544,5 +560,1191 @@ export class Webdggrid {
             features,
         };
     }
+    /**
+     * Returns all neighboring cells (sharing an edge) for each input cell.
+     *
+     * For hexagonal grids, each interior cell typically has 6 neighbors.
+     * Pentagon cells and boundary cells may have fewer. Triangle topology
+     * is not supported by the underlying DGGRID library.
+     *
+     * The output is a 2-D array: `result[i]` contains all neighbors of
+     * `sequenceNum[i]`.
+     *
+     * ```ts
+     * const neighbors = dggs.sequenceNumNeighbors([123n], 5);
+     * // neighbors[0] = [122n, 124n, 125n, 126n, 127n, 128n]
+     * ```
+     *
+     * ::: warning
+     * Triangle topology is **not supported**. Attempting to retrieve neighbors
+     * for a TRIANGLE grid will throw an error.
+     * :::
+     *
+     * @param sequenceNum - Array of `BigInt` cell IDs whose neighbors to find.
+     * @param resolution - Resolution at which the IDs were generated. Defaults
+     *   to the instance's current {@link resolution}.
+     * @returns A 2-D array of `BigInt[]`: `result[i]` is the array of neighbor
+     *   IDs for `sequenceNum[i]`.
+     * @throws If Triangle topology is used or if an invalid cell ID is provided.
+     */
+    sequenceNumNeighbors(sequenceNum, resolution = DEFAULT_RESOLUTION) {
+        const { poleCoordinates: { lat, lng }, azimuth, topology, projection, aperture, apertureSequence, } = this.dggs;
+        if (topology === Topology.TRIANGLE) {
+            throw new Error('Neighbor detection is not supported for TRIANGLE topology');
+        }
+        const isApertureSequence = !!apertureSequence;
+        const apSeq = apertureSequence || "";
+        try {
+            const resultArray = this._module.SEQNUMS_neighbors(lng, lat, azimuth, aperture, resolution, topology, projection, isApertureSequence, apSeq, sequenceNum);
+            // The result is a flat array with format:
+            // [count0, count1, ..., countN, neighbor0_0, neighbor0_1, ..., neighbor0_(count0-1), neighbor1_0, ...]
+            const inputSize = sequenceNum.length;
+            const counts = resultArray.slice(0, inputSize);
+            const neighbors = [];
+            let offset = inputSize;
+            for (let i = 0; i < inputSize; i++) {
+                const count = Number(counts[i]);
+                neighbors.push(resultArray.slice(offset, offset + count));
+                offset += count;
+            }
+            return neighbors;
+        }
+        catch (e) {
+            console.error(this._module.getExceptionMessage(e).toString());
+            throw e;
+        }
+    }
+    /**
+     * Returns the parent cell at the next coarser resolution (resolution - 1)
+     * for each input cell.
+     *
+     * The parent-child relationship forms a hierarchical index structure. For
+     * aperture 4 grids, each parent contains 4 children; for aperture 7, each
+     * parent contains 7 children.
+     *
+     * ```ts
+     * const parents = dggs.sequenceNumParent([123n, 456n], 5);
+     * // parents = [30n, 114n]  (at resolution 4)
+     * ```
+     *
+     * ::: info
+     * Calling this method at resolution 0 will throw an error because there
+     * are no cells at resolution -1.
+     * :::
+     *
+     * @param sequenceNum - Array of `BigInt` cell IDs whose parents to find.
+     * @param resolution - Resolution at which the input IDs were generated.
+     *   Must be > 0. Defaults to the instance's current {@link resolution}.
+     * @returns Array of `BigInt` parent cell IDs at resolution - 1, one per
+     *   input cell, in the same order.
+     * @throws If resolution is 0 or if an invalid cell ID is provided.
+     */
+    sequenceNumParent(sequenceNum, resolution = DEFAULT_RESOLUTION) {
+        if (resolution <= 0) {
+            throw new Error('Cannot get parent at resolution 0 or below');
+        }
+        const { poleCoordinates: { lat, lng }, azimuth, topology, projection, aperture, apertureSequence, } = this.dggs;
+        const isApertureSequence = !!apertureSequence;
+        const apSeq = apertureSequence || "";
+        try {
+            const resultArray = this._module.SEQNUMS_parents(lng, lat, azimuth, aperture, resolution, topology, projection, isApertureSequence, apSeq, sequenceNum);
+            return resultArray;
+        }
+        catch (e) {
+            console.error(this._module.getExceptionMessage(e).toString());
+            throw e;
+        }
+    }
+    /**
+     * Returns **all** parent cells that touch each input cell at the coarser
+     * resolution (resolution - 1).
+     *
+     * Unlike {@link sequenceNumParent} which returns only the primary
+     * (containing) parent, this method returns every parent cell whose area
+     * overlaps with the child cell. For interior cells this is typically 1;
+     * for cells on a parent boundary it may be 2 or more.
+     *
+     * The **first element** of each inner array is always the primary
+     * (containing) parent — the same value returned by
+     * {@link sequenceNumParent}.
+     *
+     * ```ts
+     * const allParents = dggs.sequenceNumAllParents([256n], 3);
+     * // allParents[0] = [65n, 66n]  — 65 is the containing parent,
+     * //                               66 is a touching neighbor parent
+     * ```
+     *
+     * @param sequenceNum - Array of `BigInt` cell IDs to query.
+     * @param resolution - Resolution at which the input IDs were generated
+     *   (must be > 0). Defaults to the instance's current {@link resolution}.
+     * @returns A 2-D array: `result[i]` contains all parent cell IDs that
+     *   touch `sequenceNum[i]`, with the primary parent first.
+     * @throws If `resolution` is 0 or negative, or if an invalid cell ID is
+     *   provided.
+     */
+    sequenceNumAllParents(sequenceNum, resolution = DEFAULT_RESOLUTION) {
+        if (resolution <= 0) {
+            throw new Error('Cannot get parents at resolution 0 or below');
+        }
+        try {
+            const resultArray = this._module.SEQNUMS_all_parents(...this._getParams(resolution), sequenceNum);
+            // Convert from JS array of arrays to bigint[][]
+            const result = [];
+            for (let i = 0; i < resultArray.length; i++) {
+                const inner = [];
+                for (let j = 0; j < resultArray[i].length; j++) {
+                    inner.push(resultArray[i][j]);
+                }
+                result.push(inner);
+            }
+            return result;
+        }
+        catch (e) {
+            console.error(this._module.getExceptionMessage(e).toString());
+            throw e;
+        }
+    }
+    /**
+     * Returns all child cells at the next finer resolution (resolution + 1)
+     * for each input cell.
+     *
+     * The number of children depends on the aperture:
+     * - Aperture 3: 3 children per parent
+     * - Aperture 4: 4 children per parent
+     * - Aperture 7: 7 children per parent
+     *
+     * The output is a 2-D array: `result[i]` contains all children of
+     * `sequenceNum[i]`.
+     *
+     * ```ts
+     * const children = dggs.sequenceNumChildren([30n], 4);
+     * // children[0] = [120n, 121n, 122n, 123n]  (at resolution 5, aperture 4)
+     * ```
+     *
+     * ::: info
+     * Children always include both boundary and interior cells. The returned
+     * cells completely cover the parent cell's area.
+     * :::
+     *
+     * @param sequenceNum - Array of `BigInt` cell IDs whose children to find.
+     * @param resolution - Resolution at which the input IDs were generated.
+     *   Defaults to the instance's current {@link resolution}.
+     * @returns A 2-D array of `BigInt[]`: `result[i]` is the array of child
+     *   IDs for `sequenceNum[i]` at resolution + 1.
+     * @throws If an invalid cell ID is provided or if the maximum resolution
+     *   is exceeded.
+     */
+    sequenceNumChildren(sequenceNum, resolution = DEFAULT_RESOLUTION) {
+        const { poleCoordinates: { lat, lng }, azimuth, topology, projection, aperture, apertureSequence, } = this.dggs;
+        const isApertureSequence = !!apertureSequence;
+        const apSeq = apertureSequence || "";
+        try {
+            const resultArray = this._module.SEQNUMS_children(lng, lat, azimuth, aperture, resolution, topology, projection, isApertureSequence, apSeq, sequenceNum);
+            // The result is a flat array with format:
+            // [count0, count1, ..., countN, child0_0, child0_1, ..., child0_(count0-1), child1_0, ...]
+            const inputSize = sequenceNum.length;
+            const counts = resultArray.slice(0, inputSize);
+            const children = [];
+            let offset = inputSize;
+            for (let i = 0; i < inputSize; i++) {
+                const count = Number(counts[i]);
+                children.push(resultArray.slice(offset, offset + count));
+                offset += count;
+            }
+            return children;
+        }
+        catch (e) {
+            console.error(this._module.getExceptionMessage(e).toString());
+            throw e;
+        }
+    }
+    // =========================================================================
+    // Hierarchical Address Type Conversions
+    // These methods convert between SEQNUM and hierarchical indexing systems
+    // =========================================================================
+    /**
+     * Convert a SEQNUM cell ID to VERTEX2DD (icosahedral vertex) coordinates.
+     *
+     * VERTEX2DD addresses represent positions relative to the vertices and
+     * triangular faces of the underlying icosahedron.
+     *
+     * ```ts
+     * const vertex = dggs.sequenceNumToVertex2DD(100n, 5);
+     * // vertex = { keep: true, vertNum: 1, triNum: 1, x: 0.0625, y: 0.054... }
+     * ```
+     *
+     * @param sequenceNum - The cell sequence number to convert.
+     * @param resolution - Resolution of the input cell. Defaults to the
+     *   instance's current {@link resolution}.
+     * @returns An object with `{keep, vertNum, triNum, x, y}` representing
+     *   the vertex coordinate.
+     */
+    sequenceNumToVertex2DD(sequenceNum, resolution = DEFAULT_RESOLUTION) {
+        try {
+            const result = this._module.SEQNUM_to_VERTEX2DD(...this._getParams(resolution), sequenceNum);
+            return result;
+        }
+        catch (e) {
+            console.error(this._module.getExceptionMessage(e).toString());
+            throw e;
+        }
+    }
+    /**
+     * Convert VERTEX2DD (icosahedral vertex) coordinates to a SEQNUM cell ID.
+     *
+     * ```ts
+     * const seqnum = dggs.vertex2DDToSequenceNum(true, 1, 1, 0.0625, 0.054, 5);
+     * // seqnum = 100n
+     * ```
+     *
+     * @param keep - Whether to keep this vertex.
+     * @param vertNum - Vertex number (0-11 for icosahedron).
+     * @param triNum - Triangle number on the icosahedron.
+     * @param x - X coordinate within the triangle.
+     * @param y - Y coordinate within the triangle.
+     * @param resolution - Resolution at which to compute the cell ID. Defaults
+     *   to the instance's current {@link resolution}.
+     * @returns The sequence number (BigInt) of the cell containing this coordinate.
+     */
+    vertex2DDToSequenceNum(keep, vertNum, triNum, x, y, resolution = DEFAULT_RESOLUTION) {
+        try {
+            return this._module.VERTEX2DD_to_SEQNUM(...this._getParams(resolution), keep, vertNum, triNum, x, y);
+        }
+        catch (e) {
+            console.error(this._module.getExceptionMessage(e).toString());
+            throw e;
+        }
+    }
+    /**
+     * Convert a SEQNUM cell ID to ZORDER (Z-order curve) coordinate.
+     *
+     * ZORDER uses digit-interleaved coordinates to create a space-filling
+     * curve index. This provides good spatial locality for range queries.
+     *
+     * **Compatibility:** ZORDER is only available for **aperture 3 and 4**
+     * hexagon grids. It is **NOT supported** for aperture 7.
+     *
+     * ```ts
+     * // With aperture 4:
+     * const zorder = dggs.sequenceNumToZOrder(100n, 5);
+     * // zorder = 1168684103302643712n
+     * ```
+     *
+     * @param sequenceNum - The cell sequence number to convert.
+     * @param resolution - Resolution of the input cell. Defaults to the
+     *   instance's current {@link resolution}.
+     * @returns A BigInt representing the Z-order coordinate.
+     * @throws If used with an incompatible aperture (7) or topology.
+     */
+    sequenceNumToZOrder(sequenceNum, resolution = DEFAULT_RESOLUTION) {
+        const { aperture, apertureSequence } = this.dggs;
+        // Check aperture compatibility
+        if (aperture === 7 && !apertureSequence) {
+            throw new Error('ZORDER is not available for aperture 7. ' +
+                'Use Z7 hierarchical indexing instead, or switch to aperture 3 or 4.');
+        }
+        try {
+            return this._module.SEQNUM_to_ZORDER(...this._getParams(resolution), sequenceNum);
+        }
+        catch (e) {
+            const errMsg = this._module.getExceptionMessage(e).toString();
+            if (errMsg.includes('aperture')) {
+                throw new Error(`ZORDER error: ${errMsg}. ZORDER requires aperture 3 or 4 (not 7).`);
+            }
+            console.error(errMsg);
+            throw e;
+        }
+    }
+    /**
+     * Convert a ZORDER (Z-order curve) coordinate to a SEQNUM cell ID.
+     *
+     * ```ts
+     * const seqnum = dggs.zOrderToSequenceNum(1168684103302643712n, 5);
+     * // seqnum = 100n
+     * ```
+     *
+     * @param zorderValue - The Z-order coordinate value (BigInt).
+     * @param resolution - Resolution at which to compute the cell ID. Defaults
+     *   to the instance's current {@link resolution}.
+     * @returns The sequence number (BigInt) corresponding to this Z-order value.
+     * @throws If used with an incompatible aperture (7) or topology.
+     */
+    zOrderToSequenceNum(zorderValue, resolution = DEFAULT_RESOLUTION) {
+        const { aperture, apertureSequence } = this.dggs;
+        if (aperture === 7 && !apertureSequence) {
+            throw new Error('ZORDER is not available for aperture 7. ' +
+                'Use Z7 hierarchical indexing instead, or switch to aperture 3 or 4.');
+        }
+        try {
+            return this._module.ZORDER_to_SEQNUM(...this._getParams(resolution), zorderValue);
+        }
+        catch (e) {
+            const errMsg = this._module.getExceptionMessage(e).toString();
+            if (errMsg.includes('aperture')) {
+                throw new Error(`ZORDER error: ${errMsg}. ZORDER requires aperture 3 or 4 (not 7).`);
+            }
+            console.error(errMsg);
+            throw e;
+        }
+    }
+    /**
+     * Convert a SEQNUM cell ID to Z3 (base-3 Central Place Indexing) coordinate.
+     *
+     * Z3 uses base-3 digit encoding optimized for aperture 3 hexagon grids.
+     * Each parent cell contains exactly 3 children in the hierarchy.
+     *
+     * **Compatibility:** Z3 is **only available for aperture 3** hexagon grids.
+     *
+     * ```ts
+     * // With aperture 3:
+     * const z3 = dggs.sequenceNumToZ3(100n, 5);
+     * // z3 = 1773292353277132799n
+     * ```
+     *
+     * @param sequenceNum - The cell sequence number to convert.
+     * @param resolution - Resolution of the input cell. Defaults to the
+     *   instance's current {@link resolution}.
+     * @returns A BigInt representing the Z3 coordinate (INT64 format).
+     * @throws If used with an incompatible aperture (not 3) or topology.
+     */
+    sequenceNumToZ3(sequenceNum, resolution = DEFAULT_RESOLUTION) {
+        const { aperture, topology, apertureSequence } = this.dggs;
+        if ((aperture !== 3 || topology !== 'HEXAGON') && !apertureSequence) {
+            throw new Error('Z3 is only available for aperture 3 hexagon grids. ' +
+                `Current configuration: aperture ${aperture}, topology ${topology}.`);
+        }
+        try {
+            return this._module.SEQNUM_to_Z3(...this._getParams(resolution), sequenceNum);
+        }
+        catch (e) {
+            const errMsg = this._module.getExceptionMessage(e).toString();
+            if (errMsg.includes('aperture') || errMsg.includes('Z3')) {
+                throw new Error(`Z3 error: ${errMsg}. Z3 requires aperture 3 hexagon grids.`);
+            }
+            console.error(errMsg);
+            throw e;
+        }
+    }
+    /**
+     * Convert a Z3 (base-3 Central Place Indexing) coordinate to a SEQNUM cell ID.
+     *
+     * ```ts
+     * const seqnum = dggs.z3ToSequenceNum(1773292353277132799n, 5);
+     * // seqnum = 100n
+     * ```
+     *
+     * @param z3Value - The Z3 coordinate value (BigInt, INT64 format).
+     * @param resolution - Resolution at which to compute the cell ID. Defaults
+     *   to the instance's current {@link resolution}.
+     * @returns The sequence number (BigInt) corresponding to this Z3 value.
+     * @throws If used with an incompatible aperture (not 3) or topology.
+     */
+    z3ToSequenceNum(z3Value, resolution = DEFAULT_RESOLUTION) {
+        const { aperture, topology, apertureSequence } = this.dggs;
+        if ((aperture !== 3 || topology !== 'HEXAGON') && !apertureSequence) {
+            throw new Error('Z3 is only available for aperture 3 hexagon grids. ' +
+                `Current configuration: aperture ${aperture}, topology ${topology}.`);
+        }
+        try {
+            return this._module.Z3_to_SEQNUM(...this._getParams(resolution), z3Value);
+        }
+        catch (e) {
+            const errMsg = this._module.getExceptionMessage(e).toString();
+            if (errMsg.includes('aperture') || errMsg.includes('Z3')) {
+                throw new Error(`Z3 error: ${errMsg}. Z3 requires aperture 3 hexagon grids.`);
+            }
+            console.error(errMsg);
+            throw e;
+        }
+    }
+    /**
+     * Convert a SEQNUM cell ID to Z7 (base-7 Central Place Indexing) coordinate.
+     *
+     * Z7 uses base-7 digit encoding with pure bitarithmetic operations,
+     * optimized for aperture 7 hexagon grids. Each parent cell contains
+     * exactly 7 children in the hierarchy.
+     *
+     * **Compatibility:** Z7 is **only available for aperture 7** hexagon grids.
+     *
+     * ```ts
+     * // With aperture 7:
+     * const z7 = dggs.sequenceNumToZ7(100n, 5);
+     * // z7 = 1153167795211468799n (displayed as hex: 0x1000000000000fff)
+     * ```
+     *
+     * @param sequenceNum - The cell sequence number to convert.
+     * @param resolution - Resolution of the input cell. Defaults to the
+     *   instance's current {@link resolution}.
+     * @returns A BigInt representing the Z7 coordinate (INT64/hex format).
+     * @throws If used with an incompatible aperture (not 7) or topology.
+     */
+    sequenceNumToZ7(sequenceNum, resolution = DEFAULT_RESOLUTION) {
+        const { aperture, topology, apertureSequence } = this.dggs;
+        if ((aperture !== 7 || topology !== 'HEXAGON') && !apertureSequence) {
+            throw new Error('Z7 is only available for aperture 7 hexagon grids. ' +
+                `Current configuration: aperture ${aperture}, topology ${topology}.`);
+        }
+        try {
+            return this._module.SEQNUM_to_Z7(...this._getParams(resolution), sequenceNum);
+        }
+        catch (e) {
+            const errMsg = this._module.getExceptionMessage(e).toString();
+            if (errMsg.includes('aperture') || errMsg.includes('Z7')) {
+                throw new Error(`Z7 error: ${errMsg}. Z7 requires aperture 7 hexagon grids.`);
+            }
+            console.error(errMsg);
+            throw e;
+        }
+    }
+    /**
+     * Convert a Z7 (base-7 Central Place Indexing) coordinate to a SEQNUM cell ID.
+     *
+     * ```ts
+     * const seqnum = dggs.z7ToSequenceNum(1153167795211468799n, 5);
+     * // seqnum = 100n
+     * ```
+     *
+     * @param z7Value - The Z7 coordinate value (BigInt, INT64/hex format).
+     * @param resolution - Resolution at which to compute the cell ID. Defaults
+     *   to the instance's current {@link resolution}.
+     * @returns The sequence number (BigInt) corresponding to this Z7 value.
+     * @throws If used with an incompatible aperture (not 7) or topology.
+     */
+    z7ToSequenceNum(z7Value, resolution = DEFAULT_RESOLUTION) {
+        const { aperture, topology, apertureSequence } = this.dggs;
+        if ((aperture !== 7 || topology !== 'HEXAGON') && !apertureSequence) {
+            throw new Error('Z7 is only available for aperture 7 hexagon grids. ' +
+                `Current configuration: aperture ${aperture}, topology ${topology}.`);
+        }
+        try {
+            return this._module.Z7_to_SEQNUM(...this._getParams(resolution), z7Value);
+        }
+        catch (e) {
+            const errMsg = this._module.getExceptionMessage(e).toString();
+            if (errMsg.includes('aperture') || errMsg.includes('Z7')) {
+                throw new Error(`Z7 error: ${errMsg}. Z7 requires aperture 7 hexagon grids.`);
+            }
+            console.error(errMsg);
+            throw e;
+        }
+    }
+    /**
+     * Get the quad (icosahedron face) number from a Z7 index.
+     *
+     * The quad occupies bits 63–60 of the 64-bit packed value.
+     *
+     * ```ts
+     * const quad = dggs.z7GetQuad(z7Value); // 0–11
+     * ```
+     *
+     * @param z7Value - A Z7 packed index (BigInt).
+     * @returns The quad number (0–11).
+     */
+    z7GetQuad(z7Value) {
+        return Number((z7Value & Webdggrid.Z7_QUAD_MASK) >> Webdggrid.Z7_QUAD_OFFSET);
+    }
+    /**
+     * Get the digit at a specific resolution level from a Z7 index.
+     *
+     * Each digit is 3 bits wide and occupies a fixed position in the 64-bit value.
+     * Valid digits are 0–6; the value 7 is the invalid/padding marker.
+     *
+     * ```ts
+     * const digit = dggs.z7GetDigit(z7Value, 3); // 0–6 (or 7 = invalid)
+     * ```
+     *
+     * @param z7Value - A Z7 packed index (BigInt).
+     * @param res - Resolution level (1-based, 1 to 20).
+     * @returns The digit value (0–7).
+     */
+    z7GetDigit(z7Value, res) {
+        const shift = BigInt(Webdggrid.Z7_MAX_RES - res) * Webdggrid.Z7_BITS_PER_DIGIT;
+        return Number((z7Value >> shift) & Webdggrid.Z7_DIGIT_MASK);
+    }
+    /**
+     * Set the digit at a specific resolution level in a Z7 index.
+     *
+     * Returns a new Z7 value with the digit at position `res` replaced.
+     *
+     * ```ts
+     * const child = dggs.z7SetDigit(z7Value, 6, 3); // set res-6 digit to 3
+     * ```
+     *
+     * @param z7Value - A Z7 packed index (BigInt).
+     * @param res - Resolution level (1-based, 1 to 20).
+     * @param digit - The digit value to set (0–6, or 7 for invalid).
+     * @returns A new Z7 value with the digit replaced.
+     */
+    z7SetDigit(z7Value, res, digit) {
+        const shift = BigInt(Webdggrid.Z7_MAX_RES - res) * Webdggrid.Z7_BITS_PER_DIGIT;
+        return (z7Value & ~(Webdggrid.Z7_DIGIT_MASK << shift)) | (BigInt(digit) << shift);
+    }
+    /**
+     * Extract all digits from a Z7 index up to a given resolution.
+     *
+     * ```ts
+     * const { quad, digits } = dggs.z7ExtractDigits(z7Value, 5);
+     * // quad: 1, digits: [2, 0, 3, 4, 1]
+     * ```
+     *
+     * @param z7Value - A Z7 packed index (BigInt).
+     * @param resolution - Number of digits to extract (1-based).
+     * @returns Object with `quad` (number) and `digits` (number array).
+     */
+    z7ExtractDigits(z7Value, resolution) {
+        const quad = this.z7GetQuad(z7Value);
+        const digits = [];
+        for (let r = 1; r <= resolution; r++) {
+            digits.push(this.z7GetDigit(z7Value, r));
+        }
+        return { quad, digits };
+    }
+    /**
+     * Get the quad (icosahedron face) number from a Z3 index.
+     *
+     * ```ts
+     * const quad = dggs.z3GetQuad(z3Value); // 0–11
+     * ```
+     *
+     * @param z3Value - A Z3 packed index (BigInt).
+     * @returns The quad number (0–11).
+     */
+    z3GetQuad(z3Value) {
+        return Number((z3Value & Webdggrid.Z3_QUAD_MASK) >> Webdggrid.Z3_QUAD_OFFSET);
+    }
+    /**
+     * Get the digit at a specific resolution level from a Z3 index.
+     *
+     * Each digit is 2 bits wide. Valid digits are 0–2; the value 3 is the
+     * invalid/padding marker.
+     *
+     * ```ts
+     * const digit = dggs.z3GetDigit(z3Value, 3); // 0–2 (or 3 = invalid)
+     * ```
+     *
+     * @param z3Value - A Z3 packed index (BigInt).
+     * @param res - Resolution level (1-based, 1 to 30).
+     * @returns The digit value (0–3).
+     */
+    z3GetDigit(z3Value, res) {
+        const shift = BigInt(Webdggrid.Z3_MAX_RES - res) * Webdggrid.Z3_BITS_PER_DIGIT;
+        return Number((z3Value >> shift) & Webdggrid.Z3_DIGIT_MASK);
+    }
+    /**
+     * Set the digit at a specific resolution level in a Z3 index.
+     *
+     * ```ts
+     * const child = dggs.z3SetDigit(z3Value, 6, 1); // set res-6 digit to 1
+     * ```
+     *
+     * @param z3Value - A Z3 packed index (BigInt).
+     * @param res - Resolution level (1-based, 1 to 30).
+     * @param digit - The digit value to set (0–2, or 3 for invalid).
+     * @returns A new Z3 value with the digit replaced.
+     */
+    z3SetDigit(z3Value, res, digit) {
+        const shift = BigInt(Webdggrid.Z3_MAX_RES - res) * Webdggrid.Z3_BITS_PER_DIGIT;
+        return (z3Value & ~(Webdggrid.Z3_DIGIT_MASK << shift)) | (BigInt(digit) << shift);
+    }
+    /**
+     * Extract all digits from a Z3 index up to a given resolution.
+     *
+     * ```ts
+     * const { quad, digits } = dggs.z3ExtractDigits(z3Value, 5);
+     * // quad: 1, digits: [1, 0, 2, 1, 0]
+     * ```
+     *
+     * @param z3Value - A Z3 packed index (BigInt).
+     * @param resolution - Number of digits to extract (1-based).
+     * @returns Object with `quad` (number) and `digits` (number array).
+     */
+    z3ExtractDigits(z3Value, resolution) {
+        const quad = this.z3GetQuad(z3Value);
+        const digits = [];
+        for (let r = 1; r <= resolution; r++) {
+            digits.push(this.z3GetDigit(z3Value, r));
+        }
+        return { quad, digits };
+    }
+    /**
+     * Get the quad (icosahedron face) number from a ZORDER index.
+     *
+     * ```ts
+     * const quad = dggs.zOrderGetQuad(zorderValue); // 0–11
+     * ```
+     *
+     * @param zorderValue - A ZORDER packed index (BigInt).
+     * @returns The quad number (0–11).
+     */
+    zOrderGetQuad(zorderValue) {
+        return Number((zorderValue & Webdggrid.ZORDER_QUAD_MASK) >> Webdggrid.ZORDER_QUAD_OFFSET);
+    }
+    /**
+     * Get the digit at a specific resolution level from a ZORDER index.
+     *
+     * Each digit is 2 bits wide (values 0–3).
+     *
+     * ```ts
+     * const digit = dggs.zOrderGetDigit(zorderValue, 3); // 0–3
+     * ```
+     *
+     * @param zorderValue - A ZORDER packed index (BigInt).
+     * @param res - Resolution level (1-based, 1 to 30).
+     * @returns The digit value (0–3).
+     */
+    zOrderGetDigit(zorderValue, res) {
+        const shift = BigInt(Webdggrid.ZORDER_MAX_RES - res) * Webdggrid.ZORDER_BITS_PER_DIGIT;
+        return Number((zorderValue >> shift) & Webdggrid.ZORDER_DIGIT_MASK);
+    }
+    /**
+     * Set the digit at a specific resolution level in a ZORDER index.
+     *
+     * ```ts
+     * const modified = dggs.zOrderSetDigit(zorderValue, 3, 2);
+     * ```
+     *
+     * @param zorderValue - A ZORDER packed index (BigInt).
+     * @param res - Resolution level (1-based, 1 to 30).
+     * @param digit - The digit value to set (0–3).
+     * @returns A new ZORDER value with the digit replaced.
+     */
+    zOrderSetDigit(zorderValue, res, digit) {
+        const shift = BigInt(Webdggrid.ZORDER_MAX_RES - res) * Webdggrid.ZORDER_BITS_PER_DIGIT;
+        return (zorderValue & ~(Webdggrid.ZORDER_DIGIT_MASK << shift)) | (BigInt(digit) << shift);
+    }
+    /**
+     * Extract all digits from a ZORDER index up to a given resolution.
+     *
+     * ```ts
+     * const { quad, digits } = dggs.zOrderExtractDigits(zorderValue, 5);
+     * // quad: 1, digits: [2, 0, 3, 1, 0]
+     * ```
+     *
+     * @param zorderValue - A ZORDER packed index (BigInt).
+     * @param resolution - Number of digits to extract (1-based).
+     * @returns Object with `quad` (number) and `digits` (number array).
+     */
+    zOrderExtractDigits(zorderValue, resolution) {
+        const quad = this.zOrderGetQuad(zorderValue);
+        const digits = [];
+        for (let r = 1; r <= resolution; r++) {
+            digits.push(this.zOrderGetDigit(zorderValue, r));
+        }
+        return { quad, digits };
+    }
+    // =========================================================================
+    // Low-level coordinate transformation methods
+    // These methods expose all DGGRID coordinate systems beyond GEO/SEQNUM
+    // =========================================================================
+    /**
+     * Helper to build the DGGS parameter array for WASM calls.
+     * @private
+     */
+    _getParams(resolution = DEFAULT_RESOLUTION) {
+        const { poleCoordinates: { lat, lng }, azimuth, topology, projection, aperture, apertureSequence, } = this.dggs;
+        const isApertureSequence = !!apertureSequence;
+        const apSeq = apertureSequence || "";
+        return [
+            lng,
+            lat,
+            azimuth,
+            aperture,
+            resolution,
+            topology,
+            projection,
+            isApertureSequence,
+            apSeq
+        ];
+    }
+    // -------------------------------------------------------------------------
+    // GEO transformations (beyond the high-level methods above)
+    // -------------------------------------------------------------------------
+    /**
+     * Converts geographic coordinates to PLANE coordinates.
+     *
+     * @param coordinates - Array of `[lng, lat]` pairs
+     * @param resolution - Resolution level
+     * @returns Array of `{x, y}` plane coordinates
+     */
+    geoToPlane(coordinates, resolution = DEFAULT_RESOLUTION) {
+        const xCoords = coordinates.map(c => c[0]);
+        const yCoords = coordinates.map(c => c[1]);
+        const result = this._module.GEO_to_PLANE(...this._getParams(resolution), xCoords, yCoords);
+        const size = result.length / 2;
+        const output = [];
+        for (let i = 0; i < size; i++) {
+            output.push({ x: result[i], y: result[i + size] });
+        }
+        return output;
+    }
+    /**
+     * Converts geographic coordinates to PROJTRI coordinates.
+     *
+     * @param coordinates - Array of `[lng, lat]` pairs
+     * @param resolution - Resolution level
+     * @returns Array of `{tnum, x, y}` projection triangle coordinates
+     */
+    geoToProjtri(coordinates, resolution = DEFAULT_RESOLUTION) {
+        const xCoords = coordinates.map(c => c[0]);
+        const yCoords = coordinates.map(c => c[1]);
+        const result = this._module.GEO_to_PROJTRI(...this._getParams(resolution), xCoords, yCoords);
+        const size = result.length / 3;
+        const output = [];
+        for (let i = 0; i < size; i++) {
+            output.push({
+                tnum: result[i],
+                x: result[i + size],
+                y: result[i + 2 * size]
+            });
+        }
+        return output;
+    }
+    /**
+     * Converts geographic coordinates to Q2DD coordinates.
+     *
+     * @param coordinates - Array of `[lng, lat]` pairs
+     * @param resolution - Resolution level
+     * @returns Array of `{quad, x, y}` quad 2D double coordinates
+     */
+    geoToQ2dd(coordinates, resolution = DEFAULT_RESOLUTION) {
+        const xCoords = coordinates.map(c => c[0]);
+        const yCoords = coordinates.map(c => c[1]);
+        const result = this._module.GEO_to_Q2DD(...this._getParams(resolution), xCoords, yCoords);
+        const size = result.length / 3;
+        const output = [];
+        for (let i = 0; i < size; i++) {
+            output.push({
+                quad: result[i],
+                x: result[i + size],
+                y: result[i + 2 * size]
+            });
+        }
+        return output;
+    }
+    /**
+     * Converts geographic coordinates to Q2DI coordinates.
+     *
+     * @param coordinates - Array of `[lng, lat]` pairs
+     * @param resolution - Resolution level
+     * @returns Array of `{quad, i, j}` quad 2D integer coordinates
+     */
+    geoToQ2di(coordinates, resolution = DEFAULT_RESOLUTION) {
+        const xCoords = coordinates.map(c => c[0]);
+        const yCoords = coordinates.map(c => c[1]);
+        const result = this._module.GEO_to_Q2DI(...this._getParams(resolution), xCoords, yCoords);
+        const size = result.length / 3;
+        const output = [];
+        for (let i = 0; i < size; i++) {
+            output.push({
+                quad: result[i],
+                i: BigInt(result[i + size]),
+                j: BigInt(result[i + 2 * size])
+            });
+        }
+        return output;
+    }
+    // -------------------------------------------------------------------------
+    // SEQNUM transformations (beyond the high-level methods above)
+    // -------------------------------------------------------------------------
+    /**
+     * Converts sequence numbers to PLANE coordinates.
+     *
+     * @param sequenceNum - Array of cell IDs
+     * @param resolution - Resolution level
+     * @returns Array of `{x, y}` plane coordinates
+     */
+    sequenceNumToPlane(sequenceNum, resolution = DEFAULT_RESOLUTION) {
+        const result = this._module.SEQNUM_to_PLANE(...this._getParams(resolution), sequenceNum);
+        const size = result.length / 2;
+        const output = [];
+        for (let i = 0; i < size; i++) {
+            output.push({ x: result[i], y: result[i + size] });
+        }
+        return output;
+    }
+    /**
+     * Converts sequence numbers to PROJTRI coordinates.
+     *
+     * @param sequenceNum - Array of cell IDs
+     * @param resolution - Resolution level
+     * @returns Array of `{tnum, x, y}` projection triangle coordinates
+     */
+    sequenceNumToProjtri(sequenceNum, resolution = DEFAULT_RESOLUTION) {
+        const result = this._module.SEQNUM_to_PROJTRI(...this._getParams(resolution), sequenceNum);
+        const size = result.length / 3;
+        const output = [];
+        for (let i = 0; i < size; i++) {
+            output.push({
+                tnum: result[i],
+                x: result[i + size],
+                y: result[i + 2 * size]
+            });
+        }
+        return output;
+    }
+    /**
+     * Converts sequence numbers to Q2DD coordinates.
+     *
+     * @param sequenceNum - Array of cell IDs
+     * @param resolution - Resolution level
+     * @returns Array of `{quad, x, y}` quad 2D double coordinates
+     */
+    sequenceNumToQ2dd(sequenceNum, resolution = DEFAULT_RESOLUTION) {
+        const result = this._module.SEQNUM_to_Q2DD(...this._getParams(resolution), sequenceNum);
+        const size = result.length / 3;
+        const output = [];
+        for (let i = 0; i < size; i++) {
+            output.push({
+                quad: result[i],
+                x: result[i + size],
+                y: result[i + 2 * size]
+            });
+        }
+        return output;
+    }
+    /**
+     * Converts sequence numbers to Q2DI coordinates.
+     *
+     * @param sequenceNum - Array of cell IDs
+     * @param resolution - Resolution level
+     * @returns Array of `{quad, i, j}` quad 2D integer coordinates
+     */
+    sequenceNumToQ2di(sequenceNum, resolution = DEFAULT_RESOLUTION) {
+        const result = this._module.SEQNUM_to_Q2DI(...this._getParams(resolution), sequenceNum);
+        const size = result.length / 3;
+        const output = [];
+        for (let i = 0; i < size; i++) {
+            output.push({
+                quad: result[i],
+                i: BigInt(result[i + size]),
+                j: BigInt(result[i + 2 * size])
+            });
+        }
+        return output;
+    }
+    // -------------------------------------------------------------------------
+    // Q2DI transformations
+    // -------------------------------------------------------------------------
+    /**
+     * Converts Q2DI coordinates to geographic coordinates.
+     *
+     * @param coords - Array of `{quad, i, j}` coordinates
+     * @param resolution - Resolution level
+     * @returns Array of `[lng, lat]` positions
+     */
+    q2diToGeo(coords, resolution = DEFAULT_RESOLUTION) {
+        const quads = coords.map(c => c.quad);
+        const is = coords.map(c => Number(c.i));
+        const js = coords.map(c => Number(c.j));
+        const result = this._module.Q2DI_to_GEO(...this._getParams(resolution), quads, is, js);
+        const size = result.length / 2;
+        const output = [];
+        for (let i = 0; i < size; i++) {
+            output.push([result[i], result[i + size]]);
+        }
+        return output;
+    }
+    /**
+     * Converts Q2DI coordinates to sequence numbers.
+     *
+     * @param coords - Array of `{quad, i, j}` coordinates
+     * @param resolution - Resolution level
+     * @returns Array of cell IDs
+     */
+    q2diToSequenceNum(coords, resolution = DEFAULT_RESOLUTION) {
+        const quads = coords.map(c => c.quad);
+        const is = coords.map(c => Number(c.i));
+        const js = coords.map(c => Number(c.j));
+        return this._module.Q2DI_to_SEQNUM(...this._getParams(resolution), quads, is, js);
+    }
+    /**
+     * Converts Q2DI coordinates to PLANE coordinates.
+     *
+     * @param coords - Array of `{quad, i, j}` coordinates
+     * @param resolution - Resolution level
+     * @returns Array of `{x, y}` plane coordinates
+     */
+    q2diToPlane(coords, resolution = DEFAULT_RESOLUTION) {
+        const quads = coords.map(c => c.quad);
+        const is = coords.map(c => Number(c.i));
+        const js = coords.map(c => Number(c.j));
+        const result = this._module.Q2DI_to_PLANE(...this._getParams(resolution), quads, is, js);
+        const size = result.length / 2;
+        const output = [];
+        for (let i = 0; i < size; i++) {
+            output.push({ x: result[i], y: result[i + size] });
+        }
+        return output;
+    }
+    /**
+     * Converts Q2DI coordinates to PROJTRI coordinates.
+     *
+     * @param coords - Array of `{quad, i, j}` coordinates
+     * @param resolution - Resolution level
+     * @returns Array of `{tnum, x, y}` projection triangle coordinates
+     */
+    q2diToProjtri(coords, resolution = DEFAULT_RESOLUTION) {
+        const quads = coords.map(c => c.quad);
+        const is = coords.map(c => Number(c.i));
+        const js = coords.map(c => Number(c.j));
+        const result = this._module.Q2DI_to_PROJTRI(...this._getParams(resolution), quads, is, js);
+        const size = result.length / 3;
+        const output = [];
+        for (let i = 0; i < size; i++) {
+            output.push({
+                tnum: result[i],
+                x: result[i + size],
+                y: result[i + 2 * size]
+            });
+        }
+        return output;
+    }
+    /**
+     * Converts Q2DI coordinates to Q2DD coordinates.
+     *
+     * @param coords - Array of `{quad, i, j}` coordinates
+     * @param resolution - Resolution level
+     * @returns Array of `{quad, x, y}` quad 2D double coordinates
+     */
+    q2diToQ2dd(coords, resolution = DEFAULT_RESOLUTION) {
+        const quads = coords.map(c => c.quad);
+        const is = coords.map(c => Number(c.i));
+        const js = coords.map(c => Number(c.j));
+        const result = this._module.Q2DI_to_Q2DD(...this._getParams(resolution), quads, is, js);
+        const size = result.length / 3;
+        const output = [];
+        for (let i = 0; i < size; i++) {
+            output.push({
+                quad: result[i],
+                x: result[i + size],
+                y: result[i + 2 * size]
+            });
+        }
+        return output;
+    }
+    // -------------------------------------------------------------------------
+    // Q2DD transformations
+    // -------------------------------------------------------------------------
+    /**
+     * Converts Q2DD coordinates to geographic coordinates.
+     *
+     * @param coords - Array of `{quad, x, y}` coordinates
+     * @param resolution - Resolution level
+     * @returns Array of `[lng, lat]` positions
+     */
+    q2ddToGeo(coords, resolution = DEFAULT_RESOLUTION) {
+        const quads = coords.map(c => c.quad);
+        const xs = coords.map(c => c.x);
+        const ys = coords.map(c => c.y);
+        const result = this._module.Q2DD_to_GEO(...this._getParams(resolution), quads, xs, ys);
+        const size = result.length / 2;
+        const output = [];
+        for (let i = 0; i < size; i++) {
+            output.push([result[i], result[i + size]]);
+        }
+        return output;
+    }
+    /**
+     * Converts Q2DD coordinates to sequence numbers.
+     *
+     * @param coords - Array of `{quad, x, y}` coordinates
+     * @param resolution - Resolution level
+     * @returns Array of cell IDs
+     */
+    q2ddToSequenceNum(coords, resolution = DEFAULT_RESOLUTION) {
+        const quads = coords.map(c => c.quad);
+        const xs = coords.map(c => c.x);
+        const ys = coords.map(c => c.y);
+        return this._module.Q2DD_to_SEQNUM(...this._getParams(resolution), quads, xs, ys);
+    }
+    /**
+     * Converts Q2DD coordinates to PLANE coordinates.
+     *
+     * @param coords - Array of `{quad, x, y}` coordinates
+     * @param resolution - Resolution level
+     * @returns Array of `{x, y}` plane coordinates
+     */
+    q2ddToPlane(coords, resolution = DEFAULT_RESOLUTION) {
+        const quads = coords.map(c => c.quad);
+        const xs = coords.map(c => c.x);
+        const ys = coords.map(c => c.y);
+        const result = this._module.Q2DD_to_PLANE(...this._getParams(resolution), quads, xs, ys);
+        const size = result.length / 2;
+        const output = [];
+        for (let i = 0; i < size; i++) {
+            output.push({ x: result[i], y: result[i + size] });
+        }
+        return output;
+    }
+    /**
+     * Converts Q2DD coordinates to PROJTRI coordinates.
+     *
+     * @param coords - Array of `{quad, x, y}` coordinates
+     * @param resolution - Resolution level
+     * @returns Array of `{tnum, x, y}` projection triangle coordinates
+     */
+    q2ddToProjtri(coords, resolution = DEFAULT_RESOLUTION) {
+        const quads = coords.map(c => c.quad);
+        const xs = coords.map(c => c.x);
+        const ys = coords.map(c => c.y);
+        const result = this._module.Q2DD_to_PROJTRI(...this._getParams(resolution), quads, xs, ys);
+        const size = result.length / 3;
+        const output = [];
+        for (let i = 0; i < size; i++) {
+            output.push({
+                tnum: result[i],
+                x: result[i + size],
+                y: result[i + 2 * size]
+            });
+        }
+        return output;
+    }
+    /**
+     * Converts Q2DD coordinates to Q2DI coordinates.
+     *
+     * @param coords - Array of `{quad, x, y}` coordinates
+     * @param resolution - Resolution level
+     * @returns Array of `{quad, i, j}` quad 2D integer coordinates
+     */
+    q2ddToQ2di(coords, resolution = DEFAULT_RESOLUTION) {
+        const quads = coords.map(c => c.quad);
+        const xs = coords.map(c => c.x);
+        const ys = coords.map(c => c.y);
+        const result = this._module.Q2DD_to_Q2DI(...this._getParams(resolution), quads, xs, ys);
+        const size = result.length / 3;
+        const output = [];
+        for (let i = 0; i < size; i++) {
+            output.push({
+                quad: result[i],
+                i: BigInt(result[i + size]),
+                j: BigInt(result[i + 2 * size])
+            });
+        }
+        return output;
+    }
+    // -------------------------------------------------------------------------
+    // PROJTRI transformations
+    // -------------------------------------------------------------------------
+    /**
+     * Converts PROJTRI coordinates to geographic coordinates.
+     *
+     * @param coords - Array of `{tnum, x, y}` coordinates
+     * @param resolution - Resolution level
+     * @returns Array of `[lng, lat]` positions
+     */
+    projtriToGeo(coords, resolution = DEFAULT_RESOLUTION) {
+        const tnums = coords.map(c => c.tnum);
+        const xs = coords.map(c => c.x);
+        const ys = coords.map(c => c.y);
+        const result = this._module.PROJTRI_to_GEO(...this._getParams(resolution), tnums, xs, ys);
+        const size = result.length / 2;
+        const output = [];
+        for (let i = 0; i < size; i++) {
+            output.push([result[i], result[i + size]]);
+        }
+        return output;
+    }
+    /**
+     * Converts PROJTRI coordinates to sequence numbers.
+     *
+     * @param coords - Array of `{tnum, x, y}` coordinates
+     * @param resolution - Resolution level
+     * @returns Array of cell IDs
+     */
+    projtriToSequenceNum(coords, resolution = DEFAULT_RESOLUTION) {
+        const tnums = coords.map(c => c.tnum);
+        const xs = coords.map(c => c.x);
+        const ys = coords.map(c => c.y);
+        return this._module.PROJTRI_to_SEQNUM(...this._getParams(resolution), tnums, xs, ys);
+    }
+    /**
+     * Converts PROJTRI coordinates to PLANE coordinates.
+     *
+     * @param coords - Array of `{tnum, x, y}` coordinates
+     * @param resolution - Resolution level
+     * @returns Array of `{x, y}` plane coordinates
+     */
+    projtriToPlane(coords, resolution = DEFAULT_RESOLUTION) {
+        const tnums = coords.map(c => c.tnum);
+        const xs = coords.map(c => c.x);
+        const ys = coords.map(c => c.y);
+        const result = this._module.PROJTRI_to_PLANE(...this._getParams(resolution), tnums, xs, ys);
+        const size = result.length / 2;
+        const output = [];
+        for (let i = 0; i < size; i++) {
+            output.push({ x: result[i], y: result[i + size] });
+        }
+        return output;
+    }
+    /**
+     * Converts PROJTRI coordinates to Q2DD coordinates.
+     *
+     * @param coords - Array of `{tnum, x, y}` coordinates
+     * @param resolution - Resolution level
+     * @returns Array of `{quad, x, y}` quad 2D double coordinates
+     */
+    projtriToQ2dd(coords, resolution = DEFAULT_RESOLUTION) {
+        const tnums = coords.map(c => c.tnum);
+        const xs = coords.map(c => c.x);
+        const ys = coords.map(c => c.y);
+        const result = this._module.PROJTRI_to_Q2DD(...this._getParams(resolution), tnums, xs, ys);
+        const size = result.length / 3;
+        const output = [];
+        for (let i = 0; i < size; i++) {
+            output.push({
+                quad: result[i],
+                x: result[i + size],
+                y: result[i + 2 * size]
+            });
+        }
+        return output;
+    }
+    /**
+     * Converts PROJTRI coordinates to Q2DI coordinates.
+     *
+     * @param coords - Array of `{tnum, x, y}` coordinates
+     * @param resolution - Resolution level
+     * @returns Array of `{quad, i, j}` quad 2D integer coordinates
+     */
+    projtriToQ2di(coords, resolution = DEFAULT_RESOLUTION) {
+        const tnums = coords.map(c => c.tnum);
+        const xs = coords.map(c => c.x);
+        const ys = coords.map(c => c.y);
+        const result = this._module.PROJTRI_to_Q2DI(...this._getParams(resolution), tnums, xs, ys);
+        const size = result.length / 3;
+        const output = [];
+        for (let i = 0; i < size; i++) {
+            output.push({
+                quad: result[i],
+                i: BigInt(result[i + size]),
+                j: BigInt(result[i + 2 * size])
+            });
+        }
+        return output;
+    }
 }
+// =========================================================================
+// Index digit manipulation
+// Pure bitwise operations on Z7, Z3, and ZORDER packed indices.
+// These match DGGRID's internal macros (Z7_GET_INDEX_DIGIT, etc.)
+// and do NOT require WASM calls.
+// =========================================================================
+// --- Z7 constants (3 bits per digit, max 20 resolutions) ---
+/** @internal */ Webdggrid.Z7_MAX_RES = 20;
+/** @internal */ Webdggrid.Z7_BITS_PER_DIGIT = 3n;
+/** @internal */ Webdggrid.Z7_DIGIT_MASK = 7n;
+/** @internal */ Webdggrid.Z7_QUAD_OFFSET = 60n;
+/** @internal */ Webdggrid.Z7_QUAD_MASK = 0xf000000000000000n;
+// --- Z3 constants (2 bits per digit, max 30 resolutions) ---
+/** @internal */ Webdggrid.Z3_MAX_RES = 30;
+/** @internal */ Webdggrid.Z3_BITS_PER_DIGIT = 2n;
+/** @internal */ Webdggrid.Z3_DIGIT_MASK = 3n;
+/** @internal */ Webdggrid.Z3_QUAD_OFFSET = 60n;
+/** @internal */ Webdggrid.Z3_QUAD_MASK = 0xf000000000000000n;
+// --- ZORDER constants (2 bits per digit, max 30 resolutions) ---
+/** @internal */ Webdggrid.ZORDER_MAX_RES = 30;
+/** @internal */ Webdggrid.ZORDER_BITS_PER_DIGIT = 2n;
+/** @internal */ Webdggrid.ZORDER_DIGIT_MASK = 3n;
+/** @internal */ Webdggrid.ZORDER_QUAD_OFFSET = 60n;
+/** @internal */ Webdggrid.ZORDER_QUAD_MASK = 0xf000000000000000n;
 //# sourceMappingURL=webdggrid.js.map