@accelint/geo 0.4.0 → 0.4.1

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # @accelint/geo
 
+## 0.4.1
+### Patch Changes
+
+- 34c42a0: Swap bundling to tsdown and auto generate exports entries in package.json.
+
 ## 0.4.0
 ### Minor Changes
 

package/catalog-info.yaml

@@ -16,7 +16,7 @@ metadata:
   annotations:
     backstage.io/edit-url: https://github.com/gohypergiant/standard-toolkit/blob/main/packages/geo/catalog-info.yaml
     backstage.io/techdocs-ref: dir:.
-    package/version: 0.4.0
+    package/version: 0.4.1
     github.com/project-slug: gohypergiant/standard-toolkit
   links:
     - url: https://github.com/gohypergiant/standard-toolkit/tree/main/packages/geo

package/dist/cartesian.d.ts

@@ -1,3 +1,4 @@
+//#region src/cartesian.d.ts
 /**
  * Computes the Cartesian product of multiple arrays.
  *
@@ -17,5 +18,6 @@
  * // result: [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]
  */
 declare function cartesian<T>(...all: T[][]): T[][];
-
+//#endregion
 export { cartesian };
+//# sourceMappingURL=cartesian.d.ts.map

package/dist/cartesian.js

@@ -1,10 +1,39 @@
+/*
+ * 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.
+ */
+
+
+//#region src/cartesian.ts
+/**
+* Computes the Cartesian product of multiple arrays.
+*
+* @template T
+* the type of elements in the input arrays.
+* @param {...T[][]} all
+* a variadic number of arrays to compute the Cartesian product of.
+* @returns {T[][]}
+* An array containing all possible combinations of elements from the input
+* arrays, where each combination is represented as an array.
+*
+* @remarks
+* pure function
+*
+* @example
+* const result = cartesian([1, 2], ['a', 'b']);
+* // result: [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]
+*/
 function cartesian(...all) {
-  return all.reduce(
-    (results, entries) => results.map((result) => entries.map((entry) => result.concat([entry]))).reduce((sub, res) => sub.concat(res), []),
-    [[]]
-  );
+	return all.reduce((results, entries) => results.map((result) => entries.map((entry) => result.concat([entry]))).reduce((sub, res) => sub.concat(res), []), [[]]);
 }
 
+//#endregion
 export { cartesian };
-//# sourceMappingURL=cartesian.js.map
 //# sourceMappingURL=cartesian.js.map

package/dist/cartesian.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/cartesian.ts"],"names":[],"mappings":"AA+BO,SAAS,aAAgB,GAAA,EAAmB;AACjD,EAAA,OAAO,GAAA,CAAI,MAAA;AAAA,IACT,CAAC,OAAA,EAAS,OAAA,KACR,OAAA,CACG,GAAA,CAAI,CAAC,MAAA,KAAW,OAAA,CAAQ,GAAA,CAAI,CAAC,KAAA,KAAU,MAAA,CAAO,MAAA,CAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA,CAC9D,MAAA,CAAO,CAAC,GAAA,EAAK,GAAA,KAAQ,GAAA,CAAI,MAAA,CAAO,GAAG,CAAA,EAAG,EAAE,CAAA;AAAA,IAC7C,CAAC,EAAE;AAAA,GACL;AACF","file":"cartesian.js","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 * Computes the Cartesian product of multiple arrays.\n *\n * @template T\n * the type of elements in the input arrays.\n * @param {...T[][]} all\n * a variadic number of arrays to compute the Cartesian product of.\n * @returns {T[][]}\n * An array containing all possible combinations of elements from the input\n * arrays, where each combination is represented as an array.\n *\n * @remarks\n * pure function\n *\n * @example\n * const result = cartesian([1, 2], ['a', 'b']);\n * // result: [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]\n */\nexport function cartesian<T>(...all: T[][]): T[][] {\n  return all.reduce<T[][]>(\n    (results, entries) =>\n      results\n        .map((result) => entries.map((entry) => result.concat([entry])))\n        .reduce((sub, res) => sub.concat(res), []),\n    [[]],\n  );\n}\n"]}
+{"version":3,"file":"cartesian.js","names":[],"sources":["../src/cartesian.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 * Computes the Cartesian product of multiple arrays.\n *\n * @template T\n * the type of elements in the input arrays.\n * @param {...T[][]} all\n * a variadic number of arrays to compute the Cartesian product of.\n * @returns {T[][]}\n * An array containing all possible combinations of elements from the input\n * arrays, where each combination is represented as an array.\n *\n * @remarks\n * pure function\n *\n * @example\n * const result = cartesian([1, 2], ['a', 'b']);\n * // result: [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]\n */\nexport function cartesian<T>(...all: T[][]): T[][] {\n  return all.reduce<T[][]>(\n    (results, entries) =>\n      results\n        .map((result) => entries.map((entry) => result.concat([entry])))\n        .reduce((sub, res) => sub.concat(res), []),\n    [[]],\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,SAAgB,UAAa,GAAG,KAAmB;AACjD,QAAO,IAAI,QACR,SAAS,YACR,QACG,KAAK,WAAW,QAAQ,KAAK,UAAU,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAC/D,QAAQ,KAAK,QAAQ,IAAI,OAAO,IAAI,EAAE,EAAE,CAAC,EAC9C,CAAC,EAAE,CAAC,CACL"}

package/dist/coordinates/coordinate.d.ts

@@ -1,26 +1,37 @@
-import { Format } from './latlon/internal/index.js';
-import { CoordinateSystem } from './latlon/internal/coordinate-system.js';
-import './latlon/internal/parse.js';
-import './latlon/internal/lexer.js';
+/*
+ * 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 { Format } from "./latlon/internal/index.js";
+import { CoordinateSystem } from "./latlon/internal/coordinate-system.js";
+
+//#region src/coordinates/coordinate.d.ts
 type Coordinate = {
-    /** {@interitDoc Formatter} */
-    dd: Formatter;
-    /** {@interitDoc Formatter} */
-    ddm: Formatter;
-    /** {@interitDoc Formatter} */
-    dms: Formatter;
-    /** {@interitDoc Formatter} */
-    mgrs: Formatter;
-    /** {@interitDoc Formatter} */
-    utm: Formatter;
-    errors: string[];
-    raw: CoordinateInternalValue;
-    valid: boolean;
+  /** {@interitDoc Formatter} */
+  dd: Formatter;
+  /** {@interitDoc Formatter} */
+  ddm: Formatter;
+  /** {@interitDoc Formatter} */
+  dms: Formatter;
+  /** {@interitDoc Formatter} */
+  mgrs: Formatter;
+  /** {@interitDoc Formatter} */
+  utm: Formatter;
+  errors: string[];
+  raw: CoordinateInternalValue;
+  valid: boolean;
 };
 type CoordinateInternalValue = {
-    LAT: number;
-    LON: number;
+  LAT: number;
+  LON: number;
 };
 /**
  * Output a string value of a coordinate using an available system. The
@@ -48,11 +59,11 @@ type CoordinateInternalValue = {
  */
 type Formatter = (f?: Format) => string;
 declare const coordinateSystems: Readonly<{
-    readonly dd: CoordinateSystem;
-    readonly ddm: CoordinateSystem;
-    readonly dms: CoordinateSystem;
-    readonly mgrs: CoordinateSystem;
-    readonly utm: CoordinateSystem;
+  readonly dd: CoordinateSystem;
+  readonly ddm: CoordinateSystem;
+  readonly dms: CoordinateSystem;
+  readonly mgrs: CoordinateSystem;
+  readonly utm: CoordinateSystem;
 }>;
 /**
  * Create a coordinate object enabling: lexing, parsing, validation, and
@@ -70,5 +81,6 @@ declare const coordinateSystems: Readonly<{
  * const create = createCoordinate(coordinateSystems.ddm, 'LONLAT')
  */
 declare function createCoordinate(initSystem?: CoordinateSystem, initFormat?: Format): (input: string) => Readonly<Coordinate>;
