radar-sdk-js 4.2.0-beta.0 → 4.2.0-beta.3

package/dist/radar.js

@@ -0,0 +1,2248 @@
+import maplibregl from 'maplibre-gl';
+
+class Config {
+    static setup(options = {}) {
+        Config.options = options;
+    }
+    static get() {
+        return Config.options || {};
+    }
+    static clear() {
+        Config.options = {};
+    }
+}
+Config.defaultOptions = {
+    live: false,
+    logLevel: 'error',
+    host: 'https://api.radar.io',
+    version: 'v1',
+    debug: false,
+};
+
+const LOG_LEVELS = {
+    none: 0,
+    error: 1,
+    warn: 2,
+    info: 3,
+    debug: 4,
+};
+// get the numeric level for logLevel option
+const getLevel = () => {
+    // disable logging in tests
+    if (window && window.RADAR_TEST_ENV) {
+        return LOG_LEVELS.none;
+    }
+    const { logLevel, debug } = Config.get();
+    if (debug) {
+        return LOG_LEVELS.debug;
+    }
+    if (logLevel) {
+        return LOG_LEVELS[logLevel];
+    }
+    return LOG_LEVELS.error; // default to error-level logging if not set
+};
+class Logger {
+    static debug(message) {
+        if (getLevel() === LOG_LEVELS.debug) {
+            console.log(`Radar SDK (debug): ${message.trim()}`);
+        }
+    }
+    static info(message) {
+        if (getLevel() >= LOG_LEVELS.info) {
+            console.log(`Radar SDK: ${message.trim()}`);
+        }
+    }
+    static warn(message) {
+        if (getLevel() >= LOG_LEVELS.warn) {
+            console.warn(`Radar SDK: ${message.trim()}`);
+        }
+    }
+    static error(message) {
+        if (getLevel() >= LOG_LEVELS.error) {
+            console.error(`Radar SDK: ${message.trim()}`);
+        }
+    }
+}
+
+class Storage {
+    // local storage key definitions for identifying track users
+    static get USER_ID() {
+        return 'radar-userId';
+    }
+    static get DEVICE_ID() {
+        return 'radar-deviceId';
+    }
+    static get INSTALL_ID() {
+        return 'radar-installId';
+    }
+    static get SESSION_ID() {
+        return 'radar-sessionId';
+    }
+    static get DESCRIPTION() {
+        return 'radar-description';
+    }
+    static get METADATA() {
+        return 'radar-metadata';
+    }
+    static get CACHED_LOCATION() {
+        return 'radar-cached-location';
+    }
+    static get TRIP_OPTIONS() {
+        return 'radar-trip-options';
+    }
+    static getStorage() {
+        const storage = window === null || window === void 0 ? void 0 : window.localStorage;
+        if (!storage) {
+            Logger.warn('localStorage not available.');
+        }
+        return storage;
+    }
+    static setItem(key, value) {
+        const storage = this.getStorage();
+        if (!storage) {
+            return;
+        }
+        if (value === undefined || value === null) {
+            return;
+        }
+        storage.setItem(key, value);
+    }
+    static getItem(key) {
+        const storage = this.getStorage();
+        if (!storage) {
+            return null;
+        }
+        const value = storage.getItem(key);
+        if (value !== undefined && value !== null) {
+            return value;
+        }
+        return null;
+    }
+    static getJSON(key) {
+        const item = this.getItem(key);
+        if (!item) {
+            return null;
+        }
+        try {
+            return JSON.parse(item);
+        }
+        catch (err) {
+            Logger.warn(`could not getJSON from storage for key: ${key}`);
+            return null;
+        }
+    }
+    static removeItem(key) {
+        const storage = this.getStorage();
+        if (!storage) {
+            return null;
+        }
+        storage.removeItem(key);
+    }
+    static clear() {
+        const storage = this.getStorage();
+        if (!storage) {
+            return null;
+        }
+        storage.clear();
+    }
+}
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise */
+
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+class RadarError extends Error {
+    constructor(message) {
+        super(message);
+        this.status = ''; // to be overridden (support for legacy status)
+    }
+}
+class RadarPublishableKeyError extends RadarError {
+    constructor(message) {
+        super(message);
+        this.name = 'RadarPublishableKeyError';
+        this.status = 'ERROR_PUBLISHABLE_KEY';
+    }
+}
+class RadarLocationError extends RadarError {
+    constructor(message) {
+        super(message);
+        this.name = 'RadarLocationError';
+        this.status = 'ERROR_LOCATION';
+    }
+}
+class RadarLocationPermissionsError extends RadarError {
+    constructor(message) {
+        super(message);
+        this.name = 'RadarLocationPermissionsError';
+        this.status = 'ERROR_PERMISSIONS';
+    }
+}
+class RadarDesktopAppError extends RadarError {
+    constructor() {
+        super('Desktop app not running.');
+        this.name = 'RadarDesktopAppError';
+        this.status = 'ERROR_DESKTOP_APP';
+    }
+}
+// HTTP Errors
+class RadarBadRequestError extends RadarError {
+    constructor(response) {
+        var _a;
+        super(((_a = response === null || response === void 0 ? void 0 : response.meta) === null || _a === void 0 ? void 0 : _a.message) || 'Bad request.');
+        this.name = 'RadarBadRequestError';
+        this.code = 400;
+        this.response = response;
+        this.status = 'ERROR_BAD_REQUEST';
+    }
+}
+class RadarUnauthorizedError extends RadarError {
+    constructor(response) {
+        var _a;
+        super(((_a = response === null || response === void 0 ? void 0 : response.meta) === null || _a === void 0 ? void 0 : _a.message) || 'Unauthorized.');
+        this.name = 'RadarUnauthorizedError';
+        this.code = 401;
+        this.response = response;
+        this.status = 'ERROR_UNAUTHORIZED';
+    }
+}
+class RadarPaymentRequiredError extends RadarError {
+    constructor(response) {
+        var _a;
+        super(((_a = response === null || response === void 0 ? void 0 : response.meta) === null || _a === void 0 ? void 0 : _a.message) || 'Payment required.');
+        this.name = 'RadarPaymentRequiredError';
+        this.code = 402;
+        this.response = response;
+        this.status = 'ERROR_PAYMENT_REQUIRED';
+    }
+}
+class RadarForbiddenError extends RadarError {
+    constructor(response) {
+        var _a;
+        super(((_a = response === null || response === void 0 ? void 0 : response.meta) === null || _a === void 0 ? void 0 : _a.message) || 'Forbidden.');
+        this.name = 'RadarForbiddenError';
+        this.code = 403;
+        this.response = response;
+        this.status = 'ERROR_FORBIDDEN';
+    }
+}
+class RadarNotFoundError extends RadarError {
+    constructor(response) {
+        var _a;
+        super(((_a = response === null || response === void 0 ? void 0 : response.meta) === null || _a === void 0 ? void 0 : _a.message) || 'Not found.');
+        this.name = 'RadarNotFoundError';
+        this.code = 404;
+        this.response = response;
+        this.status = 'ERROR_NOT_FOUND';
+    }
+}
+class RadarRateLimitError extends RadarError {
+    constructor(response) {
+        var _a, _b;
+        super(((_a = response === null || response === void 0 ? void 0 : response.meta) === null || _a === void 0 ? void 0 : _a.message) || 'Rate limit exceeded.');
+        this.name = 'RadarRateLimitError';
+        this.code = 429;
+        this.response = response;
+        this.type = (_b = response === null || response === void 0 ? void 0 : response.meta) === null || _b === void 0 ? void 0 : _b.type;
+        this.status = 'ERROR_RATE_LIMIT';
+    }
+}
+class RadarServerError extends RadarError {
+    constructor(response) {
+        var _a;
+        super(((_a = response === null || response === void 0 ? void 0 : response.meta) === null || _a === void 0 ? void 0 : _a.message) || 'Internal server error.');
+        this.name = 'RadarServerError';
+        this.response = response;
+        this.status = 'ERROR_SERVER';
+    }
+}
+class RadarTimeoutError extends RadarError {
+    constructor() {
+        super('Request timed out.');
+        this.name = 'RadarTimeoutError';
+        this.status = 'ERROR_TIMED_OUT';
+    }
+}
+class RadarUnknownError extends RadarError {
+    constructor(response) {
+        var _a;
+        super(((_a = response === null || response === void 0 ? void 0 : response.meta) === null || _a === void 0 ? void 0 : _a.message) || 'Something went wrong.');
+        this.name = 'RadarUnknownError';
+        this.response = response;
+        this.status = 'ERROR_UNKNOWN';
+    }
+}
+class RadarAutocompleteContainerNotFound extends RadarError {
+    constructor(message) {
+        super(message);
+        this.name = 'RadarAutocompleteContainerNotFound';
+        this.status = 'CONTAINER_NOT_FOUND';
+    }
+}
+
+// https://developer.mozilla.org/en-US/docs/Web/API/GeolocationPositionError
+const PERMISSION_ERROR_MESSAGES = {
+    1: 'Permission denied.',
+    2: 'Position unavailable.',
+    3: 'Timeout.',
+};
+const DEFAULT_POSITION_OPTIONS = {
+    maximumAge: 0,
+    timeout: 1000 * 30,
+    enableHighAccuracy: true,
+};
+// set "enableHighAccuracy" for navigator only when desiredAccuracy is "high"
+const useHighAccuracy = (desiredAccuracy) => (Boolean(desiredAccuracy === 'high'));
+class Navigator {
+    static getCurrentPosition(overrides = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const options = Config.get();
+                if (!navigator || !navigator.geolocation) {
+                    return reject(new RadarLocationError('navigator.geolocation is not available.'));
+                }
+                // use cached location if available and options are set
+                if (options.cacheLocationMinutes) {
+                    try {
+                        const rawCachedLocation = Storage.getItem(Storage.CACHED_LOCATION);
+                        if (rawCachedLocation) {
+                            const cachedLocation = JSON.parse(rawCachedLocation);
+                            const { latitude, longitude, accuracy, expiresAt } = cachedLocation || {};
+                            if (Date.now() < parseInt(expiresAt)) {
+                                if (latitude && longitude && accuracy) {
+                                    return resolve({ latitude, longitude, accuracy });
+                                }
+                            }
+                        }
+                    }
+                    catch (e) {
+                        Logger.warn('could not load cached location.');
+                    }
+                }
+                // set options from config
+                const positionOptions = Object.assign({}, DEFAULT_POSITION_OPTIONS);
+                if (options.locationMaximumAge !== undefined) {
+                    positionOptions.maximumAge = options.locationMaximumAge;
+                }
+                if (options.locationTimeout !== undefined) {
+                    positionOptions.timeout = options.locationTimeout;
+                }
+                if (options.desiredAccuracy !== undefined) {
+                    positionOptions.enableHighAccuracy = useHighAccuracy(options.desiredAccuracy);
+                }
+                // set options from overrides
+                if (overrides.desiredAccuracy !== undefined) {
+                    positionOptions.enableHighAccuracy = useHighAccuracy(overrides.desiredAccuracy);
+                }
+                Logger.info(`Using geolocation options: ${JSON.stringify(positionOptions)}`);
+                // get current location from browser
+                navigator.geolocation.getCurrentPosition((position) => {
+                    if (!position || !position.coords) {
+                        return reject(new RadarLocationError('device location return empty coordinates.'));
+                    }
+                    const { latitude, longitude, accuracy } = position.coords;
+                    // cache location if option is set
+                    if (options.cacheLocationMinutes) {
+                        const cacheLocationMinutes = Number.parseFloat(options.cacheLocationMinutes);
+                        const updatedAt = Date.now();
+                        const expiresAt = updatedAt + (cacheLocationMinutes * 60 * 1000); // convert to ms
+                        const lastLocation = { latitude, longitude, accuracy, updatedAt, expiresAt };
+                        Storage.setItem(Storage.CACHED_LOCATION, JSON.stringify(lastLocation));
+                    }
+                    return resolve({ latitude, longitude, accuracy });
+                }, (err) => {
+                    if (err && err.code) {
+                        const message = PERMISSION_ERROR_MESSAGES[err.code.toString()] || 'unknown';
+                        return reject(new RadarLocationPermissionsError(message));
+                    }
+                    return reject(new RadarLocationError('Could not determine location.'));
+                }, positionOptions);
+            });
+        });
+    }
+    static getPermissionStatus() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                if (!navigator || !navigator.permissions) {
+                    return reject(new RadarLocationError('navigator.permissions is not available.'));
+                }
+                navigator.permissions.query({ name: 'geolocation' }).then((permissionsStatus) => {
+                    let locationAuthorization = 'NOT_DETERMINED';
+                    switch (permissionsStatus.state) {
+                        case 'granted':
+                            locationAuthorization = 'GRANTED_FOREGROUND';
+                            break;
+                        case 'denied':
+                            locationAuthorization = 'DENIED';
+                            break;
+                        case 'prompt':
+                            locationAuthorization = 'NOT_DETERMINED';
+                            break;
+                    }
+                    return resolve(locationAuthorization);
+                });
+            });
+        });
+    }
+}
+
+var SDK_VERSION = '4.2.0-beta.3';
+
+class Http {
+    static request({ method, path, data, host, versioned = true, headers = {}, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const options = Config.get();
+                // check for publishableKey on request
+                const publishableKey = options.publishableKey;
+                if (!publishableKey) {
+                    reject(new RadarPublishableKeyError('publishableKey not set.'));
+                    return;
+                }
+                // setup request URL
+                const urlHost = host || options.host;
+                const version = options.version;
+                let url = `${urlHost}/${version}/${path}`;
+                if (!versioned) {
+                    url = `${urlHost}/${path}`;
+                }
+                // remove undefined values from request data
+                let body = {};
+                Object.keys(data || {}).forEach((key) => {
+                    const value = data[key];
+                    if (value !== undefined) {
+                        body[key] = value;
+                    }
+                });
+                // convert data to querystring for GET requests
+                if (method === 'GET') {
+                    const params = Object.keys(body).map((key) => (`${key}=${encodeURIComponent(body[key])}`));
+                    if (params.length > 0) {
+                        const queryString = params.join('&');
+                        url = `${url}?${queryString}`;
+                    }
+                    body = undefined; // dont send body for GET request
+                }
+                const xhr = new XMLHttpRequest();
+                xhr.open(method, url, true);
+                const defaultHeaders = {
+                    'Authorization': publishableKey,
+                    'Content-Type': 'application/json',
+                    'X-Radar-Device-Type': 'Web',
+                    'X-Radar-SDK-Version': SDK_VERSION,
+                };
+                // set custom config headers if present
+                let configHeaders = {};
+                if (typeof options.getRequestHeaders === 'function') {
+                    configHeaders = options.getRequestHeaders();
+                }
+                // combines default headers with custom headers and config headers
+                const allHeaders = Object.assign(defaultHeaders, headers, configHeaders);
+                // set headers 
+                Object.entries(allHeaders).forEach(([key, val]) => {
+                    xhr.setRequestHeader(key, val);
+                });
+                xhr.onload = () => {
+                    var _a;
+                    let response;
+                    try {
+                        if (allHeaders['Content-Type'] === 'application/json') {
+                            response = JSON.parse(xhr.response);
+                        }
+                        else {
+                            response = { code: xhr.status, data: xhr.response };
+                        }
+                    }
+                    catch (e) {
+                        return reject(new RadarServerError(response));
+                    }
+                    const error = (_a = response === null || response === void 0 ? void 0 : response.meta) === null || _a === void 0 ? void 0 : _a.error;
+                    if (error === 'ERROR_PERMISSIONS') {
+                        return reject(new RadarLocationPermissionsError('Location permissions not granted.'));
+                    }
+                    else if (error === 'ERROR_LOCATION') {
+                        return reject(new RadarLocationError('Could not determine location.'));
+                    }
+                    else if (error === 'ERROR_NETWORK') {
+                        return reject(new RadarTimeoutError());
+                    }
+                    if (xhr.status == 200) {
+                        return resolve(response);
+                    }
+                    if (options.debug) {
+                        Logger.debug(`API call failed: ${url}`);
+                        Logger.debug(JSON.stringify(response));
+                    }
+                    if (xhr.status === 400) {
+                        reject(new RadarBadRequestError(response));
+                    }
+                    else if (xhr.status === 401) {
+                        reject(new RadarUnauthorizedError(response));
+                    }
+                    else if (xhr.status === 402) {
+                        reject(new RadarPaymentRequiredError(response));
+                    }
+                    else if (xhr.status === 403) {
+                        reject(new RadarForbiddenError(response));
+                    }
+                    else if (xhr.status === 404) {
+                        reject(new RadarNotFoundError(response));
+                    }
+                    else if (xhr.status === 429) {
+                        reject(new RadarRateLimitError(response));
+                    }
+                    else if (500 <= xhr.status && xhr.status < 600) {
+                        reject(new RadarServerError(response));
+                    }
+                    else {
+                        reject(new RadarUnknownError(response));
+                    }
+                };
+                xhr.onerror = function () {
+                    if (host && (host === 'http://localhost:52516' || host === 'https://radar-verify.com:52516')) {
+                        reject(new RadarDesktopAppError());
+                    }
+                    else {
+                        reject(new RadarServerError());
+                    }
+                };
+                xhr.ontimeout = function () {
+                    reject(new RadarTimeoutError());
+                };
+                xhr.send(JSON.stringify(body));
+            });
+        });
+    }
+}
+
+class AddressesAPI {
+    static validateAddress(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const options = Config.get();
+            const response = yield Http.request({
+                method: 'GET',
+                path: 'addresses/validate',
+                data: params,
+            });
+            const { address, result } = response;
+            const validateAddressRes = {
+                address,
+                result,
+            };
+            if (options.debug) {
+                validateAddressRes.response = response;
+            }
+            return validateAddressRes;
+        });
+    }
+}
+
+const generateUUID = () => {
+    const uuid = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (char) => {
+        const r = Math.random() * 16 | 0;
+        const v = (char == 'x') ? r : (r & 0x3 | 0x8);
+        return v.toString(16);
+    });
+    return uuid;
+};
+class Device {
+    static getDeviceId() {
+        // use existing deviceId if present
+        const deviceId = Storage.getItem(Storage.DEVICE_ID);
+        if (deviceId) {
+            return deviceId;
+        }
+        // generate new deviceId
+        const uuid = generateUUID();
+        Storage.setItem(Storage.DEVICE_ID, uuid);
+        return uuid;
+    }
+    static getInstallId() {
+        // use existing installId if present
+        const deviceId = Storage.getItem(Storage.INSTALL_ID);
+        if (deviceId) {
+            return deviceId;
+        }
+        // generate new installId
+        const uuid = generateUUID();
+        Storage.setItem(Storage.INSTALL_ID, uuid);
+        return uuid;
+    }
+}
+
+const SESSION_TIMEOUT_SECS = 300; // 5 mins
+const isValid = (sessionId) => {
+    const now = Math.trunc(Date.now() / 1000);
+    const session = Number.parseInt(sessionId);
+    const diff = Math.abs(now - session);
+    return diff < SESSION_TIMEOUT_SECS;
+};
+class Session {
+    static getSessionId() {
+        const sessionId = Storage.getItem(Storage.SESSION_ID);
+        // reuse session if still within 5 min threshold
+        if (sessionId && isValid(sessionId)) {
+            return sessionId;
+        }
+        // create new session if does not already exist or expired
+        const newSessionId = Math.trunc(Date.now() / 1000).toString(); // unix ts in seconds
+        Storage.setItem(Storage.SESSION_ID, newSessionId);
+        return newSessionId;
+    }
+}
+
+class ConfigAPI {
+    static getConfig(params = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const options = Config.get();
+            if (options.version != 'v1') {
+                Logger.info('Skipping /config call.');
+                return;
+            }
+            const deviceId = params.deviceId || Device.getDeviceId();
+            const installId = params.installId || Device.getInstallId();
+            const sessionId = Session.getSessionId();
+            const locationAuthorization = yield Navigator.getPermissionStatus();
+            const data = {
+                deviceId,
+                installId,
+                sessionId,
+                locationAuthorization,
+            };
+            try {
+                yield Http.request({
+                    method: 'GET',
+                    path: 'config',
+                    data,
+                });
+            }
+            catch (err) {
+                Logger.warn(`Error calling /config: ${err.message}`);
+            }
+        });
+    }
+}
+
+class ContextAPI {
+    static getContext(location) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const options = Config.get();
+            // get device location if coordinates not provided
+            if (!location.latitude || !location.longitude) {
+                location = yield Navigator.getCurrentPosition();
+            }
+            const { latitude, longitude, accuracy } = location;
+            const response = yield Http.request({
+                method: 'GET',
+                path: 'context',
+                data: {
+                    coordinates: `${latitude},${longitude}`,
+                    accuracy,
+                },
+            });
+            const { geofences, place, country, state, dma, postalCode, } = response;
+            const contextRes = {
+                location,
+                geofences,
+                place,
+                country,
+                state,
+                dma,
+                postalCode,
+            };
+            if (options.debug) {
+                contextRes.response = response;
+            }
+            return contextRes;
+        });
+    }
+}
+
+class ConversionsAPI {
+    static logConversion(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const options = Config.get();
+            const name = params.name;
+            const userId = params.userId || Storage.getItem(Storage.USER_ID);
+            const deviceId = params.deviceId || Device.getDeviceId();
+            const installId = params.installId || Device.getInstallId();
+            const metadata = params.metadata || {};
+            const createdAt = params.createdAt;
+            if (params.revenue) {
+                metadata.revenue = params.revenue;
+            }
+            const data = {
+                name,
+                userId,
+                deviceId,
+                installId,
+                metadata,
+            };
+            if (typeof createdAt === 'string') {
+                data.createdAt = createdAt;
+            }
+            else if (createdAt instanceof Date) {
+                data.createdAt = createdAt.toISOString();
+            }
+            else {
+                data.createdAt = (new Date()).toISOString();
+            }
+            const response = yield Http.request({
+                method: 'POST',
+                path: 'events',
+                data,
+            });
+            const conversionRes = {
+                event: response.event,
+            };
+            if (options.debug) {
+                conversionRes.response = response;
+            }
+            return conversionRes;
+        });
+    }
+}
+
+class Geocoding {
+    static forwardGeocode(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const options = Config.get();
+            const { query, layers, country } = params;
+            const response = yield Http.request({
+                method: 'GET',
+                path: 'geocode/forward',
+                data: {
+                    query,
+                    layers,
+                    country,
+                },
+            });
+            const forwardGeocodeRes = {
+                addresses: response.addresses,
+            };
+            if (options.debug) {
+                forwardGeocodeRes.response = response;
+            }
+            return forwardGeocodeRes;
+        });
+    }
+    static reverseGeocode(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const options = Config.get();
+            let { latitude, longitude, layers } = params;
+            if (!latitude || !longitude) {
+                const location = yield Navigator.getCurrentPosition();
+                latitude = location.latitude;
+                longitude = location.longitude;
+            }
+            const response = yield Http.request({
+                method: 'GET',
+                path: 'geocode/reverse',
+                data: {
+                    coordinates: `${latitude},${longitude}`,
+                    layers,
+                },
+            });
+            const reverseGeocodeRes = {
+                addresses: response.addresses,
+            };
+            if (options.debug) {
+                reverseGeocodeRes.response = response;
+            }
+            return reverseGeocodeRes;
+        });
+    }
+    static ipGeocode() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const options = Config.get();
+            const response = yield Http.request({
+                method: 'GET',
+                path: 'geocode/ip',
+            });
+            const ipGeocodeRes = {
+                ip: response.ip,
+                address: response.address,
+                proxy: response.proxy,
+            };
+            if (options.debug) {
+                ipGeocodeRes.response = response;
+            }
+            return ipGeocodeRes;
+        });
+    }
+}
+
+class RoutingAPI {
+    static distance(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const options = Config.get();
+            let { origin, destination, modes, units, geometry, geometryPoints, avoid, } = params;
+            // use browser location if "near" not provided
+            if (!origin) {
+                const { latitude, longitude } = yield Navigator.getCurrentPosition();
+                origin = `${latitude},${longitude}`;
+            }
+            else if (typeof origin !== 'string') { // origin is "Location" object
+                const { latitude, longitude } = origin;
+                origin = `${latitude},${longitude}`;
+            }
+            if (typeof destination !== 'string') {
+                const { latitude, longitude } = destination;
+                destination = `${latitude},${longitude}`;
+            }
+            if (Array.isArray(modes)) {
+                modes = modes.join(',');
+            }
+            if (Array.isArray(avoid)) {
+                avoid = avoid.join(',');
+            }
+            const response = yield Http.request({
+                method: 'GET',
+                path: 'route/distance',
+                data: {
+                    origin,
+                    destination,
+                    modes,
+                    units,
+                    geometry,
+                    geometryPoints,
+                    avoid,
+                },
+            });
+            const distanceRes = {
+                routes: response.routes,
+            };
+            if (options.debug) {
+                distanceRes.response = response;
+            }
+            return distanceRes;
+        });
+    }
+    static matrix(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const options = Config.get();
+            let { origins, destinations, mode, units, avoid, } = params;
+            // use browser location if "near" not provided
+            if (!origins) {
+                const { latitude, longitude } = yield Navigator.getCurrentPosition();
+                let originStrings = [];
+                for (let i = 0; i < destinations.length; i++) {
+                    originStrings.push(`${latitude},${longitude}`);
+                }
+                origins = originStrings.join('|');
+            }
+            else if (Array.isArray(origins)) { // origin is a list of "Location" objects
+                origins = origins.map((location) => `${location.latitude},${location.longitude}`).join('|');
+            }
+            // convert array to pipe-delimited string
+            if (Array.isArray(destinations)) {
+                destinations = destinations.map((location) => `${location.latitude},${location.longitude}`).join('|');
+            }
+            if (Array.isArray(avoid)) {
+                avoid = avoid.join(',');
+            }
+            const response = yield Http.request({
+                method: 'GET',
+                path: 'route/matrix',
+                data: {
+                    origins,
+                    destinations,
+                    mode,
+                    units,
+                    avoid,
+                },
+            });
+            const matrixRes = {
+                origins: response.origins,
+                destinations: response.destinations,
+                matrix: response.matrix,
+            };
+            if (options.debug) {
+                matrixRes.response = response;
+            }
+            return matrixRes;
+        });
+    }
+}
+
+class SearchAPI {
+    static autocomplete(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const options = Config.get();
+            let { query, near, limit, layers, countryCode, expandUnits, mailable, } = params;
+            // near can be provided as a string or Location object
+            // if "near" is not provided, request will fallback to IP based location
+            if (near && typeof near !== 'string') {
+                if (near.latitude && near.longitude) {
+                    near = `${near.latitude},${near.longitude}`;
+                }
+            }
+            const response = yield Http.request({
+                method: 'GET',
+                path: 'search/autocomplete',
+                data: {
+                    query,
+                    near,
+                    limit,
+                    layers,
+                    countryCode,
+                    expandUnits,
+                    mailable,
+                },
+            });
+            const autocompleteRes = {
+                addresses: response.addresses,
+            };
+            if (options.debug) {
+                autocompleteRes.response = response;
+            }
+            return autocompleteRes;
+        });
+    }
+    static searchGeofences(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const options = Config.get();
+            let { near, radius, tags, metadata, limit, } = params;
+            // use browser location if "near" not provided
+            if (!near) {
+                const { latitude, longitude } = yield Navigator.getCurrentPosition();
+                near = `${latitude},${longitude}`;
+            }
+            else if (typeof near !== 'string') { // near is "Location" object
+                const { latitude, longitude } = near;
+                near = `${latitude},${longitude}`;
+            }
+            // convert arrays to comma-strings
+            if (Array.isArray(tags)) {
+                tags = tags.join(',');
+            }
+            const response = yield Http.request({
+                method: 'GET',
+                path: 'search/geofences',
+                data: {
+                    near,
+                    radius,
+                    tags,
+                    metadata,
+                    limit,
+                },
+            });
+            const geofencesSearchRes = {
+                geofences: response.geofences,
+            };
+            if (options.debug) {
+                geofencesSearchRes.response = response;
+            }
+            return geofencesSearchRes;
+        });
+    }
+    static searchPlaces(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const options = Config.get();
+            let { near, radius, chains, categories, groups, limit, } = params;
+            // use browser location if "near" not provided
+            if (!near) {
+                const { latitude, longitude } = yield Navigator.getCurrentPosition();
+                near = `${latitude},${longitude}`;
+            }
+            else if (typeof near !== 'string') { // near is "Location" object
+                const { latitude, longitude } = near;
+                near = `${latitude},${longitude}`;
+            }
+            // convert arrays to comma-strings
+            if (Array.isArray(chains)) {
+                chains = chains.join(',');
+            }
+            if (Array.isArray(categories)) {
+                categories = categories.join(',');
+            }
+            if (Array.isArray(groups)) {
+                groups = groups.join(',');
+            }
+            const response = yield Http.request({
+                method: 'GET',
+                path: 'search/places',
+                data: {
+                    near,
+                    radius,
+                    chains,
+                    categories,
+                    groups,
+                    limit,
+                },
+            });
+            const placeSearchRes = {
+                places: response.places,
+            };
+            if (options.debug) {
+                placeSearchRes.response = response;
+            }
+            return placeSearchRes;
+        });
+    }
+}
+
+// https://stackoverflow.com/a/44198641
+const isValidDate = (date) => date && Object.prototype.toString.call(date) === '[object Date]' && !isNaN(date);
+class TripsAPI {
+    static setTripOptions(tripOptions) {
+        if (!tripOptions) {
+            TripsAPI.clearTripOptions();
+            return;
+        }
+        const tripOptionsString = JSON.stringify(tripOptions);
+        Logger.debug(`Saving trip options: ${tripOptionsString}`);
+        Storage.setItem(Storage.TRIP_OPTIONS, tripOptionsString);
+    }
+    static getTripOptions() {
+        let tripOptions = Storage.getItem(Storage.TRIP_OPTIONS);
+        if (tripOptions) {
+            tripOptions = JSON.parse(tripOptions);
+        }
+        return tripOptions;
+    }
+    static clearTripOptions() {
+        Storage.removeItem(Storage.TRIP_OPTIONS);
+    }
+    static startTrip(tripOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const options = Config.get();
+            tripOptions = tripOptions || TripsAPI.getTripOptions();
+            if (!tripOptions) {
+                Logger.warn('tripOptions not set when calling "startTrip"');
+            }
+            const userId = tripOptions.userId || Storage.getItem(Storage.USER_ID);
+            if (userId && userId !== Storage.getItem(Storage.USER_ID)) {
+                // set as userId for tracking if provided
+                Storage.setItem(Storage.USER_ID, userId);
+            }
+            const { externalId, destinationGeofenceTag, destinationGeofenceExternalId, mode, metadata, approachingThreshold, scheduledArrivalAt, } = tripOptions;
+            const data = {
+                userId,
+                externalId,
+                destinationGeofenceTag,
+                destinationGeofenceExternalId,
+                mode,
+                metadata,
+                approachingThreshold,
+            };
+            if (isValidDate(scheduledArrivalAt)) {
+                data.scheduledArrivalAt = scheduledArrivalAt === null || scheduledArrivalAt === void 0 ? void 0 : scheduledArrivalAt.toJSON();
+            }
+            else {
+                if (scheduledArrivalAt) {
+                    Logger.warn('Invalid date format for scheduledArrivalAt');
+                }
+                data.scheduledArrivalAt = undefined;
+            }
+            const response = yield Http.request({
+                method: 'POST',
+                path: 'trips',
+                data,
+            });
+            // save trip options
+            TripsAPI.setTripOptions(tripOptions);
+            const tripRes = {
+                trip: response.trip,
+                events: response.events,
+            };
+            if (options.debug) {
+                tripRes.response = response;
+            }
+            return tripRes;
+        });
+    }
+    static updateTrip(tripOptions, status) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const options = Config.get();
+            tripOptions = tripOptions || TripsAPI.getTripOptions();
+            if (!tripOptions) {
+                Logger.warn('tripOptions not set when calling "startTrip"');
+            }
+            const { externalId, destinationGeofenceTag, destinationGeofenceExternalId, mode, metadata, approachingThreshold, scheduledArrivalAt, } = tripOptions;
+            const data = {
+                status,
+                externalId,
+                destinationGeofenceTag,
+                destinationGeofenceExternalId,
+                mode,
+                metadata,
+                approachingThreshold,
+            };
+            if (isValidDate(scheduledArrivalAt)) {
+                data.scheduledArrivalAt = scheduledArrivalAt === null || scheduledArrivalAt === void 0 ? void 0 : scheduledArrivalAt.toJSON();
+            }
+            else {
+                if (scheduledArrivalAt) {
+                    Logger.warn('Invalid date format for scheduledArrivalAt');
+                }
+                data.scheduledArrivalAt = undefined;
+            }
+            const response = yield Http.request({
+                method: 'PATCH',
+                path: `trips/${externalId}/update`,
+                data,
+            });
+            const tripRes = {
+                trip: response.trip,
+                events: response.events,
+            };
+            if (options.debug) {
+                tripRes.response = response;
+            }
+            return tripRes;
+        });
+    }
+    static completeTrip() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tripOptions = TripsAPI.getTripOptions();
+            const tripResponse = yield TripsAPI.updateTrip(tripOptions, 'completed');
+            // clear local trip options
+            TripsAPI.clearTripOptions();
+            return tripResponse;
+        });
+    }
+    static cancelTrip() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tripOptions = TripsAPI.getTripOptions();
+            const tripResponse = yield TripsAPI.updateTrip(tripOptions, 'canceled');
+            // clear local trip options
+            TripsAPI.clearTripOptions();
+            return tripResponse;
+        });
+    }
+}
+
+const base64Encode = (str) => btoa(str).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+const signJWT = (payload, key) => __awaiter(void 0, void 0, void 0, function* () {
+    const encoder = new TextEncoder();
+    const encodedHeader = base64Encode(JSON.stringify({
+        alg: 'HS256',
+        typ: 'JWT',
+    }));
+    const encodedPayload = base64Encode(JSON.stringify(payload));
+    const keyData = encoder.encode(key);
+    const messageData = encoder.encode(`${encodedHeader}.${encodedPayload}`);
+    const cryptoKey = yield crypto.subtle.importKey('raw', keyData, { name: 'HMAC', hash: { name: 'SHA-256' } }, false, ['sign']);
+    const signatureArrayBuffer = yield crypto.subtle.sign('HMAC', cryptoKey, messageData);
+    const signature = base64Encode(String.fromCharCode(...Array.from(new Uint8Array(signatureArrayBuffer))));
+    return `${encodedHeader}.${encodedPayload}.${signature}`;
+});
+
+const ping = (host) => {
+    return new Promise((resolve) => {
+        const socket = new WebSocket(host);
+        let pings = 0;
+        const latencies = [];
+        let pingInterval;
+        let timeoutInterval;
+        const ping = () => {
+            pings++;
+            const start = Date.now();
+            socket.send('ping');
+            socket.onmessage = (event) => {
+                if (event.data === 'pong') {
+                    const latency = Date.now() - start;
+                    latencies.push(latency);
+                    if (pings >= 3) {
+                        clearInterval(pingInterval);
+                        clearInterval(timeoutInterval);
+                        const median = latencies.sort((a, b) => a - b)[1];
+                        socket.close();
+                        resolve(median);
+                    }
+                }
+            };
+        };
+        const timeout = () => {
+            Logger.warn('Socket timeout');
+            clearInterval(pingInterval);
+            clearInterval(timeoutInterval);
+            socket.close();
+            resolve(-1);
+        };
+        socket.onerror = (err) => {
+            Logger.warn('Error opening socket');
+            socket.close();
+            resolve(-1);
+        };
+        socket.onopen = () => {
+            ping();
+            pingInterval = setInterval(ping, 1000);
+            timeoutInterval = setInterval(timeout, 10000);
+        };
+    });
+};
+
+class TrackAPI {
+    static trackOnce(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const options = Config.get();
+            let { latitude, longitude, accuracy, desiredAccuracy, fraud } = params;
+            // if latitude & longitude are not provided,
+            // try and retrieve device location (will prompt for location permissions)
+            if (!latitude || !longitude) {
+                const deviceLocation = yield Navigator.getCurrentPosition({ desiredAccuracy });
+                latitude = deviceLocation.latitude;
+                longitude = deviceLocation.longitude;
+                accuracy = deviceLocation.accuracy;
+            }
+            // location authorization
+            let locationAuthorization;
+            try {
+                locationAuthorization = yield Navigator.getPermissionStatus();
+            }
+            catch (err) {
+                Logger.warn(`Location authorization error: ${err.message}`);
+            }
+            // user indentification fields
+            const userId = params.userId || Storage.getItem(Storage.USER_ID);
+            const deviceId = params.deviceId || Device.getDeviceId();
+            const installId = params.installId || Device.getInstallId();
+            const sessionId = Session.getSessionId();
+            const deviceType = params.deviceType || 'Web';
+            const description = params.description || Storage.getItem(Storage.DESCRIPTION);
+            let timeZone;
+            try {
+                timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+            }
+            catch (err) {
+                Logger.warn(`Error getting time zone: ${err.message}`);
+            }
+            // save userId for trip tracking
+            if (!userId) {
+                Logger.warn('userId not provided for trackOnce.');
+            }
+            else {
+                Storage.setItem(Storage.USER_ID, userId);
+            }
+            // other info
+            const metadata = params.metadata || Storage.getJSON(Storage.METADATA);
+            // trips
+            const tripOptions = params.tripOptions || TripsAPI.getTripOptions();
+            if (tripOptions) {
+                tripOptions.version = '2';
+            }
+            const body = Object.assign(Object.assign({}, params), { locationAuthorization,
+                accuracy,
+                description,
+                deviceId,
+                deviceType, foreground: true, installId,
+                sessionId,
+                latitude,
+                longitude,
+                metadata, sdkVersion: SDK_VERSION, stopped: true, userId,
+                tripOptions,
+                timeZone });
+            let response;
+            if (fraud) {
+                const host = 'https://api-verified.radar.io';
+                const pingHost = 'ping.radar-verify.com';
+                const lang = navigator.language;
+                const langs = navigator.languages;
+                const { dk } = yield Http.request({
+                    host,
+                    method: 'GET',
+                    path: 'config',
+                    data: {
+                        deviceId,
+                        installId,
+                        sessionId,
+                        locationAuthorization,
+                    },
+                    headers: {
+                        'X-Radar-Desktop-Device-Type': 'Web',
+                    },
+                });
+                let sclVal = -1;
+                let cslVal = -1;
+                try {
+                    const [sclRes, csl] = yield Promise.all([
+                        Http.request({
+                            host: `https://${pingHost}`,
+                            method: 'GET',
+                            path: 'ping',
+                        }),
+                        ping(`wss://${pingHost}`),
+                    ]);
+                    const { scl } = sclRes;
+                    sclVal = scl;
+                    cslVal = csl;
+                }
+                catch (err) {
+                    // do nothing, send scl = -1 and csl = -1
+                }
+                const payload = {
+                    payload: JSON.stringify(Object.assign(Object.assign({}, body), { scl: sclVal, csl: cslVal, lang,
+                        langs })),
+                };
+                const token = yield signJWT(payload, dk);
+                response = yield Http.request({
+                    host,
+                    method: 'POST',
+                    path: 'track',
+                    data: {
+                        token,
+                    },
+                    headers: {
+                        'X-Radar-Body-Is-Token': 'true',
+                    },
+                });
+                if (options.debug && response && response.user) {
+                    if (!response.user.metadata) {
+                        response.user.metadata = {};
+                    }
+                    response.user.metadata['radar:debug'] = {
+                        sclVal,
+                        cslVal,
+                    };
+                }
+            }
+            else {
+                response = yield Http.request({
+                    method: 'POST',
+                    path: 'track',
+                    data: body,
+                });
+            }
+            const { user, events } = response;
+            const location = { latitude, longitude, accuracy };
+            const trackRes = {
+                user,
+                events,
+                location,
+            };
+            if (options.debug) {
+                trackRes.response = response;
+            }
+            return trackRes;
+        });
+    }
+}
+
+class VerifyAPI {
+    static trackVerified(params, encrypted = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const options = Config.get();
+            // user indentification fields
+            const userId = params.userId || Storage.getItem(Storage.USER_ID);
+            const deviceId = params.deviceId || Device.getDeviceId();
+            const installId = params.installId || Device.getInstallId();
+            const sessionId = Session.getSessionId();
+            const description = params.description || Storage.getItem(Storage.DESCRIPTION);
+            // save userId
+            if (!userId) {
+                Logger.warn('userId not provided for trackVerified.');
+            }
+            else {
+                Storage.setItem(Storage.USER_ID, userId);
+            }
+            // other info
+            const metadata = params.metadata || Storage.getJSON(Storage.METADATA);
+            const body = Object.assign(Object.assign({}, params), { description,
+                deviceId, foreground: true, installId,
+                sessionId,
+                metadata, sdkVersion: SDK_VERSION, stopped: true, userId,
+                encrypted });
+            let userAgent = navigator.userAgent;
+            const apple = userAgent && (userAgent.toLowerCase().includes('mac') || userAgent.toLowerCase().includes('iphone') || userAgent.toLowerCase().includes('ipod') || userAgent.toLowerCase().includes('ipad'));
+            const response = yield Http.request({
+                method: 'GET',
+                path: 'verify',
+                data: body,
+                host: apple ? 'https://radar-verify.com:52516' : 'http://localhost:52516',
+            });
+            const { user, events, token } = response;
+            let location;
+            if (user && user.location && user.location.coordinates && user.locationAccuracy) {
+                location = {
+                    latitude: user.location.coordinates[1],
+                    longitude: user.location.coordinates[0],
+                    accuracy: user.locationAccuracy,
+                };
+            }
+            if (encrypted) {
+                const trackTokenRes = {
+                    token,
+                };
+                if (options.debug) {
+                    trackTokenRes.response = response;
+                }
+                return trackTokenRes;
+            }
+            const trackRes = {
+                user,
+                events,
+                location,
+            };
+            if (options.debug) {
+                trackRes.response = response;
+            }
+            return trackRes;
+        });
+    }
+}
+
+const defaultMarkerOptions = {
+    color: '#000257',
+};
+class RadarMarker extends maplibregl.Marker {
+    constructor(markerOptions) {
+        const maplibreOptions = Object.assign({}, defaultMarkerOptions);
+        if (markerOptions.color) {
+            maplibreOptions.color = markerOptions.color;
+        }
+        if (markerOptions.element) {
+            maplibreOptions.element = markerOptions.element;
+        }
+        if (markerOptions.scale) {
+            maplibreOptions.scale = markerOptions.scale;
+        }
+        if (markerOptions.image) {
+            const element = document.createElement('div');
+            element.style.backgroundImage = `url(${markerOptions.image.url})`;
+            element.style.width = markerOptions.image.width;
+            element.style.height = markerOptions.image.height;
+            maplibreOptions.element = element;
+        }
+        super(maplibreOptions);
+        if (markerOptions.image) {
+            this._image = markerOptions.image;
+        }
+        // set popup text or HTML
+        if (markerOptions.text) {
+            const popup = new maplibregl.Popup({ offset: 35 }).setText(markerOptions.text);
+            this.setPopup(popup);
+        }
+        else if (markerOptions.html) {
+            const popup = new maplibregl.Popup({ offset: 35 }).setHTML(markerOptions.html);
+            this.setPopup(popup);
+        }
+    }
+    addTo(map) {
+        if (map._customMarkerRawSvg && !this._image) {
+            this._element.innerHTML = map._customMarkerRawSvg;
+        }
+        map._markers.push(this);
+        return super.addTo(map);
+    }
+    remove() {
+        if (this._map) {
+            this._map._markers = this._map._markers.filter((marker) => marker !== this);
+        }
+        return super.remove();
+    }
+    getOptions() {
+        const markerOptions = {
+            // TODO: element: marker.getElement(),
+            image: this._image,
+            color: this._color,
+            scale: this._scale,
+            offset: this.getOffset(),
+            anchor: this._anchor,
+            draggable: this.isDraggable(),
+            clickTolerance: this._clickTolerance,
+            rotation: this.getRotation(),
+            rotationAlignment: this.getRotationAlignment(),
+            pitchAlignment: this.getPitchAlignment()
+        };
+        return markerOptions;
+    }
+}
+
+const RADAR_LOGO_URL = 'https://api.radar.io/maps/static/images/logo.svg';
+class RadarLogoControl {
+    onAdd() {
+        const img = document.createElement('img');
+        img.src = RADAR_LOGO_URL;
+        this.link = document.createElement('a');
+        this.link.id = 'radar-map-logo';
+        this.link.href = 'https://radar.com?ref=powered_by_radar';
+        this.link.target = '_blank';
+        this.link.appendChild(img);
+        return this.link;
+    }
+    onRemove() {
+        var _a;
+        (_a = this.link) === null || _a === void 0 ? void 0 : _a.remove();
+    }
+}
+
+const DEFAULT_STYLE = 'radar-default-v1';
+const RADAR_STYLES = [
+    'radar-default-v1',
+    'radar-light-v1',
+    'radar-dark-v1',
+];
+const defaultMaplibreOptions = {
+    minZoom: 1,
+    maxZoom: 20,
+    attributionControl: false,
+    dragRotate: false,
+    touchPitch: false,
+    maplibreLogo: false,
+};
+const uuidRegex = /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/;
+const createStyleURL = (options, style = DEFAULT_STYLE) => (`${options.host}/maps/styles/${style}?publishableKey=${options.publishableKey}`);
+/** Check if style is a Radar style or a custom style */
+const isRadarStyle = (style) => {
+    return RADAR_STYLES.includes(style) || uuidRegex.test(style);
+};
+/** Use formatted style URL if using one of Radar's out-of-the-box styles or is a Radar custom style */
+const getStyle = (options, mapOptions) => {
+    const style = mapOptions.style;
+    if (!style || (typeof style === 'string' && isRadarStyle(style))) {
+        return createStyleURL(options, style);
+    }
+    return mapOptions.style;
+};
+class RadarMap extends maplibregl.Map {
+    constructor(mapOptions) {
+        const config = Config.get();
+        if (!config.publishableKey) {
+            Logger.warn('publishableKey not set. Call Radar.initialize() with key before creating a new map.');
+        }
+        // configure maplibre options
+        const style = getStyle(config, mapOptions);
+        const maplibreOptions = Object.assign({}, defaultMaplibreOptions, mapOptions, { style });
+        Logger.debug(`initialize map with options: ${JSON.stringify(maplibreOptions)}`);
+        // custom request handler for Radar styles
+        maplibreOptions.transformRequest = (url, resourceType) => {
+            let radarStyleURL = url;
+            let headers = { 'Authorization': config.publishableKey };
+            if (resourceType === 'Style' && isRadarStyle(url)) {
+                radarStyleURL = createStyleURL(config, url);
+            }
+            if (mapOptions.transformRequest) {
+                return mapOptions.transformRequest(radarStyleURL, resourceType);
+            }
+            if (typeof config.getRequestHeaders === 'function') {
+                headers = Object.assign(headers, config.getRequestHeaders());
+            }
+            return { url: radarStyleURL, headers };
+        };
+        super(maplibreOptions);
+        this._markers = [];
+        const container = this.getContainer();
+        if (!container.style.width && !container.style.height) {
+            Logger.warn('map container does not have a set "width" or "height"');
+        }
+        // add radar logo
+        const radarLogo = new RadarLogoControl();
+        this.addControl(radarLogo, 'bottom-left');
+        // add attribution
+        const attribution = new maplibregl.AttributionControl({ compact: false });
+        this.addControl(attribution, 'bottom-right');
+        // add zoom controls
+        const nav = new maplibregl.NavigationControl({ showCompass: false });
+        this.addControl(nav, 'bottom-right');
+        // handle map resize actions
+        const onResize = () => {
+            const attrib = document.querySelector('.maplibregl-ctrl-attrib');
+            if (attrib) {
+                const width = this.getContainer().clientWidth;
+                if (width < 380) {
+                    attrib.classList.add('hidden');
+                }
+                else {
+                    attrib.classList.remove('hidden');
+                }
+            }
+        };
+        this.on('resize', onResize);
+        this.on('load', onResize);
+        const onStyleLoad = () => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            this._customMarkerRawSvg = undefined;
+            const style = this.getStyle();
+            const customMarkers = (_a = style.metadata) === null || _a === void 0 ? void 0 : _a['radar:customMarkers'];
+            if (Array.isArray(customMarkers) && customMarkers.length > 0) {
+                const customMarker = customMarkers[0]; // only support one custom marker for now
+                try {
+                    const markerRawSvg = yield Http.request({
+                        method: 'GET',
+                        versioned: false,
+                        path: `maps/markers/${customMarker.id}`,
+                        headers: {
+                            'Content-Type': 'image/svg+xml',
+                        },
+                    });
+                    this._customMarkerRawSvg = markerRawSvg.data;
+                }
+                catch (err) {
+                    Logger.warn(`Error getting custom marker: ${customMarker.id} - using default marker.`);
+                }
+            }
+            // set markers if necessary
+            this._markers.forEach((marker) => {
+                if (this._customMarkerRawSvg && !marker._image) {
+                    // set custom marker
+                    marker._element.innerHTML = this._customMarkerRawSvg;
+                }
+                else {
+                    const markerOptions = marker.getOptions();
+                    const newMarker = new RadarMarker(markerOptions); // get default element
+                    // set default element
+                    marker._element.innerHTML = newMarker._element.innerHTML;
+                }
+            });
+        });
+        this.on('styledata', onStyleLoad);
+    }
+}
+
+class MapUI {
+    static getMapLibre() {
+        return maplibregl;
+    }
+    static createMap(mapOptions) {
+        const radarMap = new RadarMap(mapOptions);
+        return radarMap;
+    }
+    static createMarker(markerOptions = {}) {
+        const radarMarker = new RadarMarker(markerOptions);
+        return radarMarker;
+    }
+}
+
+const CLASSNAMES = {
+    WRAPPER: 'radar-autocomplete-wrapper',
+    INPUT: 'radar-autocomplete-input',
+    SEARCH_ICON: 'radar-autocomplete-search-icon',
+    RESULTS_LIST: 'radar-autocomplete-results-list',
+    RESULTS_ITEM: 'radar-autocomplete-results-item',
+    RESULTS_MARKER: 'radar-autocomplete-results-marker',
+    SELECTED_ITEM: 'radar-autocomplete-results-item-selected',
+    POWERED_BY_RADAR: 'radar-powered',
+    NO_RESULTS: 'radar-no-results',
+};
+const ARIA = {
+    EXPANDED: 'aria-expanded',
+};
+const defaultAutocompleteOptions = {
+    container: 'autocomplete',
+    debounceMS: 200,
+    minCharacters: 3,
+    limit: 8,
+    placeholder: 'Search address',
+    responsive: true,
+    disabled: false,
+    showMarkers: true,
+    hideResultsOnBlur: true,
+};
+// determine whether to use px or CSS string
+const formatCSSValue = (value) => {
+    if (typeof value === 'number') {
+        return `${value}px`;
+    }
+    return value;
+};
+const DEFAULT_WIDTH = 400;
+const setWidth = (input, options) => {
+    // if responsive and width is provided, treat it as maxWidth
+    if (options.responsive) {
+        input.style.width = '100%';
+        if (options.width) {
+            input.style.maxWidth = formatCSSValue(options.width);
+        }
+        return;
+    }
+    // if not responsive, set fixed width and unset maxWidth
+    input.style.width = formatCSSValue(options.width || DEFAULT_WIDTH);
+    input.style.removeProperty('max-width');
+};
+const setHeight = (resultsList, options) => {
+    if (options.maxHeight) {
+        resultsList.style.maxHeight = formatCSSValue(options.maxHeight);
+        resultsList.style.overflowY = 'auto'; /* allow overflow when maxHeight is applied */
+    }
+};
+const getMarkerIcon = (color = "#ACBDC8") => {
+    const fill = color.replace('#', '%23');
+    const svg = `<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+    <path d="M12.5704 6.57036C12.5704 4.11632 10.6342 2.11257 8.21016 2C8.14262 2 8.06757 2 8.00003 2C7.93249 2 7.85744 2 7.7899 2C5.35838 2.11257 3.42967 4.11632 3.42967 6.57036C3.42967 6.60037 3.42967 6.6379 3.42967 6.66792C3.42967 6.69794 3.42967 6.73546 3.42967 6.76548C3.42967 9.46717 7.09196 13.3621 7.4672 13.7598C7.61729 13.9174 7.84994 14 8.00003 14C8.15012 14 8.38277 13.9174 8.53286 13.7598C8.9156 13.3621 12.5704 9.46717 12.5704 6.76548C12.5704 6.72795 12.5704 6.69794 12.5704 6.66792C12.5704 6.6379 12.5704 6.60037 12.5704 6.57036ZM7.99252 8.28893C7.04693 8.28893 6.27395 7.52345 6.27395 6.57036C6.27395 5.61726 7.03943 4.85178 7.99252 4.85178C8.94562 4.85178 9.7111 5.61726 9.7111 6.57036C9.7111 7.52345 8.94562 8.28893 7.99252 8.28893Z" fill="${fill}"/>
+  </svg>`.trim();
+    return `data:image/svg+xml;charset=utf-8,${svg}`;
+};
+class AutocompleteUI {
+    // create a new AutocompleteUI instance
+    static createAutocomplete(autocompleteOptions) {
+        return new AutocompleteUI(autocompleteOptions);
+    }
+    constructor(options = {}) {
+        this.config = Object.assign({}, defaultAutocompleteOptions, options);
+        // setup state
+        this.isOpen = false;
+        this.debouncedFetchResults = this.debounce(this.fetchResults, this.config.debounceMS);
+        this.results = [];
+        this.highlightedIndex = -1;
+        // set threshold alias
+        if (this.config.threshold !== undefined) {
+            this.config.minCharacters = this.config.threshold;
+            Logger.warn('AutocompleteUI option "threshold" is deprecated, use "minCharacters" instead.');
+        }
+        if (options.near) {
+            if (typeof options.near === 'string') {
+                this.near = options.near;
+            }
+            else {
+                this.near = `${options.near.latitude},${options.near.longitude}`;
+            }
+        }
+        // get container element
+        let containerEL;
+        if (typeof this.config.container === 'string') { // lookup container element by ID
+            containerEL = document.getElementById(this.config.container);
+        }
+        else { // use provided element
+            containerEL = this.config.container; // HTMLElement
+        }
+        if (!containerEL) {
+            throw new RadarAutocompleteContainerNotFound(`Could not find container element: ${this.config.container}`);
+        }
+        this.container = containerEL;
+        // create wrapper for input and result list
+        this.wrapper = document.createElement('div');
+        this.wrapper.classList.add(CLASSNAMES.WRAPPER);
+        this.wrapper.style.display = this.config.responsive ? 'block' : 'inline-block';
+        setWidth(this.wrapper, this.config);
+        // result list element
+        this.resultsList = document.createElement('ul');
+        this.resultsList.classList.add(CLASSNAMES.RESULTS_LIST);
+        setHeight(this.resultsList, this.config);
+        if (containerEL.nodeName === 'INPUT') {
+            // if an <input> element is provided, use that as the inputField,
+            // and append the resultList to it's parent container
+            this.inputField = containerEL;
+            // append to dom
+            this.wrapper.appendChild(this.resultsList);
+            containerEL.parentNode.appendChild(this.wrapper);
+        }
+        else {
+            // if container is not an input, create new input and append to container
+            // create new input
+            this.inputField = document.createElement('input');
+            this.inputField.classList.add(CLASSNAMES.INPUT);
+            this.inputField.placeholder = this.config.placeholder;
+            this.inputField.type = 'text';
+            this.inputField.disabled = this.config.disabled;
+            // search icon
+            const searchIcon = document.createElement('div');
+            searchIcon.classList.add(CLASSNAMES.SEARCH_ICON);
+            // append to DOM
+            this.wrapper.appendChild(this.inputField);
+            this.wrapper.appendChild(this.resultsList);
+            this.wrapper.appendChild(searchIcon);
+            this.container.appendChild(this.wrapper);
+        }
+        // setup event listeners
+        this.inputField.addEventListener('input', this.handleInput.bind(this));
+        this.inputField.addEventListener('keydown', this.handleKeyboardNavigation.bind(this));
+        if (this.config.hideResultsOnBlur) {
+            this.inputField.addEventListener('blur', this.close.bind(this), true);
+        }
+        Logger.debug(`AutocompleteUI iniailized with options: ${JSON.stringify(this.config)}`);
+    }
+    handleInput() {
+        // Fetch autocomplete results and display them
+        const query = this.inputField.value;
+        if (query.length < this.config.minCharacters) {
+            return;
+        }
+        this.debouncedFetchResults(query)
+            .then((results) => {
+            const onResults = this.config.onResults;
+            if (onResults) {
+                onResults(results);
+            }
+            this.displayResults(results);
+        })
+            .catch((error) => {
+            Logger.warn(`Autocomplete ui error: ${error.message}`);
+            const onError = this.config.onError;
+            if (onError) {
+                onError(error);
+            }
+        });
+    }
+    debounce(fn, delay) {
+        let timeoutId;
+        let resolveFn;
+        let rejectFn;
+        return (...args) => {
+            clearTimeout(timeoutId);
+            timeoutId = setTimeout(() => {
+                const result = fn.apply(this, args);
+                if (result instanceof Promise) {
+                    result
+                        .then((value) => {
+                        if (resolveFn) {
+                            resolveFn(value);
+                        }
+                    })
+                        .catch((error) => {
+                        if (rejectFn) {
+                            rejectFn(error);
+                        }
+                    });
+                }
+            }, delay);
+            return new Promise((resolve, reject) => {
+                resolveFn = resolve;
+                rejectFn = reject;
+            });
+        };
+    }
+    fetchResults(query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { limit, layers, countryCode, expandUnits, mailable, onRequest } = this.config;
+            const params = {
+                query,
+                limit,
+                layers,
+                countryCode,
+                expandUnits,
+                mailable,
+            };
+            if (this.near) {
+                params.near = this.near;
+            }
+            if (onRequest) {
+                onRequest(params);
+            }
+            const { addresses } = yield SearchAPI.autocomplete(params);
+            return addresses;
+        });
+    }
+    displayResults(results) {
+        // Clear the previous results
+        this.clearResultsList();
+        this.results = results;
+        let marker;
+        if (this.config.showMarkers) {
+            marker = document.createElement('img');
+            marker.classList.add(CLASSNAMES.RESULTS_MARKER);
+            marker.setAttribute('src', getMarkerIcon(this.config.markerColor));
+        }
+        // Create and append list items for each result
+        results.forEach((result, index) => {
+            const li = document.createElement('li');
+            li.classList.add(CLASSNAMES.RESULTS_ITEM);
+            // construct result with bolded label
+            let listContent;
+            if (result.formattedAddress.includes(result.addressLabel) && result.layer !== 'postalCode') {
+                // if addressLabel is contained in the formatted address, bold the address label
+                const regex = new RegExp(`(${result.addressLabel}),?`);
+                listContent = result.formattedAddress.replace(regex, '<b>$1</b>');
+            }
+            else {
+                // otherwise append the address or place label to formatted address
+                const label = result.placeLabel || result.addressLabel;
+                listContent = `<b>${label}</b> ${result.formattedAddress}`;
+            }
+            li.innerHTML = listContent;
+            // prepend marker if enabled
+            if (marker) {
+                li.prepend(marker.cloneNode());
+            }
+            // add click handler to each result, use mousedown to fire before blur event
+            li.addEventListener('mousedown', () => {
+                this.select(index);
+            });
+            this.resultsList.appendChild(li);
+        });
+        this.open();
+        if (results.length > 0) {
+            const link = document.createElement('a');
+            link.href = 'https://radar.com?ref=powered_by_radar';
+            link.target = '_blank';
+            this.poweredByLink = link;
+            const poweredByText = document.createElement('span');
+            poweredByText.textContent = 'Powered by';
+            link.appendChild(poweredByText);
+            const radarLogo = document.createElement('span');
+            radarLogo.id = 'radar-powered-logo';
+            link.appendChild(radarLogo);
+            const poweredByContainer = document.createElement('div');
+            poweredByContainer.classList.add(CLASSNAMES.POWERED_BY_RADAR);
+            poweredByContainer.appendChild(link);
+            this.resultsList.appendChild(poweredByContainer);
+        }
+        else {
+            const noResultsText = document.createElement('div');
+            noResultsText.classList.add(CLASSNAMES.NO_RESULTS);
+            noResultsText.textContent = 'No results';
+            this.resultsList.appendChild(noResultsText);
+        }
+    }
+    open() {
+        if (this.isOpen) {
+            return;
+        }
+        this.wrapper.setAttribute(ARIA.EXPANDED, 'true');
+        this.resultsList.removeAttribute('hidden');
+        this.isOpen = true;
+    }
+    close(e) {
+        if (!this.isOpen) {
+            return;
+        }
+        // run this code async to allow link click to propagate before blur
+        // (add 100ms delay if closed from link click)
+        const linkClick = e && (e.relatedTarget === this.poweredByLink);
+        setTimeout(() => {
+            this.wrapper.removeAttribute(ARIA.EXPANDED);
+            this.resultsList.setAttribute('hidden', '');
+            this.highlightedIndex = -1;
+            this.isOpen = false;
+            this.clearResultsList();
+        }, linkClick ? 100 : 0);
+    }
+    goTo(index) {
+        if (!this.isOpen || !this.results.length) {
+            return;
+        }
+        // wrap around
+        if (index < 0) {
+            index = this.results.length - 1;
+        }
+        else if (index >= this.results.length) {
+            index = 0;
+        }
+        const resultItems = this.resultsList.getElementsByTagName('li');
+        if (this.highlightedIndex > -1) {
+            // clear class names on previously highlighted item
+            resultItems[this.highlightedIndex].classList.remove(CLASSNAMES.SELECTED_ITEM);
+        }
+        // add class name to newly highlighted item
+        resultItems[index].classList.add(CLASSNAMES.SELECTED_ITEM);
+        this.highlightedIndex = index;
+    }
+    handleKeyboardNavigation(event) {
+        // fallback to deprecated "keyCode" if event.code not set
+        const code = event.code !== undefined ? event.code : event.keyCode;
+        // allow event to propagate if result list is not open
+        if (!this.isOpen) {
+            return;
+        }
+        switch (code) {
+            // Next item
+            case 'Tab':
+            case 'ArrowDown':
+            case 40:
+                event.preventDefault();
+                this.goTo(this.highlightedIndex + 1);
+                break;
+            // Prev item
+            case 'ArrowUp':
+            case 38:
+                event.preventDefault();
+                this.goTo(this.highlightedIndex - 1);
+                break;
+            // Select
+            case 'Enter':
+            case 13:
+                this.select(this.highlightedIndex);
+                break;
+            // Close
+            case 'Esc':
+            case 27:
+                this.close();
+                break;
+        }
+    }
+    select(index) {
+        const result = this.results[index];
+        if (!result) {
+            Logger.warn(`No autocomplete result found at index: ${index}`);
+            return;
+        }
+        let inputValue;
+        if (result.formattedAddress.includes(result.addressLabel)) {
+            inputValue = result.formattedAddress;
+        }
+        else {
+            const label = result.placeLabel || result.addressLabel;
+            inputValue = `${label}, ${result.formattedAddress}`;
+        }
+        this.inputField.value = inputValue;
+        const onSelection = this.config.onSelection;
+        if (onSelection) {
+            onSelection(result);
+        }
+        // clear results list
+        this.close();
+    }
+    clearResultsList() {
+        this.resultsList.innerHTML = '';
+        this.results = [];
+    }
+    // remove elements from DOM
+    remove() {
+        Logger.debug('AutocompleteUI removed.');
+        this.inputField.remove();
+        this.resultsList.remove();
+        this.wrapper.remove();
+    }
+    setNear(near) {
+        if (near === undefined || near === null) {
+            this.near = undefined;
+        }
+        else if (typeof near === 'string') {
+            this.near = near;
+        }
+        else {
+            this.near = `${near.latitude},${near.longitude}`;
+        }
+        return this;
+    }
+    setPlaceholder(placeholder) {
+        this.config.placeholder = placeholder;
+        this.inputField.placeholder = placeholder;
+        return this;
+    }
+    setDisabled(disabled) {
+        this.config.disabled = disabled;
+        this.inputField.disabled = disabled;
+        return this;
+    }
+    setResponsive(responsive) {
+        this.config.responsive = responsive;
+        setWidth(this.wrapper, this.config);
+        return this;
+    }
+    setWidth(width) {
+        this.config.width = width;
+        setWidth(this.wrapper, this.config);
+        return this;
+    }
+    setMaxHeight(height) {
+        this.config.maxHeight = height;
+        setHeight(this.resultsList, this.config);
+        return this;
+    }
+    setMinCharacters(minCharacters) {
+        this.config.minCharacters = minCharacters;
+        this.config.threshold = minCharacters;
+        return this;
+    }
+    setLimit(limit) {
+        this.config.limit = limit;
+        return this;
+    }
+    setShowMarkers(showMarkers) {
+        this.config.showMarkers = showMarkers;
+        if (showMarkers) {
+            const marker = document.createElement('img');
+            marker.classList.add(CLASSNAMES.RESULTS_MARKER);
+            marker.setAttribute('src', getMarkerIcon(this.config.markerColor));
+            const resultItems = this.resultsList.getElementsByTagName('li');
+            for (let i = 0; i < resultItems.length; i++) {
+                const currentMarker = resultItems[i].getElementsByClassName(CLASSNAMES.RESULTS_MARKER)[0];
+                if (!currentMarker) {
+                    resultItems[i].prepend(marker.cloneNode());
+                }
+            }
+        }
+        else {
+            const resultItems = this.resultsList.getElementsByTagName('li');
+            for (let i = 0; i < resultItems.length; i++) {
+                const marker = resultItems[i].getElementsByClassName(CLASSNAMES.RESULTS_MARKER)[0];
+                if (marker) {
+                    marker.remove();
+                }
+            }
+        }
+        return this;
+    }
+    setMarkerColor(color) {
+        this.config.markerColor = color;
+        const marker = this.resultsList.getElementsByClassName(CLASSNAMES.RESULTS_MARKER);
+        for (let i = 0; i < marker.length; i++) {
+            marker[i].setAttribute('src', getMarkerIcon(color));
+        }
+        return this;
+    }
+    setHideResultsOnBlur(hideResultsOnBlur) {
+        this.config.hideResultsOnBlur = hideResultsOnBlur;
+        if (hideResultsOnBlur) {
+            this.inputField.addEventListener('blur', this.close.bind(this), true);
+        }
+        else {
+            this.inputField.removeEventListener('blur', this.close.bind(this), true);
+        }
+        return this;
+    }
+}
+
+const isSecretKey = (key) => (key.includes('_sk_'));
+const isLiveKey = (key) => (key.includes('_live_'));
+class Radar {
+    static get VERSION() {
+        return SDK_VERSION;
+    }
+    // "ui" namespace
+    static get ui() {
+        return {
+            maplibregl: MapUI.getMapLibre(),
+            map: MapUI.createMap,
+            marker: MapUI.createMarker,
+            autocomplete: AutocompleteUI.createAutocomplete,
+        };
+    }
+    static initialize(publishableKey, options = {}) {
+        if (!publishableKey) {
+            throw new RadarPublishableKeyError('Publishable key required in initialization.');
+        }
+        if (isSecretKey(publishableKey)) {
+            throw new RadarPublishableKeyError('Secret keys are not allowed. Please use your Radar publishable key.');
+        }
+        // store settings in global config
+        const live = isLiveKey(publishableKey);
+        const logLevel = live ? 'error' : 'info';
+        const debug = !live;
+        const radarOptions = Object.assign(Config.defaultOptions, {
+            publishableKey,
+            live,
+            logLevel,
+            debug,
+        }, options);
+        Config.setup(radarOptions);
+        Logger.info(`initialized with ${live ? 'live' : 'test'} publishableKey.`);
+        if (options.debug) {
+            Logger.info(`using options: ${JSON.stringify(options)}`);
+        }
+        // NOTE(jasonl): this allows us to run jest tests
+        // without having to mock the ConfigAPI.getConfig call
+        if (!(window === null || window === void 0 ? void 0 : window.RADAR_TEST_ENV)) {
+            ConfigAPI.getConfig();
+        }
+    }
+    static clear() {
+        Config.clear();
+    }
+    ///////////////////////
+    // geofencing platform
+    ///////////////////////
+    static setUserId(userId) {
+        if (!userId) {
+            Storage.removeItem(Storage.USER_ID);
+            return;
+        }
+        Storage.setItem(Storage.USER_ID, String(userId).trim());
+    }
+    static setDescription(description) {
+        if (!description) {
+            Storage.removeItem(Storage.DESCRIPTION);
+            return;
+        }
+        Storage.setItem(Storage.DESCRIPTION, String(description).trim());
+    }
+    static setMetadata(metadata) {
+        if (!metadata) {
+            Storage.removeItem(Storage.METADATA);
+            return;
+        }
+        Storage.setItem(Storage.METADATA, JSON.stringify(metadata));
+    }
+    static getLocation() {
+        return Navigator.getCurrentPosition();
+    }
+    static trackOnce(params = {}) {
+        try {
+            return TrackAPI.trackOnce(params);
+        }
+        finally {
+            ConfigAPI.getConfig(params); // call with updated permissions
+        }
+    }
+    static trackVerified(params = {}) {
+        return VerifyAPI.trackVerified(params);
+    }
+    static trackVerifiedToken(params = {}) {
+        return VerifyAPI.trackVerified(params, true);
+    }
+    static getContext(params) {
+        return ContextAPI.getContext(params);
+    }
+    static setTripOptions(tripOptions) {
+        TripsAPI.setTripOptions(tripOptions);
+    }
+    static clearTripOptions() {
+        TripsAPI.clearTripOptions();
+    }
+    static getTripOptions() {
+        return TripsAPI.getTripOptions();
+    }
+    static startTrip(tripOptions) {
+        return TripsAPI.startTrip(tripOptions);
+    }
+    static updateTrip(tripOptions) {
+        return TripsAPI.updateTrip(tripOptions);
+    }
+    static completeTrip() {
+        return TripsAPI.completeTrip();
+    }
+    static cancelTrip() {
+        return TripsAPI.cancelTrip();
+    }
+    static logConversion(params) {
+        return ConversionsAPI.logConversion(params);
+    }
+    /////////////////
+    // maps platform
+    /////////////////
+    static forwardGeocode(params) {
+        return Geocoding.forwardGeocode(params);
+    }
+    static reverseGeocode(params) {
+        return Geocoding.reverseGeocode(params);
+    }
+    static ipGeocode() {
+        return Geocoding.ipGeocode();
+    }
+    static autocomplete(params) {
+        return SearchAPI.autocomplete(params);
+    }
+    static searchGeofences(params) {
+        return SearchAPI.searchGeofences(params);
+    }
+    static searchPlaces(params) {
+        return SearchAPI.searchPlaces(params);
+    }
+    static validateAddress(params) {
+        return AddressesAPI.validateAddress(params);
+    }
+    static distance(params) {
+        return RoutingAPI.distance(params);
+    }
+    static matrix(params) {
+        return RoutingAPI.matrix(params);
+    }
+}
+
+export { Radar as default };
+//# sourceMappingURL=radar.js.map