universal-geocoder/dist/universal-geocoder.js

Universal geocoding abstraction server-side and client-side with multiple built-in providers

/******/ (() => { // webpackBootstrap
/******/ 	var __webpack_modules__ = ({

/***/ "./node_modules/cross-fetch/dist/browser-ponyfill.js":
/*!***********************************************************!*\
  !*** ./node_modules/cross-fetch/dist/browser-ponyfill.js ***!
  \***********************************************************/
/***/ (function(module, exports) {

var global = typeof self !== 'undefined' ? self : this;
var __self__ = (function () {
function F() {
this.fetch = false;
this.DOMException = global.DOMException
}
F.prototype = global;
return new F();
})();
(function(self) {

var irrelevant = (function (exports) {

  var support = {
    searchParams: 'URLSearchParams' in self,
    iterable: 'Symbol' in self && 'iterator' in Symbol,
    blob:
      'FileReader' in self &&
      'Blob' in self &&
      (function() {
        try {
          new Blob();
          return true
        } catch (e) {
          return false
        }
      })(),
    formData: 'FormData' in self,
    arrayBuffer: 'ArrayBuffer' in self
  };

  function isDataView(obj) {
    return obj && DataView.prototype.isPrototypeOf(obj)
  }

  if (support.arrayBuffer) {
    var viewClasses = [
      '[object Int8Array]',
      '[object Uint8Array]',
      '[object Uint8ClampedArray]',
      '[object Int16Array]',
      '[object Uint16Array]',
      '[object Int32Array]',
      '[object Uint32Array]',
      '[object Float32Array]',
      '[object Float64Array]'
    ];

    var isArrayBufferView =
      ArrayBuffer.isView ||
      function(obj) {
        return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1
      };
  }

  function normalizeName(name) {
    if (typeof name !== 'string') {
      name = String(name);
    }
    if (/[^a-z0-9\-#$%&'*+.^_`|~]/i.test(name)) {
      throw new TypeError('Invalid character in header field name')
    }
    return name.toLowerCase()
  }

  function normalizeValue(value) {
    if (typeof value !== 'string') {
      value = String(value);
    }
    return value
  }

  // Build a destructive iterator for the value list
  function iteratorFor(items) {
    var iterator = {
      next: function() {
        var value = items.shift();
        return {done: value === undefined, value: value}
      }
    };

    if (support.iterable) {
      iterator[Symbol.iterator] = function() {
        return iterator
      };
    }

    return iterator
  }

  function Headers(headers) {
    this.map = {};

    if (headers instanceof Headers) {
      headers.forEach(function(value, name) {
        this.append(name, value);
      }, this);
    } else if (Array.isArray(headers)) {
      headers.forEach(function(header) {
        this.append(header[0], header[1]);
      }, this);
    } else if (headers) {
      Object.getOwnPropertyNames(headers).forEach(function(name) {
        this.append(name, headers[name]);
      }, this);
    }
  }

  Headers.prototype.append = function(name, value) {
    name = normalizeName(name);
    value = normalizeValue(value);
    var oldValue = this.map[name];
    this.map[name] = oldValue ? oldValue + ', ' + value : value;
  };

  Headers.prototype['delete'] = function(name) {
    delete this.map[normalizeName(name)];
  };

  Headers.prototype.get = function(name) {
    name = normalizeName(name);
    return this.has(name) ? this.map[name] : null
  };

  Headers.prototype.has = function(name) {
    return this.map.hasOwnProperty(normalizeName(name))
  };

  Headers.prototype.set = function(name, value) {
    this.map[normalizeName(name)] = normalizeValue(value);
  };

  Headers.prototype.forEach = function(callback, thisArg) {
    for (var name in this.map) {
      if (this.map.hasOwnProperty(name)) {
        callback.call(thisArg, this.map[name], name, this);
      }
    }
  };

  Headers.prototype.keys = function() {
    var items = [];
    this.forEach(function(value, name) {
      items.push(name);
    });
    return iteratorFor(items)
  };

  Headers.prototype.values = function() {
    var items = [];
    this.forEach(function(value) {
      items.push(value);
    });
    return iteratorFor(items)
  };

  Headers.prototype.entries = function() {
    var items = [];
    this.forEach(function(value, name) {
      items.push([name, value]);
    });
    return iteratorFor(items)
  };

  if (support.iterable) {
    Headers.prototype[Symbol.iterator] = Headers.prototype.entries;
  }

  function consumed(body) {
    if (body.bodyUsed) {
      return Promise.reject(new TypeError('Already read'))
    }
    body.bodyUsed = true;
  }

  function fileReaderReady(reader) {
    return new Promise(function(resolve, reject) {
      reader.onload = function() {
        resolve(reader.result);
      };
      reader.onerror = function() {
        reject(reader.error);
      };
    })
  }

  function readBlobAsArrayBuffer(blob) {
    var reader = new FileReader();
    var promise = fileReaderReady(reader);
    reader.readAsArrayBuffer(blob);
    return promise
  }

  function readBlobAsText(blob) {
    var reader = new FileReader();
    var promise = fileReaderReady(reader);
    reader.readAsText(blob);
    return promise
  }

  function readArrayBufferAsText(buf) {
    var view = new Uint8Array(buf);
    var chars = new Array(view.length);

    for (var i = 0; i < view.length; i++) {
      chars[i] = String.fromCharCode(view[i]);
    }
    return chars.join('')
  }

  function bufferClone(buf) {
    if (buf.slice) {
      return buf.slice(0)
    } else {
      var view = new Uint8Array(buf.byteLength);
      view.set(new Uint8Array(buf));
      return view.buffer
    }
  }

  function Body() {
    this.bodyUsed = false;

    this._initBody = function(body) {
      this._bodyInit = body;
      if (!body) {
        this._bodyText = '';
      } else if (typeof body === 'string') {
        this._bodyText = body;
      } else if (support.blob && Blob.prototype.isPrototypeOf(body)) {
        this._bodyBlob = body;
      } else if (support.formData && FormData.prototype.isPrototypeOf(body)) {
        this._bodyFormData = body;
      } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
        this._bodyText = body.toString();
      } else if (support.arrayBuffer && support.blob && isDataView(body)) {
        this._bodyArrayBuffer = bufferClone(body.buffer);
        // IE 10-11 can't handle a DataView body.
        this._bodyInit = new Blob([this._bodyArrayBuffer]);
      } else if (support.arrayBuffer && (ArrayBuffer.prototype.isPrototypeOf(body) || isArrayBufferView(body))) {
        this._bodyArrayBuffer = bufferClone(body);
      } else {
        this._bodyText = body = Object.prototype.toString.call(body);
      }

      if (!this.headers.get('content-type')) {
        if (typeof body === 'string') {
          this.headers.set('content-type', 'text/plain;charset=UTF-8');
        } else if (this._bodyBlob && this._bodyBlob.type) {
          this.headers.set('content-type', this._bodyBlob.type);
        } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
          this.headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8');
        }
      }
    };

    if (support.blob) {
      this.blob = function() {
        var rejected = consumed(this);
        if (rejected) {
          return rejected
        }

        if (this._bodyBlob) {
          return Promise.resolve(this._bodyBlob)
        } else if (this._bodyArrayBuffer) {
          return Promise.resolve(new Blob([this._bodyArrayBuffer]))
        } else if (this._bodyFormData) {
          throw new Error('could not read FormData body as blob')
        } else {
          return Promise.resolve(new Blob([this._bodyText]))
        }
      };

      this.arrayBuffer = function() {
        if (this._bodyArrayBuffer) {
          return consumed(this) || Promise.resolve(this._bodyArrayBuffer)
        } else {
          return this.blob().then(readBlobAsArrayBuffer)
        }
      };
    }

    this.text = function() {
      var rejected = consumed(this);
      if (rejected) {
        return rejected
      }

      if (this._bodyBlob) {
        return readBlobAsText(this._bodyBlob)
      } else if (this._bodyArrayBuffer) {
        return Promise.resolve(readArrayBufferAsText(this._bodyArrayBuffer))
      } else if (this._bodyFormData) {
        throw new Error('could not read FormData body as text')
      } else {
        return Promise.resolve(this._bodyText)
      }
    };

    if (support.formData) {
      this.formData = function() {
        return this.text().then(decode)
      };
    }

    this.json = function() {
      return this.text().then(JSON.parse)
    };

    return this
  }

  // HTTP methods whose capitalization should be normalized
  var methods = ['DELETE', 'GET', 'HEAD', 'OPTIONS', 'POST', 'PUT'];

  function normalizeMethod(method) {
    var upcased = method.toUpperCase();
    return methods.indexOf(upcased) > -1 ? upcased : method
  }

  function Request(input, options) {
    options = options || {};
    var body = options.body;

    if (input instanceof Request) {
      if (input.bodyUsed) {
        throw new TypeError('Already read')
      }
      this.url = input.url;
      this.credentials = input.credentials;
      if (!options.headers) {
        this.headers = new Headers(input.headers);
      }
      this.method = input.method;
      this.mode = input.mode;
      this.signal = input.signal;
      if (!body && input._bodyInit != null) {
        body = input._bodyInit;
        input.bodyUsed = true;
      }
    } else {
      this.url = String(input);
    }

    this.credentials = options.credentials || this.credentials || 'same-origin';
    if (options.headers || !this.headers) {
      this.headers = new Headers(options.headers);
    }
    this.method = normalizeMethod(options.method || this.method || 'GET');
    this.mode = options.mode || this.mode || null;
    this.signal = options.signal || this.signal;
    this.referrer = null;

    if ((this.method === 'GET' || this.method === 'HEAD') && body) {
      throw new TypeError('Body not allowed for GET or HEAD requests')
    }
    this._initBody(body);
  }

  Request.prototype.clone = function() {
    return new Request(this, {body: this._bodyInit})
  };

  function decode(body) {
    var form = new FormData();
    body
      .trim()
      .split('&')
      .forEach(function(bytes) {
        if (bytes) {
          var split = bytes.split('=');
          var name = split.shift().replace(/\+/g, ' ');
          var value = split.join('=').replace(/\+/g, ' ');
          form.append(decodeURIComponent(name), decodeURIComponent(value));
        }
      });
    return form
  }

  function parseHeaders(rawHeaders) {
    var headers = new Headers();
    // Replace instances of \r\n and \n followed by at least one space or horizontal tab with a space
    // https://tools.ietf.org/html/rfc7230#section-3.2
    var preProcessedHeaders = rawHeaders.replace(/\r?\n[\t ]+/g, ' ');
    preProcessedHeaders.split(/\r?\n/).forEach(function(line) {
      var parts = line.split(':');
      var key = parts.shift().trim();
      if (key) {
        var value = parts.join(':').trim();
        headers.append(key, value);
      }
    });
    return headers
  }

  Body.call(Request.prototype);

  function Response(bodyInit, options) {
    if (!options) {
      options = {};
    }

    this.type = 'default';
    this.status = options.status === undefined ? 200 : options.status;
    this.ok = this.status >= 200 && this.status < 300;
    this.statusText = 'statusText' in options ? options.statusText : 'OK';
    this.headers = new Headers(options.headers);
    this.url = options.url || '';
    this._initBody(bodyInit);
  }

  Body.call(Response.prototype);

  Response.prototype.clone = function() {
    return new Response(this._bodyInit, {
      status: this.status,
      statusText: this.statusText,
      headers: new Headers(this.headers),
      url: this.url
    })
  };

  Response.error = function() {
    var response = new Response(null, {status: 0, statusText: ''});
    response.type = 'error';
    return response
  };

  var redirectStatuses = [301, 302, 303, 307, 308];

  Response.redirect = function(url, status) {
    if (redirectStatuses.indexOf(status) === -1) {
      throw new RangeError('Invalid status code')
    }

    return new Response(null, {status: status, headers: {location: url}})
  };

  exports.DOMException = self.DOMException;
  try {
    new exports.DOMException();
  } catch (err) {
    exports.DOMException = function(message, name) {
      this.message = message;
      this.name = name;
      var error = Error(message);
      this.stack = error.stack;
    };
    exports.DOMException.prototype = Object.create(Error.prototype);
    exports.DOMException.prototype.constructor = exports.DOMException;
  }

  function fetch(input, init) {
    return new Promise(function(resolve, reject) {
      var request = new Request(input, init);

      if (request.signal && request.signal.aborted) {
        return reject(new exports.DOMException('Aborted', 'AbortError'))
      }

      var xhr = new XMLHttpRequest();

      function abortXhr() {
        xhr.abort();
      }

      xhr.onload = function() {
        var options = {
          status: xhr.status,
          statusText: xhr.statusText,
          headers: parseHeaders(xhr.getAllResponseHeaders() || '')
        };
        options.url = 'responseURL' in xhr ? xhr.responseURL : options.headers.get('X-Request-URL');
        var body = 'response' in xhr ? xhr.response : xhr.responseText;
        resolve(new Response(body, options));
      };

      xhr.onerror = function() {
        reject(new TypeError('Network request failed'));
      };

      xhr.ontimeout = function() {
        reject(new TypeError('Network request failed'));
      };

      xhr.onabort = function() {
        reject(new exports.DOMException('Aborted', 'AbortError'));
      };

      xhr.open(request.method, request.url, true);

      if (request.credentials === 'include') {
        xhr.withCredentials = true;
      } else if (request.credentials === 'omit') {
        xhr.withCredentials = false;
      }

      if ('responseType' in xhr && support.blob) {
        xhr.responseType = 'blob';
      }

      request.headers.forEach(function(value, name) {
        xhr.setRequestHeader(name, value);
      });

      if (request.signal) {
        request.signal.addEventListener('abort', abortXhr);

        xhr.onreadystatechange = function() {
          // DONE (success or failure)
          if (xhr.readyState === 4) {
            request.signal.removeEventListener('abort', abortXhr);
          }
        };
      }

      xhr.send(typeof request._bodyInit === 'undefined' ? null : request._bodyInit);
    })
  }

  fetch.polyfill = true;

  if (!self.fetch) {
    self.fetch = fetch;
    self.Headers = Headers;
    self.Request = Request;
    self.Response = Response;
  }

  exports.Headers = Headers;
  exports.Request = Request;
  exports.Response = Response;
  exports.fetch = fetch;

  Object.defineProperty(exports, '__esModule', { value: true });

  return exports;

}({}));
})(__self__);
__self__.fetch.ponyfill = true;
// Remove "polyfill" property added by whatwg-fetch
delete __self__.fetch.polyfill;
// Choose between native implementation (global) or custom implementation (__self__)
// var ctx = global.fetch ? global : __self__;
var ctx = __self__; // this line disable service worker support temporarily
exports = ctx.fetch // To enable: import fetch from 'cross-fetch'
exports.default = ctx.fetch // For TypeScript consumers without esModuleInterop.
exports.fetch = ctx.fetch // To enable: import {fetch} from 'cross-fetch'
exports.Headers = ctx.Headers
exports.Request = ctx.Request
exports.Response = ctx.Response
module.exports = exports


/***/ }),

/***/ "./src/AdminLevel.ts":
/*!***************************!*\
  !*** ./src/AdminLevel.ts ***!
  \***************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "ADMIN_LEVEL_CODES": () => (/* binding */ ADMIN_LEVEL_CODES),
/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
// eslint-disable-next-line no-shadow
var ADMIN_LEVEL_CODES;
(function (ADMIN_LEVEL_CODES) {
    ADMIN_LEVEL_CODES[ADMIN_LEVEL_CODES["STATE_CODE"] = 1] = "STATE_CODE";
    ADMIN_LEVEL_CODES[ADMIN_LEVEL_CODES["COUNTY_CODE"] = 2] = "COUNTY_CODE";
})(ADMIN_LEVEL_CODES || (ADMIN_LEVEL_CODES = {}));
var AdminLevel = /** @class */ (function () {
    function AdminLevel(_a) {
        var level = _a.level, name = _a.name, code = _a.code;
        this.level = level;
        this.name = name;
        this.code = code;
    }
    AdminLevel.create = function (object) {
        return new this(object);
    };
    AdminLevel.prototype.toObject = function () {
        return {
            level: this.level,
            name: this.name,
            code: this.code,
        };
    };
    AdminLevel.prototype.getLevel = function () {
        return this.level;
    };
    AdminLevel.prototype.getName = function () {
        return this.name;
    };
    AdminLevel.prototype.getCode = function () {
        return this.code;
    };
    return AdminLevel;
}());
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (AdminLevel);


/***/ }),