-
+//#endregion
 export { coordinateSystems, createCoordinate };
+//# sourceMappingURL=coordinate.d.ts.map

package/dist/coordinates/coordinate.js

@@ -1,87 +1,81 @@
-import { systemDecimalDegrees } from './latlon/decimal-degrees/system.js';
-import { systemDegreesDecimalMinutes } from './latlon/degrees-decimal-minutes/system.js';
-import { systemDegreesMinutesSeconds } from './latlon/degrees-minutes-seconds/system.js';
-import { FORMATS_DEFAULT, SYMBOLS } from './latlon/internal/index.js';
-import { createCache } from './latlon/internal/create-cache.js';
-import { systemMGRS } from './mgrs/system.js';
-import { systemUTM } from './utm/system.js';
+/*
+ * 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 { FORMATS_DEFAULT, SYMBOLS } from "./latlon/internal/index.js";
+import { systemDecimalDegrees } from "./latlon/decimal-degrees/system.js";
+import { systemDegreesDecimalMinutes } from "./latlon/degrees-decimal-minutes/system.js";
+import { systemDegreesMinutesSeconds } from "./latlon/degrees-minutes-seconds/system.js";
+import { createCache } from "./latlon/internal/create-cache.js";
+import { systemMGRS } from "./mgrs/system.js";
+import { systemUTM } from "./utm/system.js";
+
+//#region src/coordinates/coordinate.ts
 const coordinateSystems = Object.freeze({
-  dd: systemDecimalDegrees,
-  ddm: systemDegreesDecimalMinutes,
-  dms: systemDegreesMinutesSeconds,
-  mgrs: systemMGRS,
-  utm: systemUTM
+	dd: systemDecimalDegrees,
+	ddm: systemDegreesDecimalMinutes,
+	dms: systemDegreesMinutesSeconds,
+	mgrs: systemMGRS,
+	utm: systemUTM
 });
 const freezeCoordinate = (errors, to, raw, valid) => Object.freeze({
-  dd: (format) => to(systemDecimalDegrees, format),
-  ddm: (format) => to(systemDegreesDecimalMinutes, format),
-  dms: (format) => to(systemDegreesMinutesSeconds, format),
-  mgrs: (format) => to(systemMGRS, format),
-  utm: (format) => to(systemUTM, format),
-  errors,
-  raw,
-  valid
+	dd: (format) => to(systemDecimalDegrees, format),
+	ddm: (format) => to(systemDegreesDecimalMinutes, format),
+	dms: (format) => to(systemDegreesMinutesSeconds, format),
+	mgrs: (format) => to(systemMGRS, format),
+	utm: (format) => to(systemUTM, format),
+	errors,
+	raw,
+	valid
 });
+/**
+* Create a coordinate object enabling: lexing, parsing, validation, and
+* formatting in alternative systems and formats. The system and format will be
+* used for validation and eventually for output as defaults if no alternatives
+* are provided.
+*
+* @param initSystem dd, ddm, dms, mgrs, or utm of coordinateSystems
+*
+* @remarks
+* pure function
+*
+* @example
+* const create = createCoordinate(coordinateSystems.dd, 'LATLON')
+* const create = createCoordinate(coordinateSystems.ddm, 'LONLAT')
+*/
 function createCoordinate(initSystem = coordinateSystems.dd, initFormat = FORMATS_DEFAULT) {
-  return (input) => {
-    let tokens;
-    let errors;
-    try {
-      [tokens, errors] = initSystem.parse(initFormat, input);
-      if (errors.length) {
-        throw errors;
-      }
-    } catch (errors2) {
-      return freezeCoordinate(
-        errors2,
-        () => "",
-        {},
-        false
-      );
-    }
-    const cachedValues = {
-      [initSystem.name]: createCache(
-        initFormat,
-        // because mgrs doesn't have two formats: LATLON v LONLAT
-        initSystem.name === systemMGRS.name ? input : tokens.join(" ")
-      )
-    };
-    const raw = Object.fromEntries([
-      [
-        initFormat.slice(0, 3),
-        initSystem.toFloat(
-          tokens.slice(0, tokens.indexOf(SYMBOLS.DIVIDER))
-        )
-      ],
-      [
-        initFormat.slice(3),
-        initSystem.toFloat(
-          tokens.slice(1 + tokens.indexOf(SYMBOLS.DIVIDER))
-        )
-      ]
-    ]);
-    function to(system = initSystem, format = initFormat) {
-      const key = system.name;
-      if (!cachedValues[key]?.[format]) {
-        cachedValues[key] = {
-          ...cachedValues[key],
-          // use the Format to build the object, correctly pairing the halves of
-          // the coordinate value with their labels
-          [format]: system.toFormat(
-            format,
-            [format.slice(0, 3), format.slice(3)].map(
-              (key2) => raw[key2]
-            )
-          )
-        };
-      }
-      return cachedValues[key][format];
-    }
-    return freezeCoordinate([], to, raw, true);
-  };
+	return (input) => {
+		let tokens;
+		let errors;
+		try {
+			[tokens, errors] = initSystem.parse(initFormat, input);
+			if (errors.length) throw errors;
+		} catch (errors$1) {
+			return freezeCoordinate(errors$1, () => "", {}, false);
+		}
+		const cachedValues = { [initSystem.name]: createCache(initFormat, initSystem.name === systemMGRS.name ? input : tokens.join(" ")) };
+		const raw = Object.fromEntries([[initFormat.slice(0, 3), initSystem.toFloat(tokens.slice(0, tokens.indexOf(SYMBOLS.DIVIDER)))], [initFormat.slice(3), initSystem.toFloat(tokens.slice(1 + tokens.indexOf(SYMBOLS.DIVIDER)))]]);
+		function to(system = initSystem, format = initFormat) {
+			const key = system.name;
+			if (!cachedValues[key]?.[format]) cachedValues[key] = {
+				...cachedValues[key],
+				[format]: system.toFormat(format, [format.slice(0, 3), format.slice(3)].map((key$1) => raw[key$1]))
+			};
+			return cachedValues[key][format];
+		}
+		return freezeCoordinate([], to, raw, true);
+	};
 }
 
