atriusmaps-node-sdk 3.3.632 → 3.3.634

package/dist/cjs/src/extModules/bustle.js

@@ -8,11 +8,11 @@ var Zousan = require('zousan');
 
 
 const bustleResponseComparitor = (r1, r2) => {
-  if (r1.responseOrder == null) // null or undefined
-    return r2.responseOrder == null ? 0 : 1 // any order is higher pri than none
-  if (r2.responseOrder == null)
-    return -1
-  return r1.responseOrder - r2.responseOrder
+  if (r1.responseOrder == null)
+    // null or undefined
+    return r2.responseOrder == null ? 0 : 1; // any order is higher pri than none
+  if (r2.responseOrder == null) return -1;
+  return r1.responseOrder - r2.responseOrder;
 };
 
 // Remove element from array at index specified and return the removed element.
@@ -24,62 +24,57 @@ const arRm = (ar, value) => {
   let i = 0;
   do {
     i = ar.indexOf(value, i);
-    if (i >= 0)
-      arRmAt(ar, i);
-  } while (i >= 0)
-  return ar
+    if (i >= 0) arRmAt(ar, i);
+  } while (i >= 0);
+  return ar;
 };
 
 // This creates a bus instance. When used as a Singleton,  you will only call this once
 // for the life of your app. To isolate events (perhaps for performance or security
 // reasons) you can create multple bus instances.