/***/ "./src/ExternalLoader.ts":
/*!*******************************!*\
  !*** ./src/ExternalLoader.ts ***!
  \*******************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var cross_fetch__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! cross-fetch */ "./node_modules/cross-fetch/dist/browser-ponyfill.js");
/* harmony import */ var cross_fetch__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(cross_fetch__WEBPACK_IMPORTED_MODULE_0__);
/* harmony import */ var _error__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./error */ "./src/error/ResponseError.ts");
/* harmony import */ var _utils__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./utils */ "./src/utils.ts");
var __assign = (undefined && undefined.__assign) || function () {
    __assign = Object.assign || function(t) {
        for (var s, i = 1, n = arguments.length; i < n; i++) {
            s = arguments[i];
            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
                t[p] = s[p];
        }
        return t;
    };
    return __assign.apply(this, arguments);
};
var __rest = (undefined && undefined.__rest) || function (s, e) {
    var t = {};
    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
        t[p] = s[p];
    if (s != null && typeof Object.getOwnPropertySymbols === "function")
        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
                t[p[i]] = s[p[i]];
        }
    return t;
};



var defaultOptions = {
    protocol: "http",
    method: "GET",
};
/**
 * Load data from external geocoding engines.
 */
var ExternalLoader = /** @class */ (function () {
    function ExternalLoader(options) {
        if (options === void 0) { options = defaultOptions; }
        this.options = defaultOptions;
        this.setOptions(options);
    }
    ExternalLoader.prototype.setOptions = function (options) {
        this.options = __assign(__assign({}, defaultOptions), options);
    };
    ExternalLoader.prototype.getOptions = function () {
        return this.options;
    };
    ExternalLoader.prototype.executeRequest = function (params, callback, externalLoaderHeaders, body, errorCallback) {
        var _a = this.options, protocol = _a.protocol, host = _a.host, pathname = _a.pathname, method = _a.method;
        if (!host) {
            throw new Error("A host is required for the external loader.");
        }
        if (!pathname) {
            throw new Error("A pathname is required for the external loader.");
        }
        var requestUrl = new URL(protocol + "://" + host + "/" + pathname);
        var jsonpCallback = params.jsonpCallback, requestParams = __rest(params, ["jsonpCallback"]);
        var filteredRequestParams = (0,_utils__WEBPACK_IMPORTED_MODULE_1__.filterUndefinedObjectValues)(requestParams);
        Object.keys(filteredRequestParams).forEach(function (paramKey) {
            var _a;
            return requestUrl.searchParams.append(paramKey, (_a = filteredRequestParams[paramKey]) !== null && _a !== void 0 ? _a : "");
        });
        if (jsonpCallback) {
            ExternalLoader.runJsonpCallback(requestUrl, callback, jsonpCallback);
            return;
        }
        var headers = (0,_utils__WEBPACK_IMPORTED_MODULE_1__.filterUndefinedObjectValues)(externalLoaderHeaders || {});
        cross_fetch__WEBPACK_IMPORTED_MODULE_0___default()(requestUrl.toString(), {
            headers: headers,
            method: method,
            body: method === "POST" ? JSON.stringify(body) : undefined,
        })
            .then(function (response) {
            if (!response.ok) {
                throw new _error__WEBPACK_IMPORTED_MODULE_2__.default("Received HTTP status code " + response.status + " when attempting geocoding request.", response);
            }
            return response.json();
        })
            // eslint-disable-next-line @typescript-eslint/no-explicit-any
            .then(function (data) { return callback(data); })
            .catch(function (error) {
            if (errorCallback && error instanceof _error__WEBPACK_IMPORTED_MODULE_2__.default) {
                errorCallback(error);
                return;
            }
            setTimeout(function () {
                throw error;
            });
        });
    };
    ExternalLoader.runJsonpCallback = function (requestUrl, callback, jsonpCallback) {
        if (!(0,_utils__WEBPACK_IMPORTED_MODULE_1__.isBrowser)()) {
            throw new Error('"jsonpCallback" parameter can only be used in a browser environment.');
        }
        requestUrl.searchParams.append(jsonpCallback, ExternalLoader.generateJsonpCallback(callback));
        // Create a new script element.
        var scriptElement = document.createElement("script");
        // Set its source to the JSONP API.
        scriptElement.src = requestUrl.toString();
        // Stick the script element in the page <head>.
        document.getElementsByTagName("head")[0].appendChild(scriptElement);
    };
    /**
     * Generates randomly-named function to use as a callback for JSONP requests.
     * @see https://github.com/OscarGodson/JSONP
     */
    ExternalLoader.generateJsonpCallback = function (callback) {
        // Use timestamp + a random factor to account for a lot of requests in a short time.
        // e.g. jsonp1394571775161.
        var timestamp = Date.now();
        var generatedFunction = "jsonp" + Math.round(timestamp + Math.random() * 1000001);
        // Generate the temp JSONP function using the name above.
        // First, call the function the user defined in the callback param [callback(json)].
        // Then delete the generated function from the window [delete window[generatedFunction]].
        // eslint-disable-next-line @typescript-eslint/no-explicit-any
        window[generatedFunction] = function (json) {
            callback(json);
            // eslint-disable-next-line @typescript-eslint/no-explicit-any
            delete window[generatedFunction];
        };
        return generatedFunction;
    };
    return ExternalLoader;
}());
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (ExternalLoader);


