@zukall/zap 0.0.0-stage → 0.2.0

package/dist/esm/country.d.ts

@@ -0,0 +1,6 @@
+import type { Country, CountryOption, ProvinceOption } from "./types.js";
+export declare function getCountry(countryCode: string): Country;
+/** Options for a country selector. These describe the frozen snapshot. */
+export declare function getCountries(): CountryOption[];
+/** Country-wide grids return an empty list; unknown country codes throw. */
+export declare function getProvinces(countryCode: string): ProvinceOption[];

package/dist/esm/country.js

@@ -0,0 +1,22 @@
+import { countries } from "./address_bounty.js";
+import { normalizeCode } from "./internal.js";
+export function getCountry(countryCode) {
+    const code = normalizeCode(countryCode, "countryCode");
+    if (!Object.prototype.hasOwnProperty.call(countries, code)) {
+        throw new RangeError(`Country not configured: ${code}`);
+    }
+    return countries[code];
+}
+/** Options for a country selector. These describe the frozen snapshot. */
+export function getCountries() {
+    return Object.entries(countries)
+        .map(([code, entry]) => ({ code, name: entry.name, requiresProvince: entry.provinces !== undefined }))
+        .sort((left, right) => left.name.localeCompare(right.name, "en") || left.code.localeCompare(right.code, "en"));
+}
+/** Country-wide grids return an empty list; unknown country codes throw. */
+export function getProvinces(countryCode) {
+    const country = getCountry(countryCode);
+    return Object.entries(country.provinces ?? {})
+        .map(([code, entry]) => ({ code, name: entry.name }))
+        .sort((left, right) => left.name.localeCompare(right.name, "en") || left.code.localeCompare(right.code, "en"));
+}

package/dist/esm/data.d.ts

@@ -0,0 +1,3 @@
+export { countries, additionalSourceAreas } from "./address_bounty.js";
+export { provinceCountries, provinceGrids, provinceCounts, provinceDataNotes, DZ, CD, SD, LY, TD, NE, AO, ML, ZA, ET, MR, RU, CA, US, CN, BR, AU, IN, AR, KZ, SA, ID, } from "./address_province_bounty.js";
+export type { Coordinates, Corners, Country, ProvinceCountry, Province } from "./types.js";

package/dist/esm/data.js

@@ -0,0 +1,2 @@
+export { countries, additionalSourceAreas } from "./address_bounty.js";
+export { provinceCountries, provinceGrids, provinceCounts, provinceDataNotes, DZ, CD, SD, LY, TD, NE, AO, ML, ZA, ET, MR, RU, CA, US, CN, BR, AU, IN, AR, KZ, SA, ID, } from "./address_province_bounty.js";

package/dist/esm/directions.d.ts

@@ -0,0 +1,5 @@
+import type { Coordinates } from "./types.js";
+/** Open directions to the saved GPS point, independently of display labels or protocol version. */
+export declare function getDirectionsUrl(savedAddress: Readonly<{
+    coordinates: Coordinates;
+}>): string;

package/dist/esm/directions.js

@@ -0,0 +1,10 @@
+import { validateCoordinates } from "./grid.js";
+/** Open directions to the saved GPS point, independently of display labels or protocol version. */
+export function getDirectionsUrl(savedAddress) {
+    if (!savedAddress || typeof savedAddress !== "object" || !savedAddress.coordinates || typeof savedAddress.coordinates !== "object") {
+        throw new TypeError("A saved address with coordinates is required.");
+    }
+    validateCoordinates(savedAddress.coordinates);
+    const { latitude, longitude } = savedAddress.coordinates;
+    return `https://www.google.com/maps/dir/?api=1&destination=${encodeURIComponent(`${latitude},${longitude}`)}`;
+}

package/dist/esm/encoding.d.ts

@@ -0,0 +1,3 @@
+import type { AddressEncoding } from "./types.js";
+/** Encode unrounded projected offsets; directions are chosen before flooring. */
+export declare function encodeOffsets(northingMeters: number, eastingMeters: number): AddressEncoding;

package/dist/esm/encoding.js