-function create (opts = { }) {
+function create(opts = {}) {
   // If a log option is defined, use it - and if it supports sublogs, instantiate that. If all else fails, use console
   const log = opts.log ? (opts.log.sublog ? opts.log.sublog('bustle', { color: 'pink' }) : opts.log) : console;
 
-  const ons = { }; // holds your listeners
-  const mons = { }; // holds your monitors
+  const ons = {}; // holds your listeners
+  const mons = {}; // holds your monitors
 
   // subscribes to an event. Your listener will always be called
   // with a single argument. I am considering adding another way
   // to subscribe to events by observing an event and then
   // subscribing to that observer.
-  function on (ev, fn) {
-    if (!ons[ev])
-      ons[ev] = [];
+  function on(ev, fn) {
+    if (!ons[ev]) ons[ev] = [];
 
     ons[ev].push(fn);
 
-    return () => off(ev, fn)
+    return () => off(ev, fn);
   }
 
   // Similar to "on" but is always called after all normal "on" listeners,
   // and any values returned by a monitor call are ignored (not added to the
   // response). Also, any calls to monitor listeners contains both the message
   // object AND a promise containing the response from the normal listeners.
-  function monitor (ev, fn) {
-    if (!mons[ev])
-      mons[ev] = [];
+  function monitor(ev, fn) {
+    if (!mons[ev]) mons[ev] = [];
 
     mons[ev].push(fn);
 
-    return () => moff(ev, fn)
+    return () => moff(ev, fn);
   }
 
-  function off (ev, fn) {
+  function off(ev, fn) {
     // run ASAP but not immediate, in case it removes in its own function
     Zousan.soon(() => {
-      if (!ons[ev])
-        return
+      if (!ons[ev]) return;
       arRm(ons[ev], fn);
     });
   }
 
-  function moff (ev, fn) {
+  function moff(ev, fn) {
     // run ASAP but not immediate, in case it removes in its own function
     Zousan.soon(() => {
-      if (!mons[ev])
-        return
+      if (!mons[ev]) return;
       arRm(mons[ev], fn);
     });
   }
@@ -94,12 +89,10 @@ function create (opts = { }) {
         try {
           res.push(listener(ob));
         } catch (err) {
-          if (opts.reportAllErrors)
-            log.error(err);
+          if (opts.reportAllErrors) log.error(err);
           if (opts.rejectOnError)
             res.push(Zousan.reject(err)); // will cause the Zousan.all to reject the send
-          else
-            res.push(err);
+          else res.push(err);
         }
       }
     }
@@ -111,8 +104,7 @@ function create (opts = { }) {
         try {
           listener(ob, results);
         } catch (err) {
-          if (opts.reportAllErrors)
-            log.error(err);
+          if (opts.reportAllErrors) log.error(err);
         }
       }
     }
@@ -125,30 +117,28 @@ function create (opts = { }) {
   // and returns that result. If there are 0 or more than 1 listener, the returned
   // promise is rejected
   const get = (ev, ob) =>
-    send(ev, ob).then(res => res.length !== 1
-      ? Zousan.reject(`${ev} event did not return a single result, but ${res.length} results.`)
-      : res[0]);
+    send(ev, ob).then(res =>
+      res.length !== 1
+        ? Zousan.reject(`${ev} event did not return a single result, but ${res.length} results.`)
+        : res[0],
+    );
 
   // Allows for any number of listeners to exist - but extracts the first one
   // and returns it. If there are NO listeners, undefined is returned. The promise
   // is never rejected.
   const getFirst = (ev, ob) =>
-    send(ev, ob).then(res => res.length >= 1
-      ? res.sort(bustleResponseComparitor)[0]
-      : undefined);
+    send(ev, ob).then(res => (res.length >= 1 ? res.sort(bustleResponseComparitor)[0] : undefined));
 
-  function send (ev, ob) {
+  function send(ev, ob) {
     if (opts.showEvents) {
       if (typeof opts.showEvents === 'function') {
-        if (opts.showEvents(ev, ob))
-          log.info('send with', ev, ' and ', ob);
-      } else
-        log.info('send with', ev, ' and ', ob);
+        if (opts.showEvents(ev, ob)) log.info('send with', ev, ' and ', ob);
+      } else log.info('send with', ev, ' and ', ob);
     }
-    return new Zousan(resolve => Zousan.soon(serve(ev, ob, resolve)))
+    return new Zousan(resolve => Zousan.soon(serve(ev, ob, resolve)));
   }
 
-  return { get, getFirst, moff, monitor, off, on, send }
+  return { get, getFirst, moff, monitor, off, on, send };
 }
 
 exports.create = create;

package/dist/cjs/src/extModules/flexapi/src/help.js

@@ -1,24 +1,32 @@
 'use strict';
 
-function pad (total, str) {
-  while (str.length < total) { str += ' '; }
-  return str
+function pad(total, str) {
+  while (str.length < total) {
+    str += ' ';
+  }
+  return str;
 }
 
-const getHelpHeader = () => pad(18, 'Command') + 'Arguments\n' + pad(18, '----------------') + '----------------\n';
+const getHelpHeader = () =>
+  pad(18, 'Command') + 'Arguments\n' + pad(18, '----------------') + '----------------\n';
 
 /**
  *  Returns help on the passed command signature
  */
-const getHelp = sig => pad(18, sig.command) +
-  (sig.args ? sig.args.map(argob => `${argob.name} {${argob.type}} ${argob.optional ? ' (optional)' : ' (required)'}`).join(', ') : '');
+const getHelp = sig =>
+  pad(18, sig.command) +
+  (sig.args
+    ? sig.args
+        .map(argob => `${argob.name} {${argob.type}} ${argob.optional ? ' (optional)' : ' (required)'}`)
+        .join(', ')
+    : '');
 
-const sigsort = (s1, s2) => s1.command > s2.command ? 1 : -1;
+const sigsort = (s1, s2) => (s1.command > s2.command ? 1 : -1);
 /**
  *  Returns help on the passed command signatures
  */
 const getHelpList = sigList => {
-  return sigList.sort(sigsort).reduce((ret, sig) => `${ret}${getHelp(sig)}\n`, getHelpHeader())
+  return sigList.sort(sigsort).reduce((ret, sig) => `${ret}${getHelp(sig)}\n`, getHelpHeader());
 };
 
 exports.getHelp = getHelp;

package/dist/cjs/src/extModules/flexapi/src/index.js

@@ -7,54 +7,75 @@ var validate = require('./validate.js');
 const COMMAND_VALIDATION_REGEX = /^[-_.0-9a-zA-Z]+$/;
 const JS = JSON.stringify;
 
-function create () {
+function create() {
   const commandDefsList = [];
   const commands = () => commandDefsList.map(cob => cob.sig);
-  const customTypes = { };
+  const customTypes = {};
   const library = { customTypes, commandDefsList };
   const getCommandJSON = () => ({ commands: commands(), customTypes });
 
-  function registerCommand (sig, fn) {
+  function registerCommand(sig, fn) {
     const command = sig.command;
-    if (command === undefined) { throw Error(`Invalid command specification in registerCommand: ${JS(sig)}. No 'command' property specified.`) }
+    if (command === undefined) {
+      throw Error(`Invalid command specification in registerCommand: ${JS(sig)}. No 'command' property specified.`);
+    }
 
     if (!COMMAND_VALIDATION_REGEX.test(command)) {
-      const er = Error(`Invalid command specification in registerCommand: ${JS(sig)}. Command name '${command}' not valid.`);
-      throw er
+      const er = Error(
+        `Invalid command specification in registerCommand: ${JS(sig)}. Command name '${command}' not valid.`,
+      );
+      throw er;
     }
 
     commandDefsList.push({ sig, fn });
 
-    return execute
+    return execute;
   }
 
-  function registerCustomType (name, spec) {
+  function registerCustomType(name, spec) {
     customTypes[name] = spec;
   }
 
-  function execute (cob) {
+  function execute(cob) {
     return new Zousan((resolve, reject) => {
-      if (!cob) { return reject(new Error(`No command specified in command object ${JS(cob)}`)) }
+      if (!cob) {
+        return reject(new Error(`No command specified in command object ${JS(cob)}`));
+      }
 
-      const commandMatches = library.commandDefsList
-        .filter(com => com.sig.command === cob.command);
+      const commandMatches = library.commandDefsList.filter(com => com.sig.command === cob.command);
 
-      if (commandMatches.length === 0) { return reject(new Error(`No API command '${cob.command}' found.\n${help.getHelpList(library.commandDefsList.map(o => o.sig))}`)) }
+      if (commandMatches.length === 0) {
+        return reject(
+          new Error(`No API command '${cob.command}' found.\n${help.getHelpList(library.commandDefsList.map(o => o.sig))}`),
+        );
+      }
 
       const sigMatch = validate.getSigMatch(library, cob);
 
       if (!sigMatch) {
-        if (commandMatches.length === 1) { return reject(new Error(`Required fields not present in ${JS(cob)}\n${help.getHelpHeader()}${help.getHelp(commandMatches[0].sig)}`)) } else { return reject(new Error(`Command arguments did not match any required signatures: ${JS(cob)}\n${help.getHelpList(library.commandDefsList.map(o => o.sig))}`)) }
+        if (commandMatches.length === 1) {
+          return reject(
+            new Error(`Required fields not present in ${JS(cob)}\n${help.getHelpHeader()}${help.getHelp(commandMatches[0].sig)}`),
+          );
+        } else {
+          return reject(
+            new Error(
+              `Command arguments did not match any required signatures: ${JS(cob)}\n${help.getHelpList(library.commandDefsList.map(o => o.sig))}`,
+            ),
+          );
+        }
       }
 
       // console.log(`command ${JS(cob)} is ${JS(sigMatch.sig)}`)
 
       try {
         validate.validate(library, sigMatch.sig, cob); // this will throw an error if invalid
-      } catch (e) { return reject(e) }
+      } catch (e) {
+        return reject(e);
+      }
 
       resolve(sigMatch.fn(cob));
-    })
+    });
   }
 
   registerCommand({ command: 'help', args: [] }, () => help.getHelpList(commands()));
@@ -63,8 +84,8 @@ function create () {
   return {
     registerCommand,
     registerCustomType,
-    execute
-  }
+    execute,
+  };
 }
 
 module.exports = create;

package/dist/cjs/src/extModules/flexapi/src/validate.js

@@ -1,34 +1,44 @@
 'use strict';
 
 // small helper for showing args
-const SQ = '\''; // single quote
-const sqStr = function (str) { return SQ + str + SQ };
+const SQ = "'"; // single quote
+const sqStr = function (str) {
+  return SQ + str + SQ;
+};
 
-function validate (library, sig, cob) {
-  if (sig.args)
-    checkTypeList(library.customTypes, sig.args, cob);
+function validate(library, sig, cob) {
+  if (sig.args) checkTypeList(library.customTypes, sig.args, cob);
 }
 
-function getSigMatch (library, cob) {
-  const matches = library.commandDefsList
-    .filter(cd => (cd.sig.command === cob.command) && matchesArgs(cd.sig, cob));
-  if (matches.length > 1) { throw Error('Command matches multiple signatures!') }
-  if (matches.length > 0) { return matches[0] }
-  return null // no matching signature found
+function getSigMatch(library, cob) {
+  const matches = library.commandDefsList.filter(cd => cd.sig.command === cob.command && matchesArgs(cd.sig, cob));
+  if (matches.length > 1) {
+    throw Error('Command matches multiple signatures!');
+  }
+  if (matches.length > 0) {
+    return matches[0];
+  }
+  return null; // no matching signature found
 }
 
 // returns true if each of the required arguments in the command
 // spec (c) is defined within the command object (o) - else false
-function matchesArgs (c, o) {
-  if (!c.args) { return true } // no args
+function matchesArgs(c, o) {
+  if (!c.args) {
+    return true;
+  } // no args
   return c.args.reduce(function (cs, argOb) {
-    return o[argOb.name] !== undefined || argOb.optional ? cs : false
-  }, true)
+    return o[argOb.name] !== undefined || argOb.optional ? cs : false;
+  }, true);
 }
 
-function checkMinMax (name, typeSpec, value) {
-  if (typeSpec.min !== undefined && value < typeSpec.min) { throw Error('argument ' + sqStr(name) + ' must be at least ' + typeSpec.min + ' but is ' + value) }
-  if (typeSpec.max !== undefined && value > typeSpec.max) { throw Error('argument ' + sqStr(name) + ' must be at most ' + typeSpec.max + ' but is ' + value) }
+function checkMinMax(name, typeSpec, value) {
+  if (typeSpec.min !== undefined && value < typeSpec.min) {
+    throw Error('argument ' + sqStr(name) + ' must be at least ' + typeSpec.min + ' but is ' + value);
+  }
+  if (typeSpec.max !== undefined && value > typeSpec.max) {
+    throw Error('argument ' + sqStr(name) + ' must be at most ' + typeSpec.max + ' but is ' + value);
+  }
 }
 
 /**
@@ -39,82 +49,111 @@ function checkMinMax (name, typeSpec, value) {
  * @param {*} value The JSON value to be checked against this spec
  * @return {true|string} returns true if arg is valid, else a string description of the problem
  */
-function checkType (customTypes, typeSpec, value) {
-  if (!typeSpec) // if there is no typespec to validate against, any value is ok
-    return true
+function checkType(customTypes, typeSpec, value) {
+  if (!typeSpec)
+    // if there is no typespec to validate against, any value is ok
+    return true;
 
   const name = typeSpec.name || '';
 
   // if type is a reference/custom, grab that type def but allow "optional" override - TODO: consider other overrides (perhaps all but "type"?)
   if (customTypes && customTypes[typeSpec.type])
-    typeSpec = Object.assign({}, customTypes[typeSpec.type], typeSpec, { type: customTypes[typeSpec.type].type });
+    typeSpec = Object.assign({}, customTypes[typeSpec.type], typeSpec, {
+      type: customTypes[typeSpec.type].type,
+    });
 
   if (typeSpec.type === 'integer') {
-    if (typeof value === 'string')
-      value = parseInt(value, 10);
+    if (typeof value === 'string') value = parseInt(value, 10);
     if (!Number.isInteger(value))
-      throw Error('expected integer argument for argument ' + sqStr(name) + ' but received ' + value)
+      throw Error('expected integer argument for argument ' + sqStr(name) + ' but received ' + value);
     checkMinMax(name, typeSpec, value);
-  } else
-    if (typeSpec.type === 'float') {
-      if (typeof value === 'string')
-        value = parseFloat(value);
-      if (!Number.isFinite(value))
-        throw Error('expected float argument for argument ' + sqStr(name) + ' but received \'' + value + '\'')
-      checkMinMax(name, typeSpec, value);
-    } else
-      if (typeSpec.type === 'string') {
-        if (typeof value !== 'string')
-          throw Error(`argument ${sqStr(name)} must be a string but is not (value: ${value})`)
-        if (typeSpec.minLength && value.length < typeSpec.minLength)
-          throw Error(`argument ${sqStr(name)} must be a at least ${typeSpec.minLength} characters but is '${value}' (${value.length} chars)`)
-        if (typeSpec.maxLength && value.length > typeSpec.maxLength)
-          throw Error(`argument ${sqStr(name)} must be a at most ${typeSpec.maxLength} characters but is '${value}' (${value.length} chars)`)
-      } else
-        if (typeSpec.type === 'boolean') {
-          if (value !== true && value !== false && value !== 'false' && value !== 'true' && value !== 'yes' && value !== 'no') { throw Error('argument ' + sqStr(name) + ' must be a boolean but is type ' + (typeof value) + ' with value of ' + value) }
-        } else
-          if (typeSpec.type === 'list') {
-            if (!Array.isArray(value))
-              throw Error('argument ' + sqStr(name) + ' must be a list but is not. Value = ' + value)
-            if (typeSpec.minLength !== undefined && typeSpec.minLength > value.length)
-              throw Error('argument ' + sqStr(name) + ' must contain at least ' + typeSpec.minLength + ' items but only contains ' + value.length + ' items')
-            if (typeSpec.maxLength !== undefined && typeSpec.maxLength < value.length)
-              throw Error('argument ' + sqStr(name) + ' must contain at most ' + typeSpec.maxLength + ' items but contains ' + value.length + ' items')
-            if (typeSpec.itemType) {
-              const allItemsValid = value.reduce(function (isValid, curItem) {
-                try {
-                  checkType(customTypes, typeSpec.itemType, curItem);
-                } catch (e) { return false }
-                return isValid
-              }, true);
-              if (!allItemsValid) { throw Error(`argument ${sqStr(name)} contains an invalid item(s). All items in the list must be of type: ${JSON.stringify(typeSpec.itemType)} - list: ${JSON.stringify(value)}`) }
-            }
-          } else
-            if (typeSpec.type === 'object') {
-              if (typeof (value) !== 'object' || Array.isArray(value))
-                throw Error('argument ' + sqStr(name) + ' must be an object but is not. Value = ' + value)
-              try {
-                if (typeSpec.props)
-                  checkTypeList(customTypes, typeSpec.props, value);
-              } catch (e) {
-                throw Error('Within ' + name + ', ' + e.message)
-              }
-            } else
-              if (typeSpec.type === 'multi') {
-                const oneTypeValid = typeSpec.types
-                  .reduce((isValid, curType) => {
-                    try {
-                      checkType(customTypes, curType, value);
-                    } catch (e) { return isValid }
-                    return true
-                  }, false);
-                if (!oneTypeValid)
-                  throw Error(`Argument ${sqStr(name)} can be of several types, but is not valid for any: ${value}`)
-              } else
-                throw Error('type ' + typeSpec.type + ' is an unknown type')
+  } else if (typeSpec.type === 'float') {
+    if (typeof value === 'string') value = parseFloat(value);
+    if (!Number.isFinite(value))
+      throw Error('expected float argument for argument ' + sqStr(name) + " but received '" + value + "'");
+    checkMinMax(name, typeSpec, value);
+  } else if (typeSpec.type === 'string') {
+    if (typeof value !== 'string') throw Error(`argument ${sqStr(name)} must be a string but is not (value: ${value})`);
+    if (typeSpec.minLength && value.length < typeSpec.minLength)
+      throw Error(
+        `argument ${sqStr(name)} must be a at least ${typeSpec.minLength} characters but is '${value}' (${value.length} chars)`,
+      );
+    if (typeSpec.maxLength && value.length > typeSpec.maxLength)
+      throw Error(
+        `argument ${sqStr(name)} must be a at most ${typeSpec.maxLength} characters but is '${value}' (${value.length} chars)`,
+      );
+  } else if (typeSpec.type === 'boolean') {
+    if (
+      value !== true &&
+      value !== false &&
+      value !== 'false' &&
+      value !== 'true' &&
+      value !== 'yes' &&
+      value !== 'no'
+    ) {
+      throw Error(
+        'argument ' + sqStr(name) + ' must be a boolean but is type ' + typeof value + ' with value of ' + value,
+      );
+    }
+  } else if (typeSpec.type === 'list') {
+    if (!Array.isArray(value)) throw Error('argument ' + sqStr(name) + ' must be a list but is not. Value = ' + value);
+    if (typeSpec.minLength !== undefined && typeSpec.minLength > value.length)
+      throw Error(
+        'argument ' +
+          sqStr(name) +
+          ' must contain at least ' +
+          typeSpec.minLength +
+          ' items but only contains ' +
+          value.length +
+          ' items',
+      );
+    if (typeSpec.maxLength !== undefined && typeSpec.maxLength < value.length)
+      throw Error(
+        'argument ' +
+          sqStr(name) +
+          ' must contain at most ' +
+          typeSpec.maxLength +
+          ' items but contains ' +
+          value.length +
+          ' items',
+      );
+    if (typeSpec.itemType) {
+      const allItemsValid = value.reduce(function (isValid, curItem) {
+        try {
+          checkType(customTypes, typeSpec.itemType, curItem);
+        } catch (e) {
+          return false;
+        }
+        return isValid;
+      }, true);
+      if (!allItemsValid) {
+        throw Error(
+          `argument ${sqStr(name)} contains an invalid item(s). All items in the list must be of type: ${JSON.stringify(typeSpec.itemType)} - list: ${JSON.stringify(value)}`,
+        );
+      }
+    }
+  } else if (typeSpec.type === 'object') {
+    if (typeof value !== 'object' || Array.isArray(value))
+      throw Error('argument ' + sqStr(name) + ' must be an object but is not. Value = ' + value);
+    try {
+      if (typeSpec.props) checkTypeList(customTypes, typeSpec.props, value);
+    } catch (e) {
+      throw Error('Within ' + name + ', ' + e.message);
+    }
+  } else if (typeSpec.type === 'multi') {
+    const oneTypeValid = typeSpec.types.reduce((isValid, curType) => {
+      try {
+        checkType(customTypes, curType, value);
+      } catch (e) {
+        return isValid;
+      }
+      return true;
+    }, false);
+    if (!oneTypeValid)
+      throw Error(`Argument ${sqStr(name)} can be of several types, but is not valid for any: ${value}`);
+  } else throw Error('type ' + typeSpec.type + ' is an unknown type');
 
-  return true
+  return true;
 }
 
 /**
@@ -123,10 +162,13 @@ function checkType (customTypes, typeSpec, value) {
  * @param typeList A list of types to check
  * @param args The properties object to check against
  */
-function checkTypeList (customTypes, typeList, args) {
+function checkTypeList(customTypes, typeList, args) {
   typeList.forEach(nextType => {
-    if (args[nextType.name] !== undefined) { checkType(customTypes, nextType, args[nextType.name]); } else
-      if (!nextType.optional) { throw Error('you must include a value for ' + nextType.name) }
+    if (args[nextType.name] !== undefined) {
+      checkType(customTypes, nextType, args[nextType.name]);
+    } else if (!nextType.optional) {
+      throw Error('you must include a value for ' + nextType.name);
+    }
   });
 }
 

package/dist/cjs/src/extModules/geohasher.js

@@ -17,14 +17,14 @@ const NEIGHBORS = {
   right: { even: 'bc01fg45238967deuvhjyznpkmstqrwx' },
   left: { even: '238967debc01fg45kmstqrwxuvhjyznp' },
   top: { even: 'p0r21436x8zb9dcf5h7kjnmqesgutwvy' },
-  bottom: { even: '14365h7k9dcfesgujnmqp0r2twvyx8zb' }
+  bottom: { even: '14365h7k9dcfesgujnmqp0r2twvyx8zb' },
 };
 
 const BORDERS = {
   right: { even: 'bcfguvyz' },
   left: { even: '0145hjnp' },
   top: { even: 'prxz' },
-  bottom: { even: '028b' }
+  bottom: { even: '028b' },
 };
 
 NEIGHBORS.bottom.odd = NEIGHBORS.left.even;
@@ -37,18 +37,18 @@ BORDERS.top.odd = BORDERS.right.even;
 BORDERS.left.odd = BORDERS.bottom.even;
 BORDERS.right.odd = BORDERS.top.even;
 
-function calculateAdjacent (srcHash, dir) {
+function calculateAdjacent(srcHash, dir) {
   srcHash = srcHash.toLowerCase();
   const lastChr = srcHash.charAt(srcHash.length - 1);
-  const type = (srcHash.length % 2) ? 'odd' : 'even';
+  const type = srcHash.length % 2 ? 'odd' : 'even';
   let base = srcHash.substring(0, srcHash.length - 1);
   if (BORDERS[dir][type].indexOf(lastChr) !== -1) {
     base = calculateAdjacent(base, dir);
   }
-  return base + BASE32[NEIGHBORS[dir][type].indexOf(lastChr)]
+  return base + BASE32[NEIGHBORS[dir][type].indexOf(lastChr)];
 }
 
-function encode (latitude, longitude, precision) {
+function encode(latitude, longitude, precision) {
   let isEven = 1;
   const lat = [-90, 90.0];
   const lng = [-180, 180.0];
@@ -86,7 +86,7 @@ function encode (latitude, longitude, precision) {
       ch = 0;
     }
   }
-  return geohash
+  return geohash;
 }
 
 exports.calculateAdjacent = calculateAdjacent;