/***/ }),

/***/ "./src/GeoJsonDumper.ts":
/*!******************************!*\
  !*** ./src/GeoJsonDumper.ts ***!
  \******************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
var __assign = (undefined && undefined.__assign) || function () {
    __assign = Object.assign || function(t) {
        for (var s, i = 1, n = arguments.length; i < n; i++) {
            s = arguments[i];
            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
                t[p] = s[p];
        }
        return t;
    };
    return __assign.apply(this, arguments);
};
var __rest = (undefined && undefined.__rest) || function (s, e) {
    var t = {};
    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
        t[p] = s[p];
    if (s != null && typeof Object.getOwnPropertySymbols === "function")
        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
                t[p[i]] = s[p[i]];
        }
    return t;
};
var GeoJsonDumper = /** @class */ (function () {
    function GeoJsonDumper() {
    }
    GeoJsonDumper.dump = function (geocoded) {
        var result = GeoJsonDumper.baseGeoJson;
        var _a = geocoded.toObject(), coordinates = _a.coordinates, bounds = _a.bounds, adminLevels = _a.adminLevels, geocodedProperties = __rest(_a, ["coordinates", "bounds", "adminLevels"]);
        var properties = __assign({}, geocodedProperties);
        Object.keys(properties).forEach(function (property) {
            return properties[property] === undefined && delete properties[property];
        });
        if (adminLevels && adminLevels.length > 0) {
            properties = __assign(__assign({}, properties), { adminLevels: adminLevels.map(function (adminLevel) { return adminLevel.toObject(); }) });
        }
        result = __assign(__assign({}, result), { properties: properties });
        if (coordinates) {
            result = __assign(__assign({}, result), {
                geometry: __assign(__assign({}, result.geometry), { type: "Point", coordinates: [
                        parseFloat(coordinates.longitude.toString()),
                        parseFloat(coordinates.latitude.toString()),
                    ] }),
            });
        }
        if (bounds) {
            result = __assign(__assign({}, result), { bbox: [
                    parseFloat(bounds.longitudeSW.toString()),
                    parseFloat(bounds.latitudeSW.toString()),
                    parseFloat(bounds.longitudeNE.toString()),
                    parseFloat(bounds.latitudeNE.toString()),
                ] });
        }
        return result;
    };
    GeoJsonDumper.baseGeoJson = {
        type: "Feature",
        properties: {},
        geometry: {
            type: "Point",
            coordinates: [0, 0],
        },
    };
    return GeoJsonDumper;
}());
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (GeoJsonDumper);


