@accelint/geo 0.5.1 → 0.6.0

package/dist/coordinates/latlon/internal/pipes/genome.js

@@ -19,6 +19,16 @@ const GENOME_PATTERN = /^(B?)([DN]?[MN]?[SN]?)(B?)(?:B?)([DN]?[MN]?[SN]?)(?:B?)$
 * Get the position (index) of where to insert a divider into the token list;
 * basically, the count of numeric components (left-of-divider position) plus
 * 1 if there is a bearing identifier (left-of-divider).
+*
+* @param _full - Full regex match string (unused).
+* @param args - Regex capture groups: [bearing1, number1, bearing2, number2].
+* @returns String representation of the divider index position.
+*
+* @example
+* ```typescript
+* dividerIndexer('BDNBDNB', 'B', 'DN', 'B', 'DN');
+* // '3' (bearing + 2 numeric components)
+* ```
 */
 function dividerIndexer(_full, ...args) {
 	const [bearing1 = "", number1, bearing2 = "", number2] = args;
@@ -34,6 +44,22 @@ function dividerIndexer(_full, ...args) {
 *   - S = seconds (number with seconds character following)
 *   - N = number (no identifying character following)
 *   - X = for unmatched token types
+*
+* @param acc - Accumulated genome sequence string.
+* @param t - Current token to classify.
+* @returns Updated genome sequence with new character appended.
+*
+* @example
+* ```typescript
+* genomeSequencer('', '45°');
+* // 'D'
+* ```
+*
+* @example
+* ```typescript
+* genomeSequencer('D', 'N');
+* // 'DB'
+* ```
 */
 function genomeSequencer(acc, t) {
 	if (t.includes(SYMBOLS.DEGREES)) return `${acc}D`;
@@ -46,6 +72,21 @@ function genomeSequencer(acc, t) {
 /**
 * Use the "genome" sequence of the token list to find the index for inserting
 * a missing divider token.
+*
+* @param tokens - Array of coordinate tokens to analyze.
+* @returns Index position where divider should be inserted, or 0 if pattern doesn't match.
+*
+* @example
+* ```typescript
+* getGenomeIndex(['45°', '30'', 'N', '122°', '15'', 'W']);
+* // 3 (insert divider after latitude components)
+* ```
+*
+* @example
+* ```typescript
+* getGenomeIndex(['45', '30', '15']);
+* // 0 (pattern doesn't match genome sequence)
+* ```
 */
 function getGenomeIndex(tokens) {
 	const seq = tokens.reduce(genomeSequencer, "");

package/dist/coordinates/latlon/internal/pipes/genome.js.map

@@ -1 +1 @@
-{"version":3,"file":"genome.js","names":[],"sources":["../../../../../src/coordinates/latlon/internal/pipes/genome.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 { SYMBOL_PATTERNS, SYMBOLS } from '..';\nimport type { Tokens } from '../lexer';\n\nconst GENOME_PATTERN =\n  /^(B?)([DN]?[MN]?[SN]?)(B?)(?:B?)([DN]?[MN]?[SN]?)(?:B?)$/;\n\n/**\n * Get the position (index) of where to insert a divider into the token list;\n * basically, the count of numeric components (left-of-divider position) plus\n * 1 if there is a bearing identifier (left-of-divider).\n */\nfunction dividerIndexer(_full: string, ...args: string[]) {\n  const [bearing1 = '', number1, bearing2 = '', number2] = args;\n\n  // if no numeric values exist there no way to infer a location to insert a divider\n  if (!(number1?.length && number2?.length)) {\n    return '0';\n  }\n\n  return `${number1.length + (bearing1.length || bearing2.length)}`;\n}\n\n/**\n * The genome sequence is a simplification of the tokens list:\n *\n *   - B = bearings (NSEW)\n *   - D = degrees (number with degree character following)\n *   - M = minutes (number with minutes character following)\n *   - S = seconds (number with seconds character following)\n *   - N = number (no identifying character following)\n *   - X = for unmatched token types\n */\nfunction genomeSequencer(acc: string, t: string) {\n  if (t.includes(SYMBOLS.DEGREES)) {\n    return `${acc}D`;\n  }\n\n  if (t.includes(SYMBOLS.MINUTES)) {\n    return `${acc}M`;\n  }\n\n  if (t.includes(SYMBOLS.SECONDS)) {\n    return `${acc}S`;\n  }\n\n  if (SYMBOL_PATTERNS.NSEW.test(t)) {\n    return `${acc}B`;\n  }\n\n  if (/\\d/.test(t)) {\n    return `${acc}N`;\n  }\n\n  return `${acc}X`;\n}\n\n/**\n * Use the \"genome\" sequence of the token list to find the index for inserting\n * a missing divider token.\n */\nexport function getGenomeIndex(tokens: Tokens) {\n  const seq = tokens.reduce(genomeSequencer, '');\n\n  return GENOME_PATTERN.test(seq)\n    ? Number.parseInt(seq.replace(GENOME_PATTERN, dividerIndexer), 10)\n    : 0;\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAgBA,MAAM,iBACJ;;;;;;AAOF,SAAS,eAAe,OAAe,GAAG,MAAgB;CACxD,MAAM,CAAC,WAAW,IAAI,SAAS,WAAW,IAAI,WAAW;AAGzD,KAAI,EAAE,SAAS,UAAU,SAAS,QAChC,QAAO;AAGT,QAAO,GAAG,QAAQ,UAAU,SAAS,UAAU,SAAS;;;;;;;;;;;;AAa1D,SAAS,gBAAgB,KAAa,GAAW;AAC/C,KAAI,EAAE,SAAS,QAAQ,QAAQ,CAC7B,QAAO,GAAG,IAAI;AAGhB,KAAI,EAAE,SAAS,QAAQ,QAAQ,CAC7B,QAAO,GAAG,IAAI;AAGhB,KAAI,EAAE,SAAS,QAAQ,QAAQ,CAC7B,QAAO,GAAG,IAAI;AAGhB,KAAI,gBAAgB,KAAK,KAAK,EAAE,CAC9B,QAAO,GAAG,IAAI;AAGhB,KAAI,KAAK,KAAK,EAAE,CACd,QAAO,GAAG,IAAI;AAGhB,QAAO,GAAG,IAAI;;;;;;AAOhB,SAAgB,eAAe,QAAgB;CAC7C,MAAM,MAAM,OAAO,OAAO,iBAAiB,GAAG;AAE9C,QAAO,eAAe,KAAK,IAAI,GAC3B,OAAO,SAAS,IAAI,QAAQ,gBAAgB,eAAe,EAAE,GAAG,GAChE"}
+{"version":3,"file":"genome.js","names":[],"sources":["../../../../../src/coordinates/latlon/internal/pipes/genome.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 { SYMBOL_PATTERNS, SYMBOLS } from '..';\nimport type { Tokens } from '../lexer';\n\nconst GENOME_PATTERN =\n  /^(B?)([DN]?[MN]?[SN]?)(B?)(?:B?)([DN]?[MN]?[SN]?)(?:B?)$/;\n\n/**\n * Get the position (index) of where to insert a divider into the token list;\n * basically, the count of numeric components (left-of-divider position) plus\n * 1 if there is a bearing identifier (left-of-divider).\n *\n * @param _full - Full regex match string (unused).\n * @param args - Regex capture groups: [bearing1, number1, bearing2, number2].\n * @returns String representation of the divider index position.\n *\n * @example\n * ```typescript\n * dividerIndexer('BDNBDNB', 'B', 'DN', 'B', 'DN');\n * // '3' (bearing + 2 numeric components)\n * ```\n */\nfunction dividerIndexer(_full: string, ...args: string[]) {\n  const [bearing1 = '', number1, bearing2 = '', number2] = args;\n\n  // if no numeric values exist there no way to infer a location to insert a divider\n  if (!(number1?.length && number2?.length)) {\n    return '0';\n  }\n\n  return `${number1.length + (bearing1.length || bearing2.length)}`;\n}\n\n/**\n * The genome sequence is a simplification of the tokens list:\n *\n *   - B = bearings (NSEW)\n *   - D = degrees (number with degree character following)\n *   - M = minutes (number with minutes character following)\n *   - S = seconds (number with seconds character following)\n *   - N = number (no identifying character following)\n *   - X = for unmatched token types\n *\n * @param acc - Accumulated genome sequence string.\n * @param t - Current token to classify.\n * @returns Updated genome sequence with new character appended.\n *\n * @example\n * ```typescript\n * genomeSequencer('', '45°');\n * // 'D'\n * ```\n *\n * @example\n * ```typescript\n * genomeSequencer('D', 'N');\n * // 'DB'\n * ```\n */\nfunction genomeSequencer(acc: string, t: string) {\n  if (t.includes(SYMBOLS.DEGREES)) {\n    return `${acc}D`;\n  }\n\n  if (t.includes(SYMBOLS.MINUTES)) {\n    return `${acc}M`;\n  }\n\n  if (t.includes(SYMBOLS.SECONDS)) {\n    return `${acc}S`;\n  }\n\n  if (SYMBOL_PATTERNS.NSEW.test(t)) {\n    return `${acc}B`;\n  }\n\n  if (/\\d/.test(t)) {\n    return `${acc}N`;\n  }\n\n  return `${acc}X`;\n}\n\n/**\n * Use the \"genome\" sequence of the token list to find the index for inserting\n * a missing divider token.\n *\n * @param tokens - Array of coordinate tokens to analyze.\n * @returns Index position where divider should be inserted, or 0 if pattern doesn't match.\n *\n * @example\n * ```typescript\n * getGenomeIndex(['45°', '30'', 'N', '122°', '15'', 'W']);\n * // 3 (insert divider after latitude components)\n * ```\n *\n * @example\n * ```typescript\n * getGenomeIndex(['45', '30', '15']);\n * // 0 (pattern doesn't match genome sequence)\n * ```\n */\nexport function getGenomeIndex(tokens: Tokens) {\n  const seq = tokens.reduce(genomeSequencer, '');\n\n  return GENOME_PATTERN.test(seq)\n    ? Number.parseInt(seq.replace(GENOME_PATTERN, dividerIndexer), 10)\n    : 0;\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAgBA,MAAM,iBACJ;;;;;;;;;;;;;;;;AAiBF,SAAS,eAAe,OAAe,GAAG,MAAgB;CACxD,MAAM,CAAC,WAAW,IAAI,SAAS,WAAW,IAAI,WAAW;AAGzD,KAAI,EAAE,SAAS,UAAU,SAAS,QAChC,QAAO;AAGT,QAAO,GAAG,QAAQ,UAAU,SAAS,UAAU,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6B1D,SAAS,gBAAgB,KAAa,GAAW;AAC/C,KAAI,EAAE,SAAS,QAAQ,QAAQ,CAC7B,QAAO,GAAG,IAAI;AAGhB,KAAI,EAAE,SAAS,QAAQ,QAAQ,CAC7B,QAAO,GAAG,IAAI;AAGhB,KAAI,EAAE,SAAS,QAAQ,QAAQ,CAC7B,QAAO,GAAG,IAAI;AAGhB,KAAI,gBAAgB,KAAK,KAAK,EAAE,CAC9B,QAAO,GAAG,IAAI;AAGhB,KAAI,KAAK,KAAK,EAAE,CACd,QAAO,GAAG,IAAI;AAGhB,QAAO,GAAG,IAAI;;;;;;;;;;;;;;;;;;;;;AAsBhB,SAAgB,eAAe,QAAgB;CAC7C,MAAM,MAAM,OAAO,OAAO,iBAAiB,GAAG;AAE9C,QAAO,eAAe,KAAK,IAAI,GAC3B,OAAO,SAAS,IAAI,QAAQ,gBAAgB,eAAe,EAAE,GAAG,GAChE"}

package/dist/coordinates/latlon/internal/pipes/index.d.ts

@@ -20,7 +20,21 @@ type PipeResult = ReturnType<Pipe>;
  * Consistently create a PipesResult array to return. Use this instead of
  * casting to PipesResult everywhere.
  *
- * @param e true = has error, false = no error
+ * @param t - Array of coordinate tokens.
+ * @param e - Error status: true = has error, false = no error, or error message string.
+ * @returns Pipe result tuple with tokens (empty if error) and error status.
+ *
+ * @example
+ * ```typescript
+ * pipesResult(['45', 'N', '/', '122', 'W'], false);
+ * // [['45', 'N', '/', '122', 'W'], false]
+ * ```
+ *
+ * @example
+ * ```typescript
+ * pipesResult(['45'], 'Too few numbers.');
+ * // [[], 'Too few numbers.']
+ * ```
  *
  * @remarks
  * pure function
@@ -30,7 +44,23 @@ declare const pipesResult: (t: Tokens, e: boolean | string) => PipeResult;
  * Run the tokens through a preset pipeline of violations checks exiting the
  * process as early as possible when violations are found because violations
  * will make further violations checks less accurate and could return inaccurate
- * violations that could be misleading or hide the most important violation
+ * violations that could be misleading or hide the most important violation.
+ *
+ * @param tokens - Array of parsed coordinate tokens to validate and normalize.
+ * @param format - Optional coordinate format (LATLON or LONLAT) for inference.
+ * @returns Tuple of [processed tokens, array of error messages].
+ *
+ * @example
+ * ```typescript
+ * pipesRunner(['45', 'N', '/', '122', 'W'], 'LATLON');
+ * // [['45', 'N', '/', '122', 'W'], []]
+ * ```
+ *
+ * @example
+ * ```typescript
+ * pipesRunner(['45'], 'LATLON');
+ * // [[], ['Too few numbers.']]
+ * ```
  */
 declare function pipesRunner(tokens: Tokens, format?: Format): [Tokens, string[]];
 //#endregion

package/dist/coordinates/latlon/internal/pipes/index.js

@@ -18,19 +18,56 @@ import { fixBearings } from "./fix-bearings.js";
 import { fixDivider } from "./fix-dividers.js";
 
 //#region src/coordinates/latlon/internal/pipes/index.ts
-/** Make a RegExp global. */
+/**
+* Make a RegExp global.
+*
+* @param k - Key of the SYMBOL_PATTERNS object.
+* @returns New global RegExp based on the pattern.
+*
+* @example
+* ```typescript
+* makeGlobal('NSEW');
+* // /[NSEW]/g
+* ```
+*/
 const makeGlobal = (k) => new RegExp(SYMBOL_PATTERNS[k], "g");
 /**
 * Consistently create a PipesResult array to return. Use this instead of
 * casting to PipesResult everywhere.
 *
-* @param e true = has error, false = no error
+* @param t - Array of coordinate tokens.
+* @param e - Error status: true = has error, false = no error, or error message string.
+* @returns Pipe result tuple with tokens (empty if error) and error status.
+*
+* @example
+* ```typescript
+* pipesResult(['45', 'N', '/', '122', 'W'], false);
+* // [['45', 'N', '/', '122', 'W'], false]
+* ```
+*
+* @example
+* ```typescript
+* pipesResult(['45'], 'Too few numbers.');
+* // [[], 'Too few numbers.']
+* ```
 *
 * @remarks
 * pure function
 */
 const pipesResult = (t, e) => [e ? [] : t, e];
-/** Check if there are more than 2 of something. */
+/**
+* Check if there are more than 2 of something.
+*
+* @param p - Regular expression pattern to match.
+* @returns Function that takes tokens and returns pipe result with error if >2 matches found.
+*
+* @example
+* ```typescript
+* const checkBearings = tooMany(/[NSEW]/g);
+* checkBearings(['N', 'S', 'E', 'W']);
+* // Returns error=true (more than 2 bearings)
+* ```
+*/
 const tooMany = (p) => (t) => pipesResult(t, (t.join("").match(p) ?? []).length > 2);
 const pipes = [
 	["Too many bearings.", tooMany(makeGlobal("NSEW"))],
@@ -47,7 +84,23 @@ const pipes = [
 * Run the tokens through a preset pipeline of violations checks exiting the
 * process as early as possible when violations are found because violations
 * will make further violations checks less accurate and could return inaccurate
-* violations that could be misleading or hide the most important violation
+* violations that could be misleading or hide the most important violation.
+*
+* @param tokens - Array of parsed coordinate tokens to validate and normalize.
+* @param format - Optional coordinate format (LATLON or LONLAT) for inference.
+* @returns Tuple of [processed tokens, array of error messages].
+*
+* @example
+* ```typescript
+* pipesRunner(['45', 'N', '/', '122', 'W'], 'LATLON');
+* // [['45', 'N', '/', '122', 'W'], []]
+* ```
+*
+* @example
+* ```typescript
+* pipesRunner(['45'], 'LATLON');
+* // [[], ['Too few numbers.']]
+* ```
 */
 function pipesRunner(tokens, format) {
 	let copy = tokens.slice(0);

package/dist/coordinates/latlon/internal/pipes/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["pipes: [string, Pipe][]","error: PipeResult[1]"],"sources":["../../../../../src/coordinates/latlon/internal/pipes/index.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 Format, SYMBOL_PATTERNS } from '..';\nimport { checkAmbiguousGrouping } from './check-ambiguous';\nimport { checkNumberValues } from './check-numbers';\nimport { fixBearings } from './fix-bearings';\nimport { fixDivider } from './fix-dividers';\nimport type { Tokens } from '../lexer';\n\ntype Pipe = (t: Tokens, f?: Format) => [Tokens, boolean | string];\n\nexport type PipeResult = ReturnType<Pipe>;\n\n/** Make a RegExp global. */\nconst makeGlobal = (k: keyof typeof SYMBOL_PATTERNS) =>\n  new RegExp(SYMBOL_PATTERNS[k], 'g');\n\n/**\n * Consistently create a PipesResult array to return. Use this instead of\n * casting to PipesResult everywhere.\n *\n * @param e true = has error, false = no error\n *\n * @remarks\n * pure function\n */\nexport const pipesResult = (t: Tokens, e: boolean | string): PipeResult => [\n  // if there are errors do NOT return the tokens\n  e ? [] : t,\n  e,\n];\n\n/** Check if there are more than 2 of something. */\nconst tooMany = (p: RegExp) => (t: Tokens) =>\n  pipesResult(t, (t.join('').match(p) ?? []).length > 2);\n\nconst pipes: [string, Pipe][] = [\n  // Unrecoverable violations\n  ['Too many bearings.', tooMany(makeGlobal('NSEW'))],\n  ['Too many numeric signs.', tooMany(/[-+]/g)],\n  ['Too many degrees indicators.', tooMany(makeGlobal('DEGREES'))],\n  ['Too many minutes indicators.', tooMany(makeGlobal('MINUTES'))],\n  ['Too many seconds indicators.', tooMany(makeGlobal('SECONDS'))],\n  ['Number values checks.', checkNumberValues],\n  ['Ambiguous grouping of numbers with no divider.', checkAmbiguousGrouping],\n\n  // fix values and formatting to be consistent\n  ['Unable to identify latitude from longitude.', fixDivider],\n  ['Unable to identify bearings.', fixBearings],\n];\n\n/**\n * Run the tokens through a preset pipeline of violations checks exiting the\n * process as early as possible when violations are found because violations\n * will make further violations checks less accurate and could return inaccurate\n * violations that could be misleading or hide the most important violation\n */\nexport function pipesRunner(\n  tokens: Tokens,\n  format?: Format,\n): [Tokens, string[]] {\n  let copy = tokens.slice(0);\n  let error: PipeResult[1] = false;\n  const errors = [] as string[];\n\n  for (const [message, op] of pipes) {\n    [copy, error] = op(copy, format);\n\n    if (error) {\n      // accumulate the \"errors\" because if tokens are returned\n      // the errors are only warnings and are recoverable\n      errors.push(error === true ? message : error);\n\n      if (!copy.length) {\n        return [copy, [error === true ? message : error]];\n      }\n    }\n  }\n\n  return [copy, errors];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAyBA,MAAM,cAAc,MAClB,IAAI,OAAO,gBAAgB,IAAI,IAAI;;;;;;;;;;AAWrC,MAAa,eAAe,GAAW,MAAoC,CAEzE,IAAI,EAAE,GAAG,GACT,EACD;;AAGD,MAAM,WAAW,OAAe,MAC9B,YAAY,IAAI,EAAE,KAAK,GAAG,CAAC,MAAM,EAAE,IAAI,EAAE,EAAE,SAAS,EAAE;AAExD,MAAMA,QAA0B;CAE9B,CAAC,sBAAsB,QAAQ,WAAW,OAAO,CAAC,CAAC;CACnD,CAAC,2BAA2B,QAAQ,QAAQ,CAAC;CAC7C,CAAC,gCAAgC,QAAQ,WAAW,UAAU,CAAC,CAAC;CAChE,CAAC,gCAAgC,QAAQ,WAAW,UAAU,CAAC,CAAC;CAChE,CAAC,gCAAgC,QAAQ,WAAW,UAAU,CAAC,CAAC;CAChE,CAAC,yBAAyB,kBAAkB;CAC5C,CAAC,kDAAkD,uBAAuB;CAG1E,CAAC,+CAA+C,WAAW;CAC3D,CAAC,gCAAgC,YAAY;CAC9C;;;;;;;AAQD,SAAgB,YACd,QACA,QACoB;CACpB,IAAI,OAAO,OAAO,MAAM,EAAE;CAC1B,IAAIC,QAAuB;CAC3B,MAAM,SAAS,EAAE;AAEjB,MAAK,MAAM,CAAC,SAAS,OAAO,OAAO;AACjC,GAAC,MAAM,SAAS,GAAG,MAAM,OAAO;AAEhC,MAAI,OAAO;AAGT,UAAO,KAAK,UAAU,OAAO,UAAU,MAAM;AAE7C,OAAI,CAAC,KAAK,OACR,QAAO,CAAC,MAAM,CAAC,UAAU,OAAO,UAAU,MAAM,CAAC;;;AAKvD,QAAO,CAAC,MAAM,OAAO"}
+{"version":3,"file":"index.js","names":["pipes: [string, Pipe][]","error: PipeResult[1]"],"sources":["../../../../../src/coordinates/latlon/internal/pipes/index.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 Format, SYMBOL_PATTERNS } from '..';\nimport { checkAmbiguousGrouping } from './check-ambiguous';\nimport { checkNumberValues } from './check-numbers';\nimport { fixBearings } from './fix-bearings';\nimport { fixDivider } from './fix-dividers';\nimport type { Tokens } from '../lexer';\n\ntype Pipe = (t: Tokens, f?: Format) => [Tokens, boolean | string];\n\nexport type PipeResult = ReturnType<Pipe>;\n\n/**\n * Make a RegExp global.\n *\n * @param k - Key of the SYMBOL_PATTERNS object.\n * @returns New global RegExp based on the pattern.\n *\n * @example\n * ```typescript\n * makeGlobal('NSEW');\n * // /[NSEW]/g\n * ```\n */\nconst makeGlobal = (k: keyof typeof SYMBOL_PATTERNS) =>\n  new RegExp(SYMBOL_PATTERNS[k], 'g');\n\n/**\n * Consistently create a PipesResult array to return. Use this instead of\n * casting to PipesResult everywhere.\n *\n * @param t - Array of coordinate tokens.\n * @param e - Error status: true = has error, false = no error, or error message string.\n * @returns Pipe result tuple with tokens (empty if error) and error status.\n *\n * @example\n * ```typescript\n * pipesResult(['45', 'N', '/', '122', 'W'], false);\n * // [['45', 'N', '/', '122', 'W'], false]\n * ```\n *\n * @example\n * ```typescript\n * pipesResult(['45'], 'Too few numbers.');\n * // [[], 'Too few numbers.']\n * ```\n *\n * @remarks\n * pure function\n */\nexport const pipesResult = (t: Tokens, e: boolean | string): PipeResult => [\n  // if there are errors do NOT return the tokens\n  e ? [] : t,\n  e,\n];\n\n/**\n * Check if there are more than 2 of something.\n *\n * @param p - Regular expression pattern to match.\n * @returns Function that takes tokens and returns pipe result with error if >2 matches found.\n *\n * @example\n * ```typescript\n * const checkBearings = tooMany(/[NSEW]/g);\n * checkBearings(['N', 'S', 'E', 'W']);\n * // Returns error=true (more than 2 bearings)\n * ```\n */\nconst tooMany = (p: RegExp) => (t: Tokens) =>\n  pipesResult(t, (t.join('').match(p) ?? []).length > 2);\n\nconst pipes: [string, Pipe][] = [\n  // Unrecoverable violations\n  ['Too many bearings.', tooMany(makeGlobal('NSEW'))],\n  ['Too many numeric signs.', tooMany(/[-+]/g)],\n  ['Too many degrees indicators.', tooMany(makeGlobal('DEGREES'))],\n  ['Too many minutes indicators.', tooMany(makeGlobal('MINUTES'))],\n  ['Too many seconds indicators.', tooMany(makeGlobal('SECONDS'))],\n  ['Number values checks.', checkNumberValues],\n  ['Ambiguous grouping of numbers with no divider.', checkAmbiguousGrouping],\n\n  // fix values and formatting to be consistent\n  ['Unable to identify latitude from longitude.', fixDivider],\n  ['Unable to identify bearings.', fixBearings],\n];\n\n/**\n * Run the tokens through a preset pipeline of violations checks exiting the\n * process as early as possible when violations are found because violations\n * will make further violations checks less accurate and could return inaccurate\n * violations that could be misleading or hide the most important violation.\n *\n * @param tokens - Array of parsed coordinate tokens to validate and normalize.\n * @param format - Optional coordinate format (LATLON or LONLAT) for inference.\n * @returns Tuple of [processed tokens, array of error messages].\n *\n * @example\n * ```typescript\n * pipesRunner(['45', 'N', '/', '122', 'W'], 'LATLON');\n * // [['45', 'N', '/', '122', 'W'], []]\n * ```\n *\n * @example\n * ```typescript\n * pipesRunner(['45'], 'LATLON');\n * // [[], ['Too few numbers.']]\n * ```\n */\nexport function pipesRunner(\n  tokens: Tokens,\n  format?: Format,\n): [Tokens, string[]] {\n  let copy = tokens.slice(0);\n  let error: PipeResult[1] = false;\n  const errors = [] as string[];\n\n  for (const [message, op] of pipes) {\n    [copy, error] = op(copy, format);\n\n    if (error) {\n      // accumulate the \"errors\" because if tokens are returned\n      // the errors are only warnings and are recoverable\n      errors.push(error === true ? message : error);\n\n      if (!copy.length) {\n        return [copy, [error === true ? message : error]];\n      }\n    }\n  }\n\n  return [copy, errors];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCA,MAAM,cAAc,MAClB,IAAI,OAAO,gBAAgB,IAAI,IAAI;;;;;;;;;;;;;;;;;;;;;;;;AAyBrC,MAAa,eAAe,GAAW,MAAoC,CAEzE,IAAI,EAAE,GAAG,GACT,EACD;;;;;;;;;;;;;;AAeD,MAAM,WAAW,OAAe,MAC9B,YAAY,IAAI,EAAE,KAAK,GAAG,CAAC,MAAM,EAAE,IAAI,EAAE,EAAE,SAAS,EAAE;AAExD,MAAMA,QAA0B;CAE9B,CAAC,sBAAsB,QAAQ,WAAW,OAAO,CAAC,CAAC;CACnD,CAAC,2BAA2B,QAAQ,QAAQ,CAAC;CAC7C,CAAC,gCAAgC,QAAQ,WAAW,UAAU,CAAC,CAAC;CAChE,CAAC,gCAAgC,QAAQ,WAAW,UAAU,CAAC,CAAC;CAChE,CAAC,gCAAgC,QAAQ,WAAW,UAAU,CAAC,CAAC;CAChE,CAAC,yBAAyB,kBAAkB;CAC5C,CAAC,kDAAkD,uBAAuB;CAG1E,CAAC,+CAA+C,WAAW;CAC3D,CAAC,gCAAgC,YAAY;CAC9C;;;;;;;;;;;;;;;;;;;;;;;AAwBD,SAAgB,YACd,QACA,QACoB;CACpB,IAAI,OAAO,OAAO,MAAM,EAAE;CAC1B,IAAIC,QAAuB;CAC3B,MAAM,SAAS,EAAE;AAEjB,MAAK,MAAM,CAAC,SAAS,OAAO,OAAO;AACjC,GAAC,MAAM,SAAS,GAAG,MAAM,OAAO;AAEhC,MAAI,OAAO;AAGT,UAAO,KAAK,UAAU,OAAO,UAAU,MAAM;AAE7C,OAAI,CAAC,KAAK,OACR,QAAO,CAAC,MAAM,CAAC,UAAU,OAAO,UAAU,MAAM,CAAC;;;AAKvD,QAAO,CAAC,MAAM,OAAO"}

package/dist/coordinates/latlon/internal/pipes/simpler.d.ts

@@ -13,15 +13,28 @@
 import { Tokens } from "../lexer.js";
 
 //#region src/coordinates/latlon/internal/pipes/simpler.d.ts
+
 /**
  * Create a simplified pattern string - numbers = 'N', bearings = 'B' - to
  * allow for simpler pattern matching.
  *
- * @remarks
- * pure function
+ * @param tokens - Array of coordinate tokens to simplify.
+ * @returns Simplified pattern string where 'N' = number and 'B' = bearing.
+ *
+ * @example
+ * ```typescript
+ * simpler(['45', '30', 'N', '/', '122', '15', 'W']);
+ * // 'NNBNNNB'
+ * ```
  *
  * @example
- * simplify(tokens); // 'NNNBNNNB' or similar
+ * ```typescript
+ * simpler(['45', 'N']);
+ * // 'NB'
+ * ```
+ *
+ * @remarks
+ * pure function
  */
 declare const simpler: (tokens: Tokens) => string;
 //#endregion

package/dist/coordinates/latlon/internal/pipes/simpler.js

@@ -16,11 +16,23 @@
 * Create a simplified pattern string - numbers = 'N', bearings = 'B' - to
 * allow for simpler pattern matching.
 *
-* @remarks
-* pure function
+* @param tokens - Array of coordinate tokens to simplify.
+* @returns Simplified pattern string where 'N' = number and 'B' = bearing.
+*
+* @example
+* ```typescript
+* simpler(['45', '30', 'N', '/', '122', '15', 'W']);
+* // 'NNBNNNB'
+* ```
 *
 * @example
-* simplify(tokens); // 'NNNBNNNB' or similar
+* ```typescript
+* simpler(['45', 'N']);
+* // 'NB'
+* ```
+*
+* @remarks
+* pure function
 */
 const simpler = (tokens) => tokens.map((t) => /\d/.test(t) ? "N" : "B").join("");
 

package/dist/coordinates/latlon/internal/pipes/simpler.js.map

@@ -1 +1 @@
-{"version":3,"file":"simpler.js","names":[],"sources":["../../../../../src/coordinates/latlon/internal/pipes/simpler.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 { Tokens } from '../lexer';\n\n/**\n * Create a simplified pattern string - numbers = 'N', bearings = 'B' - to\n * allow for simpler pattern matching.\n *\n * @remarks\n * pure function\n *\n * @example\n * simplify(tokens); // 'NNNBNNNB' or similar\n */\nexport const simpler = (tokens: Tokens) =>\n  tokens.map((t) => (/\\d/.test(t) ? 'N' : 'B')).join('');\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAyBA,MAAa,WAAW,WACtB,OAAO,KAAK,MAAO,KAAK,KAAK,EAAE,GAAG,MAAM,IAAK,CAAC,KAAK,GAAG"}
+{"version":3,"file":"simpler.js","names":[],"sources":["../../../../../src/coordinates/latlon/internal/pipes/simpler.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 { Tokens } from '../lexer';\n\n/**\n * Create a simplified pattern string - numbers = 'N', bearings = 'B' - to\n * allow for simpler pattern matching.\n *\n * @param tokens - Array of coordinate tokens to simplify.\n * @returns Simplified pattern string where 'N' = number and 'B' = bearing.\n *\n * @example\n * ```typescript\n * simpler(['45', '30', 'N', '/', '122', '15', 'W']);\n * // 'NNBNNNB'\n * ```\n *\n * @example\n * ```typescript\n * simpler(['45', 'N']);\n * // 'NB'\n * ```\n *\n * @remarks\n * pure function\n */\nexport const simpler = (tokens: Tokens) =>\n  tokens.map((t) => (/\\d/.test(t) ? 'N' : 'B')).join('');\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,MAAa,WAAW,WACtB,OAAO,KAAK,MAAO,KAAK,KAAK,EAAE,GAAG,MAAM,IAAK,CAAC,KAAK,GAAG"}

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

@@ -0,0 +1,75 @@
+//#region src/coordinates/latlon/internal/validate.d.ts
+/**
+ * Checks if a value is a finite number (not NaN, not Infinity, not -Infinity).
+ *
+ * @param value - The numeric value to check
+ * @returns True if the value is a finite number, false otherwise
+ *
+ * @example
+ * ```typescript
+ * isFiniteNumber(42);        // true
+ * isFiniteNumber(NaN);       // false
+ * isFiniteNumber(Infinity);  // false
+ * ```
+ */
+declare function isFiniteNumber(value: number): boolean;
+/**
+ * Validates that a value is within a signed range (-limit to +limit).
+ *
+ * @param label - The label for error messages (used as-is for range errors,
+ *                lowercased for "Invalid" errors)
+ * @param value - The numeric value to validate
+ * @param limit - The absolute limit (validates -limit to +limit)
+ * @returns Error message string if validation fails, undefined if valid
+ *
+ * @example
+ * ```typescript
+ * validateSignedRange('Latitude', 45, 90);
+ * // => undefined
+ * ```
+ *
+ * @example
+ * ```typescript
+ * validateSignedRange('Latitude', 95, 90);
+ * // => '[ERROR] Latitude value (95) is outside valid range (-90 to 90).'
+ * ```
+ *
+ * @example
+ * ```typescript
+ * validateSignedRange('Longitude', NaN, 180);
+ * // => '[ERROR] Invalid longitude value (NaN); expected a finite number.'
+ * ```
+ */
+declare function validateSignedRange(label: string, value: number, limit: number): string | undefined;
+/**
+ * Validates numeric latitude and longitude coordinate values.
+ *
+ * @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 Array of error message strings, empty if all validations pass
+ *
+ * @example
+ * ```typescript
+ * validateNumericCoordinate(45.5, -122.6);
+ * // => []
+ * ```
+ *
+ * @example
+ * ```typescript
+ * validateNumericCoordinate(91, -122.6);
+ * // => ['[ERROR] Latitude value (91) is outside valid range (-90 to 90).']
+ * ```
+ *
+ * @example
+ * ```typescript
+ * validateNumericCoordinate(NaN, 200);
+ * // => [
+ * //   '[ERROR] Invalid latitude value (NaN); expected a finite number.',
+ * //   '[ERROR] Longitude value (200) is outside valid range (-180 to 180).'
+ * // ]
+ * ```
+ */
+declare function validateNumericCoordinate(lat: number, lon: number): string[];
+//#endregion
+export { isFiniteNumber, validateNumericCoordinate, validateSignedRange };
+//# sourceMappingURL=validate.d.ts.map

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

@@ -0,0 +1,105 @@
+/*
+ * Copyright 2025 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 { violation } from "./violation.js";
+
+//#region src/coordinates/latlon/internal/validate.ts
+const LAT_LIMIT = 90;
+const LON_LIMIT = 180;
+/**
+* Checks if a value is a finite number (not NaN, not Infinity, not -Infinity).
+*
+* @param value - The numeric value to check
+* @returns True if the value is a finite number, false otherwise
+*
+* @example
+* ```typescript
+* isFiniteNumber(42);        // true
+* isFiniteNumber(NaN);       // false
+* isFiniteNumber(Infinity);  // false
+* ```
+*/
+function isFiniteNumber(value) {
+	return typeof value === "number" && Number.isFinite(value);
+}
+/**
+* Validates that a value is within a signed range (-limit to +limit).
+*
+* @param label - The label for error messages (used as-is for range errors,
+*                lowercased for "Invalid" errors)
+* @param value - The numeric value to validate
+* @param limit - The absolute limit (validates -limit to +limit)
+* @returns Error message string if validation fails, undefined if valid
+*
+* @example
+* ```typescript
+* validateSignedRange('Latitude', 45, 90);
+* // => undefined
+* ```
+*
+* @example
+* ```typescript
+* validateSignedRange('Latitude', 95, 90);
+* // => '[ERROR] Latitude value (95) is outside valid range (-90 to 90).'
+* ```
+*
+* @example
+* ```typescript
+* validateSignedRange('Longitude', NaN, 180);
+* // => '[ERROR] Invalid longitude value (NaN); expected a finite number.'
+* ```
+*/
+function validateSignedRange(label, value, limit) {
+	if (!isFiniteNumber(value)) return violation(`Invalid ${label.toLowerCase()} value (${value}); expected a finite number.`);
+	if (value < -limit || value > limit) return violation(`${label} value (${value}) is outside valid range (-${limit} to ${limit}).`);
+}
+/**
+* Validates numeric latitude and longitude coordinate values.
+*
+* @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 Array of error message strings, empty if all validations pass
+*
+* @example
+* ```typescript
+* validateNumericCoordinate(45.5, -122.6);
+* // => []
+* ```
+*
+* @example
+* ```typescript
+* validateNumericCoordinate(91, -122.6);
+* // => ['[ERROR] Latitude value (91) is outside valid range (-90 to 90).']
+* ```
+*
+* @example
+* ```typescript
+* validateNumericCoordinate(NaN, 200);
+* // => [
+* //   '[ERROR] Invalid latitude value (NaN); expected a finite number.',
+* //   '[ERROR] Longitude value (200) is outside valid range (-180 to 180).'
+* // ]
+* ```
+*/
+function validateNumericCoordinate(lat, lon) {
+	const errors = [];
+	const latError = validateSignedRange("Latitude", lat, LAT_LIMIT);
+	if (latError) errors.push(latError);
+	const lonError = validateSignedRange("Longitude", lon, LON_LIMIT);
+	if (lonError) errors.push(lonError);
+	return errors;
+}
+
+//#endregion
+export { isFiniteNumber, validateNumericCoordinate, validateSignedRange };
+//# sourceMappingURL=validate.js.map

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

@@ -0,0 +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"}

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

@@ -1,4 +1,22 @@
 //#region src/coordinates/latlon/internal/violation.d.ts
+/**
+ * Formats an error message with a standard [ERROR] prefix.
+ *
+ * @param s - The error message string to format.
+ * @returns Formatted error string with [ERROR] prefix.
+ *
+ * @example
+ * ```typescript
+ * violation('Invalid coordinate value.');
+ * // '[ERROR] Invalid coordinate value.'
+ * ```
+ *
+ * @example
+ * ```typescript
+ * violation('Degrees value (91) exceeds max value (90).');
+ * // '[ERROR] Degrees value (91) exceeds max value (90).'
+ * ```
+ */
 declare const violation: (s: string) => string;
 //#endregion
 export { violation };

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

@@ -12,6 +12,24 @@
 
 
 //#region src/coordinates/latlon/internal/violation.ts
+/**
+* Formats an error message with a standard [ERROR] prefix.
+*
+* @param s - The error message string to format.
+* @returns Formatted error string with [ERROR] prefix.
+*
+* @example
+* ```typescript
+* violation('Invalid coordinate value.');
+* // '[ERROR] Invalid coordinate value.'
+* ```
+*
+* @example
+* ```typescript
+* violation('Degrees value (91) exceeds max value (90).');
+* // '[ERROR] Degrees value (91) exceeds max value (90).'
+* ```
+*/
 const violation = (s) => `[ERROR] ${s}`;
 
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"violation.js","names":[],"sources":["../../../../src/coordinates/latlon/internal/violation.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\nexport const violation = (s: string) => `[ERROR] ${s}`;\n"],"mappings":";;;;;;;;;;;;;;AAaA,MAAa,aAAa,MAAc,WAAW"}
+{"version":3,"file":"violation.js","names":[],"sources":["../../../../src/coordinates/latlon/internal/violation.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\n/**\n * Formats an error message with a standard [ERROR] prefix.\n *\n * @param s - The error message string to format.\n * @returns Formatted error string with [ERROR] prefix.\n *\n * @example\n * ```typescript\n * violation('Invalid coordinate value.');\n * // '[ERROR] Invalid coordinate value.'\n * ```\n *\n * @example\n * ```typescript\n * violation('Degrees value (91) exceeds max value (90).');\n * // '[ERROR] Degrees value (91) exceeds max value (90).'\n * ```\n */\nexport const violation = (s: string) => `[ERROR] ${s}`;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,MAAa,aAAa,MAAc,WAAW"}

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

@@ -13,6 +13,30 @@
 import { ParseResults } from "../latlon/internal/parse.js";
 
 //#region src/coordinates/mgrs/parser.d.ts
+
+/**
+ * Parses a Military Grid Reference System (MGRS) coordinate string into latitude/longitude values.
+ *
+ * Converts MGRS coordinates to UTM, then to latitude/longitude decimal degrees. Returns
+ * detailed error messages for invalid MGRS formats including zone numbers, band letters,
+ * square identification, and numerical locations.
+ *
+ * @param _format - Format parameter (unused, MGRS has fixed format).
+ * @param input - The MGRS coordinate string to parse (e.g., '31U BF 12345 67890').
+ * @returns Parse results with coordinate values or detailed error messages.
+ *
+ * @example
+ * ```typescript
+ * parseMGRS(null, '31U BF 12345 67890');
+ * // [[['48.123456', 'N'], ['11.234567', 'E']], []]
+ * ```
+ *
+ * @example
+ * ```typescript
+ * parseMGRS(null, 'invalid');
+ * // [[], ['Invalid UTM zone number found...']]
+ * ```
+ */
 declare function parseMGRS(_format: any, input: string): ParseResults;
 //#endregion
 export { parseMGRS };