@twinmatrix/spatialverse-sdk-web 0.0.2 → 0.0.3

package/lib/cjs/meta-atlas-sdk/meta-atlas-sdk.js

@@ -13,42 +13,27 @@ var _length = _interopRequireDefault(require("@turf/length"));
 var _area = _interopRequireDefault(require("@turf/area"));
 var _cloneDeep = _interopRequireDefault(require("lodash/cloneDeep"));
 var _mapboxGlDraw = _interopRequireDefault(require("@mapbox/mapbox-gl-draw"));
-var _customStyles = require("./customStyles");
-var _draw_marker = _interopRequireDefault(require("./mapbox_draw_custom_modes/draw_marker"));
-var _marker_select = _interopRequireDefault(require("./mapbox_draw_custom_modes/marker_select"));
-var _metaAtlasSdkCore = require("./MetaAtlasCore/meta-atlas-sdk-core");
-var _MainMap = _interopRequireDefault(require("./3DMap/MainMap"));
+var _customStyles = require("./customStyles.js");
+var _draw_marker = _interopRequireDefault(require("./mapbox_draw_custom_modes/draw_marker.js"));
+var _marker_select = _interopRequireDefault(require("./mapbox_draw_custom_modes/marker_select.js"));
+var _metaAtlasSdkCore = require("./MetaAtlasCore/meta-atlas-sdk-core.js");
+var _MainMap = _interopRequireDefault(require("./3DMap/MainMap.js"));
 var _app = require("firebase/app");
 var _analytics = require("firebase/analytics");