/***/ }),

/***/ "./src/Geocoded.ts":
/*!*************************!*\
  !*** ./src/Geocoded.ts ***!
  \*************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
var __assign = (undefined && undefined.__assign) || function () {
    __assign = Object.assign || function(t) {
        for (var s, i = 1, n = arguments.length; i < n; i++) {
            s = arguments[i];
            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
                t[p] = s[p];
        }
        return t;
    };
    return __assign.apply(this, arguments);
};
var Geocoded = /** @class */ (function () {
    function Geocoded(_a) {
        var coordinates = _a.coordinates, bounds = _a.bounds, formattedAddress = _a.formattedAddress, streetNumber = _a.streetNumber, streetName = _a.streetName, subLocality = _a.subLocality, locality = _a.locality, postalCode = _a.postalCode, region = _a.region, adminLevels = _a.adminLevels, country = _a.country, countryCode = _a.countryCode, timezone = _a.timezone;
        this.coordinates = coordinates;
        this.bounds = bounds;
        this.formattedAddress = formattedAddress;
        this.streetNumber = streetNumber;
        this.streetName = streetName;
        this.subLocality = subLocality;
        this.locality = locality;
        this.postalCode = postalCode;
        this.region = region;
        this.adminLevels = adminLevels || [];
        this.country = country;
        this.countryCode = countryCode;
        this.timezone = timezone;
    }
    Geocoded.create = function (object) {
        return new this(object);
    };
    Geocoded.prototype.toObject = function () {
        return {
            coordinates: this.coordinates,
            bounds: this.bounds,
            formattedAddress: this.formattedAddress,
            streetNumber: this.streetNumber,
            streetName: this.streetName,
            subLocality: this.subLocality,
            locality: this.locality,
            postalCode: this.postalCode,
            region: this.region,
            adminLevels: this.adminLevels,
            country: this.country,
            countryCode: this.countryCode,
            timezone: this.timezone,
        };
    };
    Geocoded.prototype.withBounds = function (bounds) {
        return this.constructor.create(__assign(__assign({}, this.toObject()), { bounds: bounds }));
    };
    Geocoded.prototype.withCoordinates = function (coordinates) {
        return this.constructor.create(__assign(__assign({}, this.toObject()), { coordinates: coordinates }));
    };
    Geocoded.prototype.getCoordinates = function () {
        return this.coordinates;
    };
    Geocoded.prototype.getBounds = function () {
        return this.bounds;
    };
    Geocoded.prototype.getFormattedAddress = function () {
        return this.formattedAddress;
    };
    Geocoded.prototype.getStreetNumber = function () {
        return this.streetNumber;
    };
    Geocoded.prototype.getStreetName = function () {
        return this.streetName;
    };
    Geocoded.prototype.getSubLocality = function () {
        return this.subLocality;
    };
    Geocoded.prototype.getLocality = function () {
        return this.locality;
    };
    Geocoded.prototype.getPostalCode = function () {
        return this.postalCode;
    };
    Geocoded.prototype.getRegion = function () {
        return this.region;
    };
    Geocoded.prototype.addAdminLevel = function (adminLevel) {
        this.adminLevels.push(adminLevel);
    };
    Geocoded.prototype.getAdminLevels = function () {
        return this.adminLevels;
    };
    Geocoded.prototype.getCountry = function () {
        return this.country;
    };
    Geocoded.prototype.getCountryCode = function () {
        return this.countryCode;
    };
    Geocoded.prototype.getTimezone = function () {
        return this.timezone;
    };
    return Geocoded;
}());
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (Geocoded);