@@ -0,0 +1,17 @@
+import { ZAP_PROTOCOL } from "./protocol.js";
+/** Encode unrounded projected offsets; directions are chosen before flooring. */
+export function encodeOffsets(northingMeters, eastingMeters) {
+    const northSouthWholeMeters = Math.floor(Math.abs(northingMeters));
+    const eastWestWholeMeters = Math.floor(Math.abs(eastingMeters));
+    const northSouthRemainder = northSouthWholeMeters % ZAP_PROTOCOL.blockSizeMeters;
+    const eastWestRemainder = eastWestWholeMeters % ZAP_PROTOCOL.blockSizeMeters;
+    return {
+        northSouthBlock: Math.floor(northSouthWholeMeters / ZAP_PROTOCOL.blockSizeMeters),
+        eastWestBlock: Math.floor(eastWestWholeMeters / ZAP_PROTOCOL.blockSizeMeters),
+        northSouthDirection: northingMeters < 0 ? "S" : "N",
+        eastWestDirection: eastingMeters < 0 ? "W" : "E",
+        northSouthRemainder,
+        eastWestRemainder,
+        coordinateSuffix: `#${String(northSouthRemainder).padStart(2, "0")}-${String(eastWestRemainder).padStart(2, "0")}`,
+    };
+}

package/dist/esm/grid.d.ts

@@ -0,0 +1,23 @@
+import type { GridInput, Coordinates } from "./types.js";
+export declare function validateCoordinates(point: Coordinates): void;
+/** Shared immutable grid selection and original spherical AEQD projection. */
+export declare function projectAddress(input: GridInput): {
+    gridName: string;
+    countryVersion: string;
+    gridVersion: string;
+    coordinates: Readonly<{
+        latitude: number;
+        longitude: number;
+    }>;
+    center: Readonly<{
+        latitude: number;
+        longitude: number;
+    }>;
+    widthMeters: number;
+    heightMeters: number;
+    northingMeters: number;
+    eastingMeters: number;
+    identityComponents: (string | number)[];
+    provinceCode?: string;
+    countryCode: string;
+};

package/dist/esm/grid.js