+//#endregion
 export { coordinateSystems, createCoordinate };
-//# sourceMappingURL=coordinate.js.map
 //# sourceMappingURL=coordinate.js.map

package/dist/coordinates/coordinate.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/coordinates/coordinate.ts"],"names":["errors","key"],"mappings":"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","file":"coordinate.js","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 { systemDecimalDegrees } from './latlon/decimal-degrees/system';\nimport { systemDegreesDecimalMinutes } from './latlon/degrees-decimal-minutes/system';\nimport { systemDegreesMinutesSeconds } from './latlon/degrees-minutes-seconds/system';\nimport {\n  type Axes,\n  type Errors,\n  FORMATS_DEFAULT,\n  type Format,\n  SYMBOLS,\n} from './latlon/internal';\nimport {\n  type CoordinateCache,\n  createCache,\n} from './latlon/internal/create-cache';\nimport { systemMGRS } from './mgrs/system';\nimport { systemUTM } from './utm/system';\nimport type { CoordinateSystem } from './latlon/internal/coordinate-system';\nimport type { Tokens } from './latlon/internal/lexer';\n\ntype Coordinate = {\n  /** {@interitDoc Formatter} */\n  dd: Formatter;\n  /** {@interitDoc Formatter} */\n  ddm: Formatter;\n  /** {@interitDoc Formatter} */\n  dms: Formatter;\n  /** {@interitDoc Formatter} */\n  mgrs: Formatter;\n  /** {@interitDoc Formatter} */\n  utm: Formatter;\n  errors: string[];\n  raw: CoordinateInternalValue;\n  valid: boolean;\n};\n\n// biome-ignore lint/style/useNamingConvention: consistency with Axes type\ntype CoordinateInternalValue = { LAT: number; LON: number };\n\n/**\n * Output a string value of a coordinate using an available system. The\n * original value is preserved without conversion to an internal\n * representation - Decimal Degrees - to prevent the possibility of\n * rounding errors. All alternative values are computed from a common\n * internal value to reduce complexity.\n *\n * @link https://en.wikipedia.org/wiki/Coordinate_system\n *\n * @remarks\n * pure function\n *\n * @example\n * const create = createCoordinate(coordinateSystems.dd, 'LATLON')\n * const coord = create('89.765432109 / 123.456789012')\n *\n * // honors the instantiation format 'LATLON'\n * coord.dd() === '89.765432109 N / 123.456789012 E'\n * coord.ddm() === '89 45.92592654 N / 123 27.40734072 E'\n * coord.dms() === '89 45 55.5555924 N / 123 27 24.4404432 E'\n *\n * // change format to 'LONLAT'\n * coord.dms('LONLAT') === '123 27 24.4404432 E / 89 45 55.5555924 N'\n */\ntype Formatter = (f?: Format) => string;\n\ntype ToFloatArg = Parameters<CoordinateSystem['toFloat']>[0];\n\ntype OutputCache = Record<keyof typeof coordinateSystems, CoordinateCache>;\n\nexport const coordinateSystems = Object.freeze({\n  dd: systemDecimalDegrees,\n  ddm: systemDegreesDecimalMinutes,\n  dms: systemDegreesMinutesSeconds,\n  mgrs: systemMGRS,\n  utm: systemUTM,\n} as const);\n\nconst freezeCoordinate = (\n  errors: Coordinate['errors'],\n  to: (s?: CoordinateSystem, f?: Format) => string,\n  raw: CoordinateInternalValue,\n  valid: Coordinate['valid'],\n) =>\n  Object.freeze({\n    dd: (format?: Format) => to(systemDecimalDegrees, format),\n    ddm: (format?: Format) => to(systemDegreesDecimalMinutes, format),\n    dms: (format?: Format) => to(systemDegreesMinutesSeconds, format),\n    mgrs: (format?: Format) => to(systemMGRS, format),\n    utm: (format?: Format) => to(systemUTM, format),\n    errors,\n    raw,\n    valid,\n  } as Coordinate);\n\n/**\n * Create a coordinate object enabling: lexing, parsing, validation, and\n * formatting in alternative systems and formats. The system and format will be\n * used for validation and eventually for output as defaults if no alternatives\n * are provided.\n *\n * @param initSystem dd, ddm, dms, mgrs, or utm of coordinateSystems\n *\n * @remarks\n * pure function\n *\n * @example\n * const create = createCoordinate(coordinateSystems.dd, 'LATLON')\n * const create = createCoordinate(coordinateSystems.ddm, 'LONLAT')\n */\nexport function createCoordinate(\n  initSystem: CoordinateSystem = coordinateSystems.dd,\n  initFormat: Format = FORMATS_DEFAULT,\n) {\n  return (input: string) => {\n    let tokens: Tokens;\n    let errors: Errors;\n\n    try {\n      [tokens, errors] = initSystem.parse(initFormat, input);\n\n      if (errors.length) {\n        throw errors;\n      }\n    } catch (errors) {\n      return freezeCoordinate(\n        errors as Coordinate['errors'],\n        () => '',\n        {} as CoordinateInternalValue,\n        false,\n      );\n    }\n\n    // start with the original value for the original system in the original format\n    // other values will be computed as needed and cached per request\n    const cachedValues = {\n      [initSystem.name]: createCache(\n        initFormat,\n        // because mgrs doesn't have two formats: LATLON v LONLAT\n        initSystem.name === systemMGRS.name ? input : tokens.join(' '),\n      ),\n    } as OutputCache;\n\n    // Create the \"internal\" representation - Decimal Degrees - for\n    // consistency and ease of computation; all systems expect to\n    // start from a common starting point to reduce complexity.\n    const raw = Object.fromEntries([\n      [\n        initFormat.slice(0, 3),\n        initSystem.toFloat(\n          tokens.slice(0, tokens.indexOf(SYMBOLS.DIVIDER)) as ToFloatArg,\n        ),\n      ],\n      [\n        initFormat.slice(3),\n        initSystem.toFloat(\n          tokens.slice(1 + tokens.indexOf(SYMBOLS.DIVIDER)) as ToFloatArg,\n        ),\n      ],\n    ]) as CoordinateInternalValue;\n\n    function to(\n      system: CoordinateSystem = initSystem,\n      format: Format = initFormat,\n    ) {\n      const key = system.name as keyof typeof coordinateSystems;\n\n      if (!cachedValues[key]?.[format]) {\n        // cache \"miss\" - fill the missing value in the cache before returning it\n\n        // update the cache to include the newly computed value\n        cachedValues[key] = {\n          ...cachedValues[key],\n          // use the Format to build the object, correctly pairing the halves of\n          // the coordinate value with their labels\n          [format]: system.toFormat(\n            format,\n            ([format.slice(0, 3), format.slice(3)] as Axes[]).map(\n              (key) => raw[key],\n            ) as [number, number],\n          ),\n        };\n      }\n\n      return cachedValues[key][format];\n    }\n\n    return freezeCoordinate([] as Coordinate['errors'], to, raw, true);\n  };\n}\n"]}
+{"version":3,"file":"coordinate.js","names":["tokens: Tokens","errors: Errors","errors","key"],"sources":["../../src/coordinates/coordinate.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 { systemDecimalDegrees } from './latlon/decimal-degrees/system';\nimport { systemDegreesDecimalMinutes } from './latlon/degrees-decimal-minutes/system';\nimport { systemDegreesMinutesSeconds } from './latlon/degrees-minutes-seconds/system';\nimport {\n  type Axes,\n  type Errors,\n  FORMATS_DEFAULT,\n  type Format,\n  SYMBOLS,\n} from './latlon/internal';\nimport {\n  type CoordinateCache,\n  createCache,\n} from './latlon/internal/create-cache';\nimport { systemMGRS } from './mgrs/system';\nimport { systemUTM } from './utm/system';\nimport type { CoordinateSystem } from './latlon/internal/coordinate-system';\nimport type { Tokens } from './latlon/internal/lexer';\n\ntype Coordinate = {\n  /** {@interitDoc Formatter} */\n  dd: Formatter;\n  /** {@interitDoc Formatter} */\n  ddm: Formatter;\n  /** {@interitDoc Formatter} */\n  dms: Formatter;\n  /** {@interitDoc Formatter} */\n  mgrs: Formatter;\n  /** {@interitDoc Formatter} */\n  utm: Formatter;\n  errors: string[];\n  raw: CoordinateInternalValue;\n  valid: boolean;\n};\n\n// biome-ignore lint/style/useNamingConvention: consistency with Axes type\ntype CoordinateInternalValue = { LAT: number; LON: number };\n\n/**\n * Output a string value of a coordinate using an available system. The\n * original value is preserved without conversion to an internal\n * representation - Decimal Degrees - to prevent the possibility of\n * rounding errors. All alternative values are computed from a common\n * internal value to reduce complexity.\n *\n * @link https://en.wikipedia.org/wiki/Coordinate_system\n *\n * @remarks\n * pure function\n *\n * @example\n * const create = createCoordinate(coordinateSystems.dd, 'LATLON')\n * const coord = create('89.765432109 / 123.456789012')\n *\n * // honors the instantiation format 'LATLON'\n * coord.dd() === '89.765432109 N / 123.456789012 E'\n * coord.ddm() === '89 45.92592654 N / 123 27.40734072 E'\n * coord.dms() === '89 45 55.5555924 N / 123 27 24.4404432 E'\n *\n * // change format to 'LONLAT'\n * coord.dms('LONLAT') === '123 27 24.4404432 E / 89 45 55.5555924 N'\n */\ntype Formatter = (f?: Format) => string;\n\ntype ToFloatArg = Parameters<CoordinateSystem['toFloat']>[0];\n\ntype OutputCache = Record<keyof typeof coordinateSystems, CoordinateCache>;\n\nexport const coordinateSystems = Object.freeze({\n  dd: systemDecimalDegrees,\n  ddm: systemDegreesDecimalMinutes,\n  dms: systemDegreesMinutesSeconds,\n  mgrs: systemMGRS,\n  utm: systemUTM,\n} as const);\n\nconst freezeCoordinate = (\n  errors: Coordinate['errors'],\n  to: (s?: CoordinateSystem, f?: Format) => string,\n  raw: CoordinateInternalValue,\n  valid: Coordinate['valid'],\n) =>\n  Object.freeze({\n    dd: (format?: Format) => to(systemDecimalDegrees, format),\n    ddm: (format?: Format) => to(systemDegreesDecimalMinutes, format),\n    dms: (format?: Format) => to(systemDegreesMinutesSeconds, format),\n    mgrs: (format?: Format) => to(systemMGRS, format),\n    utm: (format?: Format) => to(systemUTM, format),\n    errors,\n    raw,\n    valid,\n  } as Coordinate);\n\n/**\n * Create a coordinate object enabling: lexing, parsing, validation, and\n * formatting in alternative systems and formats. The system and format will be\n * used for validation and eventually for output as defaults if no alternatives\n * are provided.\n *\n * @param initSystem dd, ddm, dms, mgrs, or utm of coordinateSystems\n *\n * @remarks\n * pure function\n *\n * @example\n * const create = createCoordinate(coordinateSystems.dd, 'LATLON')\n * const create = createCoordinate(coordinateSystems.ddm, 'LONLAT')\n */\nexport function createCoordinate(\n  initSystem: CoordinateSystem = coordinateSystems.dd,\n  initFormat: Format = FORMATS_DEFAULT,\n) {\n  return (input: string) => {\n    let tokens: Tokens;\n    let errors: Errors;\n\n    try {\n      [tokens, errors] = initSystem.parse(initFormat, input);\n\n      if (errors.length) {\n        throw errors;\n      }\n    } catch (errors) {\n      return freezeCoordinate(\n        errors as Coordinate['errors'],\n        () => '',\n        {} as CoordinateInternalValue,\n        false,\n      );\n    }\n\n    // start with the original value for the original system in the original format\n    // other values will be computed as needed and cached per request\n    const cachedValues = {\n      [initSystem.name]: createCache(\n        initFormat,\n        // because mgrs doesn't have two formats: LATLON v LONLAT\n        initSystem.name === systemMGRS.name ? input : tokens.join(' '),\n      ),\n    } as OutputCache;\n\n    // Create the \"internal\" representation - Decimal Degrees - for\n    // consistency and ease of computation; all systems expect to\n    // start from a common starting point to reduce complexity.\n    const raw = Object.fromEntries([\n      [\n        initFormat.slice(0, 3),\n        initSystem.toFloat(\n          tokens.slice(0, tokens.indexOf(SYMBOLS.DIVIDER)) as ToFloatArg,\n        ),\n      ],\n      [\n        initFormat.slice(3),\n        initSystem.toFloat(\n          tokens.slice(1 + tokens.indexOf(SYMBOLS.DIVIDER)) as ToFloatArg,\n        ),\n      ],\n    ]) as CoordinateInternalValue;\n\n    function to(\n      system: CoordinateSystem = initSystem,\n      format: Format = initFormat,\n    ) {\n      const key = system.name as keyof typeof coordinateSystems;\n\n      if (!cachedValues[key]?.[format]) {\n        // cache \"miss\" - fill the missing value in the cache before returning it\n\n        // update the cache to include the newly computed value\n        cachedValues[key] = {\n          ...cachedValues[key],\n          // use the Format to build the object, correctly pairing the halves of\n          // the coordinate value with their labels\n          [format]: system.toFormat(\n            format,\n            ([format.slice(0, 3), format.slice(3)] as Axes[]).map(\n              (key) => raw[key],\n            ) as [number, number],\n          ),\n        };\n      }\n\n      return cachedValues[key][format];\n    }\n\n    return freezeCoordinate([] as Coordinate['errors'], to, raw, true);\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAgFA,MAAa,oBAAoB,OAAO,OAAO;CAC7C,IAAI;CACJ,KAAK;CACL,KAAK;CACL,MAAM;CACN,KAAK;CACN,CAAU;AAEX,MAAM,oBACJ,QACA,IACA,KACA,UAEA,OAAO,OAAO;CACZ,KAAK,WAAoB,GAAG,sBAAsB,OAAO;CACzD,MAAM,WAAoB,GAAG,6BAA6B,OAAO;CACjE,MAAM,WAAoB,GAAG,6BAA6B,OAAO;CACjE,OAAO,WAAoB,GAAG,YAAY,OAAO;CACjD,MAAM,WAAoB,GAAG,WAAW,OAAO;CAC/C;CACA;CACA;CACD,CAAe;;;;;;;;;;;;;;;;AAiBlB,SAAgB,iBACd,aAA+B,kBAAkB,IACjD,aAAqB,iBACrB;AACA,SAAQ,UAAkB;EACxB,IAAIA;EACJ,IAAIC;AAEJ,MAAI;AACF,IAAC,QAAQ,UAAU,WAAW,MAAM,YAAY,MAAM;AAEtD,OAAI,OAAO,OACT,OAAM;WAEDC,UAAQ;AACf,UAAO,iBACLA,gBACM,IACN,EAAE,EACF,MACD;;EAKH,MAAM,eAAe,GAClB,WAAW,OAAO,YACjB,YAEA,WAAW,SAAS,WAAW,OAAO,QAAQ,OAAO,KAAK,IAAI,CAC/D,EACF;EAKD,MAAM,MAAM,OAAO,YAAY,CAC7B,CACE,WAAW,MAAM,GAAG,EAAE,EACtB,WAAW,QACT,OAAO,MAAM,GAAG,OAAO,QAAQ,QAAQ,QAAQ,CAAC,CACjD,CACF,EACD,CACE,WAAW,MAAM,EAAE,EACnB,WAAW,QACT,OAAO,MAAM,IAAI,OAAO,QAAQ,QAAQ,QAAQ,CAAC,CAClD,CACF,CACF,CAAC;EAEF,SAAS,GACP,SAA2B,YAC3B,SAAiB,YACjB;GACA,MAAM,MAAM,OAAO;AAEnB,OAAI,CAAC,aAAa,OAAO,QAIvB,cAAa,OAAO;IAClB,GAAG,aAAa;KAGf,SAAS,OAAO,SACf,QACC,CAAC,OAAO,MAAM,GAAG,EAAE,EAAE,OAAO,MAAM,EAAE,CAAC,CAAY,KAC/C,UAAQ,IAAIC,OACd,CACF;IACF;AAGH,UAAO,aAAa,KAAK;;AAG3B,SAAO,iBAAiB,EAAE,EAA0B,IAAI,KAAK,KAAK"}

package/dist/coordinates/latlon/decimal-degrees/formatter.d.ts

@@ -1,5 +1,19 @@
-import { FormatOptions } from '../internal/format.js';
+/*
+ * 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.
+ */
 
-declare const formatDecimalDegrees: (coordinates: [number, number], config?: FormatOptions) => string;
+import { FormatOptions } from "../internal/format.js";
 
+//#region src/coordinates/latlon/decimal-degrees/formatter.d.ts
+declare const formatDecimalDegrees: (coordinates: [number, number], config?: FormatOptions) => string;
+//#endregion
 export { formatDecimalDegrees };
+//# sourceMappingURL=formatter.d.ts.map

package/dist/coordinates/latlon/decimal-degrees/formatter.js

@@ -1,10 +1,24 @@
-import { createFormatter } from '../internal/format.js';
+/*
+ * 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 { createFormatter } from "../internal/format.js";
+
+//#region src/coordinates/latlon/decimal-degrees/formatter.ts
 const toDecimalDegrees = (num) => {
-  return `${num.toFixed(6)}\xB0`;
+	return `${num.toFixed(6)}°`;
 };
 const formatDecimalDegrees = createFormatter(toDecimalDegrees);
 
+//#endregion
 export { formatDecimalDegrees };
-//# sourceMappingURL=formatter.js.map
 //# sourceMappingURL=formatter.js.map

package/dist/coordinates/latlon/decimal-degrees/formatter.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/coordinates/latlon/decimal-degrees/formatter.ts"],"names":[],"mappings":";;AAcA,MAAM,gBAAA,GAAmB,CAAC,GAAA,KAAwB;AAChD,EAAA,OAAO,CAAA,EAAG,GAAA,CAAI,OAAA,CAAQ,CAAC,CAAC,CAAA,IAAA,CAAA;AAC1B,CAAA;AAEO,MAAM,oBAAA,GAAuB,gBAAgB,gBAAgB","file":"formatter.js","sourcesContent":["/*\n * Copyright 2025 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 { createFormatter } from '../internal/format';\n\nconst toDecimalDegrees = (num: number): string => {\n  return `${num.toFixed(6)}°`;\n};\n\nexport const formatDecimalDegrees = createFormatter(toDecimalDegrees);\n"]}
+{"version":3,"file":"formatter.js","names":[],"sources":["../../../../src/coordinates/latlon/decimal-degrees/formatter.ts"],"sourcesContent":["/*\n * Copyright 2025 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 { createFormatter } from '../internal/format';\n\nconst toDecimalDegrees = (num: number): string => {\n  return `${num.toFixed(6)}°`;\n};\n\nexport const formatDecimalDegrees = createFormatter(toDecimalDegrees);\n"],"mappings":";;;;;;;;;;;;;;;;AAcA,MAAM,oBAAoB,QAAwB;AAChD,QAAO,GAAG,IAAI,QAAQ,EAAE,CAAC;;AAG3B,MAAa,uBAAuB,gBAAgB,iBAAiB"}

package/dist/coordinates/latlon/decimal-degrees/parser.d.ts

@@ -1,8 +1,21 @@
-import { Format } from '../internal/index.js';
-import { ParseResults } from '../internal/parse.js';
-import '../internal/lexer.js';
+/*
+ * 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 { Format } from "../internal/index.js";
+import { ParseResults } from "../internal/parse.js";
+
+//#region src/coordinates/latlon/decimal-degrees/parser.d.ts
 /** Parse a Decimal Degrees coordinate. */
 declare const parseDecimalDegrees: (format: Format, input: string) => ParseResults;
-
+//#endregion
 export { parseDecimalDegrees };
+//# sourceMappingURL=parser.d.ts.map

package/dist/coordinates/latlon/decimal-degrees/parser.js

@@ -1,76 +1,74 @@
-import * as Patterning from './../../../patterning.js';
-import { PARTIAL_PATTERNS, SYMBOLS, SYMBOL_PATTERNS, BEARINGS, LIMITS } from '../internal/index.js';
-import { createParser } from '../internal/parse-format.js';
+/*
+ * 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 { fromTemplate } from "../../../patterning.js";
+import { BEARINGS, LIMITS, PARTIAL_PATTERNS, SYMBOLS, SYMBOL_PATTERNS } from "../internal/index.js";
+import { createParser } from "../internal/parse-format.js";
+
+//#region src/coordinates/latlon/decimal-degrees/parser.ts
 const checks = {
-  deg: (deg, limit) => {
-    if (Number.parseFloat(deg) > limit) {
-      return `Degrees value (${deg}) exceeds max value (${limit}).`;
-    }
-  },
-  min: (val) => {
-    if (val.includes(SYMBOLS.MINUTES)) {
-      return `Seconds indicator (${SYMBOLS.MINUTES}) not valid in Decimal Degrees.`;
-    }
-  },
-  sec: (val) => {
-    if (val.includes(SYMBOLS.SECONDS)) {
-      return `Seconds indicator (${SYMBOLS.SECONDS}) not valid in Decimal Degrees.`;
-    }
-  }
+	deg: (deg, limit) => {
+		if (Number.parseFloat(deg) > limit) return `Degrees value (${deg}) exceeds max value (${limit}).`;
+	},
+	min: (val) => {
+		if (val.includes(SYMBOLS.MINUTES)) return `Seconds indicator (${SYMBOLS.MINUTES}) not valid in Decimal Degrees.`;
+	},
+	sec: (val) => {
+		if (val.includes(SYMBOLS.SECONDS)) return `Seconds indicator (${SYMBOLS.SECONDS}) not valid in Decimal Degrees.`;
+	}
 };
 const formats = {
-  LATLON: Patterning.fromTemplate(
-    PARTIAL_PATTERNS,
-    `degLatDec NS ${SYMBOLS.DIVIDER} degLonDec EW`
-  ),
-  LONLAT: Patterning.fromTemplate(
-    PARTIAL_PATTERNS,
-    `degLonDec EW ${SYMBOLS.DIVIDER} degLatDec NS`
-  )
+	LATLON: fromTemplate(PARTIAL_PATTERNS, `degLatDec NS ${SYMBOLS.DIVIDER} degLonDec EW`),
+	LONLAT: fromTemplate(PARTIAL_PATTERNS, `degLonDec EW ${SYMBOLS.DIVIDER} degLatDec NS`)
 };
 function identifyErrors(format) {
-  return (arg, i) => {
-    if (!arg) {
-      return [[], ["Invalid coordinate value."]];
-    }
-    let { bear, deg } = arg;
-    deg ??= "0";
-    let isNegative = SYMBOL_PATTERNS.NEGATIVE_SIGN.test(deg) ? 1 : 0;
-    const bearingOptions = BEARINGS[format][i];
-    if (!bear || isNegative) {
-      bear = bearingOptions[isNegative];
-      deg = Math.abs(Number.parseFloat(deg)).toString();
-      isNegative = 0;
-    }
-    const errors = [
-      ...[checks.deg(deg, LIMITS[format][i] ?? 0)],
-      ...[checks.min([bear, deg].join(""))],
-      ...[checks.sec([bear, deg].join(""))]
-    ].filter(Boolean);
-    return errors.length ? [[], errors] : [[deg, bear], []];
-  };
+	return (arg, i) => {
+		if (!arg) return [[], ["Invalid coordinate value."]];
+		let { bear, deg } = arg;
+		deg ??= "0";
+		let isNegative = SYMBOL_PATTERNS.NEGATIVE_SIGN.test(deg) ? 1 : 0;
+		const bearingOptions = BEARINGS[format][i];
+		if (!bear || isNegative) {
+			bear = bearingOptions[isNegative];
+			deg = Math.abs(Number.parseFloat(deg)).toString();
+			isNegative = 0;
+		}
+		const errors = [
+			...[checks.deg(deg, LIMITS[format][i] ?? 0)],
+			...[checks.min([bear, deg].join(""))],
+			...[checks.sec([bear, deg].join(""))]
+		].filter(Boolean);
+		return errors.length ? [[], errors] : [[deg, bear], []];
+	};
 }
 function identifyPieces(half) {
-  if (half.length > 2 || half.length < 1) {
-    return;
-  }
-  const places = { bear: "", deg: "" };
-  return half.reduce((acc, token) => {
-    if (SYMBOL_PATTERNS.NSEW.test(token) && !acc.bear) {
-      acc.bear ||= token;
-    } else {
-      acc.deg ||= token;
-    }
-    return acc;
-  }, places);
+	if (half.length > 2 || half.length < 1) return;
+	return half.reduce((acc, token) => {
+		if (SYMBOL_PATTERNS.NSEW.test(token) && !acc.bear) acc.bear ||= token;
+		else acc.deg ||= token;
+		return acc;
+	}, {
+		bear: "",
+		deg: ""
+	});
 }
+/** Parse a Decimal Degrees coordinate. */
 const parseDecimalDegrees = createParser({
-  formats,
-  identifyErrors,
-  identifyPieces
+	formats,
+	identifyErrors,
+	identifyPieces
 });
 
+//#endregion
 export { parseDecimalDegrees };
-//# sourceMappingURL=parser.js.map
 //# sourceMappingURL=parser.js.map

package/dist/coordinates/latlon/decimal-degrees/parser.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/coordinates/latlon/decimal-degrees/parser.ts"],"names":[],"mappings":"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","file":"parser.js","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 * as Patterning from '@/patterning';\nimport {\n  BEARINGS,\n  type Format,\n  LIMITS,\n  PARTIAL_PATTERNS,\n  SYMBOL_PATTERNS,\n  SYMBOLS,\n} from '../internal';\nimport { createParser } from '../internal/parse-format';\nimport type { ParseResults } from '../internal/parse';\n\ntype DecimalDegrees = {\n  bear: string;\n  deg: string;\n};\n\nconst checks = {\n  deg: (deg: string, limit: number) => {\n    if (Number.parseFloat(deg) > limit) {\n      return `Degrees value (${deg}) exceeds max value (${limit}).`;\n    }\n  },\n  min: (val: string) => {\n    if (val.includes(SYMBOLS.MINUTES)) {\n      return `Seconds indicator (${SYMBOLS.MINUTES}) not valid in Decimal Degrees.`;\n    }\n  },\n  sec: (val: string) => {\n    if (val.includes(SYMBOLS.SECONDS)) {\n      return `Seconds indicator (${SYMBOLS.SECONDS}) not valid in Decimal Degrees.`;\n    }\n  },\n};\n\nconst formats = {\n  LATLON: Patterning.fromTemplate(\n    PARTIAL_PATTERNS,\n    `degLatDec NS ${SYMBOLS.DIVIDER} degLonDec EW`,\n  ),\n  LONLAT: Patterning.fromTemplate(\n    PARTIAL_PATTERNS,\n    `degLonDec EW ${SYMBOLS.DIVIDER} degLatDec NS`,\n  ),\n};\n\nfunction identifyErrors(format: Format) {\n  return (arg: DecimalDegrees | undefined, i: number) => {\n    if (!arg) {\n      return [[], ['Invalid coordinate value.']] as ParseResults;\n    }\n\n    let { bear, deg } = arg;\n\n    deg ??= '0';\n\n    let isNegative: 0 | 1 = SYMBOL_PATTERNS.NEGATIVE_SIGN.test(deg) ? 1 : 0;\n    const bearingOptions = BEARINGS[format][i] as [string, string];\n\n    if (!bear || isNegative) {\n      bear = bearingOptions[isNegative];\n      deg = Math.abs(Number.parseFloat(deg)).toString();\n      isNegative = 0;\n    }\n\n    const errors = [\n      ...[checks.deg(deg, LIMITS[format][i] ?? 0)],\n      ...[checks.min([bear, deg].join(''))],\n      ...[checks.sec([bear, deg].join(''))],\n    ].filter(Boolean);\n\n    return (errors.length ? [[], errors] : [[deg, bear], []]) as ParseResults;\n  };\n}\n\nfunction identifyPieces(half: string[]) {\n  if (half.length > 2 || half.length < 1) {\n    return;\n  }\n\n  const places = { bear: '', deg: '' };\n\n  return half.reduce((acc, token) => {\n    if (SYMBOL_PATTERNS.NSEW.test(token) && !acc.bear) {\n      acc.bear ||= token;\n    } else {\n      acc.deg ||= token;\n    }\n\n    return acc;\n  }, places);\n}\n\n/** Parse a Decimal Degrees coordinate. */\nexport const parseDecimalDegrees = createParser<DecimalDegrees>({\n  formats,\n  identifyErrors,\n  identifyPieces,\n});\n"]}
+{"version":3,"file":"parser.js","names":["Patterning.fromTemplate","isNegative: 0 | 1"],"sources":["../../../../src/coordinates/latlon/decimal-degrees/parser.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 * as Patterning from '@/patterning';\nimport {\n  BEARINGS,\n  type Format,\n  LIMITS,\n  PARTIAL_PATTERNS,\n  SYMBOL_PATTERNS,\n  SYMBOLS,\n} from '../internal';\nimport { createParser } from '../internal/parse-format';\nimport type { ParseResults } from '../internal/parse';\n\ntype DecimalDegrees = {\n  bear: string;\n  deg: string;\n};\n\nconst checks = {\n  deg: (deg: string, limit: number) => {\n    if (Number.parseFloat(deg) > limit) {\n      return `Degrees value (${deg}) exceeds max value (${limit}).`;\n    }\n  },\n  min: (val: string) => {\n    if (val.includes(SYMBOLS.MINUTES)) {\n      return `Seconds indicator (${SYMBOLS.MINUTES}) not valid in Decimal Degrees.`;\n    }\n  },\n  sec: (val: string) => {\n    if (val.includes(SYMBOLS.SECONDS)) {\n      return `Seconds indicator (${SYMBOLS.SECONDS}) not valid in Decimal Degrees.`;\n    }\n  },\n};\n\nconst formats = {\n  LATLON: Patterning.fromTemplate(\n    PARTIAL_PATTERNS,\n    `degLatDec NS ${SYMBOLS.DIVIDER} degLonDec EW`,\n  ),\n  LONLAT: Patterning.fromTemplate(\n    PARTIAL_PATTERNS,\n    `degLonDec EW ${SYMBOLS.DIVIDER} degLatDec NS`,\n  ),\n};\n\nfunction identifyErrors(format: Format) {\n  return (arg: DecimalDegrees | undefined, i: number) => {\n    if (!arg) {\n      return [[], ['Invalid coordinate value.']] as ParseResults;\n    }\n\n    let { bear, deg } = arg;\n\n    deg ??= '0';\n\n    let isNegative: 0 | 1 = SYMBOL_PATTERNS.NEGATIVE_SIGN.test(deg) ? 1 : 0;\n    const bearingOptions = BEARINGS[format][i] as [string, string];\n\n    if (!bear || isNegative) {\n      bear = bearingOptions[isNegative];\n      deg = Math.abs(Number.parseFloat(deg)).toString();\n      isNegative = 0;\n    }\n\n    const errors = [\n      ...[checks.deg(deg, LIMITS[format][i] ?? 0)],\n      ...[checks.min([bear, deg].join(''))],\n      ...[checks.sec([bear, deg].join(''))],\n    ].filter(Boolean);\n\n    return (errors.length ? [[], errors] : [[deg, bear], []]) as ParseResults;\n  };\n}\n\nfunction identifyPieces(half: string[]) {\n  if (half.length > 2 || half.length < 1) {\n    return;\n  }\n\n  const places = { bear: '', deg: '' };\n\n  return half.reduce((acc, token) => {\n    if (SYMBOL_PATTERNS.NSEW.test(token) && !acc.bear) {\n      acc.bear ||= token;\n    } else {\n      acc.deg ||= token;\n    }\n\n    return acc;\n  }, places);\n}\n\n/** Parse a Decimal Degrees coordinate. */\nexport const parseDecimalDegrees = createParser<DecimalDegrees>({\n  formats,\n  identifyErrors,\n  identifyPieces,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;AA6BA,MAAM,SAAS;CACb,MAAM,KAAa,UAAkB;AACnC,MAAI,OAAO,WAAW,IAAI,GAAG,MAC3B,QAAO,kBAAkB,IAAI,uBAAuB,MAAM;;CAG9D,MAAM,QAAgB;AACpB,MAAI,IAAI,SAAS,QAAQ,QAAQ,CAC/B,QAAO,sBAAsB,QAAQ,QAAQ;;CAGjD,MAAM,QAAgB;AACpB,MAAI,IAAI,SAAS,QAAQ,QAAQ,CAC/B,QAAO,sBAAsB,QAAQ,QAAQ;;CAGlD;AAED,MAAM,UAAU;CACd,QAAQA,aACN,kBACA,gBAAgB,QAAQ,QAAQ,eACjC;CACD,QAAQA,aACN,kBACA,gBAAgB,QAAQ,QAAQ,eACjC;CACF;AAED,SAAS,eAAe,QAAgB;AACtC,SAAQ,KAAiC,MAAc;AACrD,MAAI,CAAC,IACH,QAAO,CAAC,EAAE,EAAE,CAAC,4BAA4B,CAAC;EAG5C,IAAI,EAAE,MAAM,QAAQ;AAEpB,UAAQ;EAER,IAAIC,aAAoB,gBAAgB,cAAc,KAAK,IAAI,GAAG,IAAI;EACtE,MAAM,iBAAiB,SAAS,QAAQ;AAExC,MAAI,CAAC,QAAQ,YAAY;AACvB,UAAO,eAAe;AACtB,SAAM,KAAK,IAAI,OAAO,WAAW,IAAI,CAAC,CAAC,UAAU;AACjD,gBAAa;;EAGf,MAAM,SAAS;GACb,GAAG,CAAC,OAAO,IAAI,KAAK,OAAO,QAAQ,MAAM,EAAE,CAAC;GAC5C,GAAG,CAAC,OAAO,IAAI,CAAC,MAAM,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC;GACrC,GAAG,CAAC,OAAO,IAAI,CAAC,MAAM,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC;GACtC,CAAC,OAAO,QAAQ;AAEjB,SAAQ,OAAO,SAAS,CAAC,EAAE,EAAE,OAAO,GAAG,CAAC,CAAC,KAAK,KAAK,EAAE,EAAE,CAAC;;;AAI5D,SAAS,eAAe,MAAgB;AACtC,KAAI,KAAK,SAAS,KAAK,KAAK,SAAS,EACnC;AAKF,QAAO,KAAK,QAAQ,KAAK,UAAU;AACjC,MAAI,gBAAgB,KAAK,KAAK,MAAM,IAAI,CAAC,IAAI,KAC3C,KAAI,SAAS;MAEb,KAAI,QAAQ;AAGd,SAAO;IATM;EAAE,MAAM;EAAI,KAAK;EAAI,CAU1B;;;AAIZ,MAAa,sBAAsB,aAA6B;CAC9D;CACA;CACA;CACD,CAAC"}