/***/ }),

/***/ "./src/GeocoderProviderFactory.ts":
/*!****************************************!*\
  !*** ./src/GeocoderProviderFactory.ts ***!
  \****************************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var _provider__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./provider */ "./src/provider/ProviderInterface.ts");
/* harmony import */ var _provider__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./provider */ "./src/provider/bing/BingProvider.ts");
/* harmony import */ var _provider__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./provider */ "./src/provider/ChainProvider.ts");
/* harmony import */ var _provider__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./provider */ "./src/provider/geoplugin/GeoPluginProvider.ts");
/* harmony import */ var _provider__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./provider */ "./src/provider/googlemaps/GoogleMapsProvider.ts");
/* harmony import */ var _provider__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./provider */ "./src/provider/locationiq/LocationIQProvider.ts");
/* harmony import */ var _provider__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./provider */ "./src/provider/mapbox/MapboxProvider.ts");
/* harmony import */ var _provider__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./provider */ "./src/provider/mapquest/MapQuestProvider.ts");
/* harmony import */ var _provider__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./provider */ "./src/provider/nominatim/NominatimProvider.ts");
/* harmony import */ var _provider__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ./provider */ "./src/provider/opencage/OpenCageProvider.ts");
/* harmony import */ var _provider__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ./provider */ "./src/provider/yandex/YandexProvider.ts");
/* harmony import */ var _ExternalLoader__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./ExternalLoader */ "./src/ExternalLoader.ts");
var __assign = (undefined && undefined.__assign) || function () {
    __assign = Object.assign || function(t) {
        for (var s, i = 1, n = arguments.length; i < n; i++) {
            s = arguments[i];
            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
                t[p] = s[p];
        }
        return t;
    };
    return __assign.apply(this, arguments);
};
var __rest = (undefined && undefined.__rest) || function (s, e) {
    var t = {};
    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
        t[p] = s[p];
    if (s != null && typeof Object.getOwnPropertySymbols === "function")
        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
                t[p[i]] = s[p[i]];
        }
    return t;
};