@@ -0,0 +1,148 @@
+import { getCountry } from "./country.js";
+import { normalizeCode } from "./internal.js";
+import { ZAP_PROTOCOL } from "./protocol.js";
+// Versioned grid bounds come from the frozen Natural Earth snapshot.
+const EARTH_RADIUS_METERS = ZAP_PROTOCOL.earthRadiusMeters;
+function radians(degrees) {
+    return (degrees * Math.PI) / 180;
+}
+function wrap360(degrees) {
+    return ((degrees % 360) + 360) % 360;
+}
+export function validateCoordinates(point) {
+    if (!Number.isFinite(point.latitude) ||
+        !Number.isFinite(point.longitude) ||
+        Math.abs(point.latitude) > 90 ||
+        Math.abs(point.longitude) > 180) {
+        throw new RangeError("Latitude must be between -90 and 90, and longitude between -180 and 180.");
+    }
+}
+function getBounds(corners) {
+    corners.forEach(validateCoordinates);
+    const [topLeft, topRight, bottomRight, bottomLeft] = corners;
+    const north = topLeft.latitude;
+    const south = bottomLeft.latitude;
+    const west = topLeft.longitude;
+    const east = topRight.longitude;
+    if (north <= south ||
+        topRight.latitude !== north ||
+        bottomRight.latitude !== south ||
+        bottomRight.longitude !== east ||
+        bottomLeft.longitude !== west) {
+        throw new Error("Corners must form a latitude/longitude-aligned rectangle.");
+    }
+    // Supports rectangles that cross the international date line.
+    const longitudeSpan = east - west === 360 ? 360 : wrap360(east - west);
+    if (longitudeSpan === 0 || (longitudeSpan >= 180 && longitudeSpan !== 360)) {
+        throw new Error("Rectangle longitude span must be below 180 degrees or cover all 360 degrees.");
+    }
+    return {
+        north,
+        south,
+        west,
+        longitudeSpan,
+    };
+}
+/** Shared immutable grid selection and original spherical AEQD projection. */
+export function projectAddress(input) {
+    if (!input || typeof input !== "object" || Array.isArray(input)) {
+        throw new TypeError("Address input must be an object.");
+    }
+    const { countryCode, provinceCode, latitude, longitude, } = input;
+    const code = normalizeCode(countryCode, "countryCode");
+    const selectedProvinceCode = provinceCode === undefined || provinceCode === ""
+        ? undefined
+        : normalizeCode(provinceCode, "provinceCode");
+    const coordinates = {
+        latitude,
+        longitude,
+    };
+    validateCoordinates(coordinates);
+    const country = getCountry(code);
+    let corners;
+    let gridName;
+    let gridVersion;
+    // Use the user-selected province. No automatic province matching.
+    if (country.provinces !== undefined) {
+        if (!selectedProvinceCode) {
+            throw new Error("Please select your province or state.");
+        }
+        if (!Object.prototype.hasOwnProperty.call(country.provinces, selectedProvinceCode)) {
+            throw new Error(`Province not configured: ${code} ${selectedProvinceCode}`);
+        }
+        const province = country.provinces[selectedProvinceCode];
+        corners = province.corners;
+        gridName = province.name;
+        gridVersion = province.version;
+    }
+    else {
+        if (selectedProvinceCode) {
+            throw new Error(`${code} uses a country-wide grid. Omit provinceCode.`);
+        }
+        corners = country.corners;
+        gridName = country.name;
+        gridVersion = country.version;
+    }
+    const prefix = selectedProvinceCode
+        ? `${code} ${selectedProvinceCode}`
+        : code;
+    const bounds = getBounds(corners);
+    // Check only the selected grid's rectangle.
+    // Overlap with other rectangles is allowed.
+    // This does not verify administrative membership.
+    const longitudeFromWest = wrap360(longitude - bounds.west);
+    if (latitude < bounds.south ||
+        latitude > bounds.north ||
+        longitudeFromWest > bounds.longitudeSpan) {
+        throw new RangeError(`Coordinates are outside the configured ${prefix} rectangle.`);
+    }
+    // Calculate the rectangle's center.
+    const center = {
+        latitude: (bounds.north + bounds.south) / 2,
+        longitude: wrap360(bounds.west + bounds.longitudeSpan / 2 + 180) - 180,
+    };
+    // Approximate rectangle dimensions on a spherical Earth.
+    // Width follows the middle latitude; height follows a meridian.
+    const widthMeters = EARTH_RADIUS_METERS *
+        radians(bounds.longitudeSpan) *
+        Math.cos(radians(center.latitude));
+    const heightMeters = EARTH_RADIUS_METERS * radians(bounds.north - bounds.south);
+    // Spherical azimuthal equidistant projection.
+    const lat = radians(latitude);
+    const originLat = radians(center.latitude);
+    const deltaLon = radians(longitude - center.longitude);
+    const eastComponent = Math.cos(lat) * Math.sin(deltaLon);
+    const northComponent = Math.cos(originLat) * Math.sin(lat) -
+        Math.sin(originLat) * Math.cos(lat) * Math.cos(deltaLon);
+    const cosAngle = Math.sin(originLat) * Math.sin(lat) +
+        Math.cos(originLat) * Math.cos(lat) * Math.cos(deltaLon);
+    const sinAngle = Math.hypot(eastComponent, northComponent);
+    const angle = Math.atan2(sinAngle, cosAngle);
+    if (Math.PI - angle < 1e-10) {
+        throw new RangeError("Location cannot be projected from this grid center.");
+    }
+    const scale = sinAngle < 1e-15 ? 1 : angle / sinAngle;
+    return {
+        countryCode: code,
+        ...(selectedProvinceCode ? { provinceCode: selectedProvinceCode } : {}),
+        gridName,
+        countryVersion: country.version,
+        gridVersion,
+        coordinates,
+        center,
+        widthMeters: Math.round(widthMeters),
+        heightMeters: Math.round(heightMeters),
+        // Only normalize exact zero. In particular, retain sub-meter negative signs.
+        northingMeters: EARTH_RADIUS_METERS * scale * northComponent || 0,
+        eastingMeters: EARTH_RADIUS_METERS * scale * eastComponent || 0,
+        identityComponents: [
+            prefix,
+            country.version,
+            gridVersion,
+            ZAP_PROTOCOL.projection,
+            EARTH_RADIUS_METERS,
+            center.latitude,
+            center.longitude,
+        ],
+    };
+}

package/dist/esm/index.d.ts

