@accelint/geo 0.6.1 → 0.7.0

package/dist/coordinates/latlon/internal/ordinal.js.map

@@ -1 +1 @@
-{"version":3,"file":"ordinal.js","names":[],"sources":["../../../../src/coordinates/latlon/internal/ordinal.ts"],"sourcesContent":["/*\n * Copyright 2026 Hypergiant Galactic Systems Inc. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\n// __private-exports\n\n/**\n * Gets the ordinal direction (N/S/E/W) for a coordinate value.\n *\n * @param num - The coordinate value (positive or negative).\n * @param isLatitude - Whether this is a latitude coordinate (true) or longitude (false).\n * @returns Ordinal direction character: 'N', 'S', 'E', or 'W'.\n *\n * @example\n * ```typescript\n * getOrdinal(37.7749, true);\n * // 'N'\n * ```\n *\n * @example\n * ```typescript\n * getOrdinal(-122.4194, false);\n * // 'W'\n * ```\n *\n * @example\n * ```typescript\n * getOrdinal(-45, true);\n * // 'S'\n * ```\n */\nexport const getOrdinal = (num: number, isLatitude: boolean): string => {\n  if (isLatitude) {\n    return num >= 0 ? 'N' : 'S';\n  }\n  return num >= 0 ? 'E' : 'W';\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,MAAa,cAAc,KAAa,eAAgC;AACtE,KAAI,WACF,QAAO,OAAO,IAAI,MAAM;AAE1B,QAAO,OAAO,IAAI,MAAM"}
+{"version":3,"file":"ordinal.js","names":[],"sources":["../../../../src/coordinates/latlon/internal/ordinal.ts"],"sourcesContent":["/*\n * Copyright 2026 Hypergiant Galactic Systems Inc. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\n// __private-exports\n\n/**\n * Axis discriminator for a single coordinate value.\n *\n * `'lat'` selects the N/S hemisphere pair; `'lon'` selects E/W.\n */\nexport type Axis = 'lat' | 'lon';\n\n/**\n * Hemisphere letter for a coordinate value, following geo's `>= 0`\n * convention (0 maps to `N` on the lat axis and `E` on the lon axis).\n */\nexport type Hemisphere = 'N' | 'S' | 'E' | 'W';\n\n/**\n * Gets the typed hemisphere letter for a signed coordinate value on an axis.\n *\n * Follows the same `>= 0` convention as {@link getOrdinal}: a value of exactly\n * `0` maps to `N` on the latitude axis and `E` on the longitude axis.\n *\n * @param value - The signed coordinate value.\n * @param axis - Whether the value is a latitude (`'lat'`) or longitude (`'lon'`).\n * @returns Hemisphere letter: `'N'`, `'S'`, `'E'`, or `'W'`.\n *\n * @remarks pure function\n *\n * @example\n * ```typescript\n * getHemisphere(-77.0369, 'lon');\n * // 'W'\n * ```\n */\nexport const getHemisphere = (value: number, axis: Axis): Hemisphere => {\n  if (axis === 'lat') {\n    return value >= 0 ? 'N' : 'S';\n  }\n\n  return value >= 0 ? 'E' : 'W';\n};\n\n/**\n * Gets the ordinal direction (N/S/E/W) for a coordinate value.\n *\n * Retained as the established public API. Adapts {@link getHemisphere} — which\n * owns the `>= 0` convention — to a boolean axis and the wider `string` return\n * its existing callers expect.\n *\n * @param value - The coordinate value (positive or negative).\n * @param isLatitude - Whether this is a latitude coordinate (true) or longitude (false).\n * @returns Ordinal direction character: 'N', 'S', 'E', or 'W'.\n *\n * @remarks pure function\n *\n * @example\n * ```typescript\n * getOrdinal(37.7749, true);\n * // 'N'\n * ```\n *\n * @example\n * ```typescript\n * getOrdinal(-122.4194, false);\n * // 'W'\n * ```\n */\nexport const getOrdinal = (value: number, isLatitude: boolean): string =>\n  getHemisphere(value, isLatitude ? 'lat' : 'lon');\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CA,MAAa,iBAAiB,OAAe,SAA2B;AACtE,KAAI,SAAS,MACX,QAAO,SAAS,IAAI,MAAM;AAG5B,QAAO,SAAS,IAAI,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4B5B,MAAa,cAAc,OAAe,eACxC,cAAc,OAAO,aAAa,QAAQ,MAAM"}

package/dist/coordinates/latlon/internal/plain-decimal.d.ts

@@ -0,0 +1,35 @@
+//#region src/coordinates/latlon/internal/plain-decimal.d.ts
+/**
+ * Renders a small number in plain decimal notation instead of exponential.
+ *
+ * JavaScript's default number-to-string conversion switches to exponential
+ * notation below `1e-6` (`String(0.0000001)` is `'1e-7'`), which the
+ * coordinate lexer would mis-tokenize (`-7` reads as a sign) and which the
+ * round-trip formatters must not emit. Values that already render plainly are
+ * returned unchanged, so this is a no-op for ordinary coordinates.
+ *
+ * Only negative exponents are expanded, to at most 20 fraction digits — enough
+ * for any coordinate magnitude. Numbers at or above `1e21` (positive exponent)
+ * are returned as JavaScript renders them.
+ *
+ * @param value - The number to render.
+ * @returns The value in plain decimal notation with no trailing zeros.
+ *
+ * @remarks pure function
+ *
+ * @example
+ * ```typescript
+ * toPlainDecimalString(0.0000001);
+ * // '0.0000001'
+ * ```
+ *
+ * @example
+ * ```typescript
+ * toPlainDecimalString(-122.4194);
+ * // '-122.4194'
+ * ```
+ */
+declare const toPlainDecimalString: (value: number) => string;
+//#endregion
+export { toPlainDecimalString };
+//# sourceMappingURL=plain-decimal.d.ts.map

package/dist/coordinates/latlon/internal/plain-decimal.js

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2026 Hypergiant Galactic Systems Inc. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+
+//#region src/coordinates/latlon/internal/plain-decimal.ts
+/**
+* Fraction digits used to expand an exponential-notation number. Twenty covers
+* every magnitude that is meaningful for a coordinate (`1e-20°` is far below
+* the width of an atom) while staying within `toFixed`'s supported range.
+*/
+const EXPANDED_FRACTION_DIGITS = 20;
+/**
+* Renders a small number in plain decimal notation instead of exponential.
+*
+* JavaScript's default number-to-string conversion switches to exponential
+* notation below `1e-6` (`String(0.0000001)` is `'1e-7'`), which the
+* coordinate lexer would mis-tokenize (`-7` reads as a sign) and which the
+* round-trip formatters must not emit. Values that already render plainly are
+* returned unchanged, so this is a no-op for ordinary coordinates.
+*
+* Only negative exponents are expanded, to at most 20 fraction digits — enough
+* for any coordinate magnitude. Numbers at or above `1e21` (positive exponent)
+* are returned as JavaScript renders them.
+*
+* @param value - The number to render.
+* @returns The value in plain decimal notation with no trailing zeros.
+*
+* @remarks pure function
+*
+* @example
+* ```typescript
+* toPlainDecimalString(0.0000001);
+* // '0.0000001'
+* ```
+*
+* @example
+* ```typescript
+* toPlainDecimalString(-122.4194);
+* // '-122.4194'
+* ```
+*/
+const toPlainDecimalString = (value) => {
+	const rendered = `${value}`;
+	if (!rendered.includes("e-")) return rendered;
+	return value.toFixed(EXPANDED_FRACTION_DIGITS).replace(/\.?0+$/, "");
+};
+
+//#endregion
+export { toPlainDecimalString };
+//# sourceMappingURL=plain-decimal.js.map

package/dist/coordinates/latlon/internal/plain-decimal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plain-decimal.js","names":[],"sources":["../../../../src/coordinates/latlon/internal/plain-decimal.ts"],"sourcesContent":["/*\n * Copyright 2026 Hypergiant Galactic Systems Inc. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\n/**\n * Fraction digits used to expand an exponential-notation number. Twenty covers\n * every magnitude that is meaningful for a coordinate (`1e-20°` is far below\n * the width of an atom) while staying within `toFixed`'s supported range.\n */\nconst EXPANDED_FRACTION_DIGITS = 20;\n\n/**\n * Renders a small number in plain decimal notation instead of exponential.\n *\n * JavaScript's default number-to-string conversion switches to exponential\n * notation below `1e-6` (`String(0.0000001)` is `'1e-7'`), which the\n * coordinate lexer would mis-tokenize (`-7` reads as a sign) and which the\n * round-trip formatters must not emit. Values that already render plainly are\n * returned unchanged, so this is a no-op for ordinary coordinates.\n *\n * Only negative exponents are expanded, to at most 20 fraction digits — enough\n * for any coordinate magnitude. Numbers at or above `1e21` (positive exponent)\n * are returned as JavaScript renders them.\n *\n * @param value - The number to render.\n * @returns The value in plain decimal notation with no trailing zeros.\n *\n * @remarks pure function\n *\n * @example\n * ```typescript\n * toPlainDecimalString(0.0000001);\n * // '0.0000001'\n * ```\n *\n * @example\n * ```typescript\n * toPlainDecimalString(-122.4194);\n * // '-122.4194'\n * ```\n */\nexport const toPlainDecimalString = (value: number): string => {\n  const rendered = `${value}`;\n\n  if (!rendered.includes('e-')) {\n    return rendered;\n  }\n\n  return value.toFixed(EXPANDED_FRACTION_DIGITS).replace(/\\.?0+$/, '');\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAiBA,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCjC,MAAa,wBAAwB,UAA0B;CAC7D,MAAM,WAAW,GAAG;AAEpB,KAAI,CAAC,SAAS,SAAS,KAAK,CAC1B,QAAO;AAGT,QAAO,MAAM,QAAQ,yBAAyB,CAAC,QAAQ,UAAU,GAAG"}

package/dist/coordinates/latlon/internal/validate.d.ts

@@ -70,6 +70,33 @@ declare function validateSignedRange(label: string, value: number, limit: number
  * ```
  */
 declare function validateNumericCoordinate(lat: number, lon: number): string[];
+/**
+ * Reports whether latitude and longitude are both finite and in range.
+ *
+ * A boolean-only probe for hot paths that need validity but not the error
+ * messages: it short-circuits on the first finite/range failure and allocates
+ * nothing, unlike {@link validateNumericCoordinate}, which builds an error
+ * array. Use that function when the messages are consumed.
+ *
+ * @param lat - The latitude value to validate (must be -90 to 90).
+ * @param lon - The longitude value to validate (must be -180 to 180).
+ * @returns `true` when both values are finite and within range.
+ *
+ * @remarks pure function
+ *
+ * @example
+ * ```typescript
+ * isValidNumericCoordinate(45.5, -122.6);
+ * // => true
+ * ```
+ *
+ * @example
+ * ```typescript
+ * isValidNumericCoordinate(91, -122.6);
+ * // => false
+ * ```
+ */
+declare function isValidNumericCoordinate(lat: number, lon: number): boolean;
 //#endregion
-export { isFiniteNumber, validateNumericCoordinate, validateSignedRange };
+export { isFiniteNumber, isValidNumericCoordinate, validateNumericCoordinate, validateSignedRange };
 //# sourceMappingURL=validate.d.ts.map

package/dist/coordinates/latlon/internal/validate.js

@@ -99,7 +99,36 @@ function validateNumericCoordinate(lat, lon) {
 	if (lonError) errors.push(lonError);
 	return errors;
 }
+/**
+* Reports whether latitude and longitude are both finite and in range.
+*
+* A boolean-only probe for hot paths that need validity but not the error
+* messages: it short-circuits on the first finite/range failure and allocates
+* nothing, unlike {@link validateNumericCoordinate}, which builds an error
+* array. Use that function when the messages are consumed.
+*
+* @param lat - The latitude value to validate (must be -90 to 90).
+* @param lon - The longitude value to validate (must be -180 to 180).
+* @returns `true` when both values are finite and within range.
+*
+* @remarks pure function
+*
+* @example
+* ```typescript
+* isValidNumericCoordinate(45.5, -122.6);
+* // => true
+* ```
+*
+* @example
+* ```typescript
+* isValidNumericCoordinate(91, -122.6);
+* // => false
+* ```
+*/
+function isValidNumericCoordinate(lat, lon) {
+	return isFiniteNumber(lat) && isFiniteNumber(lon) && lat >= -LAT_LIMIT && lat <= LAT_LIMIT && lon >= -LON_LIMIT && lon <= LON_LIMIT;
+}
 
 //#endregion
-export { isFiniteNumber, validateNumericCoordinate, validateSignedRange };
+export { isFiniteNumber, isValidNumericCoordinate, validateNumericCoordinate, validateSignedRange };
 //# sourceMappingURL=validate.js.map

package/dist/coordinates/latlon/internal/validate.js.map

@@ -1 +1 @@
-{"version":3,"file":"validate.js","names":["errors: string[]"],"sources":["../../../../src/coordinates/latlon/internal/validate.ts"],"sourcesContent":["/*\n * Copyright 2024 Hypergiant Galactic Systems Inc. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nimport { violation } from './violation';\n\nconst LAT_LIMIT = 90;\nconst LON_LIMIT = 180;\n\n/**\n * Checks if a value is a finite number (not NaN, not Infinity, not -Infinity).\n *\n * @param value - The numeric value to check\n * @returns True if the value is a finite number, false otherwise\n *\n * @example\n * ```typescript\n * isFiniteNumber(42);        // true\n * isFiniteNumber(NaN);       // false\n * isFiniteNumber(Infinity);  // false\n * ```\n */\nexport function isFiniteNumber(value: number): boolean {\n  return typeof value === 'number' && Number.isFinite(value);\n}\n\n/**\n * Validates that a value is within a signed range (-limit to +limit).\n *\n * @param label - The label for error messages (used as-is for range errors,\n *                lowercased for \"Invalid\" errors)\n * @param value - The numeric value to validate\n * @param limit - The absolute limit (validates -limit to +limit)\n * @returns Error message string if validation fails, undefined if valid\n *\n * @example\n * ```typescript\n * validateSignedRange('Latitude', 45, 90);\n * // => undefined\n * ```\n *\n * @example\n * ```typescript\n * validateSignedRange('Latitude', 95, 90);\n * // => '[ERROR] Latitude value (95) is outside valid range (-90 to 90).'\n * ```\n *\n * @example\n * ```typescript\n * validateSignedRange('Longitude', NaN, 180);\n * // => '[ERROR] Invalid longitude value (NaN); expected a finite number.'\n * ```\n */\nexport function validateSignedRange(\n  label: string,\n  value: number,\n  limit: number,\n): string | undefined {\n  if (!isFiniteNumber(value)) {\n    return violation(\n      `Invalid ${label.toLowerCase()} value (${value}); expected a finite number.`,\n    );\n  }\n\n  if (value < -limit || value > limit) {\n    return violation(\n      `${label} value (${value}) is outside valid range (-${limit} to ${limit}).`,\n    );\n  }\n}\n\n/**\n * Validates numeric latitude and longitude coordinate values.\n *\n * @param lat - The latitude value to validate (must be -90 to 90)\n * @param lon - The longitude value to validate (must be -180 to 180)\n * @returns Array of error message strings, empty if all validations pass\n *\n * @example\n * ```typescript\n * validateNumericCoordinate(45.5, -122.6);\n * // => []\n * ```\n *\n * @example\n * ```typescript\n * validateNumericCoordinate(91, -122.6);\n * // => ['[ERROR] Latitude value (91) is outside valid range (-90 to 90).']\n * ```\n *\n * @example\n * ```typescript\n * validateNumericCoordinate(NaN, 200);\n * // => [\n * //   '[ERROR] Invalid latitude value (NaN); expected a finite number.',\n * //   '[ERROR] Longitude value (200) is outside valid range (-180 to 180).'\n * // ]\n * ```\n */\nexport function validateNumericCoordinate(lat: number, lon: number): string[] {\n  const errors: string[] = [];\n\n  const latError = validateSignedRange('Latitude', lat, LAT_LIMIT);\n  if (latError) {\n    errors.push(latError);\n  }\n\n  const lonError = validateSignedRange('Longitude', lon, LON_LIMIT);\n  if (lonError) {\n    errors.push(lonError);\n  }\n\n  return errors;\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAcA,MAAM,YAAY;AAClB,MAAM,YAAY;;;;;;;;;;;;;;AAelB,SAAgB,eAAe,OAAwB;AACrD,QAAO,OAAO,UAAU,YAAY,OAAO,SAAS,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8B5D,SAAgB,oBACd,OACA,OACA,OACoB;AACpB,KAAI,CAAC,eAAe,MAAM,CACxB,QAAO,UACL,WAAW,MAAM,aAAa,CAAC,UAAU,MAAM,8BAChD;AAGH,KAAI,QAAQ,CAAC,SAAS,QAAQ,MAC5B,QAAO,UACL,GAAG,MAAM,UAAU,MAAM,6BAA6B,MAAM,MAAM,MAAM,IACzE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCL,SAAgB,0BAA0B,KAAa,KAAuB;CAC5E,MAAMA,SAAmB,EAAE;CAE3B,MAAM,WAAW,oBAAoB,YAAY,KAAK,UAAU;AAChE,KAAI,SACF,QAAO,KAAK,SAAS;CAGvB,MAAM,WAAW,oBAAoB,aAAa,KAAK,UAAU;AACjE,KAAI,SACF,QAAO,KAAK,SAAS;AAGvB,QAAO"}
+{"version":3,"file":"validate.js","names":["errors: string[]"],"sources":["../../../../src/coordinates/latlon/internal/validate.ts"],"sourcesContent":["/*\n * Copyright 2024 Hypergiant Galactic Systems Inc. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nimport { violation } from './violation';\n\nconst LAT_LIMIT = 90;\nconst LON_LIMIT = 180;\n\n/**\n * Checks if a value is a finite number (not NaN, not Infinity, not -Infinity).\n *\n * @param value - The numeric value to check\n * @returns True if the value is a finite number, false otherwise\n *\n * @example\n * ```typescript\n * isFiniteNumber(42);        // true\n * isFiniteNumber(NaN);       // false\n * isFiniteNumber(Infinity);  // false\n * ```\n */\nexport function isFiniteNumber(value: number): boolean {\n  return typeof value === 'number' && Number.isFinite(value);\n}\n\n/**\n * Validates that a value is within a signed range (-limit to +limit).\n *\n * @param label - The label for error messages (used as-is for range errors,\n *                lowercased for \"Invalid\" errors)\n * @param value - The numeric value to validate\n * @param limit - The absolute limit (validates -limit to +limit)\n * @returns Error message string if validation fails, undefined if valid\n *\n * @example\n * ```typescript\n * validateSignedRange('Latitude', 45, 90);\n * // => undefined\n * ```\n *\n * @example\n * ```typescript\n * validateSignedRange('Latitude', 95, 90);\n * // => '[ERROR] Latitude value (95) is outside valid range (-90 to 90).'\n * ```\n *\n * @example\n * ```typescript\n * validateSignedRange('Longitude', NaN, 180);\n * // => '[ERROR] Invalid longitude value (NaN); expected a finite number.'\n * ```\n */\nexport function validateSignedRange(\n  label: string,\n  value: number,\n  limit: number,\n): string | undefined {\n  if (!isFiniteNumber(value)) {\n    return violation(\n      `Invalid ${label.toLowerCase()} value (${value}); expected a finite number.`,\n    );\n  }\n\n  if (value < -limit || value > limit) {\n    return violation(\n      `${label} value (${value}) is outside valid range (-${limit} to ${limit}).`,\n    );\n  }\n}\n\n/**\n * Validates numeric latitude and longitude coordinate values.\n *\n * @param lat - The latitude value to validate (must be -90 to 90)\n * @param lon - The longitude value to validate (must be -180 to 180)\n * @returns Array of error message strings, empty if all validations pass\n *\n * @example\n * ```typescript\n * validateNumericCoordinate(45.5, -122.6);\n * // => []\n * ```\n *\n * @example\n * ```typescript\n * validateNumericCoordinate(91, -122.6);\n * // => ['[ERROR] Latitude value (91) is outside valid range (-90 to 90).']\n * ```\n *\n * @example\n * ```typescript\n * validateNumericCoordinate(NaN, 200);\n * // => [\n * //   '[ERROR] Invalid latitude value (NaN); expected a finite number.',\n * //   '[ERROR] Longitude value (200) is outside valid range (-180 to 180).'\n * // ]\n * ```\n */\nexport function validateNumericCoordinate(lat: number, lon: number): string[] {\n  const errors: string[] = [];\n\n  const latError = validateSignedRange('Latitude', lat, LAT_LIMIT);\n  if (latError) {\n    errors.push(latError);\n  }\n\n  const lonError = validateSignedRange('Longitude', lon, LON_LIMIT);\n  if (lonError) {\n    errors.push(lonError);\n  }\n\n  return errors;\n}\n\n/**\n * Reports whether latitude and longitude are both finite and in range.\n *\n * A boolean-only probe for hot paths that need validity but not the error\n * messages: it short-circuits on the first finite/range failure and allocates\n * nothing, unlike {@link validateNumericCoordinate}, which builds an error\n * array. Use that function when the messages are consumed.\n *\n * @param lat - The latitude value to validate (must be -90 to 90).\n * @param lon - The longitude value to validate (must be -180 to 180).\n * @returns `true` when both values are finite and within range.\n *\n * @remarks pure function\n *\n * @example\n * ```typescript\n * isValidNumericCoordinate(45.5, -122.6);\n * // => true\n * ```\n *\n * @example\n * ```typescript\n * isValidNumericCoordinate(91, -122.6);\n * // => false\n * ```\n */\nexport function isValidNumericCoordinate(lat: number, lon: number): boolean {\n  return (\n    isFiniteNumber(lat) &&\n    isFiniteNumber(lon) &&\n    lat >= -LAT_LIMIT &&\n    lat <= LAT_LIMIT &&\n    lon >= -LON_LIMIT &&\n    lon <= LON_LIMIT\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAcA,MAAM,YAAY;AAClB,MAAM,YAAY;;;;;;;;;;;;;;AAelB,SAAgB,eAAe,OAAwB;AACrD,QAAO,OAAO,UAAU,YAAY,OAAO,SAAS,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8B5D,SAAgB,oBACd,OACA,OACA,OACoB;AACpB,KAAI,CAAC,eAAe,MAAM,CACxB,QAAO,UACL,WAAW,MAAM,aAAa,CAAC,UAAU,MAAM,8BAChD;AAGH,KAAI,QAAQ,CAAC,SAAS,QAAQ,MAC5B,QAAO,UACL,GAAG,MAAM,UAAU,MAAM,6BAA6B,MAAM,MAAM,MAAM,IACzE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCL,SAAgB,0BAA0B,KAAa,KAAuB;CAC5E,MAAMA,SAAmB,EAAE;CAE3B,MAAM,WAAW,oBAAoB,YAAY,KAAK,UAAU;AAChE,KAAI,SACF,QAAO,KAAK,SAAS;CAGvB,MAAM,WAAW,oBAAoB,aAAa,KAAK,UAAU;AACjE,KAAI,SACF,QAAO,KAAK,SAAS;AAGvB,QAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BT,SAAgB,yBAAyB,KAAa,KAAsB;AAC1E,QACE,eAAe,IAAI,IACnB,eAAe,IAAI,IACnB,OAAO,CAAC,aACR,OAAO,aACP,OAAO,CAAC,aACR,OAAO"}

package/dist/coordinates/mgrs/parts.d.ts

@@ -0,0 +1,86 @@
+/*
+ * Copyright 2026 Hypergiant Galactic Systems Inc. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+import { GridPartsResult } from "../utm/parts.js";
+
+//#region src/coordinates/mgrs/parts.d.ts
+/**
+ * Structured MGRS grid parts for a signed `[lat, lon]` coordinate.
+ *
+ * `zone`/`band`/`e100k`/`n100k` identify the grid square; `easting`/`northing`
+ * are the geodesy within-square metre values (`0`–`99999`) prior to truncation.
+ */
+type MgrsParts = {
+  zone: number;
+  band: string;
+  e100k: string;
+  n100k: string;
+  easting: number;
+  northing: number;
+};
+/**
+ * Converts a signed `[lat, lon]` coordinate into MGRS grid parts.
+ *
+ * Reads the geodesy `Mgrs` object fields directly instead of parsing a
+ * formatted string. The UTM/MGRS grid is defined for `-80 ≤ lat ≤ 84`
+ * inclusive; latitudes outside that band, a longitude of exactly `+180°` (the
+ * antimeridian zone singularity), or non-finite input, produce
+ * `{ ok: false, reason: 'out-of-range' }`.
+ *
+ * @param coordinate - Signed `[latitude, longitude]` tuple.
+ * @returns A discriminated result with `{ zone, band, e100k, n100k, easting, northing }` on success.
+ *
+ * @remarks pure function
+ *
+ * @example
+ * ```typescript
+ * toMgrsParts([38.8977, -77.0365]);
+ * // { ok: true, value: { zone: 18, band: 'S', e100k: 'U', n100k: 'J', easting: 23394.29…, northing: 7395.63… } }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * toMgrsParts([-81, 0]);
+ * // { ok: false, reason: 'out-of-range' }
+ * ```
+ */
+declare const toMgrsParts: ([lat, lon]: [number, number]) => GridPartsResult<MgrsParts>;
+/**
+ * Renders MGRS grid parts as their canonical coordinate string.
+ *
+ * Mirrors geodesy's `Mgrs.toString(10)`: floors the within-square metres,
+ * left-pads the zone to two digits and easting/northing to five, and joins the
+ * zone+band, the `e100k`/`n100k` grid-square pair, and the padded metres with
+ * single spaces.
+ *
+ * @param parts - The MGRS grid parts to render.
+ * @returns The canonical MGRS string, e.g. `"18S UJ 23394 07396"`.
+ *
+ * @remarks pure function
+ *
+ * @example
+ * ```typescript
+ * formatMgrsParts({ zone: 18, band: 'S', e100k: 'U', n100k: 'J', easting: 23394, northing: 7396 });
+ * // '18S UJ 23394 07396'
+ * ```
+ */
+declare const formatMgrsParts: ({
+  zone,
+  band,
+  e100k,
+  n100k,
+  easting,
+  northing
+}: MgrsParts) => string;
+//#endregion
+export { MgrsParts, formatMgrsParts, toMgrsParts };
+//# sourceMappingURL=parts.d.ts.map

package/dist/coordinates/mgrs/parts.js

@@ -0,0 +1,94 @@
+/*
+ * Copyright 2026 Hypergiant Galactic Systems Inc. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+
+import { isGridProjectable } from "../utm/parts.js";
+import { LatLon } from "geodesy/mgrs";
+
+//#region src/coordinates/mgrs/parts.ts
+/**
+* Converts a signed `[lat, lon]` coordinate into MGRS grid parts.
+*
+* Reads the geodesy `Mgrs` object fields directly instead of parsing a
+* formatted string. The UTM/MGRS grid is defined for `-80 ≤ lat ≤ 84`
+* inclusive; latitudes outside that band, a longitude of exactly `+180°` (the
+* antimeridian zone singularity), or non-finite input, produce
+* `{ ok: false, reason: 'out-of-range' }`.
+*
+* @param coordinate - Signed `[latitude, longitude]` tuple.
+* @returns A discriminated result with `{ zone, band, e100k, n100k, easting, northing }` on success.
+*
+* @remarks pure function
+*
+* @example
+* ```typescript
+* toMgrsParts([38.8977, -77.0365]);
+* // { ok: true, value: { zone: 18, band: 'S', e100k: 'U', n100k: 'J', easting: 23394.29…, northing: 7395.63… } }
+* ```
+*
+* @example
+* ```typescript
+* toMgrsParts([-81, 0]);
+* // { ok: false, reason: 'out-of-range' }
+* ```
+*/
+const toMgrsParts = ([lat, lon]) => {
+	if (!isGridProjectable([lat, lon])) return {
+		ok: false,
+		reason: "out-of-range"
+	};
+	try {
+		const mgrs = new LatLon(lat, lon).toUtm().toMgrs();
+		return {
+			ok: true,
+			value: {
+				zone: mgrs.zone,
+				band: mgrs.band,
+				e100k: mgrs.e100k,
+				n100k: mgrs.n100k,
+				easting: mgrs.easting,
+				northing: mgrs.northing
+			}
+		};
+	} catch {
+		return {
+			ok: false,
+			reason: "out-of-range"
+		};
+	}
+};
+/**
+* Renders MGRS grid parts as their canonical coordinate string.
+*
+* Mirrors geodesy's `Mgrs.toString(10)`: floors the within-square metres,
+* left-pads the zone to two digits and easting/northing to five, and joins the
+* zone+band, the `e100k`/`n100k` grid-square pair, and the padded metres with
+* single spaces.
+*
+* @param parts - The MGRS grid parts to render.
+* @returns The canonical MGRS string, e.g. `"18S UJ 23394 07396"`.
+*
+* @remarks pure function
+*
+* @example
+* ```typescript
+* formatMgrsParts({ zone: 18, band: 'S', e100k: 'U', n100k: 'J', easting: 23394, northing: 7396 });
+* // '18S UJ 23394 07396'
+* ```
+*/
+const formatMgrsParts = ({ zone, band, e100k, n100k, easting, northing }) => {
+	return `${zone.toString().padStart(2, "0")}${band} ${e100k}${n100k} ${Math.floor(easting).toString().padStart(5, "0")} ${Math.floor(northing).toString().padStart(5, "0")}`;
+};
+
+//#endregion
+export { formatMgrsParts, toMgrsParts };
+//# sourceMappingURL=parts.js.map

package/dist/coordinates/mgrs/parts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parts.js","names":[],"sources":["../../../src/coordinates/mgrs/parts.ts"],"sourcesContent":["/*\n * Copyright 2026 Hypergiant Galactic Systems Inc. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nimport { LatLon } from 'geodesy/mgrs';\nimport { type GridPartsResult, isGridProjectable } from '../utm/parts';\n\n/**\n * Structured MGRS grid parts for a signed `[lat, lon]` coordinate.\n *\n * `zone`/`band`/`e100k`/`n100k` identify the grid square; `easting`/`northing`\n * are the geodesy within-square metre values (`0`–`99999`) prior to truncation.\n */\nexport type MgrsParts = {\n  zone: number;\n  band: string;\n  e100k: string;\n  n100k: string;\n  easting: number;\n  northing: number;\n};\n\n/**\n * Converts a signed `[lat, lon]` coordinate into MGRS grid parts.\n *\n * Reads the geodesy `Mgrs` object fields directly instead of parsing a\n * formatted string. The UTM/MGRS grid is defined for `-80 ≤ lat ≤ 84`\n * inclusive; latitudes outside that band, a longitude of exactly `+180°` (the\n * antimeridian zone singularity), or non-finite input, produce\n * `{ ok: false, reason: 'out-of-range' }`.\n *\n * @param coordinate - Signed `[latitude, longitude]` tuple.\n * @returns A discriminated result with `{ zone, band, e100k, n100k, easting, northing }` on success.\n *\n * @remarks pure function\n *\n * @example\n * ```typescript\n * toMgrsParts([38.8977, -77.0365]);\n * // { ok: true, value: { zone: 18, band: 'S', e100k: 'U', n100k: 'J', easting: 23394.29…, northing: 7395.63… } }\n * ```\n *\n * @example\n * ```typescript\n * toMgrsParts([-81, 0]);\n * // { ok: false, reason: 'out-of-range' }\n * ```\n */\nexport const toMgrsParts = ([lat, lon]: [\n  number,\n  number,\n]): GridPartsResult<MgrsParts> => {\n  if (!isGridProjectable([lat, lon])) {\n    return { ok: false, reason: 'out-of-range' };\n  }\n\n  try {\n    const mgrs = new LatLon(lat, lon).toUtm().toMgrs();\n\n    return {\n      ok: true,\n      value: {\n        zone: mgrs.zone,\n        band: mgrs.band,\n        e100k: mgrs.e100k,\n        n100k: mgrs.n100k,\n        easting: mgrs.easting,\n        northing: mgrs.northing,\n      },\n    };\n  } catch {\n    // geodesy re-verifies UTM bounds when building the MGRS reference; keep\n    // the result total rather than leaking a RangeError.\n    return { ok: false, reason: 'out-of-range' };\n  }\n};\n\n/**\n * Renders MGRS grid parts as their canonical coordinate string.\n *\n * Mirrors geodesy's `Mgrs.toString(10)`: floors the within-square metres,\n * left-pads the zone to two digits and easting/northing to five, and joins the\n * zone+band, the `e100k`/`n100k` grid-square pair, and the padded metres with\n * single spaces.\n *\n * @param parts - The MGRS grid parts to render.\n * @returns The canonical MGRS string, e.g. `\"18S UJ 23394 07396\"`.\n *\n * @remarks pure function\n *\n * @example\n * ```typescript\n * formatMgrsParts({ zone: 18, band: 'S', e100k: 'U', n100k: 'J', easting: 23394, northing: 7396 });\n * // '18S UJ 23394 07396'\n * ```\n */\nexport const formatMgrsParts = ({\n  zone,\n  band,\n  e100k,\n  n100k,\n  easting,\n  northing,\n}: MgrsParts): string => {\n  const zonePadded = zone.toString().padStart(2, '0');\n  const eastingPadded = Math.floor(easting).toString().padStart(5, '0');\n  const northingPadded = Math.floor(northing).toString().padStart(5, '0');\n\n  return `${zonePadded}${band} ${e100k}${n100k} ${eastingPadded} ${northingPadded}`;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwDA,MAAa,eAAe,CAAC,KAAK,SAGA;AAChC,KAAI,CAAC,kBAAkB,CAAC,KAAK,IAAI,CAAC,CAChC,QAAO;EAAE,IAAI;EAAO,QAAQ;EAAgB;AAG9C,KAAI;EACF,MAAM,OAAO,IAAI,OAAO,KAAK,IAAI,CAAC,OAAO,CAAC,QAAQ;AAElD,SAAO;GACL,IAAI;GACJ,OAAO;IACL,MAAM,KAAK;IACX,MAAM,KAAK;IACX,OAAO,KAAK;IACZ,OAAO,KAAK;IACZ,SAAS,KAAK;IACd,UAAU,KAAK;IAChB;GACF;SACK;AAGN,SAAO;GAAE,IAAI;GAAO,QAAQ;GAAgB;;;;;;;;;;;;;;;;;;;;;;AAuBhD,MAAa,mBAAmB,EAC9B,MACA,MACA,OACA,OACA,SACA,eACuB;AAKvB,QAAO,GAJY,KAAK,UAAU,CAAC,SAAS,GAAG,IAAI,GAI5B,KAAK,GAAG,QAAQ,MAAM,GAHvB,KAAK,MAAM,QAAQ,CAAC,UAAU,CAAC,SAAS,GAAG,IAAI,CAGP,GAFvC,KAAK,MAAM,SAAS,CAAC,UAAU,CAAC,SAAS,GAAG,IAAI"}

package/dist/coordinates/mgrs/system.js

@@ -13,7 +13,7 @@
 
 import { SYMBOL_PATTERNS } from "../latlon/internal/index.js";
 import { parseMGRS } from "./parser.js";
-import { LatLon } from "geodesy/mgrs";
+import { formatMgrsParts, toMgrsParts } from "./parts.js";
 
 //#region src/coordinates/mgrs/system.ts
 /**
@@ -55,7 +55,9 @@ const systemMGRS = {
 	},
 	toFormat(format, [left, right]) {
 		const { LAT, LON } = Object.fromEntries([[format.slice(0, 3), left], [format.slice(3), right]]);
-		return new LatLon(LAT, LON).toUtm().toMgrs().toString();
+		const result = toMgrsParts([LAT, LON]);
+		if (!result.ok) throw new RangeError(`Coordinate [${LAT}, ${LON}] cannot be represented in MGRS (outside 80°S–84°N, on the +180° antimeridian, or not finite).`);
+		return formatMgrsParts(result.value);
 	}
 };
 

package/dist/coordinates/mgrs/system.js.map

@@ -1 +1 @@
-{"version":3,"file":"system.js","names":["systemMGRS: CoordinateSystem"],"sources":["../../../src/coordinates/mgrs/system.ts"],"sourcesContent":["// __private-exports\n/*\n * Copyright 2024 Hypergiant Galactic Systems Inc. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nimport { LatLon } from 'geodesy/mgrs';\nimport { type Compass, type Format, SYMBOL_PATTERNS } from '../latlon/internal';\nimport { parseMGRS } from './parser';\nimport type { CoordinateSystem } from '../latlon/internal/coordinate-system';\n\n/**\n * Military Grid Reference System (MGRS) coordinate system implementation.\n *\n * Provides parsing, conversion, and formatting for MGRS coordinates. MGRS is a geocoordinate\n * standard used by NATO militaries for locating points on Earth, based on the UTM coordinate\n * system. Format: Grid Zone Designation + 100km Square ID + Numerical Location (e.g., '31U BF 12345 67890').\n *\n * @property name - Human-readable name: 'Military Grid Reference System'.\n * @property parse - Parses MGRS coordinate strings into latitude/longitude values.\n * @property toFloat - Converts coordinate component with bearing to signed float value.\n * @property toFormat - Formats latitude/longitude pair back to MGRS coordinate string.\n *\n * @example\n * ```typescript\n * systemMGRS.parse(null, '31U BF 12345 67890');\n * // [[['48.123456', 'N'], ['11.234567', 'E']], []]\n * ```\n *\n * @example\n * ```typescript\n * systemMGRS.toFormat('LATLON', [48.123456, 11.234567]);\n * // '31U BF 12345 67890'\n * ```\n *\n * @example\n * ```typescript\n * systemMGRS.toFloat(['48.123456', 'N']);\n * // 48.123456\n * ```\n */\nexport const systemMGRS: CoordinateSystem = {\n  name: 'Military Grid Reference System',\n\n  parse: parseMGRS,\n\n  toFloat(arg) {\n    const [num, bear] = arg as [string, Compass];\n\n    return (\n      Number.parseFloat(num) *\n      (SYMBOL_PATTERNS.NEGATIVE_BEARINGS.test(bear) ? -1 : 1)\n    );\n  },\n\n  toFormat(format: Format, [left, right]: [number, number]) {\n    const { LAT, LON } = Object.fromEntries([\n      [format.slice(0, 3), left],\n      [format.slice(3), right],\n    ]) as Record<'LAT' | 'LON', number>;\n\n    const latlon = new LatLon(LAT, LON);\n\n    return latlon.toUtm().toMgrs().toString();\n  },\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDA,MAAaA,aAA+B;CAC1C,MAAM;CAEN,OAAO;CAEP,QAAQ,KAAK;EACX,MAAM,CAAC,KAAK,QAAQ;AAEpB,SACE,OAAO,WAAW,IAAI,IACrB,gBAAgB,kBAAkB,KAAK,KAAK,GAAG,KAAK;;CAIzD,SAAS,QAAgB,CAAC,MAAM,QAA0B;EACxD,MAAM,EAAE,KAAK,QAAQ,OAAO,YAAY,CACtC,CAAC,OAAO,MAAM,GAAG,EAAE,EAAE,KAAK,EAC1B,CAAC,OAAO,MAAM,EAAE,EAAE,MAAM,CACzB,CAAC;AAIF,SAFe,IAAI,OAAO,KAAK,IAAI,CAErB,OAAO,CAAC,QAAQ,CAAC,UAAU;;CAE5C"}
+{"version":3,"file":"system.js","names":["systemMGRS: CoordinateSystem"],"sources":["../../../src/coordinates/mgrs/system.ts"],"sourcesContent":["// __private-exports\n/*\n * Copyright 2024 Hypergiant Galactic Systems Inc. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nimport { type Compass, type Format, SYMBOL_PATTERNS } from '../latlon/internal';\nimport { parseMGRS } from './parser';\nimport { formatMgrsParts, toMgrsParts } from './parts';\nimport type { CoordinateSystem } from '../latlon/internal/coordinate-system';\n\n/**\n * Military Grid Reference System (MGRS) coordinate system implementation.\n *\n * Provides parsing, conversion, and formatting for MGRS coordinates. MGRS is a geocoordinate\n * standard used by NATO militaries for locating points on Earth, based on the UTM coordinate\n * system. Format: Grid Zone Designation + 100km Square ID + Numerical Location (e.g., '31U BF 12345 67890').\n *\n * @property name - Human-readable name: 'Military Grid Reference System'.\n * @property parse - Parses MGRS coordinate strings into latitude/longitude values.\n * @property toFloat - Converts coordinate component with bearing to signed float value.\n * @property toFormat - Formats latitude/longitude pair back to MGRS coordinate string.\n *\n * @example\n * ```typescript\n * systemMGRS.parse(null, '31U BF 12345 67890');\n * // [[['48.123456', 'N'], ['11.234567', 'E']], []]\n * ```\n *\n * @example\n * ```typescript\n * systemMGRS.toFormat('LATLON', [48.123456, 11.234567]);\n * // '31U BF 12345 67890'\n * ```\n *\n * @example\n * ```typescript\n * systemMGRS.toFloat(['48.123456', 'N']);\n * // 48.123456\n * ```\n */\nexport const systemMGRS: CoordinateSystem = {\n  name: 'Military Grid Reference System',\n\n  parse: parseMGRS,\n\n  toFloat(arg) {\n    const [num, bear] = arg as [string, Compass];\n\n    return (\n      Number.parseFloat(num) *\n      (SYMBOL_PATTERNS.NEGATIVE_BEARINGS.test(bear) ? -1 : 1)\n    );\n  },\n\n  toFormat(format: Format, [left, right]: [number, number]) {\n    const { LAT, LON } = Object.fromEntries([\n      [format.slice(0, 3), left],\n      [format.slice(3), right],\n    ]) as Record<'LAT' | 'LON', number>;\n\n    const result = toMgrsParts([LAT, LON]);\n\n    if (!result.ok) {\n      // The legacy `toFormat` contract throws for coordinates the grid cannot\n      // represent; the parts API returns `{ ok: false }` for the same inputs.\n      throw new RangeError(\n        `Coordinate [${LAT}, ${LON}] cannot be represented in MGRS (outside 80°S–84°N, on the +180° antimeridian, or not finite).`,\n      );\n    }\n\n    return formatMgrsParts(result.value);\n  },\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDA,MAAaA,aAA+B;CAC1C,MAAM;CAEN,OAAO;CAEP,QAAQ,KAAK;EACX,MAAM,CAAC,KAAK,QAAQ;AAEpB,SACE,OAAO,WAAW,IAAI,IACrB,gBAAgB,kBAAkB,KAAK,KAAK,GAAG,KAAK;;CAIzD,SAAS,QAAgB,CAAC,MAAM,QAA0B;EACxD,MAAM,EAAE,KAAK,QAAQ,OAAO,YAAY,CACtC,CAAC,OAAO,MAAM,GAAG,EAAE,EAAE,KAAK,EAC1B,CAAC,OAAO,MAAM,EAAE,EAAE,MAAM,CACzB,CAAC;EAEF,MAAM,SAAS,YAAY,CAAC,KAAK,IAAI,CAAC;AAEtC,MAAI,CAAC,OAAO,GAGV,OAAM,IAAI,WACR,eAAe,IAAI,IAAI,IAAI,gGAC5B;AAGH,SAAO,gBAAgB,OAAO,MAAM;;CAEvC"}

package/dist/coordinates/utm/parts.d.ts

@@ -0,0 +1,134 @@
+//#region src/coordinates/utm/parts.d.ts
+/**
+ * Lowest latitude (degrees) the UTM/MGRS grid is defined for, inclusive.
+ *
+ * Matches the patched geodesy valid range; latitudes below this yield an
+ * out-of-range result rather than a projected grid reference.
+ */
+declare const GRID_LATITUDE_MIN = -80;
+/**
+ * Highest latitude (degrees) the UTM/MGRS grid is defined for, inclusive.
+ *
+ * Matches the patched geodesy valid range; latitudes above this yield an
+ * out-of-range result rather than a projected grid reference.
+ */
+declare const GRID_LATITUDE_MAX = 84;
+/**
+ * Discriminated result for a grid-parts conversion.
+ *
+ * `ok: true` carries the structured grid parts; `ok: false` carries a typed
+ * `reason` so consumers branch on a field instead of matching error text.
+ *
+ * @template Value - The grid parts shape carried on success.
+ */
+type GridPartsResult<Value> = {
+  ok: true;
+  value: Value;
+} | {
+  ok: false;
+  reason: 'out-of-range';
+};
+/**
+ * Structured UTM grid parts for a signed `[lat, lon]` coordinate.
+ *
+ * `easting` and `northing` are the rounded integer metres geodesy yields.
+ */
+type UtmParts = {
+  zone: number;
+  hemisphere: 'N' | 'S';
+  easting: number;
+  northing: number;
+};
+/**
+ * Reports whether a latitude falls within the inclusive UTM/MGRS grid band.
+ *
+ * @param lat - The latitude in degrees.
+ * @returns `true` when `-80 ≤ lat ≤ 84`.
+ *
+ * @remarks pure function
+ */
+declare const isWithinGridBand: (lat: number) => boolean;
+/**
+ * Reports whether a longitude sits on the eastern antimeridian singularity.
+ *
+ * At exactly `+180°` the UTM zone formula yields the nonexistent zone `61`,
+ * for which geodesy throws. `-180°` and values beyond `±180°` project
+ * normally, so only `+180°` is excluded here — the same point is reachable as
+ * `-180°`, or via a caller's own longitude normalization.
+ *
+ * @param lon - The longitude in degrees.
+ * @returns `true` when `lon` is exactly `180`.
+ *
+ * @remarks pure function
+ */
+declare const isOnEasternAntimeridian: (lon: number) => boolean;
+/**
+ * Reports whether a signed `[lat, lon]` coordinate can be projected to a UTM
+ * zone (and therefore to MGRS).
+ *
+ * A coordinate is projectable when it is finite and in range, its latitude is
+ * within the inclusive `80°S`–`84°N` grid band, and it does not sit on the
+ * `+180°` antimeridian singularity. This is the single validity gate shared by
+ * {@link toUtmParts} and {@link toMgrsParts}.
+ *
+ * @param coordinate - Signed `[latitude, longitude]` tuple.
+ * @returns `true` when the coordinate projects to a grid reference.
+ *
+ * @remarks pure function
+ */
+declare const isGridProjectable: ([lat, lon]: [number, number]) => boolean;
+/**
+ * Converts a signed `[lat, lon]` coordinate into UTM grid parts.
+ *
+ * Reads the geodesy `Utm` fields directly and rounds `easting`/`northing` to
+ * integer metres (matching the existing UTM string renderer). The UTM/MGRS
+ * grid is defined for `-80 ≤ lat ≤ 84` inclusive; latitudes outside that band,
+ * a longitude of exactly `+180°` (the antimeridian zone singularity), or
+ * non-finite input, produce `{ ok: false, reason: 'out-of-range' }`.
+ *
+ * @param coordinate - Signed `[latitude, longitude]` tuple.
+ * @returns A discriminated result with `{ zone, hemisphere, easting, northing }` on success.
+ *
+ * @remarks pure function
+ *
+ * @example
+ * ```typescript
+ * toUtmParts([38.8977, -77.0365]);
+ * // { ok: true, value: { zone: 18, hemisphere: 'N', easting: 323394, northing: 4307396 } }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * toUtmParts([85, 0]);
+ * // { ok: false, reason: 'out-of-range' }
+ * ```
+ */
+declare const toUtmParts: ([lat, lon]: [number, number]) => GridPartsResult<UtmParts>;
+/**
+ * Renders UTM grid parts as their canonical coordinate string.
+ *
+ * Left-pads the zone to two digits and joins zone+hemisphere, easting, and
+ * northing with single spaces, matching geodesy's `Utm.toString()` output.
+ * `easting`/`northing` are already the rounded integer metres `toUtmParts`
+ * yields, so no further rounding is applied here.
+ *
+ * @param parts - The UTM grid parts to render.
+ * @returns The canonical UTM string, e.g. `"18N 323394 4307396"`.
+ *
+ * @remarks pure function
+ *
+ * @example
+ * ```typescript
+ * formatUtmParts({ zone: 18, hemisphere: 'N', easting: 323394, northing: 4307396 });
+ * // '18N 323394 4307396'
+ * ```
+ */
+declare const formatUtmParts: ({
+  zone,
+  hemisphere,
+  easting,
+  northing
+}: UtmParts) => string;
+//#endregion
+export { GRID_LATITUDE_MAX, GRID_LATITUDE_MIN, GridPartsResult, UtmParts, formatUtmParts, isGridProjectable, isOnEasternAntimeridian, isWithinGridBand, toUtmParts };
+//# sourceMappingURL=parts.d.ts.map