var ProviderFactory = /** @class */ (function () {
    function ProviderFactory() {
    }
    /**
     * Creates Geocoder Provider instances.
     * @param options
     *   Either a string representing the registered provider, or an object with the
     *   following settings for instigating providers:
     *     - provider: A string representing the registered provider.
     * @return
     *   An object compatible with ProviderInterface, or undefined if there's not a
     *   registered provider.
     */
    ProviderFactory.createProvider = function (options) {
        var createProviderOptions = __assign(__assign({}, _provider__WEBPACK_IMPORTED_MODULE_0__.defaultProviderOptions), (typeof options === "string" ? { provider: options } : options));
        var externalLoader = new _ExternalLoader__WEBPACK_IMPORTED_MODULE_1__.default();
        var provider = createProviderOptions.provider, providerOptions = __rest(createProviderOptions, ["provider"]);
        switch (provider) {
            case "bing":
            case "bingmaps":
            case "microsoft":
                return new _provider__WEBPACK_IMPORTED_MODULE_2__.default(externalLoader, __assign(__assign({}, _provider__WEBPACK_IMPORTED_MODULE_2__.defaultBingProviderOptions), providerOptions));
            case "chain":
                return new _provider__WEBPACK_IMPORTED_MODULE_3__.default(__assign(__assign({}, _provider__WEBPACK_IMPORTED_MODULE_3__.defaultChainProviderOptions), providerOptions));
            case "geoplugin":
                return new _provider__WEBPACK_IMPORTED_MODULE_4__.default(externalLoader, providerOptions);
            case "google":
            case "googlemaps":
                return new _provider__WEBPACK_IMPORTED_MODULE_5__.default(externalLoader, providerOptions);
            case "locationiq":
                return new _provider__WEBPACK_IMPORTED_MODULE_6__.default(externalLoader, __assign(__assign({}, _provider__WEBPACK_IMPORTED_MODULE_6__.defaultLocationIQProviderOptions), providerOptions));
            case "mapbox":
                return new _provider__WEBPACK_IMPORTED_MODULE_7__.default(externalLoader, __assign(__assign({}, _provider__WEBPACK_IMPORTED_MODULE_7__.defaultMapboxProviderOptions), providerOptions));
            case "mapquest":
                return new _provider__WEBPACK_IMPORTED_MODULE_8__.default(externalLoader, __assign(__assign({}, _provider__WEBPACK_IMPORTED_MODULE_8__.defaultMapQuestProviderOptions), providerOptions));
            case "openstreetmap":
            case "nominatim":
                return new _provider__WEBPACK_IMPORTED_MODULE_9__.default(externalLoader, __assign(__assign({}, _provider__WEBPACK_IMPORTED_MODULE_9__.defaultNominatimProviderOptions), providerOptions));
            case "opencage":
                return new _provider__WEBPACK_IMPORTED_MODULE_10__.default(externalLoader, __assign(__assign({}, _provider__WEBPACK_IMPORTED_MODULE_10__.defaultOpenCageProviderOptions), providerOptions));
            case "yandex":
                return new _provider__WEBPACK_IMPORTED_MODULE_11__.default(externalLoader, __assign(__assign({}, _provider__WEBPACK_IMPORTED_MODULE_11__.defaultYandexProviderOptions), providerOptions));
            default:
        }
        return undefined;
    };
    return ProviderFactory;
}());
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (ProviderFactory);