@@ -0,0 +1,27 @@
+import { generateAddress } from "./address.js";
+import { generateLegacyAddress } from "./legacy-address.js";
+import { getDirectionsUrl } from "./directions.js";
+import { getCountries, getCountry, getProvinces } from "./country.js";
+import { ZAP_PROTOCOL, LEGACY_ZAP_PROTOCOL } from "./protocol.js";
+export { generateAddress, generateLegacyAddress, getDirectionsUrl, getCountries, getCountry, getProvinces, ZAP_PROTOCOL, LEGACY_ZAP_PROTOCOL, };
+export type { AddressInput, AddressResult, AddressEncoding, LegacyAddressInput, LegacyAddressResult, Coordinates, Corners, GridInput, Country, CountryOption, Province, ProvinceCountry, ProvinceOption, } from "./types.js";
+/** Named namespace for applications that refer to the protocol as `zap`. */
+export declare const zap: Readonly<{
+    protocol: Readonly<{
+        readonly id: "ZAP";
+        readonly addressSuffix: "ZAP";
+        readonly name: "Zukall Addressing Protocol";
+        readonly version: "2";
+        readonly projection: "AEQD-SPHERE-v1";
+        readonly earthRadiusMeters: 6371008.8;
+        readonly blockSizeMeters: 100;
+        readonly detailSizeMeters: 1;
+        readonly encoding: "blocks-100m-detail-1m-floor-absolute-dashed-suffix-2x2-v1";
+    }>;
+    generateAddress: typeof generateAddress;
+    generateLegacyAddress: typeof generateLegacyAddress;
+    getDirectionsUrl: typeof getDirectionsUrl;
+    getCountries: typeof getCountries;
+    getCountry: typeof getCountry;
+    getProvinces: typeof getProvinces;
+}>;

package/dist/esm/index.js

@@ -0,0 +1,16 @@
+import { generateAddress } from "./address.js";
+import { generateLegacyAddress } from "./legacy-address.js";
+import { getDirectionsUrl } from "./directions.js";
+import { getCountries, getCountry, getProvinces } from "./country.js";
+import { ZAP_PROTOCOL, LEGACY_ZAP_PROTOCOL } from "./protocol.js";
+export { generateAddress, generateLegacyAddress, getDirectionsUrl, getCountries, getCountry, getProvinces, ZAP_PROTOCOL, LEGACY_ZAP_PROTOCOL, };
+/** Named namespace for applications that refer to the protocol as `zap`. */
+export const zap = Object.freeze({
+    protocol: ZAP_PROTOCOL,
+    generateAddress,
+    generateLegacyAddress,
+    getDirectionsUrl,
+    getCountries,
+    getCountry,
+    getProvinces,
+});

package/dist/esm/internal.d.ts

@@ -0,0 +1,3 @@
+/** Freeze bundled snapshots so their version cannot outlive changed grid bounds. */
+export declare function deepFreeze<T>(value: T): T;
+export declare function normalizeCode(value: unknown, field: string): string;

package/dist/esm/internal.js

@@ -0,0 +1,15 @@
+/** Freeze bundled snapshots so their version cannot outlive changed grid bounds. */
+export function deepFreeze(value) {
+    if (value && typeof value === "object" && !Object.isFrozen(value)) {
+        for (const child of Object.values(value))
+            deepFreeze(child);
+        Object.freeze(value);
+    }
+    return value;
+}
+export function normalizeCode(value, field) {
+    if (typeof value !== "string" || !value.trim()) {
+        throw new TypeError(`${field} must be a nonempty string.`);
+    }
+    return value.trim().toUpperCase();
+}

package/dist/esm/legacy-address.d.ts

@@ -0,0 +1,3 @@
+import type { LegacyAddressInput, LegacyAddressResult } from "./types.js";
+/** Explicit version-1 reproduction. Never use this to reinterpret a version-2 record. */
+export declare function generateLegacyAddress(input: LegacyAddressInput): LegacyAddressResult;

package/dist/esm/legacy-address.js

