geo-coordinates-parser 1.5.7 → 1.6.0

package/README.md

@@ -9,13 +9,14 @@ A Javascript function for reading a variety of coordinate formats and converting
 npm install geo-coordinates-parser
 ```
 
+# NOTE THAT USAGE CHANGED IN THE LAST VERSION TO BETTER SUPPOER ES6 AND COMMONJS
 ### Usage
 ```js
-const convert = require('geo-coordinates-parser');
+const { convert } = require('geo-coordinates-parser'); //CommonJS
 ```
 OR
 ```js
-import convert from 'geo-coordinates-parser' //ES6, if you're using a bundler
+import { convert } from 'geo-coordinates-parser' //ES6
 ```
 THEN
 ```js
@@ -71,13 +72,14 @@ Formats used for testing can be be accessed with:
 convert.formats
 ```
 
-**<span style="color:red">Please add coordinate formats that throw an error in the Github Issues.</span>**
+**Please add coordinate formats that throw an error in the Github Issues.**
 
-**<span style="color:red">Note that formats like 24.56S 26.48E are treated as degrees and minutes! And 24.0, 26.0 is treated as an error. If you don't want this behaviour you need to catch these cases with your own code before you use convert.</span>**
+**CAUTION!!!**
+**Coordinates like '24.56S 26.48E' are treated as degrees and minutes and '24, 26' or '24.0, 26.0' will throw an error. If you don't want this behaviour you need to catch these cases with your own code before you use convert.* *
 
 ### Want to use it in the browser?
 Add ```<script src="https://cdn.jsdelivr.net/npm/geo-coordinates-parser/bundle/geocoordsparser.js"></script>```
-to your html head and you'll have the ```convert``` function available globally. You won't have .formats, .closeEnough or .toCoordinateFormat though, only the coordinates conversion function.
+to your html head and you'll have the ```convert``` function available globally.
 
 ### Convert back to standard formats
 Sometimes we might want to convert back to more traditional formats for representing coordinates, such as DMS or DM. This can be useful for standardizing coordinates. The convert function has an enum to help.
@@ -90,4 +92,4 @@ converted.toCoordinateFormat(convert.to.DMS) /// '40° 26.771" N, 79° 56.932" W
 MIT Licence
 
 ### Acknowledgements
-Support for development was provided by the [Animal Demography Unit](http://adu.uct.ac.za) of the University of Cape Town, and the [Natural Science Collections Facility](http://nscf.co.za).
+Support for development was provided by the [Animal Demography Unit](http://adu.uct.ac.za) of the University of Cape Town, and the [Natural Science Collections Facility](http://nscf.co.za). CommonJS and ESM support was added following [https://www.sensedeep.com/blog/posts/2021/how-to-create-single-source-npm-module.html](https://www.sensedeep.com/blog/posts/2021/how-to-create-single-source-npm-module.html).

package/dist/cjs/converter.d.ts

@@ -0,0 +1,15 @@
+export default converter;
+/**
+ * Function for converting coordinates in a variety of formats to decimal coordinates
+ * @param {string} coordsString The coordinates string to convert
+ * @param {number} decimalPlaces The number of decimal places for converted coordinates; default is 5
+ * @returns {object} { verbatimCoordinates, decimalCoordinates, decimalLatitude, decimalLongitude }
+ */
+declare function converter(coordsString: string, decimalPlaces: number): object;
+declare namespace converter {
+    export { to };
+}
+declare const to: Readonly<{
+    DMS: "DMS";
+    DM: "DM";
+}>;

package/dist/cjs/converter.js

@@ -0,0 +1,363 @@
+"use strict";
+//function for converting coordinates from a string to decimal and verbatim
+//this is just a comment
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const regex_js_1 = require("./regex.js");
+const toCoordinateFormat_js_1 = __importDefault(require("./toCoordinateFormat.js"));
+/**
+ * Function for converting coordinates in a variety of formats to decimal coordinates
+ * @param {string} coordsString The coordinates string to convert
+ * @param {number} decimalPlaces The number of decimal places for converted coordinates; default is 5
+ * @returns {object} { verbatimCoordinates, decimalCoordinates, decimalLatitude, decimalLongitude }
+ */
+function converter(coordsString, decimalPlaces) {
+    //TODO add exact match to entered string, so that it can be used to filter out superflous text around it
+    if (!decimalPlaces) {
+        decimalPlaces = 5;
+    }
+    coordsString = coordsString.replace(/\s+/g, ' ').trim(); //just to tidy up whitespaces
+    let ddLat = null;
+    let ddLng = null;
+    let latdir = "";
+    let lngdir = "";
+    let match = [];
+    let matchSuccess = false;
+    if (regex_js_1.dd_re.test(coordsString)) {
+        match = regex_js_1.dd_re.exec(coordsString);
+        matchSuccess = checkMatch(match);
+        if (matchSuccess) {
+            ddLat = match[2];
+            ddLng = match[6];
+            //need to fix if there are ','s instead of '.'
+            if (ddLat.includes(',')) {
+                ddLat = ddLat.replace(',', '.');
+            }
+            if (ddLng.includes(',')) {
+                ddLng = ddLng.replace(',', '.');
+            }
+            //validation, we don't want things like 23.00000
+            //some more validation: no zero coords or degrees only
+            if (Number(Math.round(ddLat)) == Number(ddLat)) {
+                throw new Error('integer only coordinate provided');
+            }
+            if (Number(Math.round(ddLng)) == Number(ddLng)) {
+                throw new Error('integer only coordinate provided');
+            }
+            //get directions
+            if (match[1]) {
+                latdir = match[1];
+                lngdir = match[5];
+            }
+            else if (match[4]) {
+                latdir = match[4];
+                lngdir = match[8];
+            }
+        }
+        else {
+            throw new Error("invalid decimal coordinate format");
+        }
+    }
+    else if (regex_js_1.dms_periods.test(coordsString)) {
+        match = regex_js_1.dms_periods.exec(coordsString);
+        matchSuccess = checkMatch(match);
+        if (matchSuccess) {
+            ddLat = Math.abs(parseInt(match[2]));
+            if (match[4]) {
+                ddLat += match[4] / 60;
+            }
+            if (match[6]) {
+                ddLat += match[6].replace(',', '.') / 3600;
+            }
+            if (parseInt(match[2]) < 0) {
+                ddLat = -1 * ddLat;
+            }
+            ddLng = Math.abs(parseInt(match[9]));
+            if (match[11]) {
+                ddLng += match[11] / 60;
+            }
+            if (match[13]) {
+                ddLng += match[13].replace(',', '.') / 3600;
+            }
+            if (parseInt(match[9]) < 0) {
+                ddLng = -1 * ddLng;
+            }
+            //the compass directions
+            if (match[1]) {
+                latdir = match[1];
+                lngdir = match[8];
+            }
+            else if (match[7]) {
+                latdir = match[7];
+                lngdir = match[14];
+            }
+        }
+        else {
+            throw new Error("invalid DMS coordinates format");
+        }
+    }
+    else if (regex_js_1.dms_abbr.test(coordsString)) {
+        match = regex_js_1.dms_abbr.exec(coordsString);
+        matchSuccess = checkMatch(match);
+        if (matchSuccess) {
+            ddLat = Math.abs(parseInt(match[2]));
+            if (match[4]) {
+                ddLat += match[4] / 60;
+            }
+            if (match[6]) {
+                ddLat += match[6] / 3600;
+            }
+            if (parseInt(match[2]) < 0) {
+                ddLat = -1 * ddLat;
+            }
+            ddLng = Math.abs(parseInt(match[10]));
+            if (match[12]) {
+                ddLng += match[12] / 60;
+            }
+            if (match[14]) {
+                ddLng += match[14] / 3600;
+            }
+            if (parseInt(match[10]) < 0) {
+                ddLng = -1 * ddLng;
+            }
+            if (match[1]) {
+                latdir = match[1];
+                lngdir = match[9];
+            }
+            else if (match[8]) {
+                latdir = match[8];
+                lngdir = match[16];
+            }
+        }
+        else {
+            throw new Error("invalid DMS coordinates format");
+        }
+    }
+    else if (regex_js_1.coords_other.test(coordsString)) {
+        match = regex_js_1.coords_other.exec(coordsString);
+        matchSuccess = checkMatch(match);
+        if (matchSuccess) {
+            ddLat = Math.abs(parseInt(match[2]));
+            if (match[4]) {
+                ddLat += match[4] / 60;
+            }
+            if (match[6]) {
+                ddLat += match[6] / 3600;
+            }
+            if (parseInt(match[2]) < 0) {
+                ddLat = -1 * ddLat;
+            }
+            ddLng = Math.abs(parseInt(match[10]));
+            if (match[12]) {
+                ddLng += match[12] / 60;
+            }
+            if (match[14]) {
+                ddLng += match[14] / 3600;
+            }
+            if (parseInt(match[10]) < 0) {
+                ddLng = -1 * ddLng;
+            }
+            if (match[1]) {
+                latdir = match[1];
+                lngdir = match[9];
+            }
+            else if (match[8]) {
+                latdir = match[8];
+                lngdir = match[16];
+            }
+        }
+        else {
+            throw new Error("invalid coordinates format");
+        }
+    }
+    if (matchSuccess) {
+        //more validation....
+        //check longitude value - it can be wrong!
+        if (Math.abs(ddLng) >= 180) {
+            throw new Error("invalid longitude value");
+        }
+        //just to be safe check latitude also...
+        if (Math.abs(ddLat) >= 90) {
+            throw new Error("invalid latitude value");
+        }
+        //if we have one direction we must have the other
+        if ((latdir || lngdir) && (!latdir || !lngdir)) {
+            throw new Error("invalid coordinates format");
+        }
+        //the directions can't be the same
+        if (latdir && latdir == lngdir) {
+            throw new Error("invalid coordinates format");
+        }
+        //make sure the signs and cardinal directions match
+        let patt = /S|SOUTH/i;
+        if (patt.test(latdir)) {
+            if (ddLat > 0) {
+                ddLat = -1 * ddLat;
+            }
+        }
+        patt = /W|WEST/i;
+        if (patt.test(lngdir)) {
+            if (ddLng > 0) {
+                ddLng = -1 * ddLng;
+            }
+        }
+        //we need to get the verbatim coords from the string
+        //we can't split down the middle because if there are decimals they may have different numbers on each side
+        //so we need to find the separating character, or if none, use the match values to split down the middle
+        const verbatimCoordinates = match[0].trim();
+        let verbatimLat;
+        let verbatimLng;
+        const sepChars = /[,/;\u0020]/g; //comma, forward slash and spacebar
+        const seps = verbatimCoordinates.match(sepChars);
+        if (seps == null) {
+            //split down the middle
+            const middle = Math.floor(coordsString.length / 2);
+            verbatimLat = verbatimCoordinates.substring(0, middle).trim();
+            verbatimLng = verbatimCoordinates.substring(middle).trim();
+        }
+        else { //if length is odd then find the index of the middle value
+            //get the middle index
+            let middle;
+            //easy for odd numbers
+            if (seps.length % 2 == 1) {
+                middle = Math.floor(seps.length / 2);
+            }
+            else {
+                middle = (seps.length / 2) - 1;
+            }
+            //walk through seps until we get to the middle
+            let splitIndex = 0;
+            //it might be only one value
+            if (middle == 0) {
+                splitIndex = verbatimCoordinates.indexOf(seps[0]);
+                verbatimLat = verbatimCoordinates.substring(0, splitIndex).trim();
+                verbatimLng = verbatimCoordinates.substring(splitIndex + 1).trim();
+            }
+            else {
+                let currSepIndex = 0;
+                let startSearchIndex = 0;
+                while (currSepIndex <= middle) {
+                    splitIndex = verbatimCoordinates.indexOf(seps[currSepIndex], startSearchIndex);
+                    startSearchIndex = splitIndex + 1;
+                    currSepIndex++;
+                }
+                verbatimLat = verbatimCoordinates.substring(0, splitIndex).trim();
+                verbatimLng = verbatimCoordinates.substring(splitIndex + 1).trim();
+            }
+        }
+        //validation again...
+        //we only allow zeros after the period if its DM
+        const splitLat = verbatimLat.split('.');
+        if (splitLat.length == 2) {
+            if (splitLat[1] == 0 && splitLat[1].length != 2) {
+                throw new Error('invalid coordinates format');
+            }
+        }
+        const splitLon = verbatimLng.split('.');
+        if (splitLon.length == 2) {
+            if (splitLon[1] == 0 && splitLon[1].length != 2) {
+                throw new Error('invalid coordinates format');
+            }
+        }
+        //no integer coords allowed
+        //validation -- no integer coords
+        if (/^\d+$/.test(verbatimLat) || /^\d+$/.test(verbatimLng)) {
+            throw new Error('degree only coordinate/s provided');
+        }
+        //some tidying up...
+        if (isNaN(ddLat) && ddLat.includes(',')) {
+            ddLat = ddLat.replace(',', '.');
+        }
+        //all done!!
+        //just truncate the decimals appropriately
+        ddLat = Number(Number(ddLat).toFixed(decimalPlaces));
+        if (isNaN(ddLng) && ddLng.includes(',')) {
+            ddLng = ddLng.replace(',', '.');
+        }
+        ddLng = Number(Number(ddLng).toFixed(decimalPlaces));
+        return Object.freeze({
+            verbatimCoordinates,
+            verbatimLatitude: verbatimLat,
+            verbatimLongitude: verbatimLng,
+            decimalLatitude: ddLat,
+            decimalLongitude: ddLng,
+            decimalCoordinates: `${ddLat},${ddLng}`,
+            closeEnough: coordsCloseEnough,
+            toCoordinateFormat: toCoordinateFormat_js_1.default
+        });
+    }
+    else {
+        throw new Error("coordinates pattern match failed");
+    }
+}
+function checkMatch(match) {
+    if (!isNaN(match[0])) { //we've matched a number, not what we want....
+        return false;
+    }
+    //first remove the empty values from the array
+    const filteredMatch = [...match];
+    //we need to shift the array because it contains the whole coordinates string in the first item
+    filteredMatch.shift();
+    //check the array length is an even number else exit
+    if (filteredMatch.length % 2 > 0) {
+        return false;
+    }
+    //regex for testing corresponding values match
+    const numerictest = /^[-+]?\d+([\.,]\d+)?$/; //for testing numeric values
+    const stringtest = /[eastsouthnorthwest]+/i; //for testing string values (north, south, etc)
+    const halflen = filteredMatch.length / 2;
+    for (let i = 0; i < halflen; i++) {
+        const leftside = filteredMatch[i];
+        const rightside = filteredMatch[i + halflen];
+        const bothAreNumbers = numerictest.test(leftside) && numerictest.test(rightside);
+        const bothAreStrings = stringtest.test(leftside) && stringtest.test(rightside);
+        const valuesAreEqual = leftside == rightside;
+        if (leftside == undefined && rightside == undefined) { //we have to handle undefined because regex converts it to string 'undefined'!!
+            continue;
+        }
+        else if (leftside == undefined || rightside == undefined) { //no we need to handle the case where one is and the other not...
+            return false;
+        }
+        else if (bothAreNumbers || bothAreStrings || valuesAreEqual) {
+            continue;
+        }
+        else {
+            return false;
+        }
+    }
+    return true;
+}
+//functions for coordinate validation
+//as decimal arithmetic is not straightforward, we approximate
+function decimalsCloseEnough(dec1, dec2) {
+    const originaldiff = Math.abs(dec1 - dec2);
+    const diff = Number(originaldiff.toFixed(6));
+    if (diff <= 0.00001) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+function coordsCloseEnough(coordsToTest) {
+    if (coordsToTest.includes(',')) {
+        const coords = coordsToTest.split(',');
+        if (Number(coords[0]) == NaN || Number(coords[1]) == NaN) {
+            throw new Error("coords are not valid decimals");
+        }
+        else {
+            return decimalsCloseEnough(this.decimalLatitude, Number(coords[0])) && decimalsCloseEnough(this.decimalLongitude, coords[1]); //this here will be the converted coordinates object
+        }
+    }
+    else {
+        throw new Error("coords being tested must be separated by a comma");
+    }
+}
+const to = Object.freeze({
+    DMS: 'DMS',
+    DM: 'DM'
+});
+converter.to = to;
+exports.default = converter;

package/dist/cjs/merge.d.ts

@@ -0,0 +1,2 @@
+export const convert: typeof converter;
+import converter from './converter.js';

package/dist/cjs/merge.js

@@ -0,0 +1,12 @@
+"use strict";
+//adds the formats to the convert object
+//we need to use this as the source for the npm package so that the formats are not included in the bundle
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convert = void 0;
+const converter_js_1 = __importDefault(require("./converter.js"));
+const testformats_js_1 = __importDefault(require("./tests/testformats.js"));
+converter_js_1.default.formats = testformats_js_1.default.map(format => format.verbatimCoordinates);
+exports.convert = converter_js_1.default;

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{ 
+  "type": "commonjs" 
+} 

package/dist/cjs/regex.d.ts

@@ -0,0 +1,4 @@
+export const dd_re: RegExp;
+export const dms_periods: RegExp;
+export const dms_abbr: RegExp;
+export const coords_other: RegExp;

package/dist/cjs/regex.js

@@ -0,0 +1,16 @@
+"use strict";
+//Coordinates pattern matching regex
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.coords_other = exports.dms_abbr = exports.dms_periods = exports.dd_re = void 0;
+//decimal degrees
+const dd_re = /(NORTH|SOUTH|[NS])?[\s]*([+-]?[0-8]?[0-9](?:[\.,]\d{3,}))[\s]*([•º°]?)[\s]*(NORTH|SOUTH|[NS])?[\s]*[,/;]?[\s]*(EAST|WEST|[EW])?[\s]*([+-]?[0-1]?[0-9]?[0-9](?:[\.,]\d{3,}))[\s]*([•º°]?)[\s]*(EAST|WEST|[EW])?/i;
+exports.dd_re = dd_re;
+//degrees minutes seconds with '.' as separator - gives array with 15 values
+const dms_periods = /(NORTH|SOUTH|[NS])?\s*([+-]?[0-8]?[0-9])\s*(\.)\s*([0-5]?[0-9])\s*(\.)\s*((?:[0-5]?[0-9])(?:[\.,]\d{1,3})?)?\s*(NORTH|SOUTH|[NS])?(?:\s*[,/;]\s*|\s*)(EAST|WEST|[EW])?\s*([+-]?[0-1]?[0-9]?[0-9])\s*(\.)\s*([0-5]?[0-9])\s*(\.)\s*((?:[0-5]?[0-9])(?:[\.,]\d{1,3})?)?\s*(EAST|WEST|[EW])?/i;
+exports.dms_periods = dms_periods;
+//degrees minutes seconds with words 'degrees, minutes, seconds' as separators (needed because the s of seconds messes with the S of SOUTH) - gives array of 17 values
+const dms_abbr = /(NORTH|SOUTH|[NS])?\s*([+-]?[0-8]?[0-9])\s*(D(?:EG)?(?:REES)?)\s*([0-5]?[0-9])\s*(M(?:IN)?(?:UTES)?)\s*((?:[0-5]?[0-9])(?:[\.,]\d{1,3})?)?\s*(S(?:EC)?(?:ONDS)?)?\s*(NORTH|SOUTH|[NS])?(?:\s*[,/;]\s*|\s*)(EAST|WEST|[EW])?\s*([+-]?[0-1]?[0-9]?[0-9])\s*(D(?:EG)?(?:REES)?)\s*([0-5]?[0-9])\s*(M(?:IN)?(?:UTES)?)\s*((?:[0-5]?[0-9])(?:[\.,]\d{1,3})?)?\s*(S(?:EC)?(?:ONDS)?)\s*(EAST|WEST|[EW])?/i;
+exports.dms_abbr = dms_abbr;
+//everything else - gives array of 17 values 
+const coords_other = /(NORTH|SOUTH|[NS])?\s*([+-]?[0-8]?[0-9])\s*([•º°\.:]|D(?:EG)?(?:REES)?)?\s*,?([0-5]?[0-9](?:[\.,]\d{1,})?)?\s*(['′´’\.:]|M(?:IN)?(?:UTES)?)?\s*,?((?:[0-5]?[0-9])(?:[\.,]\d{1,3})?)?\s*(''|′′|’’|´´|["″”\.])?\s*(NORTH|SOUTH|[NS])?(?:\s*[,/;]\s*|\s*)(EAST|WEST|[EW])?\s*([+-]?[0-1]?[0-9]?[0-9])\s*([•º°\.:]|D(?:EG)?(?:REES)?)?\s*,?([0-5]?[0-9](?:[\.,]\d{1,})?)?\s*(['′´’\.:]|M(?:IN)?(?:UTES)?)?\s*,?((?:[0-5]?[0-9])(?:[\.,]\d{1,3})?)?\s*(''|′′|´´|’’|["″”\.])?\s*(EAST|WEST|[EW])?/i;
+exports.coords_other = coords_other;

package/dist/cjs/tests/failFormats.d.ts

@@ -0,0 +1,2 @@
+export default failingFormats;
+declare const failingFormats: string[];

package/dist/cjs/tests/failFormats.js

@@ -0,0 +1,26 @@
+"use strict";
+//TODO These formats should throw...
+Object.defineProperty(exports, "__esModule", { value: true });
+const failingFormats = [
+    '10,10',
+    '46,8',
+    '12.12323, 123',
+    '24.0, 26.0',
+    '33.25°S 18.25°E',
+    '27.0 23.0',
+    '10.00000S 10.000000E',
+    '00.00 01.00',
+    '50°4\'17.698"south, 24.34532',
+    '90°4\'17.698"south, 23°4\'17.698"east',
+    '89°4\'17.698"south, 183°4\'17.698"east',
+    '50°4\'17.698"east, 23°4\'17.698"south',
+    'E23.34355,S25.324234',
+    '23°45\'12.2\'\'S 18.33\'56.7\'\'E',
+    'S 27.45.34 23.23.23',
+    'S 27.45.34 S 23.23.23',
+    'S 90°4\'17.698" S 23°4\'17.698"',
+    '27.45.34 S S 23.23.23',
+    '27.45.34  23.23.23 E',
+    '8°83S 35°67E '
+];
+exports.default = failingFormats;

package/dist/cjs/tests/makeTestFormatsJSON.d.ts

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

package/dist/cjs/tests/makeTestFormatsJSON.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const testformats_js_1 = __importDefault(require("./testformats.js"));
+fs_1.default.writeFile("testFormats.json", JSON.stringify(testformats_js_1.default, null, 2), 'utf8', function (err) {
+    if (err) {
+        console.log("An error occured while writing JSON Object to File.");
+        return console.log(err);
+    }
+    console.log("JSON file has been saved.");
+});

package/dist/cjs/tests/test.d.ts

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

package/dist/cjs/tests/test.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const converter_js_1 = __importDefault(require("../converter.js"));
+const testformats_js_1 = __importDefault(require("../testformats.js"));
+const failFormats_js_1 = __importDefault(require("./failFormats.js"));
+let allPassed = true;
+//FORMATS THAT SHOULD BE CONVERTED
+for (const t of testformats_js_1.default) {
+    try {
+        const converted = (0, converter_js_1.default)(t.verbatimCoordinates, 8);
+        const testDecimalCoordsString = `${t.decimalLatitude},${t.decimalLongitude}`;
+        //check the calculation is correct
+        if (!converted.closeEnough(testDecimalCoordsString)) {
+            console.log("Error in decimal conversion");
+            console.log(t.verbatimCoordinates);
+            console.log(t.decimalLatitude);
+            console.log(t.decimalLongitude);
+            allPassed = false;
+        }
+        //check the verbatim coords are correct
+        if (converted.verbatimLatitude != t.verbatimLatitude || converted.verbatimLongitude != t.verbatimLongitude) {
+            console.log("Error in verbatim extraction");
+            console.log('For', t.verbatimCoordinates);
+            console.log('got', converted.verbatimLatitude, 'should be ', t.verbatimLatitude);
+            console.log('got', converted.verbatimLongitude, 'should be', t.verbatimLongitude);
+            allPassed = false;
+        }
+    }
+    catch (err) {
+        console.log("Failed to convert the following format");
+        console.log(t.verbatimCoordinates);
+        console.log(err.message);
+        allPassed = false;
+    }
+}
+//FORMATS THAT SHOULD NOT BE CONVERTED
+const converting = [];
+for (let f of failFormats_js_1.default) {
+    try {
+        const converted = (0, converter_js_1.default)(f);
+        converting.push(f);
+        allPassed = false;
+    }
+    catch (_a) {
+        //nothing here
+    }
+}
+if (converting.length) {
+    console.log("The following coordinates should NOT have converted successfully: " + converting.join(' | '));
+}
+if (allPassed) {
+    console.log("all formats successfully converted");
+}

package/dist/cjs/tests/testFormatConverter.d.ts

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

package/dist/cjs/tests/testFormatConverter.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = __importDefault(require("../src/toCoordinateFormat.js/index.js"));
+let test = {
+    decimalCoordinates: '-234.3456, 28.92435',
+    toCoordinateFormat: index_js_1.default
+};
+console.log(test.toCoordinateFormat('DMS'));

package/dist/cjs/tests/testIndividual.d.ts

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

package/dist/cjs/tests/testIndividual.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const converter_js_1 = __importDefault(require("../converter.js"));
+//const test = '26°44S 29°46E'
+//const test = '00.00, 01.00'
+const test = `8°83S 35°67E`;
+try {
+    let converted = (0, converter_js_1.default)(test);
+    console.log(converted);
+    console.log(converted.toCoordinateFormat(converter_js_1.default.to.DM));
+    //and just to make sure it's frozen
+    let previous = converted.decimalLatitude;
+    converted.decimalLatitude = 24;
+    if (converted.decimalLatitude === previous) {
+        console.log('the result is frozen');
+    }
+    else {
+        console.error('!!!The result is not frozen!!!!');
+    }
+}
+catch (err) {
+    console.log(err.message);
+}

package/dist/cjs/tests/testformats.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any[];
+export default _default;