/***/ }),

/***/ "./src/UniversalGeocoder.ts":
/*!**********************************!*\
  !*** ./src/UniversalGeocoder.ts ***!
  \**********************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var _GeocoderProviderFactory__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./GeocoderProviderFactory */ "./src/GeocoderProviderFactory.ts");

var UniversalGeocoder = /** @class */ (function () {
    function UniversalGeocoder() {
        this.version = "0.1.0";
    }
    UniversalGeocoder.createGeocoder = function (options) {
        return _GeocoderProviderFactory__WEBPACK_IMPORTED_MODULE_0__.default.createProvider(options);
    };
    return UniversalGeocoder;
}());
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (UniversalGeocoder);


/***/ }),

/***/ "./src/error/ResponseError.ts":
/*!************************************!*\
  !*** ./src/error/ResponseError.ts ***!
  \************************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
var __extends = (undefined && undefined.__extends) || (function () {
    var extendStatics = function (d, b) {
        extendStatics = Object.setPrototypeOf ||
            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
        return extendStatics(d, b);
    };
    return function (d, b) {
        if (typeof b !== "function" && b !== null)
            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    };
})();
var ResponseError = /** @class */ (function (_super) {
    __extends(ResponseError, _super);
    function ResponseError(message, response) {
        var _this = _super.call(this, message) || this;
        _this.name = "ResponseError";
        _this.response = response;
        // eslint-disable-next-line no-proto
        _this.__proto__ = ResponseError.prototype;
        return _this;
    }
    ResponseError.prototype.getResponse = function () {
        return this.response;
    };
    return ResponseError;
}(Error));
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (ResponseError);


/***/ }),

/***/ "./src/provider/ChainProvider.ts":
/*!***************************************!*\
  !*** ./src/provider/ChainProvider.ts ***!
  \***************************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "defaultChainProviderOptions": () => (/* binding */ defaultChainProviderOptions),
/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var ___WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ */ "./src/provider/ProviderInterface.ts");
/* harmony import */ var ___WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./ */ "./src/provider/ProviderHelpers.ts");
var __assign = (undefined && undefined.__assign) || function () {
    __assign = Object.assign || function(t) {
        for (var s, i = 1, n = arguments.length; i < n; i++) {
            s = arguments[i];
            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
                t[p] = s[p];
        }
        return t;
    };
    return __assign.apply(this, arguments);
};