@@ -0,0 +1,41 @@
+import { projectAddress } from "./grid.js";
+import { LEGACY_ZAP_PROTOCOL } from "./protocol.js";
+/** Explicit version-1 reproduction. Never use this to reinterpret a version-2 record. */
+export function generateLegacyAddress(input) {
+    const grid = projectAddress(input);
+    const gridSizeMeters = input.gridSizeMeters === undefined
+        ? LEGACY_ZAP_PROTOCOL.defaultGridSizeMeters : input.gridSizeMeters;
+    if (!Number.isSafeInteger(gridSizeMeters) || gridSizeMeters < 1 || gridSizeMeters > 1000) {
+        throw new RangeError("Grid size must be an integer between 1 and 1000 meters.");
+    }
+    const snap = (meters) => Math.round(meters / gridSizeMeters) * gridSizeMeters || 0;
+    const northingMeters = snap(grid.northingMeters);
+    const eastingMeters = snap(grid.eastingMeters);
+    return {
+        protocol: LEGACY_ZAP_PROTOCOL.id,
+        protocolVersion: LEGACY_ZAP_PROTOCOL.version,
+        address: [
+            `${Math.abs(northingMeters)} ${northingMeters < 0 ? "S" : "N"} ${Math.abs(eastingMeters)} ${eastingMeters < 0 ? "W" : "E"}`,
+            ...(grid.provinceCode ? [grid.provinceCode] : []),
+            grid.countryCode,
+            LEGACY_ZAP_PROTOCOL.addressSuffix,
+        ].join(", "),
+        countryCode: grid.countryCode,
+        ...(grid.provinceCode ? { provinceCode: grid.provinceCode } : {}),
+        gridName: grid.gridName,
+        coordinates: grid.coordinates,
+        center: grid.center,
+        widthMeters: grid.widthMeters,
+        heightMeters: grid.heightMeters,
+        northingMeters,
+        eastingMeters,
+        gridSizeMeters,
+        gridId: [
+            LEGACY_ZAP_PROTOCOL.id,
+            LEGACY_ZAP_PROTOCOL.version,
+            ...grid.identityComponents,
+            gridSizeMeters,
+            "nearest-positive-tie",
+        ].join(":"),
+    };
+}

package/dist/esm/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/dist/esm/protocol.d.ts

@@ -0,0 +1,22 @@
+/** ZAP means Zukall Addressing Protocol. Protocol and npm package versions are separate. */
+export declare const ZAP_PROTOCOL: Readonly<{
+    readonly id: "ZAP";
+    readonly addressSuffix: "ZAP";
+    readonly name: "Zukall Addressing Protocol";
+    readonly version: "2";
+    readonly projection: "AEQD-SPHERE-v1";
+    readonly earthRadiusMeters: 6371008.8;
+    readonly blockSizeMeters: 100;
+    readonly detailSizeMeters: 1;
+    readonly encoding: "blocks-100m-detail-1m-floor-absolute-dashed-suffix-2x2-v1";
+}>;
+/** Frozen version-1 rules, for explicitly reproducing previously issued addresses. */
+export declare const LEGACY_ZAP_PROTOCOL: Readonly<{
+    readonly id: "ZAP";
+    readonly addressSuffix: "ZAP";
+    readonly name: "Zukall Address Protocol";
+    readonly version: "1";
+    readonly projection: "AEQD-SPHERE-v1";
+    readonly earthRadiusMeters: 6371008.8;
+    readonly defaultGridSizeMeters: 5;
+}>;

package/dist/esm/protocol.js

@@ -0,0 +1,22 @@
+/** ZAP means Zukall Addressing Protocol. Protocol and npm package versions are separate. */
+export const ZAP_PROTOCOL = Object.freeze({
+    id: "ZAP",
+    addressSuffix: "ZAP",
+    name: "Zukall Addressing Protocol",
+    version: "2",
+    projection: "AEQD-SPHERE-v1",
+    earthRadiusMeters: 6_371_008.8,
+    blockSizeMeters: 100,
+    detailSizeMeters: 1,
+    encoding: "blocks-100m-detail-1m-floor-absolute-dashed-suffix-2x2-v1",
+});
+/** Frozen version-1 rules, for explicitly reproducing previously issued addresses. */
+export const LEGACY_ZAP_PROTOCOL = Object.freeze({
+    id: "ZAP",
+    addressSuffix: "ZAP",
+    name: "Zukall Address Protocol",
+    version: "1",
+    projection: "AEQD-SPHERE-v1",
+    earthRadiusMeters: 6_371_008.8,
+    defaultGridSizeMeters: 5,
+});

package/dist/esm/types.d.ts