-var _routingVisualizer = require("./utils/routing-visualizer");
-var _customerLayer = _interopRequireDefault(require("./customerLayer"));
-var _customerLayerVariant = _interopRequireDefault(require("./customerLayerVariant"));
+var _index = require("./utils/routing-visualizer/index.js");
+var _customerLayer = _interopRequireDefault(require("./customerLayer.js"));
+var _customerLayerVariant = _interopRequireDefault(require("./customerLayerVariant.js"));
 var _booleanPointInPolygon = _interopRequireDefault(require("@turf/boolean-point-in-polygon"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
-function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, "default": e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-function _regenerator() { /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/babel/babel/blob/main/packages/babel-helpers/LICENSE */ var e, t, r = "function" == typeof Symbol ? Symbol : {}, n = r.iterator || "@@iterator", o = r.toStringTag || "@@toStringTag"; function i(r, n, o, i) { var c = n && n.prototype instanceof Generator ? n : Generator, u = Object.create(c.prototype); return _regeneratorDefine2(u, "_invoke", function (r, n, o) { var i, c, u, f = 0, p = o || [], y = !1, G = { p: 0, n: 0, v: e, a: d, f: d.bind(e, 4), d: function d(t, r) { return i = t, c = 0, u = e, G.n = r, a; } }; function d(r, n) { for (c = r, u = n, t = 0; !y && f && !o && t < p.length; t++) { var o, i = p[t], d = G.p, l = i[2]; r > 3 ? (o = l === n) && (u = i[(c = i[4]) ? 5 : (c = 3, 3)], i[4] = i[5] = e) : i[0] <= d && ((o = r < 2 && d < i[1]) ? (c = 0, G.v = n, G.n = i[1]) : d < l && (o = r < 3 || i[0] > n || n > l) && (i[4] = r, i[5] = n, G.n = l, c = 0)); } if (o || r > 1) return a; throw y = !0, n; } return function (o, p, l) { if (f > 1) throw TypeError("Generator is already running"); for (y && 1 === p && d(p, l), c = p, u = l; (t = c < 2 ? e : u) || !y;) { i || (c ? c < 3 ? (c > 1 && (G.n = -1), d(c, u)) : G.n = u : G.v = u); try { if (f = 2, i) { if (c || (o = "next"), t = i[o]) { if (!(t = t.call(i, u))) throw TypeError("iterator result is not an object"); if (!t.done) return t; u = t.value, c < 2 && (c = 0); } else 1 === c && (t = i["return"]) && t.call(i), c < 2 && (u = TypeError("The iterator does not provide a '" + o + "' method"), c = 1); i = e; } else if ((t = (y = G.n < 0) ? u : r.call(n, G)) !== a) break; } catch (t) { i = e, c = 1, u = t; } finally { f = 1; } } return { value: t, done: y }; }; }(r, o, i), !0), u; } var a = {}; function Generator() {} function GeneratorFunction() {} function GeneratorFunctionPrototype() {} t = Object.getPrototypeOf; var c = [][n] ? t(t([][n]())) : (_regeneratorDefine2(t = {}, n, function () { return this; }), t), u = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(c); function f(e) { return Object.setPrototypeOf ? Object.setPrototypeOf(e, GeneratorFunctionPrototype) : (e.__proto__ = GeneratorFunctionPrototype, _regeneratorDefine2(e, o, "GeneratorFunction")), e.prototype = Object.create(u), e; } return GeneratorFunction.prototype = GeneratorFunctionPrototype, _regeneratorDefine2(u, "constructor", GeneratorFunctionPrototype), _regeneratorDefine2(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = "GeneratorFunction", _regeneratorDefine2(GeneratorFunctionPrototype, o, "GeneratorFunction"), _regeneratorDefine2(u), _regeneratorDefine2(u, o, "Generator"), _regeneratorDefine2(u, n, function () { return this; }), _regeneratorDefine2(u, "toString", function () { return "[object Generator]"; }), (_regenerator = function _regenerator() { return { w: i, m: f }; })(); }
-function _regeneratorDefine2(e, r, n, t) { var i = Object.defineProperty; try { i({}, "", {}); } catch (e) { i = 0; } _regeneratorDefine2 = function _regeneratorDefine(e, r, n, t) { function o(r, n) { _regeneratorDefine2(e, r, function (e) { return this._invoke(r, n, e); }); } r ? i ? i(e, r, { value: n, enumerable: !t, configurable: !t, writable: !t }) : e[r] = n : (o("next", 0), o("throw", 1), o("return", 2)); }, _regeneratorDefine2(e, r, n, t); }
-function asyncGeneratorStep(n, t, e, r, o, a, c) { try { var i = n[a](c), u = i.value; } catch (n) { return void e(n); } i.done ? t(u) : Promise.resolve(u).then(r, o); }
-function _asyncToGenerator(n) { return function () { var t = this, e = arguments; return new Promise(function (r, o) { var a = n.apply(t, e); function _next(n) { asyncGeneratorStep(a, r, o, _next, _throw, "next", n); } function _throw(n) { asyncGeneratorStep(a, r, o, _next, _throw, "throw", n); } _next(void 0); }); }; }
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
-function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
-function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
-function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
-function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
-function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
-function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
-function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } // const maplibregl = require('maplibre-gl');
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+// const maplibregl = require('maplibre-gl');
 var FilterType = /*#__PURE__*/function (FilterType) {
   FilterType["Name"] = "title";
   FilterType["LocalRef"] = "localRef";
   FilterType["WhatTaxonomy"] = "dimension_what";
   return FilterType;
 }(FilterType || {});
-var EventSource = exports.EventSource = /*#__PURE__*/function (EventSource) {
+let EventSource = exports.EventSource = /*#__PURE__*/function (EventSource) {
   EventSource["UrlLoad"] = "url_load";
   EventSource["MapClick"] = "map_click";
   EventSource["BannerClick"] = "banner_click";
@@ -60,81 +45,93 @@ var EventSource = exports.EventSource = /*#__PURE__*/function (EventSource) {
   EventSource["StampRallyClick"] = "stamp_rally_click";
   return EventSource;
 }({});
-var DEFAULT_MAP_STYLE = exports.DEFAULT_MAP_STYLE = 'https://api.maptiler.com/maps/01985ac8-56d2-707b-afa8-68abfe8f18be/style.json?key=12H5hrITUbJ1sDrVPqkq';
-var MetaAtlasSdk = exports.MetaAtlasSdk = /*#__PURE__*/function () {
-  function MetaAtlasSdk(accessToken, secretKey) {
-    var _this = this;
-    var onLoad = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : function () {};
-    var onLoadFail = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : function (errorMessage) {};
-    var onRoutingStatusUpdate = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : function () {};
-    var onSearchStatusUpdate = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : function () {};
-    _classCallCheck(this, MetaAtlasSdk);
-    _defineProperty(this, "onLoadCallback", undefined);
-    _defineProperty(this, "onLoadFailCallback", undefined);
-    _defineProperty(this, "mapLoaded", false);
-    _defineProperty(this, "onFailCallbackSent", false);
-    _defineProperty(this, "UserLayers", []);
-    _defineProperty(this, "defaultFocusedTaxonomy", 'where.gbtb');
-    _defineProperty(this, "currentFocus", this.defaultFocusedTaxonomy);
-    _defineProperty(this, "apiAuthenticationCallbackReceived", false);
-    _defineProperty(this, "routingVisualizer", new _routingVisualizer.RoutingVisualizer(this));
-    // When token middleware is online that will check the tokens.
-    _defineProperty(this, "tileServer", 'https://atoms-map-tiles-middleware.sandbox.spatialverse.online');
-    // HOST = 'https://atoms-sdk.qa.cag.spatialverse.online/2.0.0/';
-    _defineProperty(this, "HOST", 'https://atoms-sdk.sandbox.spatialverse.online/');
-    //empApiURL = 'https://atoms-api.changiairport.com';
-    _defineProperty(this, "empApiURL", 'https://atoms-api.sandbox.spatialverse.online');
-    // empApiURL = 'https://atoms-api.dev.cag.spatialverse.online';
-    _defineProperty(this, "mapBoxDrawSourceID", 'drawnDataSource');
-    _defineProperty(this, "drawGeojsonData", {
-      type: 'FeatureCollection',
-      features: []
-    });
-    _defineProperty(this, "popups", []);
-    _defineProperty(this, "markers", []);
-    _defineProperty(this, "addCustomerLayer", function (map, jsonToPass, onLoaded) {
-      var customerLayerUrl = jsonToPass.customerLayerUrl;
-      var sourceLayer = jsonToPass.sourceLayer;
-      _jquery["default"].getJSON(customerLayerUrl, function (customerLayers) {
-        _this.CustomerLayers = customerLayers;
-        var _iterator = _createForOfIteratorHelper(_this.CustomerLayers),
-          _step;
-        try {
-          for (_iterator.s(); !(_step = _iterator.n()).done;) {
-            var layer = _step.value;
-            layer["source-layer"] = sourceLayer;
-            map.addLayer(layer);
-            _this.map.on('click', layer.id, function (e) {
-              //setup new clicked feature
-              var clickedFeature = e.features[0];
-              _this.overRideSelectionOfDrawnPointGeometry(clickedFeature);
-              console.log('clickedFeature: ', clickedFeature);
-              _this.logAnalyticsEvent('feature_clicked', {
-                feature_clicked: clickedFeature.properties.title
-              });
-              if (clickedFeature.properties.isSearchable && clickedFeature.properties.title != 'Transit' && clickedFeature.properties.title != 'Public') {
-                var coords = clickedFeature.geometry.type === "Polygon" ? JSON.parse(clickedFeature.properties.center) : clickedFeature.geometry.coordinates;
-                _this.metaAtlasCore.setLastClickedFeature({
-                  mapObjectId: clickedFeature.properties.myMapObjectId,
-                  coordinates: coords,
-                  name: clickedFeature.properties.title,
-                  whatDimension: clickedFeature.properties.dimension_what,
-                  whereDimension: clickedFeature.properties.dimension_where,
-                  geometry: clickedFeature.geometry,
-                  properties: clickedFeature.properties,
-                  clickEvent: e
-                });
-              }
-            });
-          }
-        } catch (err) {
-          _iterator.e(err);
-        } finally {
-          _iterator.f();
-        }
-        onLoaded();
-      });
+const DEFAULT_MAP_STYLE = exports.DEFAULT_MAP_STYLE = 'https://api.maptiler.com/maps/01985ac8-56d2-707b-afa8-68abfe8f18be/style.json?key=12H5hrITUbJ1sDrVPqkq';
+class MetaAtlasSdk {
+  onLoadCallback = (() => undefined)();
+  onLoadFailCallback = (() => undefined)();
+  mapLoaded = false;
+  onFailCallbackSent = false;
+  UserLayers = [];
+  defaultFocusedTaxonomy = 'where.gbtb';
+  currentFocus = this.defaultFocusedTaxonomy;
+  apiAuthenticationCallbackReceived = false;
+  routingVisualizer = (() => new _index.RoutingVisualizer(this))();
+  // When token middleware is online that will check the tokens.
+  tileServer = 'https://atoms-map-tiles-middleware.sandbox.spatialverse.online';
+  // HOST = 'https://atoms-sdk.qa.cag.spatialverse.online/2.0.0/';
+  HOST = 'https://atoms-sdk.sandbox.spatialverse.online/';
+  //empApiURL = 'https://atoms-api.changiairport.com';
+  empApiURL = 'https://atoms-api.sandbox.spatialverse.online';
+  // empApiURL = 'https://atoms-api.dev.cag.spatialverse.online';
+
+  mapBoxDrawSourceID = 'drawnDataSource';
+  drawGeojsonData = (() => ({
+    type: 'FeatureCollection',
+    features: []
+  }))();
+  popups = [];
+  markers = [];
+  setupFirebase() {
+    const firebaseConfig = {
+      apiKey: "AIzaSyBDWO2wNkotbgjbkyqVrC_OEAJ3mbvlheI",
+      authDomain: "tmt-lenovo-tech-day-26-id.firebaseapp.com",
+      projectId: "tmt-lenovo-tech-day-26-id",
+      storageBucket: "tmt-lenovo-tech-day-26-id.firebasestorage.app",
+      messagingSenderId: "618619544262",
+      appId: "1:618619544262:web:cb7a7953a908aeed212dc7",
+      measurementId: "G-HN2FS1L0P4"
+    };
+    this.firebaseApp = (0, _app.initializeApp)(firebaseConfig);
+    this.analytics = (0, _analytics.getAnalytics)(this.firebaseApp);
+    console.log('analytics: ', this.analytics);
+  }
+  logAnalyticsEvent(eventName, properties) {
+    console.log('logAnalyticsEvent: ', eventName, properties);
+    if (!this.analytics) {
+      console.warn('Analytics is not initialized. Event not logged:', eventName);
+      return;
+    }
+    if (properties) (0, _analytics.logEvent)(this.analytics, eventName, properties);else (0, _analytics.logEvent)(this.analytics, eventName);
+  }
+  onLoad() {
+    if (this.mapLoaded === true && this.apiAuthenticationCallbackReceived === true) {
+      // Setup routing visualizer
+      this.routingVisualizer.setupRouting(this.map);
+
+      // this.map3D.init(this.map);
+
+      if (this.onLoadCallback) {
+        this.onLoadCallback();
+      }
+    }
+  }
+  onLoadFail(message) {
+    if (this.onFailCallbackSent === false) {
+      this.onFailCallbackSent = true;
+      if (this.onLoadFailCallback) {
+        this.onLoadFailCallback(message);
+      }
+    }
+  }
+  initMetaAtlasCore(onRoutingStatusUpdate, onSearchStatusUpdate) {
+    this.metaAtlasCore.init(this.empApiURL, this.accessToken, this.secretKey, data => {
+      this.apiAuthenticationCallbackReceived = true;
+      if (data.authenticated) {
+        // Load routing data
+        this.metaAtlasCore.setupRouting(onRoutingStatusUpdate);
+        this.metaAtlasCore.setupMapObjectSearch(onSearchStatusUpdate);
+        this.map3D = new _MainMap.default(this.metaAtlasCore);
+        this.onLoad();
+      } else {
+        this.onLoadFail('Failed to authenticate token');
+      }
     });
+  }
+  constructor(accessToken, secretKey) {
+    let onLoad = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : () => {};
+    let onLoadFail = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : errorMessage => {};
+    let onRoutingStatusUpdate = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : () => {};
+    let onSearchStatusUpdate = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : () => {};
     this.accessToken = accessToken;
     this.secretKey = secretKey;
     this.onLoadCallback = onLoad;
@@ -142,1054 +139,829 @@ var MetaAtlasSdk = exports.MetaAtlasSdk = /*#__PURE__*/function () {
     this.map = null;
     this.mapBoxDraw = null;
     this.maplibregl = maplibregl;
-    this.CustomerLayers = _customerLayer["default"];
-    this.CustomerLayersVariant = _customerLayerVariant["default"];
+    this.CustomerLayers = _customerLayer.default;
+    this.CustomerLayersVariant = _customerLayerVariant.default;
     this.roleName = "changipublic";
     this.verNum = "1";
     this.metaAtlasCore = new _metaAtlasSdkCore.MetaAtlasCore();
     this.initMetaAtlasCore(onRoutingStatusUpdate, onSearchStatusUpdate);
     this.setupFirebase();
   }
-  return _createClass(MetaAtlasSdk, [{
-    key: "setupFirebase",
-    value: function setupFirebase() {
-      var firebaseConfig = {
-        apiKey: "AIzaSyBDWO2wNkotbgjbkyqVrC_OEAJ3mbvlheI",
-        authDomain: "tmt-lenovo-tech-day-26-id.firebaseapp.com",
-        projectId: "tmt-lenovo-tech-day-26-id",
-        storageBucket: "tmt-lenovo-tech-day-26-id.firebasestorage.app",
-        messagingSenderId: "618619544262",
-        appId: "1:618619544262:web:cb7a7953a908aeed212dc7",
-        measurementId: "G-HN2FS1L0P4"
-      };
-      this.firebaseApp = (0, _app.initializeApp)(firebaseConfig);
-      this.analytics = (0, _analytics.getAnalytics)(this.firebaseApp);
-      console.log('analytics: ', this.analytics);
-    }
-  }, {
-    key: "logAnalyticsEvent",
-    value: function logAnalyticsEvent(eventName, properties) {
-      console.log('logAnalyticsEvent: ', eventName, properties);
-      if (!this.analytics) {
-        console.warn('Analytics is not initialized. Event not logged:', eventName);
-        return;
-      }
-      if (properties) (0, _analytics.logEvent)(this.analytics, eventName, properties);else (0, _analytics.logEvent)(this.analytics, eventName);
-    }
-  }, {
-    key: "onLoad",
-    value: function onLoad() {
-      if (this.mapLoaded === true && this.apiAuthenticationCallbackReceived === true) {
-        // Setup routing visualizer
-        this.routingVisualizer.setupRouting(this.map);
-
-        // this.map3D.init(this.map);
+  setupMap(role, mapDivOrMap) {
+    this.roleName = role;
 
-        if (this.onLoadCallback) {
-          this.onLoadCallback();
-        }
-      }
-    }
-  }, {
-    key: "onLoadFail",
-    value: function onLoadFail(message) {
-      if (this.onFailCallbackSent === false) {
-        this.onFailCallbackSent = true;
-        if (this.onLoadFailCallback) {
-          this.onLoadFailCallback(message);
-        }
-      }
-    }
-  }, {
-    key: "initMetaAtlasCore",
-    value: function initMetaAtlasCore(onRoutingStatusUpdate, onSearchStatusUpdate) {
-      var _this2 = this;
-      this.metaAtlasCore.init(this.empApiURL, this.accessToken, this.secretKey, function (data) {
-        _this2.apiAuthenticationCallbackReceived = true;
-        if (data.authenticated) {
-          // Load routing data
-          _this2.metaAtlasCore.setupRouting(onRoutingStatusUpdate);
-          _this2.metaAtlasCore.setupMapObjectSearch(onSearchStatusUpdate);
-          _this2.map3D = new _MainMap["default"](_this2.metaAtlasCore);
-          _this2.onLoad();
-        } else {
-          _this2.onLoadFail('Failed to authenticate token');
-        }
+    // Support both vanilla (string DOM ID) and React (Map instance) modes
+    if (typeof mapDivOrMap === 'string') {
+      // Vanilla mode: create new map instance
+      this.map = new maplibregl.Map({
+        container: mapDivOrMap,
+        style: DEFAULT_MAP_STYLE,
+        center: [110.40560122701005, 1.5626614114987702],
+        zoom: 18,
+        pitch: 42,
+        bearing: 23.4,
+        antialias: true,
+        attributionControl: false
       });
+    } else {
+      // React mode: use provided map instance
+      this.map = mapDivOrMap;
     }
-  }, {
-    key: "setupMap",
-    value: function setupMap(role, mapDivOrMap) {
-      var _this3 = this;
-      this.roleName = role;
 
-      // Support both vanilla (string DOM ID) and React (Map instance) modes
-      if (typeof mapDivOrMap === 'string') {
-        // Vanilla mode: create new map instance
-        this.map = new maplibregl.Map({
-          container: mapDivOrMap,
-          style: DEFAULT_MAP_STYLE,
-          center: [110.40560122701005, 1.5626614114987702],
-          zoom: 18,
-          pitch: 42,
-          bearing: 23.4,
-          antialias: true,
-          attributionControl: false
+    // Initialize map setup (common for both modes)
+    const setupLayers = () => {
+      this.map.addSource('custom', {
+        type: 'vector',
+        url: this.tileServer + '/' + this.roleName + '/' + this.verNum + '/geojson?accessToken=' + this.accessToken
+      });
+      this.logAnalyticsEvent('open_app', {
+        type: 'web',
+        token: this.accessToken
+      });
+      this.map.on('click', e => {
+        // Reset last clicks
+        this.metaAtlasCore.setLastClickedFeature({
+          mapObjectId: null,
+          coordinates: null,
+          name: null,
+          whatDimension: null,
+          whereDimension: null,
+          geometry: null,
+          properties: null,
+          clickEvent: e
         });
-      } else {
-        // React mode: use provided map instance
-        this.map = mapDivOrMap;
-      }
+        this.lastClickedDrawing = this.setDrawing();
+      });
 
-      // Initialize map setup (common for both modes)
-      var setupLayers = function setupLayers() {
-        _this3.map.addSource('custom', {
-          type: 'vector',
-          url: _this3.tileServer + '/' + _this3.roleName + '/' + _this3.verNum + '/geojson?accessToken=' + _this3.accessToken
-        });
-        _this3.logAnalyticsEvent('open_app', {
-          type: 'web',
-          token: _this3.accessToken
-        });
-        _this3.map.on('click', function (e) {
-          // Reset last clicks
-          _this3.metaAtlasCore.setLastClickedFeature({
-            mapObjectId: null,
-            coordinates: null,
-            name: null,
-            whatDimension: null,
-            whereDimension: null,
-            geometry: null,
-            properties: null,
-            clickEvent: e
+      // Setup map box draw after customerLayers so that draw geomertry shows up on top
+      const layersToAdd = this.CustomerLayers;
+      for (const layer of layersToAdd) {
+        layer["source-layer"] = 'geojson';
+        this.map.addLayer(layer);
+        this.map.on('click', layer.id, e => {
+          //setup new clicked feature
+          var clickedFeature = e.features[0];
+          console.log(clickedFeature);
+          this.logAnalyticsEvent('feature_clicked', {
+            feature_clicked: clickedFeature.properties.title
           });
-          _this3.lastClickedDrawing = _this3.setDrawing();
-        });
-
-        // Setup map box draw after customerLayers so that draw geomertry shows up on top
-        var layersToAdd = _this3.CustomerLayers;
-        var _iterator2 = _createForOfIteratorHelper(layersToAdd),
-          _step2;
-        try {
-          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-            var layer = _step2.value;
-            layer["source-layer"] = 'geojson';
-            _this3.map.addLayer(layer);
-            _this3.map.on('click', layer.id, function (e) {
-              //setup new clicked feature
-              var clickedFeature = e.features[0];
-              console.log(clickedFeature);
-              _this3.logAnalyticsEvent('feature_clicked', {
-                feature_clicked: clickedFeature.properties.title
-              });
-              _this3.overRideSelectionOfDrawnPointGeometry(clickedFeature);
-              if (clickedFeature.properties.dimension_what.includes('what.infra.garden') || clickedFeature.properties.isSearchable && clickedFeature.properties.title != 'Transit' && clickedFeature.properties.title != 'Public') {
-                var coords = clickedFeature.geometry.type === "Polygon" || clickedFeature.geometry.type === "MultiPolygon" ? JSON.parse(clickedFeature.properties.center) : clickedFeature.geometry.coordinates;
-                _this3.metaAtlasCore.setLastClickedFeature({
-                  mapObjectId: clickedFeature.properties.myMapObjectId,
-                  coordinates: coords,
-                  name: clickedFeature.properties.title,
-                  whatDimension: clickedFeature.properties.dimension_what,
-                  whereDimension: clickedFeature.properties.dimension_where,
-                  geometry: clickedFeature.geometry,
-                  properties: clickedFeature.properties,
-                  clickEvent: e
-                });
-              }
+          this.overRideSelectionOfDrawnPointGeometry(clickedFeature);
+          if (clickedFeature.properties.dimension_what.includes('what.infra.garden') || clickedFeature.properties.isSearchable && clickedFeature.properties.title != 'Transit' && clickedFeature.properties.title != 'Public') {
+            const coords = clickedFeature.geometry.type === "Polygon" || clickedFeature.geometry.type === "MultiPolygon" ? JSON.parse(clickedFeature.properties.center) : clickedFeature.geometry.coordinates;
+            this.metaAtlasCore.setLastClickedFeature({
+              mapObjectId: clickedFeature.properties.myMapObjectId,
+              coordinates: coords,
+              name: clickedFeature.properties.title,
+              whatDimension: clickedFeature.properties.dimension_what,
+              whereDimension: clickedFeature.properties.dimension_where,
+              geometry: clickedFeature.geometry,
+              properties: clickedFeature.properties,
+              clickEvent: e
             });
           }
-        } catch (err) {
-          _iterator2.e(err);
-        } finally {
-          _iterator2.f();
-        }
-        _this3.mapLoaded = true;
-        _this3.setupMapBoxDraw();
-      };
-
-      // Check if map is already loaded (React mode with pre-existing map instance)
-      if (this.map.loaded()) {
-        // Map is already loaded, execute initialization directly
-        setupLayers();
-      } else {
-        // Map not loaded yet, wait for load event (Vanilla mode)
-        this.map.on('load', setupLayers);
+        });
       }
-      this.map.on('error', function (error) {
-        _this3.onLoadFail(error.message);
+      this.mapLoaded = true;
+      this.setupMapBoxDraw();
+    };
+
+    // Check if map is already loaded (React mode with pre-existing map instance)
+    if (this.map.loaded()) {
+      // Map is already loaded, execute initialization directly
+      setupLayers();
+    } else {
+      // Map not loaded yet, wait for load event (Vanilla mode)
+      this.map.on('load', setupLayers);
+    }
+    this.map.on('error', error => {
+      this.onLoadFail(error.message);
+    });
+  }
+  setupMapBoxDraw() {
+    this.mapBoxDraw = new _mapboxGlDraw.default({
+      displayControlsDefault: false,
+      userProperties: true,
+      modes: {
+        ..._mapboxGlDraw.default.modes,
+        draw_marker: _draw_marker.default,
+        marker_select: _marker_select.default
+      },
+      styles: _customStyles.mapBoxDrawDefaultStyles
+    });
+    this.map.addControl(this.mapBoxDraw);
+    this.map.addSource(this.mapBoxDrawSourceID, {
+      'type': 'geojson',
+      'data': this.drawGeojsonData
+    });
+    for (let index = 0; index < _customStyles.customStyles.length; index++) {
+      const element = _customStyles.customStyles[index];
+      element['source'] = this.mapBoxDrawSourceID;
+      this.map.addLayer(element);
+      this.map.on('click', element.id, e => {
+        this.metaAtlasCore.setLastClickedFeature({
+          mapObjectId: null,
+          coordinates: null,
+          name: null,
+          whatDimension: null,
+          whereDimension: null,
+          geometry: null,
+          properties: null,
+          clickEvent: e
+        });
+        var clickedFeature = e.features[0];
+        this.overRideSelectionOfDrawnPointGeometry(clickedFeature);
+        if (clickedFeature.properties.id) this.lastClickedDrawing = this.getDrawingById(clickedFeature.properties.id);else this.lastClickedDrawing = this.setDrawing();
       });
     }
-  }, {
-    key: "setupMapBoxDraw",
-    value: function setupMapBoxDraw() {
-      var _this4 = this;
-      this.mapBoxDraw = new _mapboxGlDraw["default"]({
-        displayControlsDefault: false,
-        userProperties: true,
-        modes: _objectSpread(_objectSpread({}, _mapboxGlDraw["default"].modes), {}, {
-          draw_marker: _draw_marker["default"],
-          marker_select: _marker_select["default"]
-        }),
-        styles: _customStyles.mapBoxDrawDefaultStyles
-      });
-      this.map.addControl(this.mapBoxDraw);
-      this.map.addSource(this.mapBoxDrawSourceID, {
-        'type': 'geojson',
-        'data': this.drawGeojsonData
-      });
-      for (var index = 0; index < _customStyles.customStyles.length; index++) {
-        var element = _customStyles.customStyles[index];
-        element['source'] = this.mapBoxDrawSourceID;
-        this.map.addLayer(element);
-        this.map.on('click', element.id, function (e) {
-          _this4.metaAtlasCore.setLastClickedFeature({
-            mapObjectId: null,
-            coordinates: null,
-            name: null,
-            whatDimension: null,
-            whereDimension: null,
-            geometry: null,
-            properties: null,
-            clickEvent: e
+    this.mapLoaded = true;
+    this.onLoad();
+  }
+  addCustomerLayer = (map, jsonToPass, onLoaded) => {
+    let customerLayerUrl = jsonToPass.customerLayerUrl;
+    let sourceLayer = jsonToPass.sourceLayer;
+    _jquery.default.getJSON(customerLayerUrl, customerLayers => {
+      this.CustomerLayers = customerLayers;
+      for (const layer of this.CustomerLayers) {
+        layer["source-layer"] = sourceLayer;
+        map.addLayer(layer);
+        this.map.on('click', layer.id, e => {
+          //setup new clicked feature
+          const clickedFeature = e.features[0];
+          this.overRideSelectionOfDrawnPointGeometry(clickedFeature);
+          console.log('clickedFeature: ', clickedFeature);
+          this.logAnalyticsEvent('feature_clicked', {
+            feature_clicked: clickedFeature.properties.title
           });
-          var clickedFeature = e.features[0];
-          _this4.overRideSelectionOfDrawnPointGeometry(clickedFeature);
-          if (clickedFeature.properties.id) _this4.lastClickedDrawing = _this4.getDrawingById(clickedFeature.properties.id);else _this4.lastClickedDrawing = _this4.setDrawing();
+          if (clickedFeature.properties.isSearchable && clickedFeature.properties.title != 'Transit' && clickedFeature.properties.title != 'Public') {
+            const coords = clickedFeature.geometry.type === "Polygon" ? JSON.parse(clickedFeature.properties.center) : clickedFeature.geometry.coordinates;
+            this.metaAtlasCore.setLastClickedFeature({
+              mapObjectId: clickedFeature.properties.myMapObjectId,
+              coordinates: coords,
+              name: clickedFeature.properties.title,
+              whatDimension: clickedFeature.properties.dimension_what,
+              whereDimension: clickedFeature.properties.dimension_where,
+              geometry: clickedFeature.geometry,
+              properties: clickedFeature.properties,
+              clickEvent: e
+            });
+          }
         });
       }
-      this.mapLoaded = true;
-      this.onLoad();
-    }
-  }, {
-    key: "overRideSelectionOfDrawnPointGeometry",
-    value: function overRideSelectionOfDrawnPointGeometry(feature) {
-      // Check if a drawn point geometry is currently selected, it will be consider selected both in highlighted & non-highlighted state.
-      if (this.mapBoxDraw && this.mapBoxDraw.getMode() === 'simple_select' && this.mapBoxDraw.getAll().features.length === 1) {
-        var mapBoxDrawFeature = this.mapBoxDraw.getAll().features;
-        // If the passed in feature is not a drawn feature, then unselect drawn point type geometry
-        if (feature.properties.id === undefined) this.mapBoxDraw.deleteAll();
-        // If the passed in feature is a drawn feature, then unselect drawn point type geometry & highlight the passed in drawn geometry
-        else if (feature.properties.id !== undefined && mapBoxDrawFeature[0].id !== feature.properties.id) {
-          this.mapBoxDraw.deleteAll();
-          var directSelectOptions = {
-            featureId: feature.properties.id
-          };
-          // TODO: figure out why this doesn't work
-          // this.mapBoxDraw.changeMode('direct_select', directSelectOptions)
-        }
-      }
-    }
-  }, {
-    key: "getFocusTree",
-    value: function getFocusTree() {
-      return this.metaAtlasCore.getFocusTree();
-    }
-  }, {
-    key: "setDrawing",
-    value: function setDrawing() {
-      var id = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
-      var where = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
-      var geom = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
-      var props = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
-      var clickedFeature = {
-        "id": id,
-        "where": where,
-        "geometry": geom,
-        "properties": props
-      };
-      return clickedFeature;
-    }
-  }, {
-    key: "getLastClickedFeature",
-    value: function getLastClickedFeature() {
-      return this.metaAtlasCore.getLastClickedFeature();
-    }
-  }, {
-    key: "getLastClickedDrawing",
-    value: function getLastClickedDrawing() {
-      var clickedDrawing = this.lastClickedDrawing;
-      if (!this.lastClickedDrawing || this.lastClickedDrawing && (this.lastClickedDrawing.id === null || this.lastClickedDrawing.where === null)) {
-        clickedDrawing = this.setDrawing();
+      onLoaded();
+    });
+  };
+  overRideSelectionOfDrawnPointGeometry(feature) {
+    // Check if a drawn point geometry is currently selected, it will be consider selected both in highlighted & non-highlighted state.
+    if (this.mapBoxDraw && this.mapBoxDraw.getMode() === 'simple_select' && this.mapBoxDraw.getAll().features.length === 1) {
+      const mapBoxDrawFeature = this.mapBoxDraw.getAll().features;
+      // If the passed in feature is not a drawn feature, then unselect drawn point type geometry
+      if (feature.properties.id === undefined) this.mapBoxDraw.deleteAll();
+      // If the passed in feature is a drawn feature, then unselect drawn point type geometry & highlight the passed in drawn geometry
+      else if (feature.properties.id !== undefined && mapBoxDrawFeature[0].id !== feature.properties.id) {
+        this.mapBoxDraw.deleteAll();
+        const directSelectOptions = {
+          featureId: feature.properties.id
+        };
+        // TODO: figure out why this doesn't work
+        // this.mapBoxDraw.changeMode('direct_select', directSelectOptions)
       }
-      return clickedDrawing;
     }
-  }, {
-    key: "getMidPointOfFeature",
-    value: function getMidPointOfFeature(feature) {
-      return this.metaAtlasCore.getMidPointOfFeature(feature);
+  }
+  getFocusTree() {
+    return this.metaAtlasCore.getFocusTree();
+  }
+  setDrawing() {
+    let id = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+    let where = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+    let geom = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+    let props = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
+    const clickedFeature = {
+      "id": id,
+      "where": where,
+      "geometry": geom,
+      "properties": props
+    };
+    return clickedFeature;
+  }
+  getLastClickedFeature() {
+    return this.metaAtlasCore.getLastClickedFeature();
+  }
+  getLastClickedDrawing() {
+    let clickedDrawing = this.lastClickedDrawing;
+    if (!this.lastClickedDrawing || this.lastClickedDrawing && (this.lastClickedDrawing.id === null || this.lastClickedDrawing.where === null)) {
+      clickedDrawing = this.setDrawing();
     }
-  }, {
-    key: "dropPin",
-    value: function dropPin(mapItemSelected, popupStyle) {
-      var replaceLast = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
-      var pinObj = {
-        feature: mapItemSelected,
-        popupStyle: popupStyle
-      };
-      var markerElement = document.createElement('div');
-      markerElement.innerHTML = pinObj.popupStyle;
-      var popup = new maplibregl.Marker({
-        element: markerElement
-      }).setLngLat(this.getMidPointOfFeature(pinObj.feature)).addTo(this.map);
-      if (replaceLast) {
-        if (this.popups.length > 1) {
-          this.popups[this.popups.length - 1].popup.remove();
-          this.popups[this.popups.length - 1].popup = popup;
-          this.popups[this.popups.length - 1].id = pinObj.feature.mapObjectId;
-        } else {
-          if (this.popups.length > 0) this.popups[this.popups.length - 1].popup.remove();
-          this.popups = [{
-            popup: popup,
-            id: pinObj.feature.mapObjectId
-          }];
-        }
+    return clickedDrawing;
+  }
+  getMidPointOfFeature(feature) {
+    return this.metaAtlasCore.getMidPointOfFeature(feature);
+  }
+  dropPin(mapItemSelected, popupStyle) {
+    let replaceLast = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+    const pinObj = {
+      feature: mapItemSelected,
+      popupStyle: popupStyle
+    };
+    const markerElement = document.createElement('div');
+    markerElement.innerHTML = pinObj.popupStyle;
+    const popup = new maplibregl.Marker({
+      element: markerElement
+    }).setLngLat(this.getMidPointOfFeature(pinObj.feature)).addTo(this.map);
+    if (replaceLast) {
+      if (this.popups.length > 1) {
+        this.popups[this.popups.length - 1].popup.remove();
+        this.popups[this.popups.length - 1].popup = popup;
+        this.popups[this.popups.length - 1].id = pinObj.feature.mapObjectId;
       } else {
-        this.popups.push({
+        if (this.popups.length > 0) this.popups[this.popups.length - 1].popup.remove();
+        this.popups = [{
           popup: popup,
           id: pinObj.feature.mapObjectId
-        });
+        }];
       }
-      return this.popups[this.popups.length - 1].id;
+    } else {
+      this.popups.push({
+        popup: popup,
+        id: pinObj.feature.mapObjectId
+      });
     }
-  }, {
-    key: "dropMarkerForRouting",
-    value: function dropMarkerForRouting(destinations) {
-      var _this5 = this;
-      destinations.forEach(function (destination) {
-        var _destination$selected, _destination$selected2;
-        console.log(destination.selectedLocation, 'destination.selectedLocation');
-        var coordinates = (_destination$selected = destination.selectedLocation) !== null && _destination$selected !== void 0 && _destination$selected.coordinates ? destination.selectedLocation.coordinates : (_destination$selected2 = destination.selectedLocation) === null || _destination$selected2 === void 0 || (_destination$selected2 = _destination$selected2.geometry) === null || _destination$selected2 === void 0 ? void 0 : _destination$selected2.coordinates;
-        console.log(coordinates, 'Coordinates'); // Debugging line
+    return this.popups[this.popups.length - 1].id;
+  }
+  dropMarkerForRouting(destinations) {
+    destinations.forEach(destination => {
+      console.log(destination.selectedLocation, 'destination.selectedLocation');
+      const coordinates = destination.selectedLocation?.coordinates ? destination.selectedLocation.coordinates : destination.selectedLocation?.geometry?.coordinates;
+      console.log(coordinates, 'Coordinates'); // Debugging line
 
-        if (coordinates && coordinates.length === 2) {
-          var marker = new _this5.maplibregl.Marker({
-            color: '#188689'
-          }).setLngLat([coordinates[0], coordinates[1]]) // Ensure correct format
-          .addTo(_this5.map);
-          _this5.markers.push(marker);
-        } else {
-          console.error('Invalid coordinates:', coordinates);
-        }
+      if (coordinates && coordinates.length === 2) {
+        const marker = new this.maplibregl.Marker({
+          color: '#188689'
+        }).setLngLat([coordinates[0], coordinates[1]]) // Ensure correct format
+        .addTo(this.map);
+        this.markers.push(marker);
+      } else {
+        console.error('Invalid coordinates:', coordinates);
+      }
+    });
+  }
+  clearMarker() {
+    if (this.markers && this.markers.length > 0) {
+      this.markers.forEach(marker => {
+        marker.remove();
       });
     }
-  }, {
-    key: "clearMarker",
-    value: function clearMarker() {
-      if (this.markers && this.markers.length > 0) {
-        this.markers.forEach(function (marker) {
-          marker.remove();
-        });
+    this.markers = [];
+  }
+  extractLocation(text) {
+    const match = text.match(/^(?:[^_]*_){3}([^_]*)/);
+    return match ? match[1] : null;
+  }
+  hidePin() {
+    let pinId = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '-1';
+    let targetPinId;
+    if (pinId === '-1') {
+      const lastPin = this.popups[this.popups.length - 1];
+      if (!lastPin) {
+        console.warn('No pins available to hide.');
+        return;
       }
-      this.markers = [];
-    }
-  }, {
-    key: "extractLocation",
-    value: function extractLocation(text) {
-      var match = text.match(/^(?:[^_]*_){3}([^_]*)/);
-      return match ? match[1] : null;
+      targetPinId = lastPin.id;
+    } else {
+      targetPinId = pinId;
     }
-  }, {
-    key: "hidePin",
-    value: function hidePin() {
-      var pinId = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '-1';
-      var targetPinId;
-      if (pinId === '-1') {
-        var lastPin = this.popups[this.popups.length - 1];
-        if (!lastPin) {
-          console.warn('No pins available to hide.');
-          return;
-        }
-        targetPinId = lastPin.id;
-      } else {
-        targetPinId = pinId;
+    const pinToHide = this.popups.find(pin => pin.id === targetPinId);
+    if (pinToHide) {
+      let popupElem = pinToHide.popup.getElement();
+      if (popupElem) {
+        popupElem.style.display = 'none';
       }
-      var pinToHide = this.popups.find(function (pin) {
-        return pin.id === targetPinId;
-      });
-      if (pinToHide) {
-        var popupElem = pinToHide.popup.getElement();
+      console.log(`Pin with ID: ${targetPinId} is now hidden.`);
+    } else {
+      console.warn(`Pin with ID: ${targetPinId} not found.`);
+    }
+  }
+  hidePins() {
+    if (this.popups.length > 0) {
+      this.popups.forEach(obj => {
+        let popupElem = obj.popup.getElement();
         if (popupElem) {
+          console.log(popupElem.style.display);
           popupElem.style.display = 'none';
         }
-        console.log("Pin with ID: ".concat(targetPinId, " is now hidden."));
-      } else {
-        console.warn("Pin with ID: ".concat(targetPinId, " not found."));
-      }
+      });
     }
-  }, {
-    key: "hidePins",
-    value: function hidePins() {
-      if (this.popups.length > 0) {
-        this.popups.forEach(function (obj) {
-          var popupElem = obj.popup.getElement();
-          if (popupElem) {
-            console.log(popupElem.style.display);
-            popupElem.style.display = 'none';
-          }
-        });
+  }
+  showPin() {
+    let pinId = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '-1';
+    let targetPinId;
+    if (pinId === '-1') {
+      const lastPin = this.popups[this.popups.length - 1];
+      if (!lastPin) {
+        console.warn('No pins available to show.');
+        return;
       }
+      targetPinId = lastPin.id;
+    } else {
+      targetPinId = pinId;
     }
-  }, {
-    key: "showPin",
-    value: function showPin() {
-      var pinId = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '-1';
-      var targetPinId;
-      if (pinId === '-1') {
-        var lastPin = this.popups[this.popups.length - 1];
-        if (!lastPin) {
-          console.warn('No pins available to show.');
-          return;
-        }
-        targetPinId = lastPin.id;
-      } else {
-        targetPinId = pinId;
+    const pinToHide = this.popups.find(pin => pin.id === targetPinId);
+    if (pinToHide) {
+      let popupElem = pinToHide.popup.getElement();
+      if (popupElem) {
+        popupElem.style.display = 'flex';
       }
-      var pinToHide = this.popups.find(function (pin) {
-        return pin.id === targetPinId;
-      });
-      if (pinToHide) {
-        var popupElem = pinToHide.popup.getElement();
+      console.log(`Pin with ID: ${targetPinId} is now visible.`);
+    } else {
+      console.warn(`Pin with ID: ${targetPinId} not found.`);
+    }
+  }
+  showPins() {
+    if (this.popups.length > 0) {
+      this.popups.forEach(obj => {
+        let popupElem = obj.popup.getElement();
         if (popupElem) {
           popupElem.style.display = 'flex';
         }
-        console.log("Pin with ID: ".concat(targetPinId, " is now visible."));
-      } else {
-        console.warn("Pin with ID: ".concat(targetPinId, " not found."));
-      }
-    }
-  }, {
-    key: "showPins",
-    value: function showPins() {
-      if (this.popups.length > 0) {
-        this.popups.forEach(function (obj) {
-          var popupElem = obj.popup.getElement();
-          if (popupElem) {
-            popupElem.style.display = 'flex';
-          }
-        });
-      }
+      });
     }
-  }, {
-    key: "clearPin",
-    value: function clearPin() {
-      var pinId = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '-1';
-      var targetPinIndex;
-      if (pinId === '-1') {
-        targetPinIndex = this.popups.length - 1;
-        if (targetPinIndex < 0) {
-          console.warn('No pins available to clear.');
-          return;
-        }
-      } else {
-        targetPinIndex = this.popups.findIndex(function (pin) {
-          return pin.id === pinId;
-        });
-        if (targetPinIndex === -1) {
-          console.warn("Pin with ID: ".concat(pinId, " not found."));
-          return;
-        }
-      }
-      if (this.popups[targetPinIndex]) {
-        this.popups[targetPinIndex].popup.remove();
-        this.popups.splice(targetPinIndex, 1);
+  }
+  clearPin() {
+    let pinId = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '-1';
+    let targetPinIndex;
+    if (pinId === '-1') {
+      targetPinIndex = this.popups.length - 1;
+      if (targetPinIndex < 0) {
+        console.warn('No pins available to clear.');
+        return;
       }
-    }
-  }, {
-    key: "clearPins",
-    value: function clearPins() {
-      if (this.popups.length > 0) {
-        this.popups.forEach(function (obj) {
-          obj.popup.remove();
-        });
-        this.popups.length = 0;
+    } else {
+      targetPinIndex = this.popups.findIndex(pin => pin.id === pinId);
+      if (targetPinIndex === -1) {
+        console.warn(`Pin with ID: ${pinId} not found.`);
+        return;
       }
     }
-  }, {
-    key: "removePin",
-    value: function removePin() {
-      (0, _jquery["default"])('.mapboxgl-popup').remove();
-    }
-  }, {
-    key: "getCurrentFocus",
-    value: function getCurrentFocus() {
-      return this.metaAtlasCore.getCurrentFocus();
+    if (this.popups[targetPinIndex]) {
+      this.popups[targetPinIndex].popup.remove();
+      this.popups.splice(targetPinIndex, 1);
     }
-  }, {
-    key: "getCurrentFocusBuilding",
-    value: function getCurrentFocusBuilding() {
-      return this.metaAtlasCore.getCurrentFocusBuilding();
-    }
-  }, {
-    key: "getCurrentFocusFloor",
-    value: function getCurrentFocusFloor() {
-      return this.metaAtlasCore.getCurrentFocusFloor();
-    }
-  }, {
-    key: "addUserLayer",
-    value: function addUserLayer(layer) {
-      var _this6 = this;
-      this.UserLayers.push(layer);
-      this.map.addLayer(layer);
-      this.map.on('click', layer.id, function (e) {
-        //setup new clicked feature
-        var clickedFeature = e.features[0];
-        var coords = clickedFeature.geometry.type === "Polygon" ? JSON.parse(clickedFeature.properties.center) : clickedFeature.geometry.coordinates;
-        _this6.metaAtlasCore.setLastClickedFeature({
-          mapObjectId: clickedFeature.properties.id,
-          coordinates: coords,
-          name: clickedFeature.properties.name,
-          whatDimension: clickedFeature.properties.dimension_what,
-          whereDimension: clickedFeature.properties.dimension_where,
-          geometry: clickedFeature.geometry,
-          properties: clickedFeature.properties,
-          clickEvent: e
-        });
+  }
+  clearPins() {
+    if (this.popups.length > 0) {
+      this.popups.forEach(obj => {
+        obj.popup.remove();
       });
+      this.popups.length = 0;
     }
-  }, {
-    key: "filterWhereDimension",
-    value: function filterWhereDimension(dimensionWhere) {
-      // filter user layers
-      var userLayers = (0, _cloneDeep["default"])(this.UserLayers);
-      if (userLayers.length > 0) {
-        var updatedUserLayersData = this.metaAtlasCore.filterBaseMapWhereDimension(userLayers, dimensionWhere);
-        for (var index = 0; index < updatedUserLayersData.length; index++) {
-          var layerID = updatedUserLayersData[index].id;
-          var layerFilter = updatedUserLayersData[index].filter;
-          userLayers[index].filter = layerFilter;
-          this.map.setFilter(layerID, layerFilter);
-        }
+  }
+  removePin() {
+    (0, _jquery.default)('.mapboxgl-popup').remove();
+  }
+  getCurrentFocus() {
+    return this.metaAtlasCore.getCurrentFocus();
+  }
+  getCurrentFocusBuilding() {
+    return this.metaAtlasCore.getCurrentFocusBuilding();
+  }
+  getCurrentFocusFloor() {
+    return this.metaAtlasCore.getCurrentFocusFloor();
+  }
+  addUserLayer(layer) {
+    this.UserLayers.push(layer);
+    this.map.addLayer(layer);
+    this.map.on('click', layer.id, e => {
+      //setup new clicked feature
+      var clickedFeature = e.features[0];
+      const coords = clickedFeature.geometry.type === "Polygon" ? JSON.parse(clickedFeature.properties.center) : clickedFeature.geometry.coordinates;
+      this.metaAtlasCore.setLastClickedFeature({
+        mapObjectId: clickedFeature.properties.id,
+        coordinates: coords,
+        name: clickedFeature.properties.name,
+        whatDimension: clickedFeature.properties.dimension_what,
+        whereDimension: clickedFeature.properties.dimension_where,
+        geometry: clickedFeature.geometry,
+        properties: clickedFeature.properties,
+        clickEvent: e
+      });
+    });
+  }
+  filterWhereDimension(dimensionWhere) {
+    // filter user layers
+    let userLayers = (0, _cloneDeep.default)(this.UserLayers);
+    if (userLayers.length > 0) {
+      let updatedUserLayersData = this.metaAtlasCore.filterBaseMapWhereDimension(userLayers, dimensionWhere);
+      for (let index = 0; index < updatedUserLayersData.length; index++) {
+        const layerID = updatedUserLayersData[index].id;
+        const layerFilter = updatedUserLayersData[index].filter;
+        userLayers[index].filter = layerFilter;
+        this.map.setFilter(layerID, layerFilter);
       }
+    }
 
-      // filter basemap layers
-      var layers = (0, _cloneDeep["default"])(this.CustomerLayers);
-      for (var _index = 0; _index < layers.length; _index += 1) {
-        var _layerID = layers[_index].id;
-        var _layerFilter = this.map.getFilter(_layerID);
-        layers[_index].filter = _layerFilter;
-      }
-      var updatedLayersData = this.metaAtlasCore.filterBaseMapWhereDimension(layers, dimensionWhere);
-      for (var _index2 = 0; _index2 < updatedLayersData.length; _index2 += 1) {
-        var _layerID2 = updatedLayersData[_index2].id;
-        var _layerFilter2 = updatedLayersData[_index2].filter;
-        this.map.setFilter(_layerID2, _layerFilter2);
-      }
+    // filter basemap layers
+    let layers = (0, _cloneDeep.default)(this.CustomerLayers);
+    for (let index = 0; index < layers.length; index += 1) {
+      const layerID = layers[index].id;
+      const layerFilter = this.map.getFilter(layerID);
+      layers[index].filter = layerFilter;
+    }
+    let updatedLayersData = this.metaAtlasCore.filterBaseMapWhereDimension(layers, dimensionWhere);
+    for (let index = 0; index < updatedLayersData.length; index += 1) {
+      const layerID = updatedLayersData[index].id;
+      const layerFilter = updatedLayersData[index].filter;
+      this.map.setFilter(layerID, layerFilter);
+    }
 
-      // // filter non-basemap layers
-      // layers = cloneDeep(customStyles.concat(routeLayers));
-      // for (let index = 0; index < layers.length; index += 1) {
-      //   const layerID = layers[index].id;
-      //   const layerFilter = this.map.getFilter(layerID);
-      //   layers[index].filter = layerFilter;
-      // }
-      // updatedLayersData =
-      //   this.metaAtlasCore.filterLayersWhereDimension(
-      //     layers,
-      //     dimensionWhere,
-      //   );
+    // // filter non-basemap layers
+    // layers = cloneDeep(customStyles.concat(routeLayers));
+    // for (let index = 0; index < layers.length; index += 1) {
+    //   const layerID = layers[index].id;
+    //   const layerFilter = this.map.getFilter(layerID);
+    //   layers[index].filter = layerFilter;
+    // }
+    // updatedLayersData =
+    //   this.metaAtlasCore.filterLayersWhereDimension(
+    //     layers,
+    //     dimensionWhere,
+    //   );
 
-      // for (let index = 0; index < updatedLayersData.length; index += 1) {
-      //   const layerID = updatedLayersData[index].id;
-      //   const layerFilter = updatedLayersData[index].filter;
-      // }
-    }
-  }, {
-    key: "focusTo",
-    value: function focusTo(whereTaxonomyPath) {
-      var moveCamera = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-      var map = this.map;
-      var dimensionWhere = whereTaxonomyPath;
-      if (!dimensionWhere || !map) return;
-      console.log(whereTaxonomyPath, 'whereTaxonomyPath');
-      this.filterWhereDimension(dimensionWhere);
-      var isMobile = window.innerWidth < 768;
-      if (moveCamera) {
-        var flyToConfig = this.metaAtlasCore.getFlyToLocation(dimensionWhere, isMobile);
-        this.map.flyTo({
-          center: flyToConfig.center ? flyToConfig.center : this.map.getCenter(),
-          zoom: flyToConfig.zoom ? flyToConfig.zoom : this.map.getZoom(),
-          bearing: flyToConfig.bearing ? flyToConfig.bearing : this.map.getBearing(),
-          speed: 0.8
-        });
+    // for (let index = 0; index < updatedLayersData.length; index += 1) {
+    //   const layerID = updatedLayersData[index].id;
+    //   const layerFilter = updatedLayersData[index].filter;
+    // }
+  }
+  focusTo(whereTaxonomyPath) {
+    let moveCamera = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+    const map = this.map;
+    let dimensionWhere = whereTaxonomyPath;
+    if (!dimensionWhere || !map) return;
+    console.log(whereTaxonomyPath, 'whereTaxonomyPath');
+    this.filterWhereDimension(dimensionWhere);
+    const isMobile = window.innerWidth < 768;
+    if (moveCamera) {
+      const flyToConfig = this.metaAtlasCore.getFlyToLocation(dimensionWhere, isMobile);
+      this.map.flyTo({
+        center: flyToConfig.center ? flyToConfig.center : this.map.getCenter(),
+        zoom: flyToConfig.zoom ? flyToConfig.zoom : this.map.getZoom(),
+        bearing: flyToConfig.bearing ? flyToConfig.bearing : this.map.getBearing(),
+        speed: 0.8
+      });
 
-        // track inside so that only user requested focus is tracked
-        // logEvent(this.analytics, 'focus_changed', { location: dimensionWhere });
-      }
+      // track inside so that only user requested focus is tracked
+      // logEvent(this.analytics, 'focus_changed', { location: dimensionWhere });
     }
-  }, {
-    key: "filterLayersByCategories",
-    value: function filterLayersByCategories(filterType, filterValues, geomType, dimensionWhat) {
-      var map = this.map;
-      if (!filterValues || !map) return;
-      var layers = (0, _cloneDeep["default"])(this.CustomerLayers);
-      for (var index = 0; index < layers.length; index += 1) {
-        var layerID = layers[index].id;
-        var layerFilter = this.map.getFilter(layerID);
-        layers[index].filter = layerFilter;
-      }
-      var updatedLayersData = this.metaAtlasCore.filterLayersByCategories(layers, filterType, filterValues, geomType, dimensionWhat, this.map);
-      for (var _index3 = 0; _index3 < updatedLayersData.length; _index3 += 1) {
-        var _layerID3 = updatedLayersData[_index3].id;
-        var _layerFilter3 = updatedLayersData[_index3].filter;
-        this.map.setFilter(_layerID3, _layerFilter3);
-      }
+  }
+  filterLayersByCategories(filterType, filterValues, geomType, dimensionWhat) {
+    const map = this.map;
+    if (!filterValues || !map) return;
+    let layers = (0, _cloneDeep.default)(this.CustomerLayers);
+    for (let index = 0; index < layers.length; index += 1) {
+      const layerID = layers[index].id;
+      const layerFilter = this.map.getFilter(layerID);
+      layers[index].filter = layerFilter;
+    }
+    let updatedLayersData = this.metaAtlasCore.filterLayersByCategories(layers, filterType, filterValues, geomType, dimensionWhat, this.map);
+    for (let index = 0; index < updatedLayersData.length; index += 1) {
+      const layerID = updatedLayersData[index].id;
+      const layerFilter = updatedLayersData[index].filter;
+      this.map.setFilter(layerID, layerFilter);
     }
-  }, {
-    key: "filterLayersByType",
-    value: function filterLayersByType(filterType, filterValues) {
-      var geomType = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
-      var map = this.map;
-      if (!filterValues || !map) return;
-      var userLayers = (0, _cloneDeep["default"])(this.UserLayers);
-      if (userLayers.length > 0) {
-        var updatedUserLayersData = this.metaAtlasCore.filterLayersByType(userLayers, filterType, filterValues, geomType);
-        for (var index = 0; index < updatedUserLayersData.length; index++) {
-          var layerID = updatedUserLayersData[index].id;
-          var layerFilter = updatedUserLayersData[index].filter;
-          userLayers[index].filter = layerFilter;
-          this.map.setFilter(layerID, layerFilter);
-        }
+  }
+  filterLayersByType(filterType, filterValues) {
+    let geomType = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+    const map = this.map;
+    if (!filterValues || !map) return;
+    let userLayers = (0, _cloneDeep.default)(this.UserLayers);
+    if (userLayers.length > 0) {
+      let updatedUserLayersData = this.metaAtlasCore.filterLayersByType(userLayers, filterType, filterValues, geomType);
+      for (let index = 0; index < updatedUserLayersData.length; index++) {
+        const layerID = updatedUserLayersData[index].id;
+        const layerFilter = updatedUserLayersData[index].filter;
+        userLayers[index].filter = layerFilter;
+        this.map.setFilter(layerID, layerFilter);
       }
     }
-  }, {
-    key: "styleLayersByType",
-    value: function styleLayersByType(filterType, filterValues, property, value) {
-      if (!filterValues || !this.map) return;
-      var styleJson = this.map.getStyle();
-      var layers = styleJson.layers;
-      var updatedLayersData = this.metaAtlasCore.styleLayersByType(layers, filterType, filterValues, property, value);
-      for (var index = 0; index < updatedLayersData.length; index += 1) {
-        var layerID = updatedLayersData[index].id;
-        var layerStyle = updatedLayersData[index].paint;
-        var layerType = updatedLayersData[index].type;
-        if (layerType && (layerType === 'fill' || layerType === 'line')) {
-          if (layerStyle[property]) {
-            this.map.setPaintProperty(layerID, property, layerStyle[property]);
-          }
+  }
+  styleLayersByType(filterType, filterValues, property, value) {
+    if (!filterValues || !this.map) return;
+    let styleJson = this.map.getStyle();
+    let layers = styleJson.layers;
+    let updatedLayersData = this.metaAtlasCore.styleLayersByType(layers, filterType, filterValues, property, value);
+    for (let index = 0; index < updatedLayersData.length; index += 1) {
+      const layerID = updatedLayersData[index].id;
+      const layerStyle = updatedLayersData[index].paint;
+      const layerType = updatedLayersData[index].type;
+      if (layerType && (layerType === 'fill' || layerType === 'line')) {
+        if (layerStyle[property]) {
+          this.map.setPaintProperty(layerID, property, layerStyle[property]);
         }
       }
     }
-  }, {
-    key: "clearStyleLayersByType",
-    value: function clearStyleLayersByType(filterType, filterValues, property) {
-      if (!this.map) return;
-      var styleJson = this.map.getStyle();
-      var layers = styleJson.layers;
-      var updatedLayersData = this.metaAtlasCore.clearStyleLayersByType(layers, filterType, filterValues, property);
-      for (var index = 0; index < updatedLayersData.length; index += 1) {
-        var layerID = updatedLayersData[index].id;
-        var layerStyle = updatedLayersData[index].paint;
-        var layerType = updatedLayersData[index].type;
-        if (layerType && (layerType === 'fill' || layerType === 'line')) {
-          if (layerStyle[property]) {
-            this.map.setPaintProperty(layerID, property, layerStyle[property]);
-          }
+  }
+  clearStyleLayersByType(filterType, filterValues, property) {
+    if (!this.map) return;
+    let styleJson = this.map.getStyle();
+    let layers = styleJson.layers;
+    let updatedLayersData = this.metaAtlasCore.clearStyleLayersByType(layers, filterType, filterValues, property);
+    for (let index = 0; index < updatedLayersData.length; index += 1) {
+      const layerID = updatedLayersData[index].id;
+      const layerStyle = updatedLayersData[index].paint;
+      const layerType = updatedLayersData[index].type;
+      if (layerType && (layerType === 'fill' || layerType === 'line')) {
+        if (layerStyle[property]) {
+          this.map.setPaintProperty(layerID, property, layerStyle[property]);
         }
       }
     }
-  }, {
-    key: "changeTerminalInFocusToUserViewpoint",
-    value: function changeTerminalInFocusToUserViewpoint() {
-      var defaultFloor = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-      var center = this.map.getCenter().wrap();
-      var centerArray = [center.lng, center.lat];
-      // console.log('center: ', center);
-      if (this.metaAtlasCore.checkUserViewport(centerArray, this.getCurrentFocusBuilding(), this.getCurrentFocusFloor())) return true;
-      //get building to focus to
-      var building = this.metaAtlasCore.getUserViewportBuilding(centerArray);
-      // console.log("focus to:");
-      // console.log(building);
-      if (!building) return false;
-      //focus to default floor provided
-      if (building["name"] in defaultFloor) {
-        this.focusTo(defaultFloor[building["name"]], false);
-        return true;
-      }
-      //focus to default floor in focusTree
-      // if (!building.hasOwnProperty("defaultFloorPath")) return true;
-      // this.focusTo(building["defaultFloorPath"], false);
-
+  }
+  changeTerminalInFocusToUserViewpoint() {
+    let defaultFloor = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    let center = this.map.getCenter().wrap();
+    const centerArray = [center.lng, center.lat];
+    // console.log('center: ', center);
+    if (this.metaAtlasCore.checkUserViewport(centerArray, this.getCurrentFocusBuilding(), this.getCurrentFocusFloor())) return true;
+    //get building to focus to
+    let building = this.metaAtlasCore.getUserViewportBuilding(centerArray);
+    // console.log("focus to:");
+    // console.log(building);
+    if (!building) return false;
+    //focus to default floor provided
+    if (building["name"] in defaultFloor) {
+      this.focusTo(defaultFloor[building["name"]], false);
       return true;
     }
-  }, {
-    key: "isLocationWithinHongKong",
-    value: function isLocationWithinHongKong(location) {
-      // Define the polygon coordinates
-      var polygonCoordinates = [[103.59716039266556, 1.2570288388163817], [103.5792058079661, 1.2001127572538621], [103.69481581677104, 1.2005505778590049], [103.9124604166791, 1.2408297702235416], [104.07843084598773, 1.3003717948835174], [104.09332001378709, 1.3428384139758691], [104.06568408463107, 1.4395702492902842], [104.01405273250049, 1.430831826129534], [103.94486100905976, 1.4264524124152587], [103.88661860370877, 1.4347670822090777], [103.84020398120549, 1.470670314084117], [103.79466396668937, 1.467591709607774], [103.75700361138325, 1.4470255906078648], [103.72197278477057, 1.4605952336399213], [103.68041038922672, 1.4408697939934143], [103.64577440712543, 1.379174061413977], [103.59716039266556, 1.2570288388163817], [103.59716039266556, 1.2570288388163817] // Close the polygon by repeating the first point
-      ];
+    //focus to default floor in focusTree
+    // if (!building.hasOwnProperty("defaultFloorPath")) return true;
+    // this.focusTo(building["defaultFloorPath"], false);
 
-      // Create the polygon using Turf.js
-      var polygon = (0, _helpers.polygon)([polygonCoordinates]);
+    return true;
+  }
+  isLocationWithinHongKong(location) {
+    // Define the polygon coordinates
+    const polygonCoordinates = [[103.59716039266556, 1.2570288388163817], [103.5792058079661, 1.2001127572538621], [103.69481581677104, 1.2005505778590049], [103.9124604166791, 1.2408297702235416], [104.07843084598773, 1.3003717948835174], [104.09332001378709, 1.3428384139758691], [104.06568408463107, 1.4395702492902842], [104.01405273250049, 1.430831826129534], [103.94486100905976, 1.4264524124152587], [103.88661860370877, 1.4347670822090777], [103.84020398120549, 1.470670314084117], [103.79466396668937, 1.467591709607774], [103.75700361138325, 1.4470255906078648], [103.72197278477057, 1.4605952336399213], [103.68041038922672, 1.4408697939934143], [103.64577440712543, 1.379174061413977], [103.59716039266556, 1.2570288388163817], [103.59716039266556, 1.2570288388163817] // Close the polygon by repeating the first point
+    ];
 
-      // Define the point to check
-      var point = (0, _helpers.point)(location); // Replace with your point's coordinates
+    // Create the polygon using Turf.js
+    const polygon = (0, _helpers.polygon)([polygonCoordinates]);
 
-      // Check if the point is within the polygon
-      var isInside = (0, _booleanPointInPolygon["default"])(point, polygon);
-      return isInside;
-    }
-  }, {
-    key: "getMapObjectsByFilteredLocalRef",
-    value: function getMapObjectsByFilteredLocalRef() {
-      var _this$metaAtlasCore;
-      return (_this$metaAtlasCore = this.metaAtlasCore).getMapObjectsByFilteredLocalRef.apply(_this$metaAtlasCore, arguments);
-    }
-  }, {
-    key: "getMapObjectsByName",
-    value: function getMapObjectsByName() {
-      var _this$metaAtlasCore2;
-      return (_this$metaAtlasCore2 = this.metaAtlasCore).getMapObjectsByName.apply(_this$metaAtlasCore2, arguments);
-    }
-  }, {
-    key: "getMapObjectById",
-    value: function getMapObjectById() {
-      var _this$metaAtlasCore3;
-      return (_this$metaAtlasCore3 = this.metaAtlasCore).getMapObjectById.apply(_this$metaAtlasCore3, arguments);
-    }
-  }, {
-    key: "getMapObjectByLocalRef",
-    value: function getMapObjectByLocalRef() {
-      var _this$metaAtlasCore4;
-      return (_this$metaAtlasCore4 = this.metaAtlasCore).getMapObjectByLocalRef.apply(_this$metaAtlasCore4, arguments);
-    }
-  }, {
-    key: "getMapObjectMatchingLocalRef",
-    value: function getMapObjectMatchingLocalRef() {
-      var _this$metaAtlasCore5;
-      return (_this$metaAtlasCore5 = this.metaAtlasCore).getMapObjectMatchingLocalRef.apply(_this$metaAtlasCore5, arguments);
-    }
-  }, {
-    key: "getMapObjectsMatchingLocalRefs",
-    value: function getMapObjectsMatchingLocalRefs() {
-      var _this$metaAtlasCore6;
-      return (_this$metaAtlasCore6 = this.metaAtlasCore).getMapObjectsMatchingLocalRefs.apply(_this$metaAtlasCore6, arguments);
-    }
-  }, {
-    key: "getMapObjectsByWhatTaxonomy",
-    value: function getMapObjectsByWhatTaxonomy() {
-      var _this$metaAtlasCore7;
-      return (_this$metaAtlasCore7 = this.metaAtlasCore).getMapObjectsByWhatTaxonomy.apply(_this$metaAtlasCore7, arguments);
-    }
-  }, {
-    key: "getMapObjectsByWhatTaxonomyAPI",
-    value: function getMapObjectsByWhatTaxonomyAPI() {
-      var _this$metaAtlasCore8;
-      return (_this$metaAtlasCore8 = this.metaAtlasCore).getMapObjectsByWhatTaxonomyAPI.apply(_this$metaAtlasCore8, arguments);
-    }
-  }, {
-    key: "getMapObjectsByWhereTaxonomy",
-    value: function getMapObjectsByWhereTaxonomy() {
-      var _this$metaAtlasCore9;
-      return (_this$metaAtlasCore9 = this.metaAtlasCore).getMapObjectsByWhereTaxonomy.apply(_this$metaAtlasCore9, arguments);
-    }
-  }, {
-    key: "getMapObjectsByWhatAndWhereTaxonomy",
-    value: function getMapObjectsByWhatAndWhereTaxonomy() {
-      var _this$metaAtlasCore0;
-      return (_this$metaAtlasCore0 = this.metaAtlasCore).getMapObjectsByWhatAndWhereTaxonomy.apply(_this$metaAtlasCore0, arguments);
-    }
-  }, {
-    key: "getMapObjectsInWhatTaxonomy",
-    value: function getMapObjectsInWhatTaxonomy() {
-      var _this$metaAtlasCore1;
-      return (_this$metaAtlasCore1 = this.metaAtlasCore).getMapObjectsInWhatTaxonomy.apply(_this$metaAtlasCore1, arguments);
-    }
-  }, {
-    key: "getMapObjectsInWhereTaxonomy",
-    value: function getMapObjectsInWhereTaxonomy() {
-      var _this$metaAtlasCore10;
-      return (_this$metaAtlasCore10 = this.metaAtlasCore).getMapObjectsInWhereTaxonomy.apply(_this$metaAtlasCore10, arguments);
-    }
+    // Define the point to check
+    const point = (0, _helpers.point)(location); // Replace with your point's coordinates
 
-    // Routing
-  }, {
-    key: "computeRoute",
-    value: function computeRoute() {
-      var _this$routingVisualiz;
-      return (_this$routingVisualiz = this.routingVisualizer).computeRoute.apply(_this$routingVisualiz, arguments);
-    }
-  }, {
-    key: "computeRoutes",
-    value: function computeRoutes(mapObjectIds) {
-      var _this7 = this;
-      var wheelChairAccessibleRouteOnly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-      var source = arguments.length > 2 ? arguments[2] : undefined;
-      var ref = this;
-      var logRouteEvent = /*#__PURE__*/function () {
-        var _ref = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2() {
-          var getNameByIdAsync, getNamesFromIds, names;
-          return _regenerator().w(function (_context2) {
-            while (1) switch (_context2.n) {
-              case 0:
-                getNameByIdAsync = function getNameByIdAsync(id) {
-                  return new Promise(function (resolve) {
-                    if (typeof id !== 'string') resolve('User GPS Location');
-                    ref.getMapObjectById(id, function (mapObj) {
-                      var _mapObj$;
-                      resolve((_mapObj$ = mapObj[0]) === null || _mapObj$ === void 0 ? void 0 : _mapObj$.name);
-                    });
-                  });
-                };
-                getNamesFromIds = /*#__PURE__*/function () {
-                  var _ref2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(idList) {
-                    var namePromises;
-                    return _regenerator().w(function (_context) {
-                      while (1) switch (_context.n) {
-                        case 0:
-                          namePromises = idList.map(function (id) {
-                            return getNameByIdAsync(id);
-                          });
-                          _context.n = 1;
-                          return Promise.all(namePromises);
-                        case 1:
-                          return _context.a(2, _context.v);
-                      }
-                    }, _callee);
-                  }));
-                  return function getNamesFromIds(_x) {
-                    return _ref2.apply(this, arguments);
-                  };
-                }();
-                _context2.n = 1;
-                return getNamesFromIds(mapObjectIds);
-              case 1:
-                names = _context2.v;
-                names.forEach(function (name) {
-                  _this7.logAnalyticsEvent('route_per_object', {
-                    destination: name,
-                    route_per_object_event_source: source
-                  });
-                });
-                _this7.logAnalyticsEvent('route', {
-                  destinations: names,
-                  route_event_source: source
-                });
-              case 2:
-                return _context2.a(2);
-            }
-          }, _callee2);
-        }));
-        return function logRouteEvent() {
-          return _ref.apply(this, arguments);
-        };
-      }();
-      logRouteEvent();
-      return this.routingVisualizer.computeRoutes(mapObjectIds, wheelChairAccessibleRouteOnly);
-    }
-  }, {
-    key: "setActiveRoute",
-    value: function setActiveRoute() {
-      var _this$routingVisualiz2;
-      return (_this$routingVisualiz2 = this.routingVisualizer).setActiveRoute.apply(_this$routingVisualiz2, arguments);
-    }
-  }, {
-    key: "getActiveRoute",
-    value: function getActiveRoute() {
-      var _this$routingVisualiz3;
-      return (_this$routingVisualiz3 = this.routingVisualizer).getActiveRoute.apply(_this$routingVisualiz3, arguments);
-    }
-  }, {
-    key: "highlightRouteSegment",
-    value: function highlightRouteSegment() {
-      var _this$routingVisualiz4;
-      return (_this$routingVisualiz4 = this.routingVisualizer).highlightRouteSegment.apply(_this$routingVisualiz4, arguments);
-    }
-  }, {
-    key: "clearRoute",
-    value: function clearRoute() {
-      var _this$routingVisualiz5;
-      return (_this$routingVisualiz5 = this.routingVisualizer).clearRoute.apply(_this$routingVisualiz5, arguments);
-    }
+    // Check if the point is within the polygon
+    const isInside = (0, _booleanPointInPolygon.default)(point, polygon);
+    return isInside;
+  }
+  getMapObjectsByFilteredLocalRef() {
+    return this.metaAtlasCore.getMapObjectsByFilteredLocalRef(...arguments);
+  }
+  getMapObjectsByName() {
+    return this.metaAtlasCore.getMapObjectsByName(...arguments);
+  }
+  getMapObjectById() {
+    return this.metaAtlasCore.getMapObjectById(...arguments);
+  }
+  getMapObjectByLocalRef() {
+    return this.metaAtlasCore.getMapObjectByLocalRef(...arguments);
+  }
+  getMapObjectMatchingLocalRef() {
+    return this.metaAtlasCore.getMapObjectMatchingLocalRef(...arguments);
+  }
+  getMapObjectsMatchingLocalRefs() {
+    return this.metaAtlasCore.getMapObjectsMatchingLocalRefs(...arguments);
+  }
+  getMapObjectsByWhatTaxonomy() {
+    return this.metaAtlasCore.getMapObjectsByWhatTaxonomy(...arguments);
+  }
+  getMapObjectsByWhatTaxonomyAPI() {
+    return this.metaAtlasCore.getMapObjectsByWhatTaxonomyAPI(...arguments);
+  }
+  getMapObjectsByWhereTaxonomy() {
+    return this.metaAtlasCore.getMapObjectsByWhereTaxonomy(...arguments);
+  }
+  getMapObjectsByWhatAndWhereTaxonomy() {
+    return this.metaAtlasCore.getMapObjectsByWhatAndWhereTaxonomy(...arguments);
+  }
+  getMapObjectsInWhatTaxonomy() {
+    return this.metaAtlasCore.getMapObjectsInWhatTaxonomy(...arguments);
+  }
+  getMapObjectsInWhereTaxonomy() {
+    return this.metaAtlasCore.getMapObjectsInWhereTaxonomy(...arguments);
+  }
 
-    // Drawing
-  }, {
-    key: "drawGeometryOnMap",
-    value: function drawGeometryOnMap(type, onDrawEnd) {
-      var _this8 = this;
-      var onlyVisibleAtCurrentFocus = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-      //if already in edit mode
-      if (this.mapBoxDraw.getMode() !== 'simple_select') return false;
-      var modeChanged = false;
-      if (type === 'draw_point') {
-        this.mapBoxDraw.changeMode("draw_point");
-        modeChanged = true;
-      } else if (type === 'draw_line_string') {
-        this.mapBoxDraw.changeMode("draw_line_string");
-        modeChanged = true;
-      } else if (type === 'draw_polygon') {
-        this.mapBoxDraw.changeMode("draw_polygon");
-        modeChanged = true;
-      } else if (type === 'draw_marker') {
-        this.mapBoxDraw.changeMode("draw_marker");
-        modeChanged = true;
-      } else console.warn("Unsupported mode passed to drawGeometryOnMap");
-      if (modeChanged) {
-        this.map.once('draw.create', function (drawings) {
-          var finalDrawing = drawings['features'][0];
-          finalDrawing.properties.id = finalDrawing.id;
-          if (onlyVisibleAtCurrentFocus) finalDrawing.properties.dimension_where = _this8.getCurrentFocus();else finalDrawing.properties.dimension_where = _this8.defaultFocusedTaxonomy;
-          onDrawEnd(finalDrawing);
+  // Routing
+  computeRoute() {
+    return this.routingVisualizer.computeRoute(...arguments);
+  }
+  computeRoutes(mapObjectIds) {
+    let wheelChairAccessibleRouteOnly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    let source = arguments.length > 2 ? arguments[2] : undefined;
+    const ref = this;
+    const logRouteEvent = async () => {
+      const getNameByIdAsync = id => {
+        return new Promise(resolve => {
+          if (typeof id !== 'string') resolve('User GPS Location');
+          ref.getMapObjectById(id, mapObj => {
+            resolve(mapObj[0]?.name);
+          });
         });
-        this.map.once('draw.modechange', function () {
-          _this8.mapBoxDraw.deleteAll();
-          // if (this.mapBoxDraw.getMode() === 'simple_select') onDrawEnd();
-          // else console.warn("Unexpected mode received in mode change callback");
+      };
+      const getNamesFromIds = async idList => {
+        const namePromises = idList.map(id => getNameByIdAsync(id));
+        return await Promise.all(namePromises);
+      };
+      const names = await getNamesFromIds(mapObjectIds);
+      names.forEach(name => {
+        this.logAnalyticsEvent('route_per_object', {
+          destination: name,
+          route_per_object_event_source: source
         });
+      });
+      this.logAnalyticsEvent('route', {
+        destinations: names,
+        route_event_source: source
+      });
+    };
+    logRouteEvent();
+    return this.routingVisualizer.computeRoutes(mapObjectIds, wheelChairAccessibleRouteOnly);
+  }
+  setActiveRoute() {
+    return this.routingVisualizer.setActiveRoute(...arguments);
+  }
+  getActiveRoute() {
+    return this.routingVisualizer.getActiveRoute(...arguments);
+  }
+  highlightRouteSegment() {
+    return this.routingVisualizer.highlightRouteSegment(...arguments);
+  }
+  clearRoute() {
+    return this.routingVisualizer.clearRoute(...arguments);
+  }
+
+  // Drawing
+  drawGeometryOnMap(type, onDrawEnd) {
+    let onlyVisibleAtCurrentFocus = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    //if already in edit mode
+    if (this.mapBoxDraw.getMode() !== 'simple_select') return false;
+    let modeChanged = false;
+    if (type === 'draw_point') {
+      this.mapBoxDraw.changeMode("draw_point");
+      modeChanged = true;
+    } else if (type === 'draw_line_string') {
+      this.mapBoxDraw.changeMode("draw_line_string");
+      modeChanged = true;
+    } else if (type === 'draw_polygon') {
+      this.mapBoxDraw.changeMode("draw_polygon");
+      modeChanged = true;
+    } else if (type === 'draw_marker') {
+      this.mapBoxDraw.changeMode("draw_marker");
+      modeChanged = true;
+    } else console.warn("Unsupported mode passed to drawGeometryOnMap");
+    if (modeChanged) {
+      this.map.once('draw.create', drawings => {
+        let finalDrawing = drawings['features'][0];
+        finalDrawing.properties.id = finalDrawing.id;
+        if (onlyVisibleAtCurrentFocus) finalDrawing.properties.dimension_where = this.getCurrentFocus();else finalDrawing.properties.dimension_where = this.defaultFocusedTaxonomy;
+        onDrawEnd(finalDrawing);
+      });
+      this.map.once('draw.modechange', () => {
+        this.mapBoxDraw.deleteAll();
+        // if (this.mapBoxDraw.getMode() === 'simple_select') onDrawEnd();
+        // else console.warn("Unexpected mode received in mode change callback");
+      });
+    }
+    return modeChanged;
+  }
+  isInDrawMode() {
+    return this.mapBoxDraw && this.mapBoxDraw.getAll().features.length > 0;
+  }
+  addDrawingsToBaseMap(drawings) {
+    this.drawGeojsonData.features = this.drawGeojsonData.features.concat(drawings);
+    this.map.getSource(this.mapBoxDrawSourceID).setData(this.drawGeojsonData);
+  }
+  getDrawingById(id) {
+    for (let index = 0; index < this.drawGeojsonData.features.length; index++) {
+      const drawing = this.drawGeojsonData.features[index];
+      if (drawing.id === id) {
+        return drawing;
       }
-      return modeChanged;
     }
-  }, {
-    key: "isInDrawMode",
-    value: function isInDrawMode() {
-      return this.mapBoxDraw && this.mapBoxDraw.getAll().features.length > 0;
+    return undefined;
+  }
+  editDrawing(id) {
+    if (id === undefined) {
+      console.warn("maplibregl.Feature data passed to editDrawing does not contain an id. Edit request cancelled. Make sure the feature data passed in was created using draw");
+      return false;
     }
-  }, {
-    key: "addDrawingsToBaseMap",
-    value: function addDrawingsToBaseMap(drawings) {
-      this.drawGeojsonData.features = this.drawGeojsonData.features.concat(drawings);
-      this.map.getSource(this.mapBoxDrawSourceID).setData(this.drawGeojsonData);
+    let drawing = this.getDrawingById(id);
+    if (drawing === undefined) {
+      console.warn("There is no data against the id passed in to editDrawing, operation cancelled.");
+      return false;
     }
-  }, {
-    key: "getDrawingById",
-    value: function getDrawingById(id) {
-      for (var index = 0; index < this.drawGeojsonData.features.length; index++) {
-        var drawing = this.drawGeojsonData.features[index];
-        if (drawing.id === id) {
-          return drawing;
+    let featureCollection = {
+      type: 'FeatureCollection',
+      features: [drawing]
+    };
+    //console.log(featureCollection)
+    this.mapBoxDraw.set(featureCollection);
+    const saveEditsToBaseMap = featureId => {
+      const updatedFeature = this.mapBoxDraw.get(featureId);
+      this.mapBoxDraw.deleteAll();
+      if (updatedFeature) {
+        let featureFoundInBaseMapData = false;
+        for (let index = 0; index < this.drawGeojsonData.features.length; index++) {
+          const feature = this.drawGeojsonData.features[index];
+          if (feature.id === updatedFeature.id) {
+            this.drawGeojsonData.features[index] = updatedFeature;
+            featureFoundInBaseMapData = true;
+          }
         }
+        if (featureFoundInBaseMapData) this.map.getSource(this.mapBoxDrawSourceID).setData(this.drawGeojsonData);else console.warn("Edited feature data not found in base map. Make sure addFeaturesToBaseMap was called on feature data before editing.");
       }
-      return undefined;
-    }
-  }, {
-    key: "editDrawing",
-    value: function editDrawing(id) {
-      var _this9 = this;
-      if (id === undefined) {
-        console.warn("maplibregl.Feature data passed to editDrawing does not contain an id. Edit request cancelled. Make sure the feature data passed in was created using draw");
-        return false;
-      }
-      var drawing = this.getDrawingById(id);
-      if (drawing === undefined) {
-        console.warn("There is no data against the id passed in to editDrawing, operation cancelled.");
-        return false;
+    };
+    if (drawing.geometry.type !== 'Point') {
+      if (drawing.properties.marker !== undefined) {
+        this.mapBoxDraw.changeMode('marker_select', {
+          featureId: drawing.id
+        });
+      } else {
+        this.mapBoxDraw.changeMode('direct_select', {
+          featureId: drawing.id
+        });
       }
-      var featureCollection = {
-        type: 'FeatureCollection',
-        features: [drawing]
-      };
-      //console.log(featureCollection)
-      this.mapBoxDraw.set(featureCollection);
-      var saveEditsToBaseMap = function saveEditsToBaseMap(featureId) {
-        var updatedFeature = _this9.mapBoxDraw.get(featureId);
-        _this9.mapBoxDraw.deleteAll();
-        if (updatedFeature) {
-          var featureFoundInBaseMapData = false;
-          for (var index = 0; index < _this9.drawGeojsonData.features.length; index++) {
-            var feature = _this9.drawGeojsonData.features[index];
-            if (feature.id === updatedFeature.id) {
-              _this9.drawGeojsonData.features[index] = updatedFeature;
-              featureFoundInBaseMapData = true;
-            }
+      this.map.once('draw.modechange', () => {
+        if (this.mapBoxDraw.getMode() !== 'simple_select') return;
+        saveEditsToBaseMap(drawing.id);
+      });
+    } else {
+      let featureToEditSelectedAlready = false;
+      const onSelectionChanged = selectionData => {
+        //console.log(selectionData, drawing)
+        if (selectionData.features.length > 0 && selectionData.features[0].id === drawing.id) {
+          if (!featureToEditSelectedAlready) {
+            featureToEditSelectedAlready = true;
           }
-          if (featureFoundInBaseMapData) _this9.map.getSource(_this9.mapBoxDrawSourceID).setData(_this9.drawGeojsonData);else console.warn("Edited feature data not found in base map. Make sure addFeaturesToBaseMap was called on feature data before editing.");
+        } else if (featureToEditSelectedAlready) {
+          saveEditsToBaseMap(drawing.id);
+          this.map.off('draw.selectionchange', onSelectionChanged);
         }
       };
-      if (drawing.geometry.type !== 'Point') {
-        if (drawing.properties.marker !== undefined) {
-          this.mapBoxDraw.changeMode('marker_select', {
-            featureId: drawing.id
-          });
-        } else {
-          this.mapBoxDraw.changeMode('direct_select', {
-            featureId: drawing.id
-          });
-        }
-        this.map.once('draw.modechange', function () {
-          if (_this9.mapBoxDraw.getMode() !== 'simple_select') return;
-          saveEditsToBaseMap(drawing.id);
-        });
-      } else {
-        var featureToEditSelectedAlready = false;
-        var _onSelectionChanged = function onSelectionChanged(selectionData) {
-          //console.log(selectionData, drawing)
-          if (selectionData.features.length > 0 && selectionData.features[0].id === drawing.id) {
-            if (!featureToEditSelectedAlready) {
-              featureToEditSelectedAlready = true;
-            }
-          } else if (featureToEditSelectedAlready) {
-            saveEditsToBaseMap(drawing.id);
-            _this9.map.off('draw.selectionchange', _onSelectionChanged);
-          }
-        };
-        this.map.on('draw.selectionchange', _onSelectionChanged);
-      }
-      return true;
+      this.map.on('draw.selectionchange', onSelectionChanged);
     }
-  }, {
-    key: "removeDrawing",
-    value: function removeDrawing(id) {
-      for (var index = 0; index < this.drawGeojsonData.features.length; index++) {
-        var drawing = this.drawGeojsonData.features[index];
-        if (drawing.id === id) {
-          this.drawGeojsonData.features.splice(index, 1);
-          this.map.getSource(this.mapBoxDrawSourceID).setData(this.drawGeojsonData);
-          return true;
-        }
+    return true;
+  }
+  removeDrawing(id) {
+    for (let index = 0; index < this.drawGeojsonData.features.length; index++) {
+      const drawing = this.drawGeojsonData.features[index];
+      if (drawing.id === id) {
+        this.drawGeojsonData.features.splice(index, 1);
+        this.map.getSource(this.mapBoxDrawSourceID).setData(this.drawGeojsonData);
+        return true;
       }
-      return false;
     }
-  }, {
-    key: "createMarker",
-    value: function createMarker(options) {
-      if (options === undefined) options = {};
-      options.draggable = true;
-      options.color = '#FFB52E';
-      var marker = new maplibregl.Marker(options).setLngLat(this.map.getCenter()).addTo(this.map);
-      this.map.once('click', function () {
-        marker.setDraggable(false);
+    return false;
+  }
+  createMarker(options) {
+    if (options === undefined) options = {};
+    options.draggable = true;
+    options.color = '#FFB52E';
+    const marker = new maplibregl.Marker(options).setLngLat(this.map.getCenter()).addTo(this.map);
+    this.map.once('click', () => {
+      marker.setDraggable(false);
 
-        // update color
-        var color = '#3FB1CE';
-        var markerElement = marker.getElement();
-        markerElement.querySelectorAll('svg g[fill="' + marker._color + '"]')[0].setAttribute("fill", color);
-        marker._color = color;
-      });
-      return marker;
-    }
-  }, {
-    key: "getCoordinates",
-    value: function getCoordinates(feature) {
-      return (0, _invariant.getCoords)(feature);
-    }
-  }, {
-    key: "getLength",
-    value: function getLength(feature) {
-      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
-        units: 'kilometers'
-      };
-      if (feature.geometry && feature.geometry.type) {
-        var type = feature.geometry.type;
-        if (type === 'LineString' || type === 'MultiLineString') {
-          return (0, _length["default"])(feature, options);
-        }
-      }
-      console.warn("Unsupported geometry type provided to getLength");
-      return undefined;
-    }
-  }, {
-    key: "getArea",
-    value: function getArea(feature) {
-      return (0, _area["default"])(feature);
-    }
+      // update color
+      const color = '#3FB1CE';
+      let markerElement = marker.getElement();
+      markerElement.querySelectorAll('svg g[fill="' + marker._color + '"]')[0].setAttribute("fill", color);
+      marker._color = color;
+    });
+    return marker;
+  }
+  getCoordinates(feature) {
+    return (0, _invariant.getCoords)(feature);
+  }
+  getLength(feature) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+      units: 'kilometers'
+    };
+    if (feature.geometry && feature.geometry.type) {
+      const type = feature.geometry.type;
+      if (type === 'LineString' || type === 'MultiLineString') {
+        return (0, _length.default)(feature, options);
+      }
+    }
+    console.warn("Unsupported geometry type provided to getLength");
+    return undefined;
+  }
+  getArea(feature) {
+    return (0, _area.default)(feature);
+  }
 
-    /**
-     * Get the 3D map instance for 3D model operations
-     */
-  }, {
-    key: "getMap3D",
-    value: function getMap3D() {
-      return this.map3D;
-    }
-  }]);
-}();
+  /**
+   * Get the 3D map instance for 3D model operations
+   */
+  getMap3D() {
+    return this.map3D;
+  }
+}
+exports.MetaAtlasSdk = MetaAtlasSdk;
 //# sourceMappingURL=meta-atlas-sdk.js.map