var defaultChainProviderOptions = __assign(__assign({}, ___WEBPACK_IMPORTED_MODULE_0__.defaultProviderOptions), { providers: [] });
var ChainProvider = /** @class */ (function () {
    function ChainProvider(options) {
        if (options === void 0) { options = defaultChainProviderOptions; }
        this.options = options;
    }
    ChainProvider.prototype.geocode = function (query, callback, errorCallback) {
        var _this = this;
        if (this.options.parallelize || this.options.first) {
            if (!callback) {
                return new Promise(function (resolve, reject) {
                    return _this.geocodeAllProviders(query, function (results) { return resolve(results); }, function (error) { return reject(error); });
                });
            }
            return this.geocodeAllProviders(query, callback, errorCallback);
        }
        if (!callback) {
            return new Promise(function (resolve, reject) {
                return _this.geocodeNextProvider(_this.options.providers, query, function (results) { return resolve(results); }, function (error) { return reject(error); });
            });
        }
        return this.geocodeNextProvider(this.options.providers, query, callback, errorCallback);
    };
    ChainProvider.prototype.geodecode = function (latitudeOrQuery, longitudeOrCallback, callbackOrErrorCallback, errorCallback) {
        var _this = this;
        var reverseQuery = ___WEBPACK_IMPORTED_MODULE_1__.default.getReverseQueryFromParameters(latitudeOrQuery, longitudeOrCallback);
        var reverseCallback = ___WEBPACK_IMPORTED_MODULE_1__.default.getCallbackFromParameters(longitudeOrCallback, callbackOrErrorCallback);
        var reverseErrorCallback = ___WEBPACK_IMPORTED_MODULE_1__.default.getErrorCallbackFromParameters(longitudeOrCallback, callbackOrErrorCallback, errorCallback);
        if (this.options.parallelize || this.options.first) {
            if (!reverseCallback) {
                return new Promise(function (resolve, reject) {
                    return _this.geodecodeAllProviders(reverseQuery, function (results) { return resolve(results); }, function (error) { return reject(error); });
                });
            }
            return this.geodecodeAllProviders(reverseQuery, reverseCallback, reverseErrorCallback);
        }
        if (!reverseCallback) {
            return new Promise(function (resolve, reject) {
                return _this.geodecodeNextProvider(_this.options.providers, reverseQuery, function (results) { return resolve(results); }, function (error) { return reject(error); });
            });
        }
        return this.geodecodeNextProvider(this.options.providers, reverseQuery, reverseCallback, reverseErrorCallback);
    };
    ChainProvider.prototype.geocodeNextProvider = function (providers, query, callback, errorCallback) {
        var _this = this;
        var provider = providers[0], nextProviders = providers.slice(1);
        var resultCallback = function (results) {
            if (results.length > 0) {
                callback(results);
                return;
            }
            _this.geocodeNextProvider(nextProviders, query, callback, errorCallback);
        };
        var resultErrorCallback = function (responseError) {
            if (errorCallback) {
                errorCallback(responseError);
            }
            if (!errorCallback) {
                // eslint-disable-next-line no-console
                console.error("An error has occurred when geocoding with the provider " + provider.constructor.name, responseError);
            }
            resultCallback([]);
        };
        provider.geocode(query, resultCallback, resultErrorCallback);
    };
    ChainProvider.prototype.geodecodeNextProvider = function (providers, reverseQuery, callback, errorCallback) {
        var _this = this;
        var provider = providers[0], nextProviders = providers.slice(1);
        var resultCallback = function (results) {
            if (results.length > 0) {
                callback(results);
                return;
            }
            _this.geodecodeNextProvider(nextProviders, reverseQuery, callback, errorCallback);
        };
        var resultErrorCallback = function (responseError) {
            if (errorCallback) {
                errorCallback(responseError);
            }
            if (!errorCallback) {
                // eslint-disable-next-line no-console
                console.error("An error has occurred when geodecoding with the provider " + provider.constructor.name, responseError);
            }
            resultCallback([]);
        };
        provider.geodecode(reverseQuery, resultCallback, resultErrorCallback);
    };
    ChainProvider.prototype.geocodeAllProviders = function (query, callback, errorCallback) {
        var _this = this;
        var providerResults = new Map();
        var callbackCalled = false;
        var getProviderResult = function () {
            return _this.options.providers.reduce(function (result, provider) {
                var providerResult = result;
                if (undefined === providerResult && _this.options.first) {
                    providerResult = [];
                }
                if (undefined === providerResult) {
                    return undefined;
                }
                if (providerResult.length > 0) {
                    return providerResult;
                }
                return providerResults.get(provider.constructor.name);
            }, []);
        };
        var resultProviderCallback = function (providerName) { return function (results) {
            providerResults.set(providerName, results);
            var providerResult = getProviderResult();
            if (!callbackCalled && providerResult) {
                callback(providerResult);
                callbackCalled = true;
            }
        }; };
        var resultProviderErrorCallback = function (providerName) { return function (responseError) {
            if (errorCallback) {
                errorCallback(responseError);
            }
            if (!errorCallback) {
                // eslint-disable-next-line no-console
                console.error("An error has occurred when geocoding with the provider " + providerName, responseError);
            }
            resultProviderCallback(providerName)([]);
        }; };
        this.options.providers.forEach(function (provider) {
            var providerName = provider.constructor.name;
            provider.geocode(query, resultProviderCallback(providerName), resultProviderErrorCallback(providerName));
        });
    };
    ChainProvider.prototype.geodecodeAllProviders = function (reverseQuery, callback, errorCallback) {
        var _this = this;
        var providerResults = new Map();
        var callbackCalled = false;
        var getProviderResult = function () {
            return _this.options.providers.reduce(function (result, provider) {
                var providerResult = result;
                if (undefined === providerResult && _this.options.first) {
                    providerResult = [];
                }
                if (undefined === providerResult) {
                    return undefined;
                }
                if (providerResult.length > 0) {
                    return providerResult;
                }
                return providerResults.get(provider.constructor.name);
            }, []);
        };
        var resultProviderCallback = function (providerName) { return function (results) {
            providerResults.set(providerName, results);