@@ -0,0 +1,114 @@
+/** WGS84 latitude and longitude in decimal degrees. */
+export type Coordinates = Readonly<{
+    latitude: number;
+    longitude: number;
+}>;
+export type Corners = readonly [
+    topLeft: Coordinates,
+    topRight: Coordinates,
+    bottomRight: Coordinates,
+    bottomLeft: Coordinates
+];
+export type Province = Readonly<{
+    name: string;
+    version: string;
+    corners: Corners;
+}>;
+/** Original source snapshot, with the singular `province` field. */
+export type ProvinceCountry = Readonly<{
+    name: string;
+    version: string;
+    province: Readonly<Record<string, Province>>;
+}>;
+/** Configuration used by the generator, with the plural `provinces` field. */
+export type Country = Readonly<{
+    name: string;
+    version: string;
+}> & ({
+    readonly corners: Corners;
+    readonly provinces?: never;
+} | {
+    readonly corners?: never;
+    readonly provinces: Readonly<Record<string, Province>>;
+});
+export type GridInput = {
+    countryCode: string;
+    /** Required for countries that use province grids; omitted for other countries. */
+    provinceCode?: string;
+    latitude: number;
+    longitude: number;
+};
+export type AddressInput = GridInput & {
+    /** Optional display label; never changes the grid origin. */
+    city?: string;
+    /** Separate display metadata; omitted from the coordinate address text. */
+    street?: string;
+    /** Removed in protocol 2. Use generateLegacyAddress for protocol-1 records. */
+    gridSizeMeters?: never;
+};
+export type LegacyAddressInput = GridInput & {
+    /** Whole meters, from 1 through 1000. Defaults to 5. */
+    gridSizeMeters?: number;
+};
+export type AddressEncoding = Readonly<{
+    northSouthBlock: number;
+    eastWestBlock: number;
+    northSouthDirection: "N" | "S";
+    eastWestDirection: "E" | "W";
+    /** Whole-meter magnitude within the block, from 0 through 99. */
+    northSouthRemainder: number;
+    eastWestRemainder: number;
+    /** Two digits per remainder, north/south first, e.g. #03-06. */
+    coordinateSuffix: string;
+}>;
+export type AddressResult = Readonly<{
+    protocol: "ZAP";
+    protocolVersion: "2";
+    address: string;
+    countryCode: string;
+    provinceCode?: string;
+    city?: string;
+    street?: string;
+    countryVersion: string;
+    gridVersion: string;
+    gridName: string;
+    coordinates: Coordinates;
+    center: Coordinates;
+    widthMeters: number;
+    heightMeters: number;
+    /** Unrounded signed projected offsets from the original GPS coordinates. */
+    northingMeters: number;
+    eastingMeters: number;
+    blockSizeMeters: 100;
+    detailSizeMeters: 1;
+    encoding: "blocks-100m-detail-1m-floor-absolute-dashed-suffix-2x2-v1";
+    /** Persist with the address to identify the snapshot, projection, and encoding. */
+    gridId: string;
+}> & AddressEncoding;
+/** Original protocol-1 result; its offsets remain snapped to gridSizeMeters. */
+export type LegacyAddressResult = Readonly<{
+    protocol: "ZAP";
+    protocolVersion: "1";
+    address: string;
+    countryCode: string;
+    provinceCode?: string;
+    gridName: string;
+    coordinates: Coordinates;
+    center: Coordinates;
+    widthMeters: number;
+    heightMeters: number;
+    northingMeters: number;
+    eastingMeters: number;
+    gridSizeMeters: number;
+    /** Persist with the address to identify the snapshot and projection rules. */
+    gridId: string;
+}>;
+export type CountryOption = Readonly<{
+    code: string;
+    name: string;
+    requiresProvince: boolean;
+}>;
+export type ProvinceOption = Readonly<{
+    code: string;
+    name: string;
+}>;

package/dist/esm/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,69 @@
 {
   "name": "@zukall/zap",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "description": "ZAP (Zukall Addressing Protocol): deterministic 100-meter grid blocks with whole-meter detail from GPS coordinates.",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/esm/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/index.d.ts",
+        "default": "./dist/cjs/index.js"
+      }
+    },
+    "./data": {
+      "import": {
+        "types": "./dist/esm/data.d.ts",
+        "default": "./dist/esm/data.js"
+      },
+      "require": {
+        "types": "./dist/cjs/data.d.ts",
+        "default": "./dist/cjs/data.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "PROTOCOL.md",
+    "PROTOCOL-V1.md",
+    "LICENSE",
+    "THIRD-PARTY-NOTICES.md"
+  ],
+  "sideEffects": false,
+  "engines": {
+    "node": ">=20"
+  },
+  "keywords": [
+    "zap",
+    "zukall",
+    "zukall-addressing-protocol",
+    "address",
+    "geolocation",
+    "coordinates",
+    "grid",
+    "typescript"
+  ],
+  "scripts": {
+    "build": "node scripts/build.mjs",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "test": "npm run build && node --test",
+    "check": "npm run typecheck && npm test",
+    "prepack": "npm run check",
+    "pack:check": "node scripts/verify-package.mjs"
+  },
+  "devDependencies": {
+    "typescript": "5.9.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}