@mappedin/mappedin-js 5.3.0 → 5.5.0

package/lib/esm/renderer/index.d.ts

@@ -4,6 +4,7 @@
 //   ../minisearch
 //   ../@tweenjs/tween.js
 //   ../geojson
+//   ../stats.js
 
 declare module '@mappedin/mappedin-js' {
     import { MapView } from '@mappedin/mappedin-js/renderer/MapView';
@@ -12,6 +13,7 @@ declare module '@mappedin/mappedin-js' {
     import type { TMapViewOptions, TJourneyOptions } from '@mappedin/mappedin-js/renderer/MapView.types';
     import { labelThemes } from '@mappedin/mappedin-js/renderer/MapView.types';
     import { MARKER_ANCHOR } from '@mappedin/mappedin-js/renderer/internal/Mappedin.Marker';
+    export type { Marker } from '@mappedin/mappedin-js/renderer/layers/Markers';
     export { BEARING_TYPE, ACTION_TYPE } from '@mappedin/mappedin-js/navigator';
     export type { IDirectionsResult, E_MESSAGES as E_GET_DIRECTIONS_MESSAGES } from '@mappedin/mappedin-js/navigator';
     export type { IFlatLabels, FlatLabels } from '@mappedin/mappedin-js/renderer/MapView.FlatLabels';
@@ -42,6 +44,7 @@ declare module '@mappedin/mappedin-js' {
     export { COLLISION_RANKING_TIERS, STATE, E_SDK_EVENT, E_BLUEDOT_STATE_REASON, E_BLUEDOT_MARKER_STATE, E_BLUEDOT_EVENT, E_BLUEDOT_STATE, E_CAMERA_EVENT, E_CAMERA_DIRECTION, SAFE_AREA_INSET_TYPE, ANIMATION_TWEENS, CAMERA_EASING_MODE } from '@mappedin/mappedin-js/renderer/MapView.enums';
     export { getVenue, getVenueBundle, showVenue, downloadBundle, getVenueBundleURL, downloadVenueBundleMVF, PositionUpdater, MappedinDestinationSet, MARKER_ANCHOR, labelThemes };
     import DefaultAssetManager from '@mappedin/mappedin-js/renderer/internal/Mappedin.AssetManager';
+    import { TTileManagerOptions } from '@mappedin/mappedin-js/renderer/layers/Outdoor-Context/Mappedin.TileManager';
     /**
         * @internal
         */
@@ -75,17 +78,32 @@ declare module '@mappedin/mappedin-js' {
         * @internal
         */
     export function __useSceneManager(value: boolean): void;
+    export function __enableTileManager(options?: TTileManagerOptions): void;
+    export { 
+    /**
+        * @internal
+        */
+    AzureOutdoorContextProvider, 
+    /**
+        * @internal
+        */
+    OpenStreetMapOutdoorContext } from './layers/Outdoor-Context/Outdoor-Context.provider';
+    export type { 
+    /**
+        * @internal
+        */
+    IOutdoorContextProvider } from './layers/Outdoor-Context/Outdoor-Context.provider';
 }
 
 declare module '@mappedin/mappedin-js/renderer/MapView' {
     import { Texture } from 'three';
     import './internal/Mappedin.css';
     import { Mappedin, MappedinCoordinate, MappedinLocation, MappedinMap, MappedinNode, MappedinPolygon } from '@mappedin/mappedin-js/get-venue';
-    import { E_SDK_EVENT_PAYLOAD, TCreateMarkerOptions, TLabelAllLocationFlatLabelOptions, TLabelAllLocationFloatingLabelOptions, TMapViewOptions, TPathOptions, TCreateTooltipCommonOptions, TCreateTooltipOptions } from '@mappedin/mappedin-js/renderer/MapView.types';
+    import { E_SDK_EVENT_PAYLOAD, TCreateMarkerOptions, TLabelAllLocationFlatLabelOptions, TLabelAllLocationFloatingLabelOptions, TMapViewOptions, TPathOptions, TCreateTooltipCommonOptions, TCreateTooltipOptions, TMapClickEvent } from '@mappedin/mappedin-js/renderer/MapView.types';
     import { E_SDK_EVENT, STATE } from '@mappedin/mappedin-js/renderer/MapView.enums';
-    import Marker from '@mappedin/mappedin-js/renderer/internal/Mappedin.Marker';
     import SmartTooltip from '@mappedin/mappedin-js/renderer/internal/Mappedin.SmartTooltip';
     import Camera from '@mappedin/mappedin-js/renderer/Camera';
+    import { Marker } from '@mappedin/mappedin-js/renderer/layers/Markers';
     import { PubSub } from '@mappedin/mappedin-js/renderer/internal/pub-sub.typed';
     import BlueDotLayer from '@mappedin/mappedin-js/renderer/layers/BlueDot';
     import JourneyLayer from '@mappedin/mappedin-js/renderer/layers/Journey';
@@ -106,7 +124,20 @@ declare module '@mappedin/mappedin-js/renderer/MapView' {
             SET_STATE_SILENT = 10,
             BLUE_DOT_UPDATE_POSITION = 11,
             BLUE_DOT_SET_FOLLOWING = 12,
-            CLEAR_MOUSE = 13
+            CLEAR_MOUSE = 13,
+            MAP_CLICK = 14,
+            USER_ZOOM = 15,
+            USER_ZOOM_BEGIN = 16,
+            USER_ROTATE = 17,
+            USER_ROTATE_BEGIN = 18,
+            USER_PAN = 19,
+            USER_PAN_BEGIN = 20,
+            USER_TILT = 21,
+            USER_MULTI_BEGIN = 22,
+            USER_MULTI_END = 23,
+            FOCUSON_BEGIN = 24,
+            USER_HANDS_ON = 25,
+            USER_HANDS_OFF = 26
     }
     export type INTERNAL_EVENT_PAYLOAD = {
             [INTERNAL_EVENT.SET_MAP_START]: undefined;
@@ -128,6 +159,19 @@ declare module '@mappedin/mappedin-js/renderer/MapView' {
                     y: number;
             };
             [INTERNAL_EVENT.BLUE_DOT_SET_FOLLOWING]: boolean;
+            [INTERNAL_EVENT.MAP_CLICK]: TMapClickEvent;
+            [INTERNAL_EVENT.USER_ZOOM]: undefined;
+            [INTERNAL_EVENT.USER_ZOOM_BEGIN]: undefined;
+            [INTERNAL_EVENT.USER_ROTATE_BEGIN]: undefined;
+            [INTERNAL_EVENT.USER_MULTI_BEGIN]: undefined;
+            [INTERNAL_EVENT.USER_PAN_BEGIN]: undefined;
+            [INTERNAL_EVENT.USER_ROTATE]: undefined;
+            [INTERNAL_EVENT.USER_MULTI_END]: undefined;
+            [INTERNAL_EVENT.FOCUSON_BEGIN]: undefined;
+            [INTERNAL_EVENT.USER_HANDS_ON]: undefined;
+            [INTERNAL_EVENT.USER_HANDS_OFF]: undefined;
+            [INTERNAL_EVENT.USER_PAN]: undefined;
+            [INTERNAL_EVENT.USER_TILT]: undefined;
     };
     export class MapView extends PubSub<E_SDK_EVENT_PAYLOAD, E_SDK_EVENT> {
             #private;
@@ -365,8 +409,9 @@ declare module '@mappedin/mappedin-js/renderer/MapView' {
                 * but if you are doing something weird, or have your own special tween for something, you will want to call this function.
                 * You can call it as often as you want, it just sets a flag that we need to render again, and renders a few frames if we weren't already doing that.
                 * Ignored in 2D.
+                * @deprecated
                 */
-            tryRendering(renderMode?: any): void;
+            tryRendering(_renderMode?: any): void;
             /**
                 * Finds the main Location associated with a Polygon. This means a Location
                 * attached to the Polygon that has no parents, or, if there are none of those,
@@ -390,6 +435,19 @@ declare module '@mappedin/mappedin-js/renderer/MapView' {
                 * @returns MappedinPolygon[]
                 */
             getPolygonsAtCoordinate(coordinate: MappedinCoordinate, options?: TGetPolygonsAtCoordinateOptions): MappedinPolygon[];
+            /**
+                * Finds all the polygons on a screen coordinate x and y. If multiple
+                * polygons are stacked on top of each other, the array of polygons returned will be
+                * in the order of farthest to closest.
+                *
+                * By default, this only considers interactive polygons.
+                *
+                * @param x
+                * @param y
+                * @param options {@link TGetPolygonsAtCoordinateOptions}
+                * @returns MappedinPolygon[]
+                */
+            getPolygonsAtScreenCoordinate(x: number, y: number, options?: TGetPolygonsAtCoordinateOptions): MappedinPolygon[];
             /**
                 * Destroy instance and reclaim memory. Note: this does not destroy the instance of {@link Mappedin}
                 * that was passed in. For applications that require destroying and re-creating the mapView, it is
@@ -1360,7 +1418,7 @@ declare module '@mappedin/mappedin-js/renderer/internal/Mappedin.Marker' {
         LEFT = 3,
         RIGHT = 4
     }
-    class Marker extends HTMLCollider implements IHTMLCollider {
+    class InternalMarker extends HTMLCollider implements IHTMLCollider {
         _el: Element | null;
         style: TTooltipStyle;
         polygon: any;
@@ -1372,7 +1430,41 @@ declare module '@mappedin/mappedin-js/renderer/internal/Mappedin.Marker' {
         colliderDidGoOffscreen(): void;
         colliderDidUpdateVisiblity(): void;
     }
-    export default Marker;
+    export default InternalMarker;
+}
+
+declare module '@mappedin/mappedin-js/renderer/layers/Markers' {
+    import { MappedinCoordinate, MappedinNode } from '@mappedin/mappedin-js/get-venue';
+    import { TCreateMarkerOptions } from '@mappedin/mappedin-js/renderer';
+    import InternalMarker from '@mappedin/mappedin-js/renderer/internal/Mappedin.Marker';
+    import { ICore } from '@mappedin/mappedin-js/renderer/Core.interface';
+    /**
+        * A marker containing some HTML content.
+        */
+    export class Marker {
+            #private;
+            constructor(internalMarker: InternalMarker);
+            /**
+                * A generated ID for this marker.
+                */
+            get id(): string;
+            /**
+                * The container element for this marker. This element's position is automatically updated.
+                */
+            get containerEl(): any;
+            /**
+                * The content that was provided when creating this marker.
+                */
+            get contentEl(): any;
+    }
+    class MarkersLayer {
+            #private;
+            constructor(core: ICore);
+            createMarker(nodeOrCoordinate: MappedinNode | MappedinCoordinate, contentHtml: string, options?: TCreateMarkerOptions): Marker;
+            removeMarker(markerOrMarkerId: Marker | Marker['id']): void;
+            removeAllMarkers(): void;
+    }
+    export default MarkersLayer;
 }
 
 declare module '@mappedin/mappedin-js/navigator' {
@@ -1681,6 +1773,64 @@ declare module '@mappedin/mappedin-js/renderer/internal/Mappedin.AssetManager' {
     }
 }
 
+declare module '@mappedin/mappedin-js/renderer/layers/Outdoor-Context/Mappedin.TileManager' {
+    import { Box3 } from 'three';
+    import { ICore } from '@mappedin/mappedin-js/renderer/Core.interface';
+    import { MappedinCoordinate, MappedinMap } from '@mappedin/mappedin-js/renderer/index.rn';
+    import Object3D from '@mappedin/mappedin-js/renderer/internal/object3D.destroy';
+    import { MapView } from '@mappedin/mappedin-js/renderer/MapView';
+    import { Tile } from '@mappedin/mappedin-js/renderer/layers/Outdoor-Context/Mappedin.Tile';
+    import { IOutdoorContextProvider } from '@mappedin/mappedin-js/renderer/layers/Outdoor-Context/Outdoor-Context.provider';
+    export enum TILE_RENDER_MODES {
+            NORMAL = 0,
+            AGGRESSIVE = 1
+    }
+    export const TILE_COLOR = "#f0f0f1";
+    /**
+        * @internal
+        */
+    export type TTileManagerOptions = {
+            tileRenderMode?: TILE_RENDER_MODES;
+            provider: IOutdoorContextProvider;
+    };
+    export class TileManager {
+            #private;
+            static ENABLED: boolean;
+            static OPTIONS: TTileManagerOptions;
+            tileSize: number;
+            token: string;
+            apiKey?: string;
+            tileRenderMode: TILE_RENDER_MODES;
+            currentAbortController: AbortController;
+            attributionEl: HTMLDivElement;
+            outdoorContextProvider: IOutdoorContextProvider;
+            constructor(mapView: MapView, core: ICore);
+            createAttributionEl(): void;
+            renderVisibleTiles: () => void;
+            _renderVisibleTiles(): void;
+            cachedZoomLevel: number;
+            fetchTiles(): void;
+            zoomLevelToAltitudeMap: number[][];
+            plane: Object3D;
+            tiles: Tile[];
+            maskMeshBoundingBox: Box3;
+            fetchTilesForZoomLevel(zoomLevel: number): Promise<void>;
+            /**
+                * This function populates a layer of tiles starting from the center clockwise
+                *
+                * Here's an example of layer = 1
+                *
+                * [ ][ ][ ][ ][ ]
+                * [ ][1][2][3][ ]
+                * [ ][8][X][4][ ]
+                * [ ][7][6][5][ ]
+                * [ ][ ][ ][ ][ ]
+                */
+            populateLayer(layerId: number | undefined, center: MappedinCoordinate, zoomLevel: number, metersPerTile: number, referenceMap: MappedinMap): void;
+            checkIfTileIsInBoundingBox(tile: Tile): any;
+    }
+}
+
 declare module '@mappedin/mappedin-js/get-venue/MappedinDirections' {
     import { IDirectionsResult } from '@mappedin/mappedin-js/navigator';
     import { ACTION_TYPE, BEARING_TYPE } from '@mappedin/mappedin-js/navigator/Directive';
@@ -1871,7 +2021,7 @@ declare module '@mappedin/mappedin-js/renderer/Camera' {
                     bottom: number;
                     right: number;
             }): void;
-            getSafeAreaInsets(): any;
+            getSafeAreaInsets(): import("./MapView.types").TPadding;
             /**
                 * Focus the Camera view on a collection of targets and animate to that state.
                 * @returns a Promise that resolves when the animation finishes, or rejects when it is cancelled.
@@ -2028,8 +2178,10 @@ declare module '@mappedin/mappedin-js/renderer/layers/BlueDot' {
                 * @private
                 */
             constructor(mapView: MapView, core: ICore, eventsLayer: EventSystemLayer);
-            on(eventName: any, fn: any): void;
-            off(eventName: any, fn: any): void;
+            on<EVENT_NAME extends E_BLUEDOT_EVENT>(eventName: EVENT_NAME, fn: (payload: E_BLUEDOT_EVENT_PAYLOAD[EVENT_NAME] extends {
+                    data: null;
+            } ? E_BLUEDOT_EVENT_PAYLOAD[EVENT_NAME]['data'] : E_BLUEDOT_EVENT_PAYLOAD[EVENT_NAME]) => void): void;
+            off<EVENT_NAME extends E_BLUEDOT_EVENT>(eventName: EVENT_NAME, fn: (payload: E_BLUEDOT_EVENT_PAYLOAD[EVENT_NAME]) => void): void;
             /**
                 * Enables Blue Dot. BlueDot then emits {@link TBlueDotStateChange} and {@link TBlueDotPositionUpdate} events via {@link E_BLUEDOT_EVENT}
                 */
@@ -2086,6 +2238,7 @@ declare module '@mappedin/mappedin-js/renderer' {
     import type { TMapViewOptions, TJourneyOptions } from '@mappedin/mappedin-js/renderer/MapView.types';
     import { labelThemes } from '@mappedin/mappedin-js/renderer/MapView.types';
     import { MARKER_ANCHOR } from '@mappedin/mappedin-js/renderer/internal/Mappedin.Marker';
+    export type { Marker } from '@mappedin/mappedin-js/renderer/layers/Markers';
     export { BEARING_TYPE, ACTION_TYPE } from '@mappedin/mappedin-js/navigator';
     export type { IDirectionsResult, E_MESSAGES as E_GET_DIRECTIONS_MESSAGES } from '@mappedin/mappedin-js/navigator';
     export type { IFlatLabels, FlatLabels } from '@mappedin/mappedin-js/renderer/MapView.FlatLabels';
@@ -2116,6 +2269,7 @@ declare module '@mappedin/mappedin-js/renderer' {
     export { COLLISION_RANKING_TIERS, STATE, E_SDK_EVENT, E_BLUEDOT_STATE_REASON, E_BLUEDOT_MARKER_STATE, E_BLUEDOT_EVENT, E_BLUEDOT_STATE, E_CAMERA_EVENT, E_CAMERA_DIRECTION, SAFE_AREA_INSET_TYPE, ANIMATION_TWEENS, CAMERA_EASING_MODE } from '@mappedin/mappedin-js/renderer/MapView.enums';
     export { getVenue, getVenueBundle, showVenue, downloadBundle, getVenueBundleURL, downloadVenueBundleMVF, PositionUpdater, MappedinDestinationSet, MARKER_ANCHOR, labelThemes };
     import DefaultAssetManager from '@mappedin/mappedin-js/renderer/internal/Mappedin.AssetManager';
+    import { TTileManagerOptions } from '@mappedin/mappedin-js/renderer/layers/Outdoor-Context/Mappedin.TileManager';
     /**
         * @internal
         */
@@ -2149,6 +2303,21 @@ declare module '@mappedin/mappedin-js/renderer' {
         * @internal
         */
     export function __useSceneManager(value: boolean): void;
+    export function __enableTileManager(options?: TTileManagerOptions): void;
+    export { 
+    /**
+        * @internal
+        */
+    AzureOutdoorContextProvider, 
+    /**
+        * @internal
+        */
+    OpenStreetMapOutdoorContext } from './layers/Outdoor-Context/Outdoor-Context.provider';
+    export type { 
+    /**
+        * @internal
+        */
+    IOutdoorContextProvider } from './layers/Outdoor-Context/Outdoor-Context.provider';
 }
 
 declare module '@mappedin/mappedin-js/get-venue/Mappedin.types' {
@@ -3230,7 +3399,7 @@ declare module '@mappedin/mappedin-js/get-venue/MappedinNavigatable' {
     import type { MappedinPolygon } from '@mappedin/mappedin-js/get-venue/MappedinPolygon';
     import type { MappedinNode } from '@mappedin/mappedin-js/get-venue/MappedinNode';
     import { MappedinDestinationSet } from '@mappedin/mappedin-js/get-venue/MappedinDestinationSet';
-    import type { Mappedin } from '@mappedin/mappedin-js/get-venue/Mappedin';
+    import { Mappedin } from '@mappedin/mappedin-js/get-venue/Mappedin';
     import { MappedinDirections } from '@mappedin/mappedin-js/get-venue/MappedinDirections';
     export type TDirectionToOptions = {
             accessible?: boolean;
@@ -3253,7 +3422,7 @@ declare module '@mappedin/mappedin-js/get-venue/MappedinNavigatable' {
 }
 
 declare module '@mappedin/mappedin-js/get-venue/Mappedin.CustomerAnalytics' {
-    import { MappedinCategory, MappedinLocation } from '@mappedin/mappedin-js/get-venue';
+    import { MappedinCategory, MappedinLocation, MappedinNavigatable } from '@mappedin/mappedin-js/get-venue';
     type AnalyticsOptions = {
             clientId?: string;
             clientSecret?: string;
@@ -3267,7 +3436,12 @@ declare module '@mappedin/mappedin-js/get-venue/Mappedin.CustomerAnalytics' {
     interface IAnalytics {
             locationSelected(location: MappedinLocation): void;
             categorySelected(category: MappedinCategory): void;
-            getDirections(start: MappedinLocation, end: MappedinLocation): void;
+            /**
+                * @hidden
+                * @internal
+                * @deprecated
+                */
+            getDirections(start: MappedinNavigatable, end: MappedinNavigatable): void;
     }
     interface IInternalAnalytics extends IAnalytics {
             track(target: string, query: any): void;
@@ -3884,15 +4058,10 @@ declare module '@mappedin/mappedin-js/renderer/internal/pub-sub' {
 }
 
 declare module '@mappedin/mappedin-js/renderer/Core.interface' {
-    import { MappedinMap, Mappedin, MappedinCoordinate, MappedinPolygon, MappedinNode } from '@mappedin/mappedin-js/get-venue';
-    import { Vector2, Vector3 } from 'three';
-    import { changeListenerFn, TMapViewOptions } from '@mappedin/mappedin-js/renderer/MapView.types';
-    import RENDER from '@mappedin/mappedin-js/renderer/internal/Mappedin.RenderTasks';
-    import { INTERNAL_EVENT_PAYLOAD } from '@mappedin/mappedin-js/renderer/MapView';
+    import { MappedinPolygon, MappedinNode } from '@mappedin/mappedin-js/get-venue';
     import { TPadding } from '@mappedin/mappedin-js/renderer';
-    import Tween, { Easing } from '@tweenjs/tween.js';
-    import { TaskScheduler } from '@mappedin/mappedin-js/get-venue/Mappedin.TaskScheduler';
-    import SceneManager from '@mappedin/mappedin-js/renderer/MapView.SceneManager';
+    import { Easing } from '@tweenjs/tween.js';
+    import Core from '@mappedin/mappedin-js/renderer/Core';
     export type TFocusOptionsLegacy = {
             /**
                 * An array of Nodes to focus in on
@@ -3937,186 +4106,7 @@ declare module '@mappedin/mappedin-js/renderer/Core.interface' {
             points?: any[];
             callback: () => void;
     };
-    export interface ICore {
-            new (container: HTMLElement, venue: Mappedin, options?: TMapViewOptions): ICore;
-            /**
-                * @internal
-                */
-            currentScale: number;
-            /**
-                * @internal
-                */
-            USE_SCENE_MANAGER: boolean;
-            referenceMap: MappedinMap;
-            taskScheduler: TaskScheduler;
-            sceneManager: SceneManager;
-            loadOptions?: TMapViewOptions['loadOptions'];
-            imageFlippingEnabled: boolean;
-            imageFlippingCache: any;
-            cachedPadding: any;
-            getCameraFrameForPoints: any;
-            polygonMeshesById: any;
-            textLabelsByPolygonId: any;
-            renderer: any;
-            scene: any;
-            cameraParameters: Vector2;
-            resolution: Vector2;
-            determineNewLabelSize: any;
-            on<EVENT_NAME extends keyof INTERNAL_EVENT_PAYLOAD>(eventName: EVENT_NAME, fn: changeListenerFn<INTERNAL_EVENT_PAYLOAD[EVENT_NAME]>): void;
-            off<EVENT_NAME extends keyof INTERNAL_EVENT_PAYLOAD>(eventName: EVENT_NAME, fn: changeListenerFn<INTERNAL_EVENT_PAYLOAD[EVENT_NAME]>): void;
-            publish<EVENT_NAME extends keyof INTERNAL_EVENT_PAYLOAD>(eventName: EVENT_NAME, payload?: INTERNAL_EVENT_PAYLOAD[EVENT_NAME]): void;
-            /**
-                * Manual camera controls for MapView. Generally you should be using the functions on MapView like {{#crossLink "MapView/focusOn:method"}}{{/crossLink}},
-                * but if you have some cool animations in mind, you can do it with the {{#crossLink "CameraControls"}}{{/crossLink}}.
-                * Some of the functions don't do anything in 2D.
-                *
-                */
-            controls: any;
-            /**
-                * The Venue data this MapView is using.
-                *
-                * @property venue {MappedinVenue}
-                * @final
-                */
-            readonly venue: Mappedin;
-            /**
-                * The div MapView is using.
-                *
-                * @property container {Div}
-                * @final
-                */
-            readonly container: HTMLElement;
-            /**
-                * The ID of the Map currently being displayed.
-                *
-                */
-            readonly currentMap: string;
-            /**
-                * Change this factor to influence how much the camera zooms in on a {@link IMapView3D.focusOn} call.
-                *
-                * @property focusZoomFactor {Integer}
-                * @default 3
-                */
-            focusZoomFactor: number;
-            /**
-                * Returns the value you should call {@link CameraControls.setZoom} on to fit the Polygon exactly.
-                *
-                * @return The zoom level that will fit the Polygon
-                */
-            getZoomLevelForPolygon(props: {
-                    /**
-                        * The Polygon or Polygon ID to get the zoom level for
-                        */
-                    polygonOrPolygonId: MappedinPolygon | string;
-            }): number;
-            /**
-                * Returns the value you should call {@link CameraControls.setZoom} on to fit the {@link IMapView3D.currentMap} exactly.
-                *
-                * @return The zoom level that will fit the {@link IMapView3D.currentMap}.
-                */
-            getZoomLevelForCurrentMap(): number;
-            /**
-                * Returns the angle that points to north, in radians, from the default orientation.
-                *
-                * @return The angle to north from the default orientation, in radians.
-                */
-            getNorth(): number;
-            /**
-                * Takes an element on the DOM and rotates it such that the top is pointing north. It will rotate with the camera, staying locked
-                * on north. If you would like to align it do a different direction, or a different side of the element, pass in an offset. This
-                * is how you would do a compass rose.
-                *
-                * This will modify your element's transform.
-                *
-                * @param element The element on the page to rotate.
-                * @param offset The amount to offset the rotation by, in radians.
-                *
-                */
-            lockNorth(element: HTMLElement, offset?: number): void;
-            /**
-                * Stops the MapView from trying to rotate your element with the camera. Do this if you remove the element, or want to stop it from rotating.
-                * @param element The node to stop rotating. It won't reset the transform, just leave it as is.
-                */
-            unlockNorth(element: HTMLElement): void;
-            currentInteractionEvent: string;
-            interactivePolygons: any;
-            highlightedPolygons: any;
-            cameraPlane: any;
-            /**
-                * Called any time a user touches or clicks the map. Only fires on "single" touches/clicks.
-                *
-                * @param position Object containing the latitude & longitude of the location touched on the map
-                * @param polygons Array of polygon IDs that were touched, in order of front to back.
-                * @param nearBlueDot Whether the touch was close enough to the Blue Dot to be considered a touch on the Blue Dot.
-                */
-            onMapClicked(position: {
-                    latitude: number;
-                    longitude: number;
-            }, polygons: string[], maps: MappedinMap[], nearBlueDot: boolean): void;
-            /**
-                * This is called when an interactive Polygon is clicked on.
-                * You will almost certainly want to replace this with your own function in your client app.
-                * Return "false" if you have consumed the event and it shouldn't bubble down to other Polygons beneath this one.
-                *
-                * @param polygonId polygonId passed in when tapping an interactive polygon
-                */
-            onPolygonClicked(polygonId: string): boolean | void;
-            onMapChanged(map: string): void;
-            getPositionLatLon(lat: number, lon: number, map?: MappedinMap | string): Vector3;
-            getPositionPolygon(polygon: MappedinPolygon | string): Vector3;
-            /**
-                * Takes an x/y pair in Mappedin coordinate space and gives you a Vector3 in scene space
-                * @param nodeOrCoordinate a node or coordinate
-                */
-            convertTo3DMapPosition(nodeOrCoordinate: MappedinCoordinate | MappedinNode): Vector3;
-            /**
-                * Converts a Vector-like object into a MappedinCoordinate for a map.
-                * @param position an object with x and y, like a Vector3
-                * @param mapClass An optional map; otherwise, the current map will be used.
-                */
-            convert3DMapPositionToCoordinate(position: {
-                    x: number;
-                    y: number;
-            }, mapClass?: MappedinMap): MappedinCoordinate;
-            /**
-                * Converts a 2D x,y screen position into a 3D MappedinCoordinate using projection
-                */
-            convertScreenCoordinateToMapCoordinate(x: number, y: number, map: MappedinMap): MappedinCoordinate;
-            setPadding(padding: {
-                    top: number;
-                    left: number;
-                    bottom: number;
-                    right: number;
-            }): void;
-            /**
-                * This is fired when the user taps/clicks on the MapView without hitting an interactive Polygon.
-                * You will almost certainly want to replace this with your own function in your client app.
-                * You would probably use this to clear any Polygon highlighting, in certain situations.
-                */
-            onNothingClicked(): void;
-            smartCollisionEngine: any;
-            mapObjects: any;
-            /**
-                * The scene only renders when something has changed. This should be something a 3rd party developer doesn't need to worry about,
-                * but if you are doing something weird, or have your own special tween for something, you will want to call this function.
-                * You can call it as often as you want, it just sets a flag that we need to render again, and renders a few frames if we weren't already doing that.
-                * Ignored in 2D.
-                */
-            tryRendering(renderMode?: typeof RENDER): void;
-            setMap(mapOrMapId: MappedinMap | string): Promise<null>;
-            getPositionNode(node: MappedinNode): Vector3;
-            cameraObject: any;
-            setBackgroundColor(color: string, alpha?: number): void;
-            mapManager: any;
-            focusOn(focusOptions: TFocusOptionsLegacy): Tween;
-            canvasWidth: number;
-            canvasHeight: number;
-            /**
-                * Resets the MapView to the default state.
-                */
-            resetState(): void;
-            destroy(): void;
-    }
+    export type ICore = Core;
 }
 
 declare module '@mappedin/mappedin-js/renderer/internal/blue-dot-manager' {
@@ -4261,7 +4251,7 @@ declare module '@mappedin/mappedin-js/renderer/internal/Mappedin.FloatingLabel'
     }
     export type TFloatingLabelAppearance = {
             /**
-                * Margin around the label and marker. This will affect label density
+                * Margin around the label and marker. This will affect label density, with a mininum of 7px around
                 * @default 6
                 */
             margin?: number;
@@ -4319,6 +4309,10 @@ declare module '@mappedin/mappedin-js/renderer/internal/Mappedin.FloatingLabel'
                                 */
                             inactive?: string;
                     };
+                    /**
+                        * Size of bounding box of SVG icon
+                        */
+                    iconSize?: number;
                     /**
                         * SVG of icon to place inside Floating Label
                         */
@@ -4352,6 +4346,7 @@ declare module '@mappedin/mappedin-js/renderer/internal/Mappedin.FloatingLabel'
                             active: string;
                             inactive: string;
                     };
+                    iconSize?: number;
                     icon?: string;
                     iconVisibilityThreshold?: number;
             };
@@ -4416,6 +4411,7 @@ declare module '@mappedin/mappedin-js/renderer/internal/Mappedin.FloatingLabel'
             static imagePromiseCache: {
                     [key in number]?: Promise<HTMLImageElement>;
             };
+            get pinCanvasSize(): number;
             draw(context: CanvasRenderingContext2D): void;
     }
     export default FloatingLabel;
@@ -4455,8 +4451,8 @@ declare module '@mappedin/mappedin-js/renderer/internal/Mappedin.HTMLCollider' {
 
 declare module '@mappedin/mappedin-js/renderer/internal/Mappedin.SmartCollider' {
     import SmartCollisionEngine from '@mappedin/mappedin-js/renderer/internal/Mappedin.SmartCollisionEngine';
-    import { Vector3 } from 'three';
     import { Rectangle } from '@mappedin/mappedin-js/renderer/internal/quad-tree';
+    import { MappedinCoordinate, MappedinNode } from '@mappedin/mappedin-js/renderer/index.rn';
     export type TRange = [number, number, number, number];
     type TCustomCollider<T> = ICollider & T;
     export type TColliderStrategyProps = {
@@ -4483,6 +4479,10 @@ declare module '@mappedin/mappedin-js/renderer/internal/Mappedin.SmartCollider'
         'show' = 1,
         'hide' = 2
     }
+    export type TColliderPosition = {
+        nodeOrCoordinate: MappedinNode | MappedinCoordinate;
+        height?: number;
+    };
     export interface ICollider {
         dimensions: TDimensions;
         screenPosition: [number, number];
@@ -4501,7 +4501,7 @@ declare module '@mappedin/mappedin-js/renderer/internal/Mappedin.SmartCollider'
         offscreen?: boolean;
         setAction: (action: EColliderAction) => void;
         action?: EColliderAction;
-        position: Vector3;
+        position: TColliderPosition;
         __engine?: SmartCollisionEngine;
         enable: () => void;
         disable: () => void;
@@ -4770,6 +4770,98 @@ declare module '@mappedin/mappedin-js/renderer/layers/Labels/FloatingLabelContro
     export default FloatingLabelController;
 }
 
+declare module '@mappedin/mappedin-js/renderer/index.rn' {
+    import { getVenue, getVenueBundle, Mappedin, MappedinDestinationSet } from '@mappedin/mappedin-js/get-venue';
+    import { randomId } from '@mappedin/mappedin-js/--/common/random-id';
+    export * from '@mappedin/mappedin-js/renderer/MapView.enums';
+    export { getVenue, 
+    /**
+      * @deprecated
+      */
+    getVenueBundle, MappedinDestinationSet, Mappedin, randomId };
+    export { GEOLOCATION_STATUS, COLLISION_RANKING_TIERS, E_BLUEDOT_STATE_REASON, E_BLUEDOT_STATE, E_BLUEDOT_MARKER_STATE, STATE, MARKER_ANCHOR, E_SDK_EVENT, E_BLUEDOT_EVENT, E_CAMERA_EVENT, E_CAMERA_DIRECTION, SAFE_AREA_INSET_TYPE, ANIMATION_TWEENS, CAMERA_EASING_MODE } from '@mappedin/mappedin-js/renderer/MapView.enums';
+    export { labelThemes } from '@mappedin/mappedin-js/renderer/MapView.types';
+    export type { IFlatLabels } from '@mappedin/mappedin-js/renderer/MapView.FlatLabels';
+    export type { IFloatingLabels } from '@mappedin/mappedin-js/renderer/MapView.FloatingLabels';
+    export type { TBlueDotPositionUpdate, TBlueDotStateChange, TJourneyOptions, TMapViewOptions, TCreateMarkerOptions, TGeolocationObject, TPathOptions, TFlatLabelOptions, TAddFloatingLabelOptions, TAddFlatLabelOptions, TLabelAllLocationCommonOptions, TFloatingLabelAllLocationsOptions, TFlatLabelAllLocationsOptions, TLabelAllLocationFlatLabelOptions, TLabelAllLocationFloatingLabelOptions, TEnableBlueDotOptions, TFloatingLabelAppearance, TFlatLabelAppearance, CAMERA_EVENT_PAYLOAD, TMapClickEvent, TGetPolygonsAtCoordinateOptions } from '@mappedin/mappedin-js/renderer/MapView.types';
+    export { BEARING_TYPE, ACTION_TYPE } from '@mappedin/mappedin-js/navigator';
+    export type { IDirectionsResult, E_MESSAGES as E_GET_DIRECTIONS_MESSAGES } from '@mappedin/mappedin-js/navigator';
+    export type { TGetVenueBundleOptions, TGetVenueOptions, TMappedinDirective, TShowVenueOptions, TMappedinOfflineSearchOptions, TMappedinOfflineSearchResult, TMappedinOfflineSearchSuggestions, TMappedinOfflineSearchAllOptions, TMappedinOfflineAllSearchMatch } from '@mappedin/mappedin-js/get-venue';
+    export { MappedinLocation, MappedinPolygon, MappedinNode, MappedinCategory, MappedinMap, MappedinEvent, MappedinMapGroup, MappedinVenue, MappedinVortex, MappedinDirections, MappedinNavigatable, MappedinCoordinate, MappedinRankings, MAP_RENDER_MODE, OfflineSearch, MappedinCollectionType } from '@mappedin/mappedin-js/get-venue';
+    export type { TSafeAreaInsets, TCameraTargets, TFocusOnCameraOptions, TCameraTransform, TCameraAnimationOptions } from '@mappedin/mappedin-js/renderer/Camera';
+}
+
+declare module '@mappedin/mappedin-js/renderer/internal/object3D.destroy' {
+    export default Object3D;
+}
+
+declare module '@mappedin/mappedin-js/renderer/layers/Outdoor-Context/Mappedin.Tile' {
+    import { Texture, Mesh, MeshBasicMaterial } from 'three';
+    import { ICore } from '@mappedin/mappedin-js/renderer/Core.interface';
+    import { MappedinCoordinate, MappedinMap } from '@mappedin/mappedin-js/renderer/index.rn';
+    import { TileManager } from '@mappedin/mappedin-js/renderer/layers/Outdoor-Context/Mappedin.TileManager';
+    export class Tile {
+        #private;
+        center: MappedinCoordinate;
+        zoomLevel: number;
+        mesh: Mesh;
+        material: MeshBasicMaterial;
+        texture: Texture;
+        cache: {
+            tileXY?: {
+                tileX: number;
+                tileY: number;
+            };
+            tileBoundingBoxInLatLon?: number[];
+        };
+        get tileXY(): {
+            tileX: number;
+            tileY: number;
+        };
+        get tileBoundingBoxInLatLon(): number[];
+        constructor(center: MappedinCoordinate, zoomLevel: number, tileManager: TileManager, core: ICore, currentAbortController: AbortController);
+        rendered: boolean;
+        discardTexture(): void;
+        applyTexture(): void;
+        render(metersPerTile: number, referenceMap: MappedinMap): any;
+    }
+}
+
+declare module '@mappedin/mappedin-js/renderer/layers/Outdoor-Context/Outdoor-Context.provider' {
+    export interface IOutdoorContextProvider {
+        fetchTile(tileX: number, tileY: number, zoom: number, signal: AbortSignal): Promise<Response>;
+        fetchAttribution?(zoomLevel: number, bounds: [number, number, number, number]): Promise<Response>;
+    }
+    export class AzureOutdoorContextProvider implements IOutdoorContextProvider {
+        lang: string;
+        apiKey?: string;
+        token?: string;
+        tileSize: number;
+        tilesetId: string;
+        constructor(lang?: string, tileSize?: 256 | 512, apiKey?: string, token?: string);
+        makeURL(x: number, y: number, zoom: number): string;
+        /**
+          * Fetch attribution for the current tiles
+          * format: [SouthwestCorner_Longitude, SouthwestCorner_Latitude, NortheastCorner_Longitude, NortheastCorner_Latitude]
+          */
+        fetchAttribution(zoomLevel: number, bounds: [number, number, number, number]): Promise<Response>;
+        fetchTile(tileX: number, tileY: number, zoom: number, signal: AbortSignal): Promise<Response>;
+    }
+    export class GoogleOutdoorContextProvider implements IOutdoorContextProvider {
+        apiKey: string;
+        sessionToken: string;
+        lang: string;
+        constructor(lang: string | undefined, apiKey: string);
+        makeURL(x: number, y: number, zoom: number): string;
+        fetchSessionToken(): Promise<void>;
+        fetchTile(tileX: number, tileY: number, zoom: number, signal: any): Promise<Response>;
+    }
+    export class OpenStreetMapOutdoorContext implements IOutdoorContextProvider {
+        makeURL(x: number, y: number, z: number): string;
+        fetchTile(tileX: number, tileY: number, zoom: number, signal: any): Promise<Response>;
+    }
+}
+
 declare module '@mappedin/mappedin-js/renderer/layers/EventSystem' {
     import { Object3D, Color } from 'three';
     import { MapView } from '@mappedin/mappedin-js/renderer';
@@ -4780,7 +4872,7 @@ declare module '@mappedin/mappedin-js/renderer/layers/EventSystem' {
         core: ICore;
         blueDotManager?: BlueDotManager;
         rendererDomElement: any;
-        currentHover: null;
+        currentHover: string | null;
         hoverLabel: any;
         hoverColor: Color;
         options: {
@@ -4822,7 +4914,7 @@ declare module '@mappedin/mappedin-js/renderer/layers/EventSystem' {
         hasTouched: boolean;
         calculateMouseCoordinates: (event: any) => void;
         getMouseRayIntersects: (objects: Object3D | Object3D[]) => any;
-        detectPolygonsUnderMouse: () => any[];
+        detectPolygonsUnderMouse: () => string[];
         detectMapsUnderMouse: () => any;
         getMouseMapPosition: () => {
             x: number;
@@ -4867,7 +4959,7 @@ declare module '@mappedin/mappedin-js/renderer/internal/Mappedin.Journey' {
         constructor(directions: MappedinDirections | MappedinDirections[], options: TJourneyOptions | undefined, mapView: MapView, core: ICore);
         setStep: (step: any) => void;
         static instance: Journey | null;
-        static create(directions: MappedinDirections | MappedinDirections[], options: any, mapView: MapView, mapManager: any): Journey;
+        static create(directions: MappedinDirections | MappedinDirections[], options: any, mapView: MapView, core: ICore): Journey;
         destroy(): void;
     }
 }
@@ -5146,423 +5238,1415 @@ declare module '@mappedin/mappedin-js/get-venue/MappedinTheme' {
     }
 }
 
-declare module '@mappedin/mappedin-js/renderer/internal/Mappedin.RenderTasks' {
-    export default RENDER;
-    namespace RENDER {
-        const ANIMATED: string;
-        const ALWAYS_ON_TOP: string;
-        const ALL: string;
-        const TWEEN: string;
-    }
-}
-
-declare module '@mappedin/mappedin-js/get-venue/Mappedin.TaskScheduler' {
+declare module '@mappedin/mappedin-js/renderer/Core' {
+    import './internal/externals/globalThisPolyfill';
+    import { Mesh, PerspectiveCamera, Scene, Vector2 } from 'three';
+    import './internal/object3D.destroy';
+    import Renderer from '@mappedin/mappedin-js/renderer/internal/Mappedin.Renderer.js';
+    import { TaskScheduler } from '@mappedin/mappedin-js/get-venue/Mappedin.TaskScheduler';
+    import MapManager from '@mappedin/mappedin-js/renderer/internal/Mappedin.MapManager';
+    import { FlatLabel } from '@mappedin/mappedin-js/renderer/internal/Mappedin.LabelAtlas.js';
+    import SmartCollisionEngine from '@mappedin/mappedin-js/renderer/internal/Mappedin.SmartCollisionEngine';
+    import { TGetPolygonsAtCoordinateOptions, TMapViewOptions } from '@mappedin/mappedin-js/renderer/MapView.types';
+    import { Mappedin as IMappedin, MappedinCoordinate, MappedinMap, MappedinNode } from '@mappedin/mappedin-js/get-venue';
+    import { PubSub } from '@mappedin/mappedin-js/renderer/internal/pub-sub.typed';
+    import { INTERNAL_EVENT, INTERNAL_EVENT_PAYLOAD, MapView } from '@mappedin/mappedin-js/renderer/MapView';
+    import { TPadding } from '@mappedin/mappedin-js/renderer';
+    import MapObject from '@mappedin/mappedin-js/renderer/internal/Mappedin.MapObject';
+    import SceneManager from '@mappedin/mappedin-js/renderer/MapView.SceneManager';
+    export const raycaster: any;
+    let Mappedin: any;
     /**
-        * A function that can be submitted to the Task Scheduler to run each frame for
-        * some provided number of frames. A single update can be repeatedly submitted;
-        * if the number of frames left on the update is less than `frameCount`, it will
-        * be reset to `frameCount`.
-        *
-        * @class FrameUpdate
-        * @private
+        * Some preset orderings for updates.
         */
-    export class FrameUpdate {
+    export const UPDATE_ORDERING: {
+            BEFORE_CAMERA: number;
+            CAMERA: number;
+            AFTER_CAMERA: number;
+            RENDER: number;
+            AFTER_RENDER: number;
+            AFTER_ALL_UPDATES: number;
+    };
+    type TCoreColors = {
+            defaultHover2D: string;
+            select: string;
+            text: string;
+            path: string;
+            pathPulse: string;
+            textSelect: string;
+    };
+    class Core extends PubSub<INTERNAL_EVENT_PAYLOAD, INTERNAL_EVENT> {
+            #private;
+            static USE_SCENE_MANAGER: boolean;
+            imageFlippingCache: {};
+            imageFlippingEnabled: boolean;
+            MapView: MapView;
+            type: string;
+            container: HTMLDivElement;
+            venue: IMappedin;
+            colors: TCoreColors;
+            loadOptions: TMapViewOptions['loadOptions'];
+            smartCollisionEngine: SmartCollisionEngine;
+            taskScheduler: TaskScheduler;
+            renderer: Renderer;
+            highlightedPolygons: Record<string, string>;
+            scene: Scene;
+            focusZoomFactor: number;
+            cameraObject: PerspectiveCamera;
+            polygonMeshesById: Record<string, Mesh>;
+            textLabelsByPolygonId: Record<string, FlatLabel>;
+            labelOrientationDelay: number;
+            interactivePolygons: Record<string, boolean>;
+            mapManager: MapManager | undefined;
+            sceneManager: SceneManager | undefined;
+            mapObjects: Map<MappedinMap['id'], MapObject>;
+            referenceMap: MappedinMap;
+            currentInteractionEvent: INTERNAL_EVENT | undefined;
+            resolution: Vector2;
+            cameraParameters: Vector2;
+            controls: typeof Mappedin.CameraControls;
+            cameraPlane: Mesh;
+            canvasWidth: number;
+            canvasHeight: number;
+            cachedPadding: TPadding;
+            currentScale: number;
+            rendererDomElement: HTMLCanvasElement;
+            resolutionScale: number;
+            constructor(container: HTMLDivElement, venue: IMappedin, options: (TMapViewOptions & {
+                    onDataLoaded?: ((data: IMappedin) => void) | undefined;
+                    onFirstMapLoaded?: ((data: IMappedin) => void) | undefined;
+            }) | undefined, MapView: MapView);
+            get currentMap(): string | null;
+            getPolygon: (polygon: any) => any;
+            showEntireMap: (options: any) => any;
+            resetPanBounds: () => void;
+            focusOn: (options: any) => any;
+            focusOnPolygon: (polygon: any, changeZoom: any, duration: any, curve: any) => any;
+            focusOnPath: (path: any, polygons: any, changeZoom: any, duration: any, curve: any) => any;
+            getCameraFrameForPoints: (pointCloud: any, horizontalFovFactor: any, verticalFovFactor: any, padding: any, ignoreZoom: any) => {
+                    position: any;
+                    zoom: any;
+            };
+            setPadding: (padding?: TPadding | undefined) => void;
+            getZoomLevelForPolygon: (polygon: any) => any;
+            getZoomLevelForCurrentMap: () => any;
+            getZoomLevelForObject: (object: any) => any;
+            resetCamera: (forceOrigin?: boolean) => void;
             /**
-                * Create a new frame update that can be submitted to a scheduler.
-                * 	@constructor
-                *	@param [options] {Object} Options for the update
-                *	@param [options.callback] {function}
-                *		The actual function to run every time this update is scheduled for
-                *		a frame.
-                *	@param [options.frameCount=1] {number}
-                *		How many frames this update should run for when it's submitted to
-                *		a scheduler
-                *	@param [options.ordering=0] {number}
-                *		An ordering value that's used to determine the order in which
-                *		frame updates will be run within a frame; larger numbers will
-                *		be run first
-                *	@param [options.supersededBy=[]] {[FrameUpdate]}
-                *		If this update is scheduled to run in a frame, but another update in
-                *		the provided list is also scheduled to run on that frame, then
-                *		this update will not be run.
-                *	@param [options.name=undefined] {string}
-                *		If provided, an arbitrary name for logging purposes.
-                *	@param [options.userdata] {Any}
-                *		Arbitrary data that you can store along with this update.
-                */
-            constructor(options: {
-                    callback: Function;
-                    frameCount?: number;
-                    ordering?: number;
-                    supersededBy?: Set<never>;
-                    name: string;
-                    userdata?: Record<string, any>;
-            });
-            _callback: Function;
-            _frameCount: number;
-            _ordering: number;
-            _supersededBy: Set<never>;
-            name: string;
-            _remainingFrameCount: number;
-            _lastFrameTime: number;
-            userdata?: Record<string, any>;
-            /**
-                * Return the amount of time that this frame update took to execute during
-                * its most recent execution, in milliseconds. If called during this frame
-                * update, the value returned will be for the previous invocation. If called
-                * before this frame update has been executed at least once, the returned
-                * value is unspecified.
-                *
-                * @method lastFrameTime
-                * @return {number} the previous frame time, in milliseconds
-                */
-            getLastFrameTime(): number;
-    }
-    /**
-        * A task that can be submitted to the Task Scheduler to be run every time
-        * there is a frame update with spare time in the frame.
-        *
-        * @class FrameTask
-        * @private
-        */
-    export class FrameTask {
-            /**
-                * Create a new frame task that can be submitted to a scheduler.
-                * 	@constructor
-                *	@param [options] {Object} Options for the task
-                *	@param [options.callback] {function}
-                *		The actual function to run when this task is scheduled.
-                *	@param [options.group=null] {FrameTaskGroup}
-                *		If provided, a group to which this task will be added when scheduled
-                *	@param [options.priority=0] {number}
-                *		Tasks with higher priority will be taken from the queue before tasks
-                *		with a lower priority.
-                *	@param [options.postponeOnAdd=false] {number}
-                *		If true, this task will not be run until `resumeTask` is called on the
-                *		scheduler.
-                *	@param [options.name=undefined] {string}
-                *		If provided, an arbitrary name for logging purposes.
-                *	@param [options.userdata] {Any}
-                *		Arbitrary data that you can store along with this task.
-                */
-            constructor(options: {
-                    userdata: Record<string, any>;
-                    priority: number;
-                    group?: FrameTaskGroup;
-                    postponeOnAdd: number | boolean;
-                    name: string;
-                    lastFrameTime: number;
-                    callback: Function;
-            });
-            _postponed: number | boolean;
-            userdata: Record<string, any>;
-            _priority: number;
-            _group: FrameTaskGroup | null;
-            name: string;
-            _lastFrameTime: number;
-            _callback: Function;
-            _complete: boolean;
-            _scheduled: boolean;
-            _cancelled: boolean;
-            /**
-                * Return true if this task has been run at least once.
-                *
-                * @method isComplete
-                * @return {boolean}
-                */
-            isComplete(): boolean;
-            /**
-                * Return the amount of time that this frame task took to execute,
-                * in milliseconds. If this task has not yet completed, the returned value
-                * is unspecified.
+                * Gets a position (to anchor a {{#crossLink "Marker"}}{{/crossLink}} usually) from a latitude and longitude.
                 *
-                * @method lastFrameTime
-                * @return {number} the frame time, in milliseconds
+                * @method getPositionLatLon
+                * @param latitude {Number} Latitude of position
+                * @param longitude {Number} Longitude of position
+                * @returns A position you can use with a Marker either initially or to update later when the user (for example) moves
                 */
-            getLastFrameTime(): number;
-    }
-    /**
-        * A group of tasks that must all be completed before the group is considered
-        * complete. The tasks will be automatically garbage collected so that references
-        * to the task don't linger.
-        *
-        * @class FrameTaskGroup
-        * @private
-        */
-    export class FrameTaskGroup {
+            getPositionLatLon: (lat: number, lon: number, mapId?: string | null | undefined) => any;
+            lockNorth: (element: any, offset?: number) => void;
+            unlockNorth: (element: any) => void;
+            convertTo3DMapPosition: (nodeOrCoordinate: MappedinNode | MappedinCoordinate) => any;
             /**
-                * Create a new frame task group.
-                *
-                * 	@constructor
-                *	@param [options] {Object} Options for the task group
-                *	@param [options.onComplete] {function}
-                *		A callback that will be triggered once every task in this group
-                *		has been completed. This callback may schedule a task, and the
-                *		scheduler will run that task in the same frame, if there is still
-                *		frame time for it.
-                *	@param [options.priority=0] {number}
-                *		The priority of all the tasks in this group.
-                *	@param [options.postponeOnAdd=false] {number}
-                *		If true, tasks from this task group will not be run until `resumeTask`
-                *		is called on the scheduler with this group.
-                *	@param [options.name=undefined] {string}
-                *		If provided, an arbitrary name for logging purposes.
-                *	@param [options.userdata] {Any}
-                *		Arbitrary data that you can store along with this task group.
+                * Converts a 2D x,y screen position into a 3D MappedinCoordinate using projection
                 */
-            constructor(options: {
-                    onComplete?: Function;
-                    priority?: number;
-                    userdata: Record<string, any>;
-                    postponeOnAdd: number | boolean;
-                    name: string;
-            });
-            _postponed: number | boolean;
-            _onComplete: Function;
-            _priority: number;
-            userdata: Record<string, any>;
-            name: string;
-            _tasks: Set<any>;
-            _scheduledTasks: Set<any>;
-            _scheduled: boolean;
-            _cancelled: boolean;
+            convertScreenCoordinateToMapCoordinate: (x: number, y: number, map: MappedinMap) => any;
+            convert3DMapPositionToCoordinate: (coord: any, mapClass?: MappedinMap | null | undefined) => any;
+            getPositionPolygon: (polygon: any) => any;
+            getPositionNode: (node: any) => any;
+            hideAllLabels: () => void;
+            setBackgroundColor: (color: any, alpha: any) => void;
+            setSize: (width: any, height: any) => void;
+            getMapScale: () => number;
+            getNorth: () => number;
             /**
-                * Return true if every task in this group has been run at least once.
-                * @method isComplete
-                * @return {boolean}
+                * The scene only renders when something has changed. This should be something a 3rd party developer doesn't need to worry about,
+                * but if you are doing something weird, or have your own special tween for something, you will want to call this function.
+                * You can call it as often as you want, it just sets a flag that we need to render again, and renders a few frames if we weren't already doing that.
+                * @method tryRendering
+                * @param [renderMode=RENDER.ALL] {RENDER} Which parts of the scene to re-render
                 */
-            isComplete(): boolean;
+            tryRendering: (renderMode?: any) => void;
             /**
-                * Return a list of tasks in this group. This will be a copy of the
-                * underlying task group, so it's safe to mutate the group while
-                * iterating over this array.
+                * Display the performance characteristics and debug controls for this
+                * MapView.
                 *
-                * @method tasks
-                * @return {[FrameTask]} list of tasks in this group
+                * @method showDebugUI
                 */
-            getTasks(): any[];
+            showDebugUI: () => void;
             /**
-                * Empty this task group. This will trivially satisfy `isComplete`.
+                * Hide the performance characteristics and debug controls for this
+                * MapView.
                 *
-                * @method clear
+                * @method hideDebugUI
                 */
-            clear(): void;
+            hideDebugUI: () => void;
+            determineNewLabelSize: () => void;
+            setMap: (map: string | MappedinMap) => Promise<any>;
+            getPolygonsAtScreenCoordinate: (coordinate: any, hoverableMeshChildren: any[], options?: TGetPolygonsAtCoordinateOptions | undefined) => any;
+            getPolygonsAtCoordinate: (coordinate: MappedinCoordinate, hoverableMeshChildren: any[], options?: TGetPolygonsAtCoordinateOptions | undefined) => any;
             /**
-                * Return one arbitrary incomplete task from this group, or undefined if
-                * there are none.
+                * Destroys instance and frees resources
                 *
-                * @method _popTask
-                * @return {FrameTask} arbitrary scheduled task
-                * @private
+                * @method destroy
                 */
-            _popTask(): any;
+            destroy: () => void;
     }
-    /**
-        * A timer for the task scheduler that uses real wall-time to determine if there's
-        * enough remaining time in a frame to execute another task.
-        *
-        * @class RealTimeTimer
-        * @private
-        */
-    export class RealTimeTimer {
-            _maxMillisecondsPerFrame: number;
-            _time: number;
-            /**
-                * @constructor
-                * @param [options] {Object} Options for the timer
-                * @param [options.maxMillisecondsPerFrame]
-                *     If the time since the beginning of the frame has been less than
-                *     or equal to this value, then another task may be executed
-                */
-            constructor(options?: {
-                    maxMillisecondsPerFrame?: number;
-            });
-            /**
-                * Begin timing a frame.
-                *
-                * @method beginFrame
-                */
-            beginFrame(): void;
-            /**
-                * If true, there is enough time remaining to execute another task.
-                *
-                * @method hasTimeRemaining
-                * @return {boolean}
-                */
-            hasTimeRemaining(): boolean;
+    export default Core;
+}
+
+declare module '@mappedin/mappedin-js/renderer/internal/shave-text' {
+    export type TDrawFn = (ctx: CanvasRenderingContext2D, x: number, y: number) => void;
+    type TShave = (str: string, size: number, maxWidth: number, maxLines?: number, lineHeight?: number, options?: {
+        strokeText: boolean;
+    }) => {
+        maxWidth: number;
+        maxHeight: number;
+        lines: number;
+        draw: TDrawFn;
+    };
+    export const shaveText: TShave;
+    export {};
+}
+
+declare module '@mappedin/mappedin-js/renderer/internal/Mappedin.SmartCollisionEngine' {
+    import './Mappedin.SmartCollisionEngine.scss';
+    import { ICollider, TRange, TColliderPosition } from '@mappedin/mappedin-js/renderer/internal/Mappedin.SmartCollider';
+    import { MappedinMap, MapView } from '@mappedin/mappedin-js/renderer';
+    import { ICore } from '@mappedin/mappedin-js/renderer/Core.interface';
+    import { Rectangle, QuadTree } from '@mappedin/mappedin-js/renderer/internal/quad-tree';
+    export const COLLIDER_STRATEGY_LOW_PRIORITY = "LOW_PRIORITY";
+    class SmartCollisionEngine {
+        #private;
+        colliderCanvas: HTMLCanvasElement;
+        debugCanvas: HTMLCanvasElement;
+        colliderCanvasContext: CanvasRenderingContext2D;
+        debugCanvasContext: CanvasRenderingContext2D;
+        collisionEngineContainerEl: HTMLDivElement;
+        stepsX: any;
+        stepsY: any;
+        totalWidth: any;
+        totalHeight: any;
+        project: any;
+        colliders: Map<string, ICollider>;
+        offscreenRanges: TRange[];
+        get sortedColliders(): ICollider[];
+        initialized: boolean;
+        mapView: MapView;
+        core: ICore;
+        screen: Rectangle;
+        constructor(mapView: any, core: ICore);
+        beginUpdate(): void;
+        init: (container: HTMLDivElement, projectFn: (position: TColliderPosition, mapId: MappedinMap['id']) => {
+            x: number;
+            y: number;
+        }) => void;
+        qtree: QuadTree;
+        recompute: () => void;
+        draw: () => void;
+        reposition: () => void;
+        add: (colliderId: string, collider: ICollider) => void;
+        remove: (colliderId: string) => void;
+        update: () => void;
+        resize: (container: any) => void;
+        destroy: () => void;
     }
-    /**
-        * A timer that ticks every time `hasTimeRemaining` is called.
-        *
-        * @class FixedTimer
-        * @private
-        */
-    export class FixedTimer {
-            _ticks: number;
-            maxTasksPerFrame: number;
-            /**
-                * @constructor
-                * @param [options] {Object} Options for the timer
-                * @param [options.maxTasksPerFrame=5]
-                *     The number of tasks that will be exceuted in a single update call.
-                *     Can be modified as the `maxTasksPerFrame` property on this boject.
-                */
-            constructor(options?: {
-                    maxTasksPerFrame?: number;
-            });
-            /**
-                * Begin timing a frame.
-                *
-                * @method beginFrame
-                */
-            beginFrame(): void;
-            /**
-                * If true, there is enough time remaining to execute another task.
-                *
-                * @method hasTimeRemaining
-                * @return {boolean}
-                */
-            hasTimeRemaining(): boolean;
+    export default SmartCollisionEngine;
+}
+
+declare module '@mappedin/mappedin-js/renderer/internal/quad-tree' {
+    export function contains(rect1: Rectangle, rect2: Rectangle): boolean;
+    export function intersects(rect1: Rectangle, rect2: Rectangle): boolean;
+    class Rectangle {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+        userData?: any;
+        constructor(x: number, y: number, w: number, h: number, userData?: any);
+        contains(rectangle: Rectangle): boolean;
+        intersects(rectangle: Rectangle): boolean;
+        draw(context: CanvasRenderingContext2D): void;
+    }
+    class QuadTree {
+        boundary: Rectangle;
+        capacity: number;
+        objects: Rectangle[];
+        topLeft: QuadTree;
+        topRight: QuadTree;
+        bottomLeft: QuadTree;
+        bottomRight: QuadTree;
+        divided: boolean;
+        parent?: QuadTree;
+        getSize(): any;
+        constructor(boundary: Rectangle, parent?: QuadTree);
+        subdivide(): void;
+        query(rectangle: Rectangle): Rectangle[];
+        insert(rectangle: Rectangle): boolean;
+        drawObjects(context: CanvasRenderingContext2D): void;
+        draw(context: CanvasRenderingContext2D): void;
+    }
+    export { QuadTree, Rectangle };
+}
+
+declare module '@mappedin/mappedin-js/navigator/Edge' {
+    import INode from '@mappedin/mappedin-js/navigator/interfaces/INode';
+    import IVortex from '@mappedin/mappedin-js/navigator/interfaces/IVortex';
+    class Edge {
+        origin: INode;
+        destination: INode;
+        vortex?: IVortex;
+        distance: number;
+        angle: number;
+        weight: number;
+        constructor({ origin, destination, vortex, elevationDelta, distance, angle }: {
+            origin: INode;
+            destination: INode;
+            vortex?: IVortex;
+            elevationDelta?: number;
+            distance?: number;
+            angle?: number;
+        });
+    }
+    export default Edge;
+}
+
+declare module '@mappedin/mappedin-js/navigator/interfaces/IMap' {
+    interface IGeoReference {
+        target: {
+            x: number;
+            y: number;
+        };
+        control: {
+            x: number;
+            y: number;
+        };
+    }
+    interface IMap {
+        id: string;
+        name: string;
+        shortName: string;
+        elevation?: number;
+        scale?: number;
+        x_scale?: number;
+        georeference?: IGeoReference[];
+        [propName: string]: any;
+    }
+    export default IMap;
+}
+
+declare module '@mappedin/mappedin-js/navigator/interfaces/INode' {
+    interface INode {
+        id: string;
+        x: number;
+        y: number;
+        map: string;
+        externalId?: string;
+        [propName: string]: any;
+    }
+    export default INode;
+}
+
+declare module '@mappedin/mappedin-js/navigator/interfaces/IVortex' {
+    interface IVortex {
+        id: string;
+        name: string;
+        type: string;
+        weight: number;
+        multiplier: number;
+        [propName: string]: any;
+    }
+    export default IVortex;
+}
+
+declare module '@mappedin/mappedin-js/navigator/interfaces/ILocation' {
+    interface ILocation {
+        id: string;
+        name: string;
+        [propName: string]: any;
+    }
+    export default ILocation;
+}
+
+declare module '@mappedin/mappedin-js/renderer/internal/Mappedin.LabelAtlas' {
+    export namespace DEFAULT_LABEL_SIZING {
+        const MARGIN: number;
+        const HEIGHT_MARGIN: number;
+        const SIZE: number;
+    }
+    export class Atlas {
+        layers: any[];
+        canvas: HTMLCanvasElement;
+        context: CanvasRenderingContext2D | null;
+        addLabel(map: any, lines: any, font: any, size: any, scope: any, pixelsPerScale: any): Label | undefined;
+        removeLayer(layer: any): void;
+        measure(text: any, font: any, size: any): TextMetrics;
+        onWebGLContextRestored(): void;
+        dispose(): void;
+    }
+    export class FlatLabel {
+        constructor(options: any, venue: any, mapObject: any, DEFAULT_FONT: any, polygonMeshesById: any, textLabelsByPolygonId: any, mapView: any, scope: any, atlas: any);
+        id: any;
+        text: any;
+        stateText: string;
+        fullText: any;
+        font: any;
+        atlas: any;
+        canvasBounds: any;
+        mapScale: any;
+        margin: number;
+        heightMargin: number;
+        scaleMin: any;
+        scaleStep: any;
+        multiline: any;
+        height: number | null;
+        polygonMeshesById: any;
+        polyId: any;
+        map: any;
+        color: any;
+        hoverColor: any;
+        baseColor: any;
+        hideOnCreate: boolean;
+        hoverLabelText: any;
+        fontSize: number;
+        hoverLabelMode: any;
+        hoverLabelClass: any;
+        showHoverLabel: boolean;
+        hoverIfLabelFails: boolean;
+        textLabelsByPolygonId: any;
+        create(): void;
+        invalid: boolean | undefined;
+        label: any;
+        created: boolean | undefined;
+        flipIfNeeded(cameraAngle: any): void;
+        removeSelf(bulk: any): void;
+        doNotCreate: boolean | undefined;
+        setColor(textColor: any): void;
+        setHoverColor: (color: any) => void;
+        clearColor(): void;
+        hide(): void;
+        show(): void;
+        toString(): any;
+    }
+    class Label {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        layer: any;
+        index: any;
+        layout(map: any, origin: any, size: any, rotation: any, uv: any, color: any): void;
     }
+    export {};
+}
+
+import { Color, DepthTexture, Mesh, Vector2, NearestFilter, OrthographicCamera, PlaneBufferGeometry, RGBAFormat, Scene, ShaderMaterial, UnsignedIntType, WebGLRenderTarget, WebGL1Renderer, DepthStencilFormat } from 'three';
+import CAMERA_LAYER from '@mappedin/mappedin-js/renderer/internal/Mappedin.CameraLayers.js';
+import RENDER from '@mappedin/mappedin-js/renderer/internal/Mappedin.RenderTasks';
+import CompositeVertexShader from '@mappedin/mappedin-js/renderer/internal/shaders/Mappedin.Composite.Vertex.glsl';
+import CompositeFragmentShader from '@mappedin/mappedin-js/renderer/internal/shaders/Mappedin.Composite.Fragment.glsl';
+import Stats from 'stats.js';
+import Logger from '@mappedin/mappedin-js/--/common/Mappedin.Logger';
+let SHOW_FPS = false;
+let stats;
+if (SHOW_FPS) {
+        stats = new Stats();
+        stats.showPanel(0); // 0: fps, 1: ms, 2: mb, 3+: custom
+        document.body.appendChild(stats.dom);
+}
+/**
+    * A class that controls the rendering resources for a canvas output.
+    *
+    * @class Renderer
+    * @private
+    */
+export default class Renderer {
+        /**
+            * 	@constructor
+            *	@param renderOptions {Object} Options for rendering
+            *	@param [options.multiBufferRendering=false] {boolean}
+            *		Whether to use a multi-buffer renderer
+            *	@param [options.alpha=true] {boolean}
+            *		If true, will allow for a semi-transparent background
+            *	@param [options.antialias=false] {boolean}
+            *		If true, will attempt to antialias rendering if supported
+            *	@param [options.backgroundColor='#ffffff'] {Color | string}
+            *		The color that will be displayed behind the scene
+            *	@param [options.backgroundAlpha=1.0] {number}
+            *		The opacity of the background color
+            *	@param [options.onWebGLContextCreationError=null] {function}
+            *		A callback that will be triggered if WebGL context creation fails
+            *	@param [options.onWebGLContextLost=null] {function}
+            *		A callback that will be triggered if the WebGL context is killed
+            *	@param [options.onWebGLContextRestored=null] {function}
+            *		A callback that will be triggered when three.js reacquires a WebGL context
+            *	@param [options.onWebGLRendererError=null] {function}
+            *		A callback that will be triggered if the renderer throws an error
+            */
+        constructor(renderOptions) {
+                renderOptions.multiBufferRendering =
+                        renderOptions.multiBufferRendering || false;
+                this.contextLost = false;
+                this.implementation = renderOptions.multiBufferRendering
+                        ? new MultiBufferRenderer(renderOptions)
+                        : new SingleBufferRenderer(renderOptions);
+                this.onWebGLContextCreationError =
+                        renderOptions.onWebGLContextCreationError;
+                this.onWebGLContextLost = renderOptions.onWebGLContextLost;
+                this.onWebGLContextRestored = renderOptions.onWebGLContextRestored;
+                this.webGLContextCreationErrorListener = this.domElement().addEventListener('webglcontextcreationerror', e => this.reportWebGlContextCreationError(e));
+                this.webGLContextLostListener = this.domElement().addEventListener('webglcontextlost', e => this.reportWebGlContextLost(e));
+                this.webGLContextRestoredListener = this.domElement().addEventListener('webglcontextrestored', e => this.reportWebGLContextRestored(e));
+                let backgroundColor = renderOptions.backgroundColor;
+                if (typeof backgroundColor === 'string') {
+                        backgroundColor = new Color(renderOptions.backgroundColor);
+                }
+                if (backgroundColor == null) {
+                        backgroundColor = new Color('#ffffff');
+                }
+                let backgroundAlpha = renderOptions.backgroundAlpha;
+                if (backgroundAlpha == null) {
+                        backgroundAlpha = 1.0;
+                }
+                this.shouldConsiderAlpha = renderOptions.alpha || false;
+                this.antialias = renderOptions.antialias || false;
+                this.setBackgroundColor(backgroundColor, backgroundAlpha);
+        }
+        /**
+            * Dispose of any resources and connections allocated by the renderer.
+            *
+            * @method destroy
+            */
+        destroy() {
+                this.domElement().removeEventListener('webglcontextcreationerror', this.webGLContextCreationErrorListener);
+                this.domElement().removeEventListener('webglcontextlost', this.webGLContextLostListener);
+                this.domElement().removeEventListener('webglcontextrestored', this.webGLContextRestoredListener);
+                this.implementation.destroy();
+        }
+        /**
+            * Render the scene to the provided framebuffer. A null framebuffer will
+            * render to the default canvas.
+            *
+            * @method render
+            * @param renderTask {RENDER}
+            * @param renderTarget {null or WebGLRenderTarget}
+            * @param scene {Scene}
+            * @param sceneCamera {Camera}
+            */
+        render(renderTask, renderTarget, scene, sceneCamera) {
+                this.implementation.render(renderTask, renderTarget, scene, sceneCamera);
+        }
+        /**
+            * Return the maximum supported anisotropy of this renderer.
+            *
+            * @method getMaxAnisotropy
+            * @return {number}
+            */
+        getMaxAnisotropy() {
+                return this.implementation.renderer.capabilities.getMaxAnisotropy();
+        }
+        /**
+            * Return the size of the renderer's target.
+            *
+            * @method getBufferSize
+            * @return {Vector2}
+            */
+        getBufferSize() {
+                return this.implementation.renderer.getSize(new Vector2());
+        }
+        /**
+            * Return the WebGL context associated with this renderer, to ensure
+            * other objects that use WebGL will put their textures in the same
+            * context.
+            *
+            * @method context
+            * @return {WebGLRenderingContext} context used by this renderer
+            */
+        getContext() {
+                return this.implementation.renderer.getContext();
+        }
+        /**
+            * Preload a texture, I think. Not actually sure what this does. TODO.
+            *
+            * @method preloadTexture
+            * @param texture {Texture}
+            */
+        preloadTexture(texture) {
+                this.implementation.renderer.initTexture(texture);
+        }
+        /**
+            * Set the renderer and all its internal buffers to the provided width and
+            * height in pixels.
+            *
+            * @method setBufferSize
+            * @param width {number}
+            * @param height {number}
+            */
+        setBufferSize(width, height) {
+                this.implementation.setBufferSize(width, height);
+        }
+        get backgroundColor() {
+                return this.implementation.backgroundColor;
+        }
+        get backgroundAlpha() {
+                return this.implementation.backgroundAlpha;
+        }
+        /**
+            * Set the color and opacity that will be drawn behind the scene.
+            *
+            * @method setBackgroundColor
+            * @param color {Color}
+            * @param alpha {number}
+            */
+        setBackgroundColor(color, alpha) {
+                if (!this.shouldConsiderAlpha) {
+                        alpha = 1.0;
+                }
+                alpha = alpha !== undefined ? +alpha : 1.0;
+                alpha = alpha >= 0.0 && alpha <= 1.0 ? alpha : 1.0;
+                this.implementation.setBackgroundColor(color, alpha);
+        }
+        /**
+            * Assign an outdoor context to this renderer, which will be included as
+            * part of the `STATIC` rendering pass.
+            *
+            * @method setMapboxOutdoorContext
+            * @param {MapboxOutdoorContext} mapboxOutdoorContext context to draw
+            */
+        setMapboxOutdoorContext(mapboxOutdoorContext) {
+                this.implementation.setMapboxOutdoorContext(mapboxOutdoorContext);
+        }
+        // Return the DOM element to which this renderer will render when provided
+        // a `null` `renderTarget` in the `render` method. You can position this
+        // DOM element and add it to the DOM as you see fit.
+        domElement() {
+                return this.implementation.renderer.domElement;
+        }
+        // Return true if this renderer is available to use for rendering. If false,
+        // this means that the context is currently lost, or the renderer failed to
+        // initialize.
+        isAvailable() {
+                return this.implementation.renderer != null && !this.contextLost;
+        }
+        // Temporary solution until https://github.com/mrdoob/three.js/issues/12447 is addressed
+        disposeOfRenderLists() {
+                this.implementation.renderer.renderLists.dispose();
+        }
+        reportWebGlContextCreationError(e) {
+                if (this.onWebGLContextCreationError) {
+                        this.onWebGLContextCreationError(e);
+                }
+        }
+        reportWebGlContextLost(e) {
+                e.preventDefault();
+                if (this.onWebGLContextLost) {
+                        this.onWebGLContextLost(e);
+                }
+                this.contextLost = true;
+        }
+        reportWebGLContextRestored() {
+                if (this.onWebGLContextRestored) {
+                        this.onWebGLContextRestored();
+                }
+                this.contextLost = false;
+        }
+}
+/**
+    * A legacy renderer that renders all the elements in the scene to a single
+    * buffer. Does not support things like transparent paths behind polygons
+    * natively, but can potentially fake it.
+    *
+    * 2019/07/10 Terence Dickson
+    * Generally has worse performance under average loads compared to the
+    * multi-buffer renderer, as the multi-buffer renderer can avoid re-rendering
+    * the entire map if only animated elements on the map have changed.
+    *
+    * @class SingleBufferRenderer
+    * @private
+    */
+class SingleBufferRenderer {
+        constructor(renderOptions) {
+                try {
+                        this.renderer = new WebGL1Renderer({
+                                alpha: renderOptions.alpha || false,
+                                stencil: true,
+                                antialias: renderOptions.antialias,
+                                powerPreference: 'high-performance',
+                                preserveDrawingBuffer: true
+                        });
+                }
+                catch (e) {
+                        if (renderOptions.onWebGLRendererError) {
+                                renderOptions.onWebGLRendererError(e);
+                        }
+                }
+                this.backgroundColor = new Color();
+                this.backgroundAlpha = 1.0;
+                this.mapboxOutdoorContext = null;
+        }
+        /**
+            * Dispose of the renderer.
+            */
+        destroy() {
+                this.renderer.dispose();
+        }
+        /**
+            * Re-render the scene. This ignores the `renderTask` argument, as all
+            * re-renders in the single-buffer renderer are full re-renders.
+            *
+            * @method render
+            * @param renderTask {RENDER}
+            * @param renderTarget {null or WebGLRenderTarget}
+            * @param scene {Scene}
+            * @param sceneCamera {Camera}
+            */
+        render(renderTask, renderTarget, scene, sceneCamera) {
+                sceneCamera.layers.enable(CAMERA_LAYER.STATIC);
+                sceneCamera.layers.enable(CAMERA_LAYER.ANIMATED);
+                sceneCamera.layers.enable(CAMERA_LAYER.ALWAYS_ON_TOP);
+                this.renderer.autoClear = false;
+                this.renderer.setClearColor(this.backgroundColor, this.backgroundAlpha);
+                this.renderer.setRenderTarget(renderTarget);
+                this.renderer.clear();
+                if (SHOW_FPS) {
+                        stats.begin();
+                }
+                this.renderer.render(scene, sceneCamera);
+                if (SHOW_FPS) {
+                        stats.end();
+                }
+                if (this.mapboxOutdoorContext != null) {
+                        this.renderer.state.reset();
+                        this.mapboxOutdoorContext.render({
+                                resolution: this.renderer.getSize(new Vector2()),
+                                camera: sceneCamera
+                        });
+                        this.renderer.state.reset();
+                }
+        }
+        /**
+            * Set the size of the renderer.
+            *
+            * @method setBufferSize
+            * @param width {number}
+            * @param height {number}
+            */
+        setBufferSize(width, height) {
+                this.renderer.setSize(width, height, false);
+        }
+        /**
+            * Set the color and opacity that will be drawn behind the scene.
+            *
+            * @method setBackgroundColor
+            * @param color {Color}
+            * @param alpha {number}
+            */
+        setBackgroundColor(color, alpha) {
+                this.backgroundColor = color;
+                this.backgroundAlpha = alpha;
+        }
+        /**
+            * Assign an outdoor context to this renderer.
+            *
+            * @method setMapboxOutdoorContext
+            * @param {MapboxOutdoorContext} mapboxOutdoorContext context to draw
+            */
+        setMapboxOutdoorContext(mapboxOutdoorContext) {
+                this.mapboxOutdoorContext = mapboxOutdoorContext;
+        }
+}
+/**
+    * Our new renderer that renders static elements to one buffer and animated
+    * elements to another buffer, allowing only the latter buffer to be
+    * re-rendered if the camera isn't moving. There is also a third buffer that
+    * can be used to render elements that must appear always on top.
+    *
+    * Does not yet support antialiasing.
+    *
+    * 2019/07/10 Terence Dickson
+    * Generally has better performance under average loads compared to the
+    * single-buffer renderer, but does not work on IE 11.
+    *
+    * @class MultiBufferRenderer
+    * @private
+    */
+class MultiBufferRenderer {
+        constructor(renderOptions) {
+                try {
+                        this.renderer = new WebGL1Renderer({
+                                alpha: renderOptions.alpha || false,
+                                antialias: false,
+                                stencil: true,
+                                powerPreference: 'high-performance',
+                                preserveDrawingBuffer: true
+                        });
+                }
+                catch (e) {
+                        if (renderOptions.onWebGLRendererError) {
+                                renderOptions.onWebGLRendererError(e);
+                        }
+                }
+                this.backgroundColor = new Color();
+                this.backgroundAlpha = 1.0;
+                this.mapboxOutdoorContext = null;
+                // The render target (color and depth textures) that will be used to
+                // store the static scene, to composite it with the animated scene.
+                this.staticSceneRenderTarget = new WebGLRenderTarget(this.renderer.width, this.renderer.height);
+                this.staticSceneRenderTarget.texture.format = RGBAFormat;
+                this.staticSceneRenderTarget.texture.minFilter = NearestFilter;
+                this.staticSceneRenderTarget.texture.magFilter = NearestFilter;
+                this.staticSceneRenderTarget.texture.generateMipmaps = false;
+                this.staticSceneRenderTarget.stencilBuffer = true;
+                this.staticSceneRenderTarget.depthBuffer = true;
+                this.staticSceneRenderTarget.depthTexture = new DepthTexture();
+                this.staticSceneRenderTarget.depthTexture.type = UnsignedIntType;
+                this.staticSceneRenderTarget.depthTexture.format = DepthStencilFormat;
+                // The render target that will be used to store the dynamic scene,
+                // re-rendered once per frame while animated elements exist in the
+                // 3D scene (e.g., paths.)
+                this.animatedSceneRenderTarget = new WebGLRenderTarget(this.renderer.width, this.renderer.height);
+                this.animatedSceneRenderTarget.texture.format = RGBAFormat;
+                this.animatedSceneRenderTarget.stencilBuffer = true;
+                this.animatedSceneRenderTarget.texture.minFilter = NearestFilter;
+                this.animatedSceneRenderTarget.texture.magFilter = NearestFilter;
+                this.animatedSceneRenderTarget.texture.generateMipmaps = false;
+                this.animatedSceneRenderTarget.stencilBuffer = true;
+                this.animatedSceneRenderTarget.depthBuffer = true;
+                this.animatedSceneRenderTarget.depthTexture = new DepthTexture();
+                this.animatedSceneRenderTarget.depthTexture.type = UnsignedIntType;
+                this.animatedSceneRenderTarget.depthTexture.format = DepthStencilFormat;
+                // The render target that will be used to store the scene whose elements
+                // are always drawn on top of everything else. Rendering is done once per
+                // frame while such elements exist in the 3D scene, just like the animated scene target.
+                // 2020/08/18 - Daniel Vijayakumar
+                // This buffer should be used for animated objects that must appear on top of everything
+                // else. I can't think of any use-cases where you'd ever want *static* elements to be
+                // always on top. If this is not adequate, we can solve this problem with yet a 4th buffer.
+                // although this would create a combinatoric explosion of render passes and might start
+                // eating into the gains of the multi-buffer approach.
+                this.alwaysOnTopSceneRenderTarget = new WebGLRenderTarget(this.renderer.width, this.renderer.height);
+                this.alwaysOnTopSceneRenderTarget.texture.format = RGBAFormat;
+                this.alwaysOnTopSceneRenderTarget.texture.minFilter = NearestFilter;
+                this.alwaysOnTopSceneRenderTarget.texture.magFilter = NearestFilter;
+                this.alwaysOnTopSceneRenderTarget.texture.generateMipmaps = false;
+                this.alwaysOnTopSceneRenderTarget.stencilBuffer = true;
+                this.alwaysOnTopSceneRenderTarget.depthBuffer = true;
+                this.alwaysOnTopSceneRenderTarget.depthTexture = new DepthTexture();
+                this.alwaysOnTopSceneRenderTarget.depthTexture.type = UnsignedIntType;
+                this.alwaysOnTopSceneRenderTarget.depthTexture.format = DepthStencilFormat;
+                this.compositeUniforms = {
+                        staticSceneColorTexture: {
+                                type: 't',
+                                value: this.staticSceneRenderTarget.texture
+                        },
+                        staticSceneDepthTexture: {
+                                type: 't',
+                                value: this.staticSceneRenderTarget.depthTexture
+                        },
+                        animatedSceneColorTexture: {
+                                type: 't',
+                                value: this.animatedSceneRenderTarget.texture
+                        },
+                        animatedSceneDepthTexture: {
+                                type: 't',
+                                value: this.animatedSceneRenderTarget.depthTexture
+                        },
+                        alwaysOnTopSceneColorTexture: {
+                                type: 't',
+                                value: this.alwaysOnTopSceneRenderTarget.texture
+                        }
+                };
+                // The scene that renders a full-screen quad that will sample from
+                // all render targets to produce the composited result.
+                this.compositeCamera = new OrthographicCamera(-1, 1, 1, -1, 0, 1);
+                this.compositeMaterial = new ShaderMaterial({
+                        uniforms: this.compositeUniforms,
+                        vertexShader: CompositeVertexShader,
+                        fragmentShader: CompositeFragmentShader
+                });
+                this.compositeFullscreenQuad = new Mesh(new PlaneBufferGeometry(2, 2), this.compositeMaterial);
+                this.compositeScene = new Scene();
+                this.compositeScene.add(this.compositeFullscreenQuad);
+        }
+        /**
+            * Dispose of the renderer and its buffers.
+            */
+        destroy() {
+                this.staticSceneRenderTarget.dispose();
+                this.animatedSceneRenderTarget.dispose();
+                this.alwaysOnTopSceneRenderTarget.dispose();
+                this.renderer.dispose();
+        }
+        /**
+            * Compose all buffers into the final image that is sent to the viewport.
+            *
+            * @private
+            * @method renderComposite
+            * @param renderTarget {null or WebGLRenderTarget}
+            */
+        renderComposite(renderTarget) {
+                this.renderer.setRenderTarget(renderTarget);
+                this.renderer.clear();
+                // 23/05/2019 Terence Dickson
+                // We need to disable depth writes on the fullscreen-quad, since
+                // otherwise it is considered "very close to the camera" and will
+                // obscure the path rendering. Keep an eye on this if you update
+                // three.js, since we're modifying properties on the WebGL context
+                // itself, and three.js might decide to override this in the future.
+                this.renderer.getContext().depthMask(false);
+                this.renderer.render(this.compositeScene, this.compositeCamera);
+                this.renderer.getContext().depthMask(true);
+        }
+        /**
+            * Renders the scene's animated layer to its dedicated buffer.
+            *
+            * @private
+            * @method renderToAnimatedBuffer
+            * @param {*} scene
+            * @param {*} sceneCamera
+            */
+        renderToAnimatedBuffer(scene, sceneCamera) {
+                sceneCamera.layers.set(CAMERA_LAYER.ANIMATED);
+                this.renderer.setClearColor(new Color(), 0.0);
+                this.renderer.setRenderTarget(this.animatedSceneRenderTarget);
+                this.renderer.clear();
+                this.renderer.render(scene, sceneCamera);
+        }
+        /**
+            * Render the provided scene using the given camera, re-rendering only
+            * the animated parts.
+            *
+            * @method renderAnimated
+            * @param renderTarget {null or WebGLRenderTarget}
+            * @param scene {Scene}
+            * @param sceneCamera {Camera}
+            */
+        renderAnimated(renderTarget, scene, sceneCamera) {
+                this.renderToAnimatedBuffer(scene, sceneCamera);
+                this.renderComposite(renderTarget);
+        }
+        /**
+            * Renders the scene's always-on-top layer to its dedicated buffer.
+            *
+            * @private
+            * @method renderToAlwaysOnTopBuffer
+            * @param {*} scene
+            * @param {*} sceneCamera
+            */
+        renderToAlwaysOnTopBuffer(scene, sceneCamera) {
+                sceneCamera.layers.set(CAMERA_LAYER.ALWAYS_ON_TOP);
+                this.renderer.setClearColor(new Color(), 0.0);
+                this.renderer.setRenderTarget(this.alwaysOnTopSceneRenderTarget);
+                this.renderer.clear();
+                this.renderer.render(scene, sceneCamera);
+        }
+        /**
+            * Render the provided scene using the given camera, re-rendering only
+            * the parts that should appear on top of all other elements.
+            *
+            * @method renderAlwaysOnTop
+            * @param renderTarget {null or WebGLRenderTarget}
+            * @param scene {Scene}
+            * @param sceneCamera {Camera}
+            */
+        renderAlwaysOnTop(renderTarget, scene, sceneCamera) {
+                this.renderToAlwaysOnTopBuffer(scene, sceneCamera);
+                this.renderComposite(renderTarget);
+        }
+        /**
+            * Render all of the scene layers, then combine them.
+            *
+            * @method renderAll
+            * @param renderTarget {null or WebGLRenderTarget}
+            * @param scene {Scene}
+            * @param sceneCamera {Camera}
+            */
+        renderAll(renderTarget, scene, sceneCamera) {
+                // First, render to static buffer
+                sceneCamera.layers.set(CAMERA_LAYER.STATIC);
+                this.renderer.autoClear = false;
+                this.renderer.setClearColor(this.backgroundColor, this.backgroundAlpha);
+                this.renderer.setRenderTarget(this.staticSceneRenderTarget);
+                this.renderer.clear();
+                this.renderer.render(scene, sceneCamera);
+                // Then render mapbox outdoor context
+                if (this.mapboxOutdoorContext != null) {
+                        this.renderer.state.reset();
+                        this.mapboxOutdoorContext.render({
+                                resolution: this.renderer.getSize(new Vector2()),
+                                camera: sceneCamera,
+                                renderTarget: this.staticSceneRenderTarget
+                        });
+                        this.renderer.state.reset();
+                }
+                // Next, render the remaining buffers
+                this.renderToAnimatedBuffer(scene, sceneCamera);
+                this.renderToAlwaysOnTopBuffer(scene, sceneCamera);
+                // Finally, composite the scene
+                this.renderComposite(renderTarget);
+        }
+        /**
+            * Re-render the scene, depending on which parts of the scene have been
+            * invalidated.
+            *
+            * @method render
+            * @param renderTarget {null or WebGLRenderTarget}
+            * @param scene {Scene}
+            * @param sceneCamera {Camera}
+            */
+        render(renderTask, renderTarget, scene, sceneCamera) {
+                if (renderTask === RENDER.ANIMATED) {
+                        this.renderAnimated(renderTarget, scene, sceneCamera);
+                }
+                else if (renderTask === RENDER.ALWAYS_ON_TOP) {
+                        this.renderAlwaysOnTop(renderTarget, scene, sceneCamera);
+                }
+                else if (renderTask === RENDER.ALL) {
+                        this.renderAll(renderTarget, scene, sceneCamera);
+                }
+                else {
+                        Logger.error('Renderer.render called with invalid renderTask');
+                }
+        }
+        /**
+            * Set the size of the renderer, and all its internal buffers.
+            *
+            * @method setBufferSize
+            * @param width {number}
+            * @param height {number}
+            */
+        setBufferSize(width, height) {
+                this.renderer.setSize(width, height, false);
+                this.staticSceneRenderTarget.setSize(width, height);
+                this.animatedSceneRenderTarget.setSize(width, height);
+                this.alwaysOnTopSceneRenderTarget.setSize(width, height);
+        }
+        /**
+            * Set the color and opacity that will be drawn behind the scene.
+            *
+            * @method setBackgroundColor
+            * @param color {Color}
+            * @param alpha {number}
+            */
+        setBackgroundColor(color, alpha) {
+                this.backgroundColor = color;
+                this.backgroundAlpha = alpha;
+        }
+        /**
+            * Assign an outdoor context to this renderer.
+            *
+            * @method setMapboxOutdoorContext
+            * @param {MapboxOutdoorContext} mapboxOutdoorContext context to draw
+            */
+        setMapboxOutdoorContext(mapboxOutdoorContext) {
+                this.mapboxOutdoorContext = mapboxOutdoorContext;
+        }
+}
+
+declare module '@mappedin/mappedin-js/get-venue/Mappedin.TaskScheduler' {
     /**
-        * A class that handles scheduling tasks to be performed within the time
-        * constraints of frame updates, triggered using `requestAnimationFrame`.
+        * A function that can be submitted to the Task Scheduler to run each frame for
+        * some provided number of frames. A single update can be repeatedly submitted;
+        * if the number of frames left on the update is less than `frameCount`, it will
+        * be reset to `frameCount`.
         *
-        * Tasks can either be scheduled once per frame (called "frame updates"), or
-        * to execute as many times per frame as there is room for after processing
-        * all frame updates (called "frame tasks").
-        *
-        * Posted tasks will always run during the same frame, assuming there's time to
-        * process them. However, an update or task that posts an update will not run
-        * that update until the next frame.
-        *
-        * @class TaskScheduler
+        * @class FrameUpdate
         * @private
         */
-    export class TaskScheduler {
+    export class FrameUpdate {
             /**
-                * Construct a new `TaskScheduler` with no tasks scheduled.
-                *
-                * @constructor
-                * @param [options] {Object} Options for the scheduler
-                * @param [options.timer=new RealTimeTimer()]
-                *     Timer that determines whether there is sufficient time left in a frame
-                *     to continue executing tasks
-                * @param [options.performance=false]
-                *     If true, this task scheduler will annotate tasks and frame updates with
-                *     performance information.
+                * Create a new frame update that can be submitted to a scheduler.
+                * 	@constructor
+                *	@param [options] {Object} Options for the update
+                *	@param [options.callback] {function}
+                *		The actual function to run every time this update is scheduled for
+                *		a frame.
+                *	@param [options.frameCount=1] {number}
+                *		How many frames this update should run for when it's submitted to
+                *		a scheduler
+                *	@param [options.ordering=0] {number}
+                *		An ordering value that's used to determine the order in which
+                *		frame updates will be run within a frame; larger numbers will
+                *		be run first
+                *	@param [options.supersededBy=[]] {[FrameUpdate]}
+                *		If this update is scheduled to run in a frame, but another update in
+                *		the provided list is also scheduled to run on that frame, then
+                *		this update will not be run.
+                *	@param [options.name=undefined] {string}
+                *		If provided, an arbitrary name for logging purposes.
+                *	@param [options.userdata] {Any}
+                *		Arbitrary data that you can store along with this update.
                 */
-            constructor(options?: {
-                    timer?: RealTimeTimer;
-                    performance?: boolean;
+            constructor(options: {
+                    callback: Function;
+                    frameCount?: number;
+                    ordering?: number;
+                    supersededBy?: Set<any>;
+                    name: string;
+                    userdata?: Record<string, any>;
             });
-            _raf?: (callback: FrameRequestCallback) => number;
-            _timer: RealTimeTimer;
-            _performance: boolean;
-            _scheduledUpdatesByOrdering: Multimap;
-            _scheduledTasksByPriority: Multimap;
-            _postponedTasks: Set<any>;
-            _requestAnimationFrameHandle: number | null;
-            _updatesToRunThisFrame: any[];
+            _callback: Function;
+            _frameCount: number;
+            _ordering: number;
+            _supersededBy: Set<any>;
+            name: string;
+            _remainingFrameCount: number;
             _lastFrameTime: number;
-            _updatesRunLastFrame: Set<any>;
-            /**
-                * Empty the task scheduler's queue. All tasks in it will be cancelled.
-                *
-                * @method clear
-                */
-            clear(): void;
-            /**
-                * Destroy this task scheduler and remove all tasks from it.
-                *
-                * @method destroy
-                */
-            destroy(): void;
+            userdata?: Record<string, any>;
             /**
-                * Schedule this task scheduler to execute updates and tasks on the next
-                * available animation frame.
+                * Return the amount of time that this frame update took to execute during
+                * its most recent execution, in milliseconds. If called during this frame
+                * update, the value returned will be for the previous invocation. If called
+                * before this frame update has been executed at least once, the returned
+                * value is unspecified.
                 *
-                * @method requestAnimationFrame
+                * @method lastFrameTime
+                * @return {number} the previous frame time, in milliseconds
                 */
-            requestAnimationFrame(): void;
+            getLastFrameTime(): number;
+    }
+    /**
+        * A task that can be submitted to the Task Scheduler to be run every time
+        * there is a frame update with spare time in the frame.
+        *
+        * @class FrameTask
+        * @private
+        */
+    export class FrameTask {
             /**
-                * Run all scheduled updates, and re-schedule another animation frame if any
-                * scheduled updates still exist. If any scheduled update specifies
-                * `shouldRunTasksAfterCompletion`, this will also run queued tasks until the
-                * frame time runs out.
-                *
-                * @method update
-                * @param timestamp {number} the current animation time, as returned from
-                * `performance.now()`; will be automatically filled in by
-                * `requestAnimationFrame` when it triggers this as a callback
+                * Create a new frame task that can be submitted to a scheduler.
+                * 	@constructor
+                *	@param [options] {Object} Options for the task
+                *	@param [options.callback] {function}
+                *		The actual function to run when this task is scheduled.
+                *	@param [options.group=null] {FrameTaskGroup}
+                *		If provided, a group to which this task will be added when scheduled
+                *	@param [options.priority=0] {number}
+                *		Tasks with higher priority will be taken from the queue before tasks
+                *		with a lower priority.
+                *	@param [options.postponeOnAdd=false] {number}
+                *		If true, this task will not be run until `resumeTask` is called on the
+                *		scheduler.
+                *	@param [options.name=undefined] {string}
+                *		If provided, an arbitrary name for logging purposes.
+                *	@param [options.userdata] {Any}
+                *		Arbitrary data that you can store along with this task.
                 */
-            update(timestamp: number): void;
+            constructor(options: {
+                    userdata: Record<string, any>;
+                    priority: number;
+                    group?: FrameTaskGroup;
+                    postponeOnAdd: number | boolean;
+                    name: string;
+                    lastFrameTime: number;
+                    callback: Function;
+            });
+            _postponed: number | boolean;
+            userdata: Record<string, any>;
+            _priority: number;
+            _group: FrameTaskGroup | null;
+            name: string;
+            _lastFrameTime: number;
+            _callback: Function;
+            _complete: boolean;
+            _scheduled: boolean;
+            _cancelled: boolean;
             /**
-                * Execute all tasks that are currently pending, without regard for the
-                * available frame time.
+                * Return true if this task has been run at least once.
                 *
-                * @method flushTasks
+                * @method isComplete
+                * @return {boolean}
                 */
-            flushTasks(): void;
+            isComplete(): boolean;
             /**
-                * Return the amount of time elapsed during the last completed frame update,
-                * in milliseconds. This value is unspecified if the task scheduler's
-                * `update` method has not yet run or if the scheduler has been cleared.
-                * If called during a frame update, this will
-                * return the time elapsed during the previous frame update.
+                * Return the amount of time that this frame task took to execute,
+                * in milliseconds. If this task has not yet completed, the returned value
+                * is unspecified.
                 *
                 * @method lastFrameTime
-                * @return {number} time elapsed during last frame update, in milliseconds
+                * @return {number} the frame time, in milliseconds
                 */
             getLastFrameTime(): number;
+    }
+    /**
+        * A group of tasks that must all be completed before the group is considered
+        * complete. The tasks will be automatically garbage collected so that references
+        * to the task don't linger.
+        *
+        * @class FrameTaskGroup
+        * @private
+        */
+    export class FrameTaskGroup {
             /**
-                * Return a set containing every update that was run during the previous
-                * frame update. This will be empty if the task scheduler's `update` method
-                * has not yet been run or if the scheduler has been cleared.
-                */
-            getUpdatesRunLastFrame(): Set<any>;
-            _executeOneTask(timestamp: number): void;
-            /**
-                * Schedule an update to be run for the next `update.frameCount` frames. If
-                * the update already exists in the scheduler, the update's frame count will
-                * be refreshed to `update.frameCount`. This will also schedule an animation
-                * frame to begin processing the update.
+                * Create a new frame task group.
                 *
-                * @method scheduleUpdate
-                * @param task {FrameUpdate} the update to schedule
+                * 	@constructor
+                *	@param [options] {Object} Options for the task group
+                *	@param [options.onComplete] {function}
+                *		A callback that will be triggered once every task in this group
+                *		has been completed. This callback may schedule a task, and the
+                *		scheduler will run that task in the same frame, if there is still
+                *		frame time for it.
+                *	@param [options.priority=0] {number}
+                *		The priority of all the tasks in this group.
+                *	@param [options.postponeOnAdd=false] {number}
+                *		If true, tasks from this task group will not be run until `resumeTask`
+                *		is called on the scheduler with this group.
+                *	@param [options.name=undefined] {string}
+                *		If provided, an arbitrary name for logging purposes.
+                *	@param [options.userdata] {Any}
+                *		Arbitrary data that you can store along with this task group.
                 */
-            scheduleUpdate(update: FrameUpdate): void;
+            constructor(options: {
+                    onComplete?: Function;
+                    priority?: number;
+                    userdata: Record<string, any>;
+                    postponeOnAdd: number | boolean;
+                    name: string;
+            });
+            _postponed: number | boolean;
+            _onComplete: Function;
+            _priority: number;
+            userdata: Record<string, any>;
+            name: string;
+            _tasks: Set<any>;
+            _scheduledTasks: Set<any>;
+            _scheduled: boolean;
+            _cancelled: boolean;
             /**
-                * Schedule a task to be run during a frame update. This will also schedule
-                * an animation frame to begin processing the task queue.
-                *
-                * @method scheduleTask
-                * @param task {FrameTask} the task to schedule
+                * Return true if every task in this group has been run at least once.
+                * @method isComplete
+                * @return {boolean}
                 */
-            scheduleTask(task: FrameTask): void;
+            isComplete(): boolean;
             /**
-                * If the given update is in the queue, remove it.
+                * Return a list of tasks in this group. This will be a copy of the
+                * underlying task group, so it's safe to mutate the group while
+                * iterating over this array.
                 *
-                * @method cancelUpdate
-                * @param task {FrameUpdate} the update to cancel
+                * @method tasks
+                * @return {[FrameTask]} list of tasks in this group
                 */
-            cancelUpdate(update: FrameUpdate): void;
+            getTasks(): any[];
             /**
-                * If the given task or group is in the queue, remove it. Cancelling a
-                * completed task is a no-op.
-                *
-                * Canceling an individual task will also remove it from its task group, if
-                * it isn't already complete.
+                * Empty this task group. This will trivially satisfy `isComplete`.
                 *
-                * @method cancelTask
-                * @param task {FrameTask or FrameTaskGroup} the task to cancel
+                * @method clear
                 */
-            cancelTask(task: FrameTask | FrameTaskGroup): void;
+            clear(): void;
             /**
-                * Set the provided task or group not to run, until it's resumed using `resumeTask`.
+                * Return one arbitrary incomplete task from this group, or undefined if
+                * there are none.
                 *
-                * Tasks that are in a group can't be postponed individually; instead, call
-                * `postponeTask` with the entire group.
+                * @method _popTask
+                * @return {FrameTask} arbitrary scheduled task
+                * @private
+                */
+            _popTask(): any;
+    }
+    /**
+        * A timer for the task scheduler that uses real wall-time to determine if there's
+        * enough remaining time in a frame to execute another task.
+        *
+        * @class RealTimeTimer
+        * @private
+        */
+    export class RealTimeTimer {
+            _maxMillisecondsPerFrame: number;
+            _time: number;
+            /**
+                * @constructor
+                * @param [options] {Object} Options for the timer
+                * @param [options.maxMillisecondsPerFrame]
+                *     If the time since the beginning of the frame has been less than
+                *     or equal to this value, then another task may be executed
+                */
+            constructor(options?: {
+                    maxMillisecondsPerFrame?: number;
+            });
+            /**
+                * Begin timing a frame.
+                *
+                * @method beginFrame
+                */
+            beginFrame(): void;
+            /**
+                * If true, there is enough time remaining to execute another task.
+                *
+                * @method hasTimeRemaining
+                * @return {boolean}
+                */
+            hasTimeRemaining(): boolean;
+    }
+    /**
+        * A timer that ticks every time `hasTimeRemaining` is called.
+        *
+        * @class FixedTimer
+        * @private
+        */
+    export class FixedTimer {
+            _ticks: number;
+            maxTasksPerFrame: number;
+            /**
+                * @constructor
+                * @param [options] {Object} Options for the timer
+                * @param [options.maxTasksPerFrame=5]
+                *     The number of tasks that will be exceuted in a single update call.
+                *     Can be modified as the `maxTasksPerFrame` property on this boject.
+                */
+            constructor(options?: {
+                    maxTasksPerFrame?: number;
+            });
+            /**
+                * Begin timing a frame.
+                *
+                * @method beginFrame
+                */
+            beginFrame(): void;
+            /**
+                * If true, there is enough time remaining to execute another task.
+                *
+                * @method hasTimeRemaining
+                * @return {boolean}
+                */
+            hasTimeRemaining(): boolean;
+    }
+    /**
+        * A class that handles scheduling tasks to be performed within the time
+        * constraints of frame updates, triggered using `requestAnimationFrame`.
+        *
+        * Tasks can either be scheduled once per frame (called "frame updates"), or
+        * to execute as many times per frame as there is room for after processing
+        * all frame updates (called "frame tasks").
+        *
+        * Posted tasks will always run during the same frame, assuming there's time to
+        * process them. However, an update or task that posts an update will not run
+        * that update until the next frame.
+        *
+        * @class TaskScheduler
+        * @private
+        */
+    export class TaskScheduler {
+            /**
+                * Construct a new `TaskScheduler` with no tasks scheduled.
+                *
+                * @constructor
+                * @param [options] {Object} Options for the scheduler
+                * @param [options.timer=new RealTimeTimer()]
+                *     Timer that determines whether there is sufficient time left in a frame
+                *     to continue executing tasks
+                * @param [options.performance=false]
+                *     If true, this task scheduler will annotate tasks and frame updates with
+                *     performance information.
+                */
+            constructor(options?: {
+                    timer?: RealTimeTimer;
+                    performance?: boolean;
+            });
+            _raf?: (callback: FrameRequestCallback) => number;
+            _timer: RealTimeTimer;
+            _performance: boolean;
+            _scheduledUpdatesByOrdering: Multimap;
+            _scheduledTasksByPriority: Multimap;
+            _postponedTasks: Set<any>;
+            _requestAnimationFrameHandle: number | null;
+            _updatesToRunThisFrame: any[];
+            _lastFrameTime: number;
+            _updatesRunLastFrame: Set<any>;
+            /**
+                * Empty the task scheduler's queue. All tasks in it will be cancelled.
+                *
+                * @method clear
+                */
+            clear(): void;
+            /**
+                * Destroy this task scheduler and remove all tasks from it.
+                *
+                * @method destroy
+                */
+            destroy(): void;
+            /**
+                * Schedule this task scheduler to execute updates and tasks on the next
+                * available animation frame.
+                *
+                * @method requestAnimationFrame
+                */
+            requestAnimationFrame(): void;
+            /**
+                * Run all scheduled updates, and re-schedule another animation frame if any
+                * scheduled updates still exist. If any scheduled update specifies
+                * `shouldRunTasksAfterCompletion`, this will also run queued tasks until the
+                * frame time runs out.
+                *
+                * @method update
+                * @param timestamp {number} the current animation time, as returned from
+                * `performance.now()`; will be automatically filled in by
+                * `requestAnimationFrame` when it triggers this as a callback
+                */
+            update(timestamp: number): void;
+            /**
+                * Execute all tasks that are currently pending, without regard for the
+                * available frame time.
+                *
+                * @method flushTasks
+                */
+            flushTasks(): void;
+            /**
+                * Return the amount of time elapsed during the last completed frame update,
+                * in milliseconds. This value is unspecified if the task scheduler's
+                * `update` method has not yet run or if the scheduler has been cleared.
+                * If called during a frame update, this will
+                * return the time elapsed during the previous frame update.
+                *
+                * @method lastFrameTime
+                * @return {number} time elapsed during last frame update, in milliseconds
+                */
+            getLastFrameTime(): number;
+            /**
+                * Return a set containing every update that was run during the previous
+                * frame update. This will be empty if the task scheduler's `update` method
+                * has not yet been run or if the scheduler has been cleared.
+                */
+            getUpdatesRunLastFrame(): Set<any>;
+            _executeOneTask(timestamp: number): void;
+            /**
+                * Schedule an update to be run for the next `update.frameCount` frames. If
+                * the update already exists in the scheduler, the update's frame count will
+                * be refreshed to `update.frameCount`. This will also schedule an animation
+                * frame to begin processing the update.
+                *
+                * @method scheduleUpdate
+                * @param task {FrameUpdate} the update to schedule
+                */
+            scheduleUpdate(update: FrameUpdate): void;
+            /**
+                * Schedule a task to be run during a frame update. This will also schedule
+                * an animation frame to begin processing the task queue.
+                *
+                * @method scheduleTask
+                * @param task {FrameTask} the task to schedule
+                */
+            scheduleTask(task: FrameTask): void;
+            /**
+                * If the given update is in the queue, remove it.
+                *
+                * @method cancelUpdate
+                * @param task {FrameUpdate} the update to cancel
+                */
+            cancelUpdate(update: FrameUpdate): void;
+            /**
+                * If the given task or group is in the queue, remove it. Cancelling a
+                * completed task is a no-op.
+                *
+                * Canceling an individual task will also remove it from its task group, if
+                * it isn't already complete.
+                *
+                * @method cancelTask
+                * @param task {FrameTask or FrameTaskGroup} the task to cancel
+                */
+            cancelTask(task: FrameTask | FrameTaskGroup): void;
+            /**
+                * Set the provided task or group not to run, until it's resumed using `resumeTask`.
+                *
+                * Tasks that are in a group can't be postponed individually; instead, call
+                * `postponeTask` with the entire group.
                 *
                 * @method postponeTask
                 * @param task {FrameTask or FrameTaskGroup} the task to postpone
@@ -5650,371 +6734,810 @@ declare module '@mappedin/mappedin-js/get-venue/Mappedin.TaskScheduler' {
                 * @method popFromMaxKey
                 * @return {Any} arbitrary value from the highest key's set, or undefined
                 * if the map is empty
-                */
-            popFromMaxKey(): any;
-            /**
-                * Return an iterator over every value in this multimap, at every key.
-                * Mutating the multimap during iteration will result in undefined
-                * behaviour.
-                *
-                * @method values
-                * @return {Iterator} iterator over the values in the map
-                */
-            values(): {
-                    [Symbol.iterator]: () => any;
-                    next: () => any;
-            };
-            /**
-                * A list of keys in this set, sorted by numeric value. Not cloned,
-                * for efficiency's sake, so please don't mutate it.
-                *
-                * @method keys
-                * @return {[number]} sorted list of numeric keys in the map
-                */
-            keys(): any[];
-            /**
-                * The number of elements in this multimap, equal to the sum of the sizes
-                * of each key's set of values.
-                *
-                * @property size {number} number of elements in this multimap
-                */
-            get size(): number;
-    }
-    export {};
-}
-
-declare module '@mappedin/mappedin-js/renderer/MapView.SceneManager' {
-    import { MappedinMap } from '@mappedin/mappedin-js/get-venue';
-    import { TCameraTransform, TCameraAnimationOptions } from '@mappedin/mappedin-js/renderer/Camera';
-    import { ICore } from '@mappedin/mappedin-js/renderer/Core.interface';
-    import MapViewScene from '@mappedin/mappedin-js/renderer/MapView.Scene';
-    export type TSceneTransitionOptions = {
-            /**
-                * Map to set as active during the transition. This will decide where the camera will be positioned, as well as which
-                * colliders are enabled.
-                */
-            activeMap?: MappedinMap;
-            verticalDistanceBetweenMaps?: number;
-            /**
-                * Camera options to use when transitioning to the new scene
-                */
-            cameraTransform?: TCameraTransform;
-            cameraAnimationOptions?: TCameraAnimationOptions;
-            /**
-                * Whether to auto focus on the active map or leave the camera where it is.
-                * For single building venues, this should look the same way it did with MapManager
-                * For multi-building venues, this means the camera will not pan over to where the active map
-                * is relative to the world, which may look like broken behavior.
-                * @default true
-                */
-            autoFocusOnActiveMap?: boolean;
-    };
-    class SceneManager {
-            #private;
-            currentScene: MapViewScene;
-            constructor(core: ICore, startingScene: MapViewScene);
-            get currentMap(): MappedinMap;
-            renderGrid(): void;
-            transitionTo(scene: MapViewScene, transitionOptions?: TSceneTransitionOptions): Promise<void>;
-    }
-    export default SceneManager;
-}
-
-declare module '@mappedin/mappedin-js/renderer/internal/shave-text' {
-    export type TDrawFn = (ctx: CanvasRenderingContext2D, x: number, y: number) => void;
-    type TShave = (str: string, size: number, maxWidth: number, maxLines?: number, lineHeight?: number, options?: {
-        strokeText: boolean;
-    }) => {
-        maxWidth: number;
-        maxHeight: number;
-        lines: number;
-        draw: TDrawFn;
-    };
-    export const shaveText: TShave;
-    export {};
-}
-
-declare module '@mappedin/mappedin-js/renderer/internal/Mappedin.SmartCollisionEngine' {
-    import { Vector3 } from 'three';
-    import './Mappedin.SmartCollisionEngine.scss';
-    import { ICollider, TRange } from '@mappedin/mappedin-js/renderer/internal/Mappedin.SmartCollider';
-    import { MappedinMap, MapView } from '@mappedin/mappedin-js/renderer';
-    import { ICore } from '@mappedin/mappedin-js/renderer/Core.interface';
-    import { Rectangle, QuadTree } from '@mappedin/mappedin-js/renderer/internal/quad-tree';
-    export const COLLIDER_STRATEGY_LOW_PRIORITY = "LOW_PRIORITY";
-    class SmartCollisionEngine {
-        #private;
-        colliderCanvas: HTMLCanvasElement;
-        debugCanvas: HTMLCanvasElement;
-        colliderCanvasContext: CanvasRenderingContext2D;
-        debugCanvasContext: CanvasRenderingContext2D;
-        collisionEngineContainerEl: HTMLDivElement;
-        stepsX: any;
-        stepsY: any;
-        totalWidth: any;
-        totalHeight: any;
-        project: any;
-        colliders: Map<string, ICollider>;
-        offscreenRanges: TRange[];
-        get sortedColliders(): ICollider[];
-        initialized: boolean;
-        mapView: MapView;
-        core: ICore;
-        screen: Rectangle;
-        constructor(mapView: any, core: ICore);
-        beginUpdate(): void;
-        init: (container: HTMLDivElement, projectFn: ({ position, mapId }: {
-            position: any;
-            mapId: MappedinMap['id'];
-        }) => {
-            x: number;
-            y: number;
-        }) => void;
-        qtree: QuadTree;
-        recompute: () => void;
-        draw: () => void;
-        reposition: () => void;
-        add: (colliderId: string, collider: ICollider) => void;
-        remove: (colliderId: string) => void;
-        update: () => void;
-        resize: (container: any) => void;
-        destroy: () => void;
-    }
-    export default SmartCollisionEngine;
-}
-
-declare module '@mappedin/mappedin-js/renderer/internal/quad-tree' {
-    export function contains(rect1: Rectangle, rect2: Rectangle): boolean;
-    export function intersects(rect1: Rectangle, rect2: Rectangle): boolean;
-    class Rectangle {
-        x: number;
-        y: number;
-        w: number;
-        h: number;
-        userData?: any;
-        constructor(x: number, y: number, w: number, h: number, userData?: any);
-        contains(rectangle: Rectangle): boolean;
-        intersects(rectangle: Rectangle): boolean;
-        draw(context: CanvasRenderingContext2D): void;
-    }
-    class QuadTree {
-        boundary: Rectangle;
-        capacity: number;
-        objects: Rectangle[];
-        topLeft: QuadTree;
-        topRight: QuadTree;
-        bottomLeft: QuadTree;
-        bottomRight: QuadTree;
-        divided: boolean;
-        parent?: QuadTree;
-        getSize(): any;
-        constructor(boundary: Rectangle, parent?: QuadTree);
-        subdivide(): void;
-        query(rectangle: Rectangle): Rectangle[];
-        insert(rectangle: Rectangle): boolean;
-        drawObjects(context: CanvasRenderingContext2D): void;
-        draw(context: CanvasRenderingContext2D): void;
-    }
-    export { QuadTree, Rectangle };
-}
-
-declare module '@mappedin/mappedin-js/navigator/Edge' {
-    import INode from '@mappedin/mappedin-js/navigator/interfaces/INode';
-    import IVortex from '@mappedin/mappedin-js/navigator/interfaces/IVortex';
-    class Edge {
-        origin: INode;
-        destination: INode;
-        vortex?: IVortex;
-        distance: number;
-        angle: number;
-        weight: number;
-        constructor({ origin, destination, vortex, elevationDelta, distance, angle }: {
-            origin: INode;
-            destination: INode;
-            vortex?: IVortex;
-            elevationDelta?: number;
-            distance?: number;
-            angle?: number;
-        });
-    }
-    export default Edge;
-}
-
-declare module '@mappedin/mappedin-js/navigator/interfaces/IMap' {
-    interface IGeoReference {
-        target: {
-            x: number;
-            y: number;
-        };
-        control: {
-            x: number;
-            y: number;
-        };
-    }
-    interface IMap {
-        id: string;
-        name: string;
-        shortName: string;
-        elevation?: number;
-        scale?: number;
-        x_scale?: number;
-        georeference?: IGeoReference[];
-        [propName: string]: any;
-    }
-    export default IMap;
-}
-
-declare module '@mappedin/mappedin-js/navigator/interfaces/INode' {
-    interface INode {
-        id: string;
-        x: number;
-        y: number;
-        map: string;
-        externalId?: string;
-        [propName: string]: any;
-    }
-    export default INode;
-}
-
-declare module '@mappedin/mappedin-js/navigator/interfaces/IVortex' {
-    interface IVortex {
-        id: string;
-        name: string;
-        type: string;
-        weight: number;
-        multiplier: number;
-        [propName: string]: any;
-    }
-    export default IVortex;
-}
-
-declare module '@mappedin/mappedin-js/navigator/interfaces/ILocation' {
-    interface ILocation {
-        id: string;
-        name: string;
-        [propName: string]: any;
-    }
-    export default ILocation;
-}
-
-declare module '@mappedin/mappedin-js/renderer/internal/Mappedin.LabelAtlas' {
-    export namespace DEFAULT_LABEL_SIZING {
-        const MARGIN: number;
-        const HEIGHT_MARGIN: number;
-        const SIZE: number;
-    }
-    export class Atlas {
-        layers: any[];
-        canvas: HTMLCanvasElement;
-        context: CanvasRenderingContext2D | null;
-        addLabel(map: any, lines: any, font: any, size: any, scope: any, pixelsPerScale: any): Label | undefined;
-        removeLayer(layer: any): void;
-        measure(text: any, font: any, size: any): TextMetrics;
-        onWebGLContextRestored(): void;
-        dispose(): void;
-    }
-    export class FlatLabel {
-        constructor(options: any, venue: any, mapObject: any, DEFAULT_FONT: any, polygonMeshesById: any, textLabelsByPolygonId: any, mapView: any, scope: any, atlas: any);
-        id: any;
-        text: any;
-        stateText: string;
-        fullText: any;
-        font: any;
-        atlas: any;
-        canvasBounds: any;
-        mapScale: any;
-        margin: number;
-        heightMargin: number;
-        scaleMin: any;
-        scaleStep: any;
-        multiline: any;
-        height: number | null;
-        polygonMeshesById: any;
-        polyId: any;
-        map: any;
-        color: any;
-        hoverColor: any;
-        baseColor: any;
-        hideOnCreate: boolean;
-        hoverLabelText: any;
-        fontSize: number;
-        hoverLabelMode: any;
-        hoverLabelClass: any;
-        showHoverLabel: boolean;
-        hoverIfLabelFails: boolean;
-        textLabelsByPolygonId: any;
-        create(): void;
-        invalid: boolean | undefined;
-        label: any;
-        created: boolean | undefined;
-        flipIfNeeded(cameraAngle: any): void;
-        removeSelf(bulk: any): void;
-        doNotCreate: boolean | undefined;
-        setColor(textColor: any): void;
-        setHoverColor: (color: any) => void;
-        clearColor(): void;
-        hide(): void;
-        show(): void;
-        toString(): any;
-    }
-    class Label {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-        layer: any;
-        index: any;
-        layout(map: any, origin: any, size: any, rotation: any, uv: any, color: any): void;
+                */
+            popFromMaxKey(): any;
+            /**
+                * Return an iterator over every value in this multimap, at every key.
+                * Mutating the multimap during iteration will result in undefined
+                * behaviour.
+                *
+                * @method values
+                * @return {Iterator} iterator over the values in the map
+                */
+            values(): {
+                    [Symbol.iterator]: () => any;
+                    next: () => any;
+            };
+            /**
+                * A list of keys in this set, sorted by numeric value. Not cloned,
+                * for efficiency's sake, so please don't mutate it.
+                *
+                * @method keys
+                * @return {[number]} sorted list of numeric keys in the map
+                */
+            keys(): any[];
+            /**
+                * The number of elements in this multimap, equal to the sum of the sizes
+                * of each key's set of values.
+                *
+                * @property size {number} number of elements in this multimap
+                */
+            get size(): number;
     }
     export {};
 }
 
-declare module '@mappedin/mappedin-js/renderer/index.rn' {
-    import { getVenue, getVenueBundle, Mappedin, MappedinDestinationSet } from '@mappedin/mappedin-js/get-venue';
-    import { randomId } from '@mappedin/mappedin-js/--/common/random-id';
-    export * from '@mappedin/mappedin-js/renderer/MapView.enums';
-    export { getVenue, 
-    /**
-      * @deprecated
-      */
-    getVenueBundle, MappedinDestinationSet, Mappedin, randomId };
-    export { GEOLOCATION_STATUS, COLLISION_RANKING_TIERS, E_BLUEDOT_STATE_REASON, E_BLUEDOT_STATE, E_BLUEDOT_MARKER_STATE, STATE, MARKER_ANCHOR, E_SDK_EVENT, E_BLUEDOT_EVENT, E_CAMERA_EVENT, E_CAMERA_DIRECTION, SAFE_AREA_INSET_TYPE, ANIMATION_TWEENS, CAMERA_EASING_MODE } from '@mappedin/mappedin-js/renderer/MapView.enums';
-    export { labelThemes } from '@mappedin/mappedin-js/renderer/MapView.types';
-    export type { IFlatLabels } from '@mappedin/mappedin-js/renderer/MapView.FlatLabels';
-    export type { IFloatingLabels } from '@mappedin/mappedin-js/renderer/MapView.FloatingLabels';
-    export type { TBlueDotPositionUpdate, TBlueDotStateChange, TJourneyOptions, TMapViewOptions, TCreateMarkerOptions, TGeolocationObject, TPathOptions, TFlatLabelOptions, TAddFloatingLabelOptions, TAddFlatLabelOptions, TLabelAllLocationCommonOptions, TFloatingLabelAllLocationsOptions, TFlatLabelAllLocationsOptions, TLabelAllLocationFlatLabelOptions, TLabelAllLocationFloatingLabelOptions, TEnableBlueDotOptions, TFloatingLabelAppearance, TFlatLabelAppearance, CAMERA_EVENT_PAYLOAD, TMapClickEvent, TGetPolygonsAtCoordinateOptions } from '@mappedin/mappedin-js/renderer/MapView.types';
-    export { BEARING_TYPE, ACTION_TYPE } from '@mappedin/mappedin-js/navigator';
-    export type { IDirectionsResult, E_MESSAGES as E_GET_DIRECTIONS_MESSAGES } from '@mappedin/mappedin-js/navigator';
-    export type { TGetVenueBundleOptions, TGetVenueOptions, TMappedinDirective, TShowVenueOptions, TMappedinOfflineSearchOptions, TMappedinOfflineSearchResult, TMappedinOfflineSearchSuggestions, TMappedinOfflineSearchAllOptions, TMappedinOfflineAllSearchMatch } from '@mappedin/mappedin-js/get-venue';
-    export { MappedinLocation, MappedinPolygon, MappedinNode, MappedinCategory, MappedinMap, MappedinEvent, MappedinMapGroup, MappedinVenue, MappedinVortex, MappedinDirections, MappedinNavigatable, MappedinCoordinate, MappedinRankings, MAP_RENDER_MODE, OfflineSearch, MappedinCollectionType } from '@mappedin/mappedin-js/get-venue';
-    export type { TSafeAreaInsets, TCameraTargets, TFocusOnCameraOptions, TCameraTransform, TCameraAnimationOptions } from '@mappedin/mappedin-js/renderer/Camera';
+declare module '@mappedin/mappedin-js/renderer/internal/Mappedin.MapManager' {
+    export default MapManager;
+    class MapManager extends PubSub {
+            constructor(polygonMeshesById: any, renderer: any, mapView: any, taskScheduler: any, loadOptions?: {});
+            mapObjects: Map<any, any>;
+            currentMap: undefined;
+            object: any;
+            _showCount: number;
+            _mapObjectsSortedByElevationDirty: boolean;
+            expanded: boolean;
+            polygonMeshesById: any;
+            mapView: any;
+            renderer: any;
+            loadOptions: {};
+            addMap(mapClass: any, callback?: () => void): any;
+            setMap(mapClassOrId: any, callback: any): Promise<any>;
+            removeMap(mapClassOrId: any): void;
+            removeAllMaps(): void;
+            loadMaps(maps: any, startingMap: any, onFirstMapLoaded?: () => void, onDataLoaded?: () => void, onError?: () => void): void;
+            /**
+             * Expand maps to display within view, typically used for multi-floor navigation. When passed a connection, maps included will not be displayed, instead, their 2d projection
+             will be available in the resulting promise, which can be used to display a 2D component in the client-side app.
+             *
+             * @method expandMaps
+             * @param mapIds {Array} Array of mapIds or mapObjects to display while expanded. For connections, pass &#123; connection: true, maps: [], connectionNodes: [], &#125;
+             * @param  options {Object} Options object @optional
+                    @param [options.focus=false] {Boolean} Focus the camera onto expanded maps
+                    @param [options.debug=false] {Boolean} Display cubes around focus bounding box for debug info
+                    @param [options.rotation=0] {Number} Rotation of scene relative to zero (degrees)
+                    @param [options.duration=300] {Number} Duration of focus animation in ms
+                    @returns {Promise} Promise that resolves to 2d screen projections of each layer/map (see example)
+                    @example
+            // expand maps with 3 connection maps in between
+            expandMaps(
+                    '55e89771d982bc06ca000000',
+                            {
+                                    connection: true,
+                                    // connection nodes are an exit node from the '55e89771' man and entry node for the '55e9c73f' map
+                                    connectionNodes: [{
+                                            map: "55e89771",
+                                            x: 6232,
+                                            y: 4575
+                                    }, {
+                                            map: "55e9c73",
+                                            x: 5945.000000000001,
+                                            y: 4059.000000000001
+                                    }],
+                                    maps: [
+                                            '55e9acbf',
+                                            '55e8a9ed',
+                                            '55e85e23'
+                                    ]
+                            },
+                            '55e9c73f'
+                     );
+    
+                     // resulting promise (sorted by elevation (top to bottom))
+    
+                     [
+                            {
+                                    min: { x: -100, y: -50 },
+                                    max: { x: -100, y: -50 }
+                            },
+                            {
+                                    min: { x: -100, y: -50 },
+                                    max: { x: -100, y: -50 }
+                            },
+                            {
+                                    min: { x: -100, y: -50 },
+                                    max: { x: -100, y: -50 }
+                            }
+                     ]
+             */
+            expandMaps(mapsToExpand: any, options: any): Promise<any>;
+            /**
+             * Contract maps and display the current map
+             *
+             * @method contractMaps
+             * @param  options {Object} Options object @optional
+                    @param [options.focus] {Boolean} Focus the camera onto current map
+                    @param [options.debug] {Boolean} Display cubes around focus bounding box for debug info
+                    @param [options.duration=300] {Number} Duration of focus animation in ms
+             */
+            contractMaps(options?: any): Promise<any>;
+            expandPanBounds(bounds: any): void;
+            /**
+                * This can be used to invoke a callback function for _every_ set map invocation.
+                * @param {Function} cb callback function
+                */
+            addPersistentSetMapCallback(cb: Function): void;
+            persistentSetMapCallbacks: any;
+            setMapCallbacks: any[] | undefined;
+            get mapObjectsSortedByElevation(): any[];
+            _mapObjectsSortedByElevation: any[] | undefined;
+            get visibleMaps(): any[];
+            getCompoundBoundingBoxPoints(objects: any): any[];
+            multiFloorView: MultiFloorView | undefined;
+            renderedMaps: any[] | undefined;
+            projections: any[] | undefined;
+            mapsFullyLoaded(callback?: () => void): Promise<void>;
+            /**
+                * Scroll maps up
+                * This will shift maps down to show next one (above)
+                */
+            scrollMapsUp(): Promise<any>;
+            /**
+                * Scroll maps down
+                * This will shift maps up to show next one (below)
+                */
+            scrollMapsDown(): Promise<any>;
+            tiltMaps(tilt: any): void;
+            resize(): void;
+    }
+    import { PubSub } from "@mappedin/mappedin-js/renderer/internal/pub-sub";
+    import MultiFloorView from "@mappedin/mappedin-js/renderer/internal/Mappedin.MultiFloorView";
 }
 
-declare module '@mappedin/mappedin-js/renderer/MapView.Scene' {
-    import { MappedinMap } from '@mappedin/mappedin-js/get-venue';
-    import { ICore } from '@mappedin/mappedin-js/renderer/Core.interface';
-    import MapObject from '@mappedin/mappedin-js/renderer/internal/Mappedin.MapObject';
-    import { TSceneTransitionOptions } from '@mappedin/mappedin-js/renderer/MapView.SceneManager';
-    class MapViewScene {
-        #private;
-        maps: MappedinMap[];
-        object: any;
-        currentMap: MappedinMap;
-        mapObjects: Map<MappedinMap['id'], MapObject>;
-        constructor(maps: MappedinMap[], core: ICore);
-        /**
-          * Determine each maps position and rotation relative to the refernce map
-          */
-        determineMapPositionAndRotation(map: MappedinMap): {
-            position: any[];
-            scale: number[];
-            rotation: number[];
+import { Mesh, BufferAttribute, InstancedBufferAttribute, InstancedBufferGeometry, Object3D, Color, CanvasTexture, RawShaderMaterial } from 'three';
+import { getObjectId, getObject } from '@mappedin/mappedin-js/renderer/internal/utils';
+import HoverLabel from '@mappedin/mappedin-js/renderer/internal/Mappedin.HoverLabel.js';
+import LabelAtlasFragment from '@mappedin/mappedin-js/renderer/internal/shaders/Mappedin.LabelAtlas.Fragment.glsl';
+import LabelAtlasVertex from '@mappedin/mappedin-js/renderer/internal/shaders/Mappedin.LabelAtlas.Vertex.glsl';
+export const DEFAULT_LABEL_SIZING = {
+    MARGIN: 2,
+    HEIGHT_MARGIN: 0.5,
+    SIZE: 1.2
+};
+const FONT_SIZE = 56;
+const SIZE_IN_METERS = FONT_SIZE / DEFAULT_LABEL_SIZING.SIZE; // About this, make it the same as legacy labels anyway
+const PIXELS_PER_METER = FONT_SIZE / 2;
+const METERS_PER_PIXEL = 1 / PIXELS_PER_METER;
+const CANVAS_MAX_LABELS = 64;
+const MIN_SLOT_SIZE = 16;
+const LABEL_PADDING = 4;
+class Label {
+    constructor() {
+        this.x = 0;
+        this.y = 0;
+        this.width = 0;
+        this.height = 0;
+        this.layer = null;
+        this.index = null;
+    }
+    /// This _just_ lays out the vertex into the attribute buffers.
+    layout(map, origin, size, rotation, uv, color) {
+        let angle = (this.canvasBounds.rotation * Math.PI) / 180;
+        let width = this.width * this.pixelsPerMu;
+        let height = this.height * this.pixelsPerMu;
+        // fix the alignment of the labels. This just shifts them around
+        // in canvasBound area to the left/right/center
+        let offset;
+        if (this.canvasBounds.align == 'left') {
+            offset = this.margin;
+        }
+        else if (this.canvasBounds.align == 'right') {
+            offset = this.canvasBounds.maxWidth - width - this.margin;
+        }
+        else if (this.canvasBounds.align == 'center') {
+            offset = (this.canvasBounds.maxWidth - width - this.margin) / 2;
+        }
+        let offsetX = offset * Math.cos(angle);
+        let offsetY = -offset * Math.sin(angle);
+        let index = this.index;
+        origin.setXYZ(index, this.canvasBounds.x - map.width / 2 + offsetX, -this.canvasBounds.y + map.height / 2 + offsetY, this.z + 0.1);
+        size.setXY(index, width, height);
+        rotation.setX(index, angle);
+        let canvas = this.layer.canvas;
+        uv.setXYZW(index, this.x / canvas.width, 1 - this.y / canvas.height, this.width / canvas.width, this.height / canvas.height);
+        color.setXYZ(index, this.color.r, this.color.g, this.color.b);
+        // mark all the arrays as needing to be updated (reuploaded) since
+        // they have now been changed.
+        origin.needsUpdate = true;
+        size.needsUpdate = true;
+        rotation.needsUpdate = true;
+        uv.needsUpdate = true;
+        color.needsUpdate = true;
+    }
+}
+class Slot {
+    constructor(x, y, width, height) {
+        this.x = x;
+        this.y = y;
+        this.width = width;
+        this.height = height;
+    }
+    leftOverSpace(glyph) {
+        // check to see if it would not fit.
+        if (this.width < glyph.width || this.height < glyph.height) {
+            return null;
+        }
+        return (this.height * (this.width - glyph.width) +
+            this.width * (this.height - glyph.height));
+    }
+    /// split this slot into 0-2 spaces.
+    split(label, spaces, index) {
+        label.x = this.x;
+        label.y = this.y;
+        if (this.width - label.height < MIN_SLOT_SIZE &&
+            this.height - label.height < MIN_SLOT_SIZE) {
+            // delete itself from the array
+            spaces.splice(index, 1);
+        }
+        else if (this.width === label.width) {
+            spaces.splice(index, 1, new Slot(this.x, this.y + label.height, this.width, this.height - label.height));
+        }
+        else if (this.height === label.height) {
+            spaces.splice(index, 1, new Slot(this.x + label.width, this.y, this.width - label.width, this.height));
+        }
+        else {
+            spaces.splice(index, 1, new Slot(this.x + label.width, this.y, this.width - label.width, label.height), new Slot(this.x, this.y + label.height, this.width, this.height - label.height));
+        }
+    }
+}
+class AtlasLayer {
+    /// Creates a new Atlas Layer,
+    constructor(atlas, map, width, height) {
+        // height can be anything so we have to match it to a close power of two
+        let power = 5; // start with 5 because 2^5 is 32 which is a good lower bounds
+        while (Math.pow(2, power) < height) {
+            power += 1;
+        }
+        height = Math.pow(2, power);
+        power = 10; // start with 5 because 2^10 is 1024 which is a good lower bounds
+        while (Math.pow(2, power) < width) {
+            power += 1;
+        }
+        width = Math.pow(2, power);
+        this.atlas = atlas;
+        // the map that this layer is used for, since this get rendered
+        // as a single object we cannot for any reason reuse a layer for a
+        // different map.
+        this.map = map;
+        this.canvasWidth = width;
+        this.canvasHeight = height;
+        // create a canvas and context to draw the text labels into
+        this.canvas = document.createElement('canvas');
+        this.canvas.width = this.canvasWidth;
+        this.canvas.height = this.canvasHeight;
+        this.context = this.canvas.getContext('2d');
+        this.context.textBaseline = 'bottom';
+        // the list of free space in the canvas that we can put blocks int
+        this.spaces = [new Slot(0, 0, this.canvas.width, this.canvas.height)];
+        // an array of free slots for when labels get destroyed
+        this.free = [];
+        // an array of labels that are contained
+        this.labels = [];
+        this.count = CANVAS_MAX_LABELS;
+        // Create buffers to hold the binary data for rendering data
+        let origin = new Float32Array(this.count * 3);
+        let size = new Float32Array(this.count * 2);
+        let rotation = new Float32Array(this.count);
+        let uv = new Float32Array(this.count * 4);
+        let color = new Float32Array(this.count * 3);
+        this.uv = new InstancedBufferAttribute(uv, 4, false, 1);
+        this.uv.set(uv);
+        this.uv.needsUpdate = true;
+        this.origin = new InstancedBufferAttribute(origin, 3, false, 1);
+        this.origin.set(origin);
+        this.origin.needsUpdate = true;
+        this.size = new InstancedBufferAttribute(size, 2, false, 1);
+        this.size.set(size);
+        this.size.needsUpdate = true;
+        this.rotation = new InstancedBufferAttribute(rotation, 1, false, 1);
+        this.rotation.set(rotation);
+        this.rotation.needsUpdate = true;
+        this.color = new InstancedBufferAttribute(color, 3, true, 1);
+        this.color.set(color);
+        this.color.needsUpdate = true;
+        // these will probably always be zero, but we want to make sure anyhow
+        // a none zero sized element might render with an invalid texture
+        // coordinate which would be pretty bad.
+        for (let i = 0; i < this.count; i++) {
+            this.zero(i);
+        }
+        // create the polygon, this is just a square 1x1
+        let positions = new Float32Array([0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0]);
+        let indicies = [0, 3, 1, 3, 2, 1];
+        // Setup the geometry buffer
+        this.geometry = new InstancedBufferGeometry();
+        this.geometry.setIndex(indicies);
+        this.geometry.setAttribute('position', new BufferAttribute(positions, 3));
+        this.geometry.setAttribute('size', this.size);
+        this.geometry.setAttribute('origin', this.origin);
+        this.geometry.setAttribute('rotation', this.rotation);
+        this.geometry.setAttribute('uv', this.uv);
+        this.geometry.setAttribute('color', this.color);
+        // Three allows for wrapping of a canvas into a texture, neat
+        this.texture = new CanvasTexture(this.canvas);
+        this.texture.anisotropy = 16;
+        // create the shader
+        this.material = new RawShaderMaterial();
+        this.material.vertexShader = LabelAtlasVertex;
+        this.material.fragmentShader = LabelAtlasFragment;
+        this.material.uniforms = {
+            textureLabel: { value: this.texture }
         };
-        /** Render scene */
-        render(map: MappedinMap, transitionOptions?: TSceneTransitionOptions, isStartingScene?: boolean): Promise<void>;
+        // marked as transparent because the we alpha blend the textures
+        this.material.transparent = true;
+        // create the mesh
+        this.mesh = new Mesh(this.geometry, this.material);
+        // create a 3D object for the scene graph containing the mesh
+        this.obj = new Object3D();
+        this.obj.add(this.mesh);
+        // This logic uses a custom vertex shader to position and size the
+        // actual vertices. This has a side effect of the renderer not actually
+        // knowing the size of the object. Disabling the frustum culling
+        // prevents this.
+        this.obj.frustumCulled = false;
+        this.mesh.frustumCulled = false;
+        // add to the map
+        this.map.add(this.obj);
+    }
+    // return the number of bytes left in this layer
+    space() {
+        return this.spaces.map(x => x.width * x.height).reduce((x, y) => x + y);
+    }
+    // set a index of the arrays to zero.
+    zero(index) {
+        this.origin.array[index * 3 + 0] = 0;
+        this.origin.array[index * 3 + 1] = 0;
+        this.origin.array[index * 3 + 2] = 0;
+        this.size.array[index * 2 + 0] = 0;
+        this.size.array[index * 2 + 1] = 0;
+        this.rotation.array[index] = 0;
+        this.uv.array[index * 4 + 0] = 0;
+        this.uv.array[index * 4 + 1] = 0;
+        this.uv.array[index * 4 + 2] = 0;
+        this.uv.array[index * 4 + 3] = 0;
+        this.color.array[index * 3 + 0] = 0;
+        this.color.array[index * 3 + 1] = 0;
+        this.color.array[index * 3 + 2] = 0;
+        this.origin.needsUpdate = true;
+        this.size.needsUpdate = true;
+        this.rotation.needsUpdate = true;
+        this.uv.needsUpdate = true;
+        this.color.needsUpdate = true;
+    }
+    // find space for a label, if there is no space this will return false.
+    // if space was found, the label is added to this Atlas and the label index
+    // is set.
+    //
+    // Note: The label is added for house keeping, the values of the buffers
+    // 		 have not been configured yet. And the text has not been rendered
+    findSpace(label) {
+        // even if there is space, there is no space left in the draw buffers
+        if (this.free.length != 0 && this.labels.length == this.count) {
+            return false;
+        }
+        // search 'spaces' for the entry that fits the glyph best. 'best' means
+        // least amount of wasted space, ideally 0.
+        let best = -1;
+        for (let i = 0; i < this.spaces.length; i++) {
+            let space = this.spaces[i].leftOverSpace(label);
+            if (space === null) {
+                continue;
+            }
+            if (best === -1 || this.spaces[i].leftOverSpace(label) < space) {
+                best = i;
+            }
+        }
+        if (best !== -1) {
+            this.spaces[best].split(label, this.spaces, best);
+            label.layer = this;
+            // Append an element to an array if there no free slots,
+            // if there are free slots we reuse the space instead.
+            if (this.free.length === 0) {
+                label.index = this.labels.length;
+                this.labels.push(label);
+            }
+            else {
+                label.index = this.free.pop();
+                this.labels[label.index] = label;
+            }
+        }
+        // returns true if there was space found.
+        return best != -1;
+    }
+    // remove this label from the internal contents of this atlas.
+    remove(label) {
+        if (label.index === undefined) {
+            return;
+        }
+        // remove this object from the vertex array.
+        this.zero(label.index);
+        // clear the pixel memory to avoid reuse of this area getting messed up
+        this.context.clearRect(label.x, label.y, label.width, label.height);
+        // add the free spaces to the free list
+        this.spaces.push(new Slot(label.x, label.y, label.width, label.height));
+        this.free.push(label.index);
+        this.labels[label.index] = null;
+        // check to see if there is actually any labels left
+        let empty = true;
+        for (let iLabel of this.labels) {
+            empty = empty && iLabel != null;
+            if (!empty) {
+                break;
+            }
+        }
+        // if there are no labels left, remove this layer
+        if (empty) {
+            this.atlas.removeLayer(this);
+        }
+    }
+    // render a label to the canvas
+    render(label) {
+        this.context.save();
+        this.context.rect(label.x + 1, label.y + 1, label.width - 1 * 2, label.height - 1 * 2);
+        this.context.clip();
+        this.context.font = label.size + 'px ' + label.font;
+        for (let line of label.lines) {
+            this.context.fillText(line.text, line.x + label.x + LABEL_PADDING, line.y + label.y + line.height + LABEL_PADDING);
+        }
+        this.texture.needsUpdate = true;
+        this.context.restore();
+    }
+    // Reset canvas and re-render all labels
+    onWebGLContextRestored() {
+        this.canvas = document.createElement('canvas');
+        this.canvas.width = this.canvasWidth;
+        this.canvas.height = this.canvasHeight;
+        this.context = this.canvas.getContext('2d');
+        this.context.textBaseline = 'bottom';
+        this.texture = new CanvasTexture(this.canvas);
+        this.texture.anisotropy = 16;
+        this.material.uniforms.textureLabel.value = this.texture;
+        for (let label of this.labels) {
+            if (label != null) {
+                this.render(label);
+            }
+        }
+    }
+    // free all resources associated with this layer
+    dispose() {
+        this.geometry.dispose();
+        this.material.dispose();
+        this.texture.dispose();
+    }
+}
+class Atlas {
+    constructor() {
+        this.layers = [];
+        this.canvas = document.createElement('canvas');
+        this.context = this.canvas.getContext('2d');
+    }
+    /// adds label to the atlas
+    addLabel(map, lines, font, size, scope, pixelsPerScale) {
+        // get the max width / height
+        let height = 0;
+        let width = 0;
+        for (let line of lines) {
+            width = Math.max(Math.ceil(line.width + line.x), width);
+            height = Math.max(Math.ceil(line.height + line.y), height);
+        }
+        let label = new Label();
+        label.map = map;
+        label.width = width + LABEL_PADDING * 2;
+        label.height = height + LABEL_PADDING * 2;
+        label.lines = lines;
+        label.font = font;
+        label.size = size;
+        label.canvasBounds = scope.canvasBounds;
+        label.margin = scope.margin;
+        label.heightMargin = scope.heightMargin;
+        label.pixelsPerMu = pixelsPerScale;
+        label.z = scope.height;
+        label.view = scope;
+        label.color = scope.color;
+        let layer;
+        // find a slot to place this label in
+        for (let iLayer of this.layers) {
+            layer = iLayer;
+            if (layer.map !== map) {
+                layer = null;
+                continue;
+            }
+            if (layer.findSpace(label)) {
+                break;
+            }
+            layer = null;
+        }
+        // no space was found, create a new layer
+        if (layer == null) {
+            layer = new AtlasLayer(this, map, label.width, label.height);
+            this.layers.push(layer);
+            if (!layer.findSpace(label)) {
+                return;
+            }
+            // order the layers such that the least populated ones are first.
+            this.layers.sort((a, b) => b.space() - a.space());
+        }
+        layer.render(label);
+        label.layout(map.mapClass, layer.origin, layer.size, layer.rotation, layer.uv, layer.color);
+        label.layer = layer;
+        return label;
+    }
+    // delete a layer from the list of layers
+    removeLayer(layer) {
+        let index = this.layers.indexOf(layer);
+        if (index != -1) {
+            this.layers.splice(index, 1);
+        }
+    }
+    // measure the size of a element with a given font and size
+    measure(text, font, size) {
+        this.context.font = size + 'px ' + font;
+        return this.context.measureText(text);
+    }
+    // Retore all layers
+    onWebGLContextRestored() {
+        for (let layer of this.layers) {
+            layer.onWebGLContextRestored();
+        }
+    }
+    // cleans up all the layers of the Atlas
+    dispose() {
+        for (let layer of this.layers) {
+            layer.dispose();
+        }
+    }
+}
+class FlatLabel {
+    constructor(options, venue, mapObject, DEFAULT_FONT, polygonMeshesById, textLabelsByPolygonId, mapView, scope, atlas) {
+        let polygon = getObject(options.polygon, venue.polygons);
+        this.id = polygon.id;
+        this.text = (options.shortText || options.text).trim();
+        this.stateText = options.stateText ? ' (' + options.stateText + ')' : '';
+        this.fullText = this.stateText ? this.text + this.stateText : this.text;
+        this.font = options.font || DEFAULT_FONT;
+        this.atlas = atlas;
+        this.canvasBounds = options.canvasBounds || polygon.canvasBounds;
+        this.mapScale = mapObject.getMapScale() || 1;
+        this.margin =
+            (options.margin || DEFAULT_LABEL_SIZING.MARGIN) * this.mapScale;
+        this.heightMargin =
+            (options.heightMargin || DEFAULT_LABEL_SIZING.HEIGHT_MARGIN) *
+                this.mapScale;
+        this.scaleMin = options.scaleMin || 0.25;
+        this.scaleStep = options.scaleStep > 0 ? options.scaleStep : 0.25;
+        this.multiline = options.multiline == undefined ? true : options.multiline;
+        this.height = Number(options.height) || null;
+        this.polygonMeshesById = polygonMeshesById;
+        this.polyId =
+            options.polygonId || getObjectId(options.polygon, venue.polygons);
+        this.map = mapObject;
+        this.color = new Color(options.color || scope.colors.text || '#000000');
+        this.hoverColor = new Color(options.hoverColor || this.color);
+        this.baseColor = this.color;
+        this.hideOnCreate = false;
+        this.hoverLabelText = options.text.trim();
+        this.fontSize =
+            options.fontSize * this.mapScale ||
+                options.size * SIZE_IN_METERS ||
+                FONT_SIZE;
+        this.hoverLabelMode = options.hoverLabelMode3D || HoverLabel.MODES.ALL;
+        this.hoverLabelClass = options.hoverLabelClass || 'mMapviewHoverLabel';
+        this.showHoverLabel =
+            this.hoverLabelMode == HoverLabel.MODES.ALL ||
+                this.hoverLabelMode == HoverLabel.MODES.NO_TEXT_LABEL_ONLY;
+        this.hoverIfLabelFails =
+            this.hoverLabelMode == HoverLabel.MODES.ALL ||
+                this.hoverLabelMode == HoverLabel.MODES.NO_TEXT_LABEL_ONLY;
+        this.textLabelsByPolygonId = textLabelsByPolygonId;
+        this.map.textObjects.push(this);
+    }
+    create() {
+        let scope = this;
+        // This could get killed before we even get to creation
+        if (this.doNotCreate) {
+            return;
+        }
+        if (scope.canvasBounds == null) {
+            scope.invalid = true;
+            scope.message = "No Canvas Bounds. Can't draw text '" + scope.text + "'";
+            scope.showHoverLabel = scope.hoverIfLabelFails;
+            return;
+        }
+        scope.showHoverLabel = this.hoverLabelMode == HoverLabel.MODES.ALL;
+        let muPerPixel = METERS_PER_PIXEL * this.mapScale;
+        let pixelsPerMu = PIXELS_PER_METER / this.mapScale;
+        let labelsToAttempt = [this.text];
+        if (this.stateText.length)
+            labelsToAttempt.unshift(this.fullText);
+        for (let attempt of labelsToAttempt) {
+            // attempt to layout the words
+            let words = attempt.split(' ').map(function (word) {
+                return {
+                    width: scope.atlas.measure(word, scope.font, scope.fontSize).width,
+                    word: word
+                };
+            });
+            // convert the canvas bounds to an area minus in pixels
+            let availableWidth = (this.canvasBounds.maxWidth - this.margin * 2) * pixelsPerMu;
+            let availableHeight = (this.canvasBounds.maxHeight - this.heightMargin * 2) * pixelsPerMu;
+            let maxShrinkSteps = (1 - this.scaleMin) / this.scaleStep;
+            let minimumShrinkSteps = 0;
+            let spaceWidth = this.atlas.measure(' ', this.font, this.fontSize).width;
+            let lineHeight = getTextHeight(this.fontSize + 'px ' + this.font);
+            for (let i = 0, iLen = words.length; i < iLen; i++) {
+                let width = words[i].width;
+                let wShrinkSteps = Math.ceil((width - availableWidth) / (width * this.scaleStep));
+                minimumShrinkSteps = Math.max(wShrinkSteps, minimumShrinkSteps);
+            }
+            if (this.height == null) {
+                if (this.polygonMeshesById[this.polyId]) {
+                    let target = this.polygonMeshesById[this.polyId];
+                    if (!target.geometry.boundingBox) {
+                        target.geometry.computeBoundingBox();
+                    }
+                    this.height = target.geometry.boundingBox.max.z + target.position.z;
+                }
+                else {
+                    this.height = 0;
+                }
+            }
+            var lines;
+            var shrinkStep;
+            var currentScale;
+            let scaleStep = this.scaleStep;
+            shrink: for (shrinkStep = minimumShrinkSteps; shrinkStep <= maxShrinkSteps; shrinkStep++) {
+                currentScale = 1 - shrinkStep * scaleStep;
+                let thisLineWidth = words[0].width * currentScale;
+                lines = [
+                    {
+                        text: words[0].word,
+                        width: thisLineWidth,
+                        height: lineHeight * currentScale,
+                        x: 0,
+                        y: 0
+                    }
+                ];
+                for (let iWordSize = 1; iWordSize < words.length; iWordSize++) {
+                    let wordSize = words[iWordSize];
+                    let spaceForNextWord = (wordSize.width + spaceWidth) * currentScale;
+                    if (thisLineWidth + spaceForNextWord < availableWidth) {
+                        // Add to line
+                        lines[lines.length - 1].text += ' ' + wordSize.word;
+                        lines[lines.length - 1].width += spaceForNextWord;
+                        thisLineWidth += spaceForNextWord;
+                    }
+                    else {
+                        // New line
+                        if (!this.multiline)
+                            continue shrink;
+                        lines[lines.length - 1].width = thisLineWidth;
+                        thisLineWidth = wordSize.width * currentScale;
+                        lines.push({
+                            text: wordSize.word,
+                            width: thisLineWidth,
+                            height: lineHeight * currentScale,
+                            x: 0,
+                            y: lines[lines.length - 1].height + lines[lines.length - 1].y
+                        });
+                    }
+                }
+                let requiredHeight = lines.length * lineHeight * currentScale;
+                if (requiredHeight <= availableHeight) {
+                    this.invalid = false;
+                    break;
+                }
+            }
+            if (this.invalid == false)
+                break;
+        }
+        if (this.invalid == false) {
+            // center each line
+            let lineTotalWidth = lines
+                .map(x => Math.ceil(x.width))
+                .reduce((a, b) => Math.max(a, b));
+            for (let line of lines) {
+                line.x = (lineTotalWidth - line.width) / 2;
+            }
+            // lines, font, size, scope, pixelsPerScale
+            this.label = this.atlas.addLabel(this.map, lines, this.font, this.fontSize * currentScale, this, muPerPixel);
+        }
+        this.created = true;
+    }
+    // eslint-disable-next-line class-methods-use-this
+    flipIfNeeded(cameraAngle) {
+        // this is done in the shader, so we will not do anything here
+        // this function simply exists for parity with 'TextLabel'
+    }
+    removeSelf(bulk) {
+        if (this.created) {
+            if (this.label != null) {
+                this.label.layer.remove(this.label);
+                this.label = null;
+            }
+            if (!bulk) {
+                this.map.textObjects = this.map.textObjects.filter(object => object != this);
+                // Delete from textLabelsByPolygonId
+                Object.keys(this.textLabelsByPolygonId).forEach(key => {
+                    if (this.textLabelsByPolygonId[key] == this) {
+                        delete this.textLabelsByPolygonId[key];
+                    }
+                });
+            }
+        }
+        else {
+            this.doNotCreate = true;
+        }
+    }
+    setColor(textColor) {
+        const color = new Color(textColor);
+        const sameColor = this.color.equals(color);
+        const withLabel = Boolean(this.label?.layer);
+        this.color = color;
+        if (!sameColor && withLabel) {
+            this.label.color = this.color;
+            this.label.layout(this.map.mapClass, this.label.layer.origin, this.label.layer.size, this.label.layer.rotation, this.label.layer.uv, this.label.layer.color);
+        }
+    }
+    setHoverColor = color => {
+        this.hoverColor = new Color(color);
+    };
+    clearColor() {
+        this.setColor(this.baseColor);
+    }
+    hide() {
+        if (this.label) {
+            this.label.layer.zero(this.label.index);
+        }
+        else {
+            this.hideOnCreate = true;
+        }
+    }
+    show() {
+        if (this.label) {
+            let layer = this.label.layer;
+            let map = this.map;
+            let label = this.label;
+            label.layout(map.mapClass, layer.origin, layer.size, layer.rotation, layer.uv, layer.color);
+        }
+        else {
+            this.hideOnCreate = false;
+        }
+    }
+    toString() {
+        return this.hoverLabelText;
     }
-    export default MapViewScene;
 }
+let textHeightCache = new Map();
+var getTextHeight = function (font) {
+    // check if the font is in the cache because modifying the dom is expensive
+    let height = textHeightCache[font];
+    if (height != undefined) {
+        return height;
+    }
+    let text = document.createElement('span');
+    text.textContent = 'Hg';
+    text.style.font = font;
+    let block = document.createElement('div');
+    block.style.cssText = 'display: inline-block; width: 1px; height: 0px;';
+    let div = document.createElement('div');
+    div.appendChild(text);
+    div.appendChild(block);
+    let body = document.body;
+    body.appendChild(div);
+    try {
+        var bounding = text.getBoundingClientRect();
+    }
+    finally {
+        div.remove();
+    }
+    // add the element to the cache
+    if (bounding.height != undefined) {
+        textHeightCache[font] = bounding.height;
+        height = bounding.height;
+    }
+    return height;
+};
+export { Atlas, FlatLabel };
 
 declare module '@mappedin/mappedin-js/renderer/internal/Mappedin.MapObject' {
     export namespace TASK_PRIORITY {
@@ -6105,7 +7628,24 @@ declare module '@mappedin/mappedin-js/renderer/internal/Mappedin.MapObject' {
             loadMethodUsed: string | undefined;
             _dispose(objectToDispose: any): void;
             add(childObjectToAdd: any): void;
+            /**
+                * Convert lat/lon to local map position vector
+                */
             getPositionLatLon(lat: any, lon: any): any;
+            /**
+                * Previously, each map was centered around 0,0,0 and scaled to fit the map.
+                * With scene manager, each map is positioned and scaled relative to the base map/world
+                * Since most 3D objects (like blue dot) are added to the map via `getPositionLatLon`, they already
+                * have the map's matrix applied, on top of being affected as a child of the map's own transform
+                * This method inverts the map's matrix to resolve the double matrix application issue.
+                * TODO: investigate a better way to handle this
+                */
+            addToObject(child: any): void;
+            /**
+                * Translates objects that are added to the map (such as blue dot), assuming they are added via `getPositionLatLon`,
+                * or `convertTo3DMapPosition`, where the map's matrix has already been applied.
+                */
+            translateChild(child: any, position: any): void;
             getMapScale(): null;
             getNorth(): null;
             disableAllImageFlipping(): void;
@@ -6204,3 +7744,484 @@ declare module '@mappedin/mappedin-js/renderer/internal/Mappedin.MapObject' {
     import { FrameTaskGroup } from "@mappedin/mappedin-js/get-venue/Mappedin.TaskScheduler";
 }
 
+declare module '@mappedin/mappedin-js/renderer/MapView.SceneManager' {
+    import { MappedinMap } from '@mappedin/mappedin-js/get-venue';
+    import { TCameraTransform, TCameraAnimationOptions } from '@mappedin/mappedin-js/renderer/Camera';
+    import { ICore } from '@mappedin/mappedin-js/renderer/Core.interface';
+    import MapViewScene from '@mappedin/mappedin-js/renderer/MapView.Scene';
+    export type TSceneTransitionOptions = {
+            /**
+                * Map to set as active during the transition. This will decide where the camera will be positioned, as well as which
+                * colliders are enabled.
+                */
+            activeMap?: MappedinMap;
+            verticalDistanceBetweenMaps?: number;
+            /**
+                * Camera options to use when transitioning to the new scene
+                */
+            cameraTransform?: TCameraTransform;
+            cameraAnimationOptions?: TCameraAnimationOptions;
+            /**
+                * Whether to auto focus on the active map or leave the camera where it is.
+                * For single building venues, this should look the same way it did with MapManager
+                * For multi-building venues, this means the camera will not pan over to where the active map
+                * is relative to the world, which may look like broken behavior.
+                * @default true
+                */
+            autoFocusOnActiveMap?: boolean;
+    };
+    class SceneManager {
+            #private;
+            currentScene: MapViewScene;
+            constructor(core: ICore, startingScene: MapViewScene);
+            get currentMap(): MappedinMap;
+            renderGrid(): void;
+            transitionTo(scene: MapViewScene, transitionOptions?: TSceneTransitionOptions): Promise<void>;
+    }
+    export default SceneManager;
+}
+
+/**
+  * Camera layers that are used for rendering, which are assigned to objects
+  * in the scene representation and used for multi-buffer rendering. By
+  * default, all three.js objects are created on the `STATIC` layer.
+  */
+const CAMERA_LAYER = {
+    /// A camera layer holding all the elements that are only re-rendered on
+    /// camera movement and map invalidation, such as the map itself.
+    /// By default, all objects in the scene are members of this layer. If you
+    /// have a scene element that has to be re-rendered with higher frequency,
+    /// make sure to disable this layer on the object, and enable the
+    /// `ANIMATED` layer on it instead.
+    STATIC: 0,
+    /// A camera layer holding elements that are re-rendered every frame that
+    /// they exist, such as paths.
+    ANIMATED: 1,
+    /// A camera layer holding all elements that must be rendered on top of all
+    /// other layers. Like the `ANIMATED` layer, these elements are re-rendered
+    /// every frame that they exist. A good example object is the blue-dot object.
+    ALWAYS_ON_TOP: 2
+};
+export default CAMERA_LAYER;
+
+declare module '@mappedin/mappedin-js/renderer/internal/Mappedin.RenderTasks' {
+    /**
+      * Tasks that can be submitted to the renderer. The `STATIC_AND_ANIMATED` task
+      * is equivalent to a full re-render.
+      */
+    enum RENDER {
+        ANIMATED = "animated",
+        ALWAYS_ON_TOP = "always_on_top",
+        ALL = "all",
+        TWEEN = "tween"
+    }
+    export default RENDER;
+}
+
+varying vec2 vUv;
+
+void main() {
+    vUv = uv;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+}
+
+varying vec2 vUv;
+uniform sampler2D staticSceneColorTexture;
+uniform sampler2D staticSceneDepthTexture;
+uniform sampler2D animatedSceneColorTexture;
+uniform sampler2D animatedSceneDepthTexture;
+uniform sampler2D alwaysOnTopSceneColorTexture;
+
+vec4 alphaBlend(vec4 background, vec4 foreground) {
+    vec3 resultColor = (
+        foreground.rgb * foreground.a +
+        background.rgb * background.a * (1.0 - foreground.a)
+    );
+    float resultAlpha = foreground.a + background.a * (1.0 - foreground.a);
+    return vec4(resultColor / resultAlpha, resultAlpha);
+}
+
+vec4 alphaBlendPremultipliedAlpha(vec4 background, vec4 foreground) {
+    return foreground + (background * (1.0 - foreground.a));
+}
+
+void main() {
+    float staticDepth = texture2D(staticSceneDepthTexture, vUv).r;
+    float animatedDepth = texture2D(animatedSceneDepthTexture, vUv).r;
+
+    vec4 staticColor = texture2D(staticSceneColorTexture, vUv).rgba;
+    vec4 animatedColor = texture2D(animatedSceneColorTexture, vUv).rgba;
+
+    if (staticDepth < animatedDepth) {
+        // 19/06/10 Terence Dickson
+        // Spoiler alert! This is to help prepare for CE-1352, where alpha
+        // may be partial instead of zero. Not implementing that as part of
+        // this PR, however.
+        animatedColor.a *= 0.0;
+    }
+
+    vec4 lowerColor = alphaBlend(staticColor, animatedColor);
+    vec4 alwaysOnTopColor = texture2D(alwaysOnTopSceneColorTexture, vUv).rgba;
+
+    gl_FragColor = alphaBlendPremultipliedAlpha(lowerColor, alwaysOnTopColor);
+}
+
+declare module '@mappedin/mappedin-js/renderer/internal/Mappedin.MultiFloorView' {
+    export namespace VIEW_STATE {
+        const SINGLE_FLOOR: string;
+        const MULTI_FLOOR: string;
+    }
+    export namespace START {
+        const TOP: string;
+        const BOTTOM: string;
+    }
+    export namespace DIR {
+        const DOWN: string;
+        const UP: string;
+    }
+    export default MultiFloorView;
+    class MultiFloorView {
+        constructor(mapView: any, object: any, maps: any, options: any);
+        _focusMapsStart: string;
+        _focusMapsDir: string;
+        _focusMapsLen: number;
+        _focusAnimCurve: any;
+        _focusAnimDuration: number;
+        rotationAxis: any;
+        mapBoundingBoxes: any[];
+        _helperBoundingBoxes: any[];
+        mapAxesHelpers: any[];
+        mapView: any;
+        object: any;
+        options: any;
+        padding: any;
+        rotation: any;
+        maps: any;
+        debug: any;
+        mapSpacing: number;
+        mapTilt: number;
+        resize(): void;
+        focusOnMaps({ start, len, dir, mapIndices, duration, curve }?: {
+            start?: string | undefined;
+            len?: number | undefined;
+            dir?: string | undefined;
+            mapIndices: any;
+            duration?: number | undefined;
+            curve?: any;
+        }): Promise<any>;
+        get viewPortHeight(): number;
+        get viewPortWidth(): number;
+        positionMaps(): void;
+        addMaps(maps: any): void;
+        removeMaps(): void;
+        addMapBoundingBoxes(): void;
+        removeMapBoundingBoxes(): void;
+        removeHelperBoundingBoxes(): void;
+        addAxesHelpers(): void;
+        removeAxesHelpers(): void;
+        set mapTiltDegrees(arg: number);
+        get mapTiltDegrees(): number;
+        /**
+         * Display 2D screen projections of each 3D map object in the journey. Useful for drawing 2D elements on screen.
+       *
+         * @attribute projections
+         * @readOnly
+       *
+         * @returns {Array} Array for Objects with min/max x/y values
+         * @example
+    
+        projections = [{
+            max: {
+                x: 1062.4393974378236,
+                y: 745.7583492891705
+            },
+            min: {
+                x: 17.560602562176346,
+                y: 225.0806956450056
+            }
+        ...
+        ]
+         */
+        get projections(): any[];
+        tiltMaps(tiltRad: any): void;
+        _focusBox: any;
+        _scrollWindow: number | undefined;
+        tween: any;
+        getFocusMaps(start: any, dir: any, len: any): any;
+        getFocusBox(): any;
+        getVisibleMaps(): any;
+        getVisibleMapIds(): any;
+        getVisibleMapIndices(): number[];
+        getMapsByIndices(indices: any): any;
+        get bottomMapVisible(): any;
+        get topMapVisible(): any;
+        scrollMapsUp(): Promise<any>;
+        scrollMapsDown(): Promise<any>;
+        destroy(): void;
+    }
+}
+
+declare module '@mappedin/mappedin-js/renderer/internal/utils' {
+    /**
+        *	Utils function listing
+        *
+        * - scrubMaterial
+        * - getDeviceID
+        * - getSessionID
+        * - getObjectID
+        * - getObject
+        * - getBoundingBox
+        * - getBiggestBoundingBox
+        * - upackBoundingBox
+        * - getMapScale
+        * - throttle -> taken from lodash.js
+        * - getProjectionScaleFactor
+        * - getZoom
+        */
+    export function isGatewayKey(key: any): boolean;
+    export function getCombinedBoundingBox(objects: any): any;
+    export function getMapsBoundingBox(maps: any, mapPadding: any): any;
+    export function scrubMaterial(material: any): void;
+    export function getDeviceID(): string;
+    export function getSessionID(): string;
+    export function getObjectId(object: any): any;
+    export function getObject(obj: any, array: any): any;
+    export function getBoundingBox(object: any): any;
+    export function getBiggestBoundingBox(objects: any): {
+            min: any;
+            max: any;
+    };
+    export function unpackBoundingBox(boundingBox: any): any[];
+    export function getMapScale(map: any): number;
+    export function getNorth(map: any): number;
+    export function throttle(func: any, wait: any, options: any): (...args: any[]) => any;
+    export function debounce(func: any, wait: any, immediate: any): (...args: any[]) => void;
+    export function flatten(list: any): any;
+    export function uniq(arr: any): any;
+    export function toStyleString(styles: any): string;
+    /**
+    /*  getProjectionScaleFactor()
+    /*  finds the scale ratio between screen coordinates and 3D coordinates (in X-Z plane)
+    /*
+                *                                    R
+                *                                  /|
+                *    C : Camera                  /  |
+                *    PQ : Projection Plane     /    |
+                *    OR : Origin             /      |
+                *    F : FOV               /        |
+                *                      Q /          |
+                *                      /|           |
+                *                    /  |           |
+                *                  /    |           |
+                *                /      |           |
+                *              /        |           |
+                *            / F/2      |           |
+                *         C ------------P------------ O
+                *
+                *
+                *   ProjectionScaleFactor = ( OR / PQ )
+                *   PQ = canvasHeight / 2
+                *   CQ = zoom
+                *
+                *   OR / C0 = tan(F/2)
+                *   so OR = CO * tan(F/2)
+                */
+    export function getProjectionScaleFactor(FOV: any, canvasHeight: any, zoom: any): number;
+    /** getZoom
+        *
+        *  C - Camera, OP -- picture plane (canvas), S - origin,
+        *  QR - front side of maps Bounding Box, F: FOV
+        *
+        *                           Z-axis
+        *                     R_____|______
+        *                    /|     |     |
+        *                  /  |     |     |
+        *               P/    |     |     | maps BB
+        *              /|     |     |     |
+        *            /  |     |     |     |
+        *          /    |     |     |     |
+        *        / F    |E    |T    |S    |
+        *    C /--------|-----|-----|-----|------ orthogonal to Y axis, midpoint of focus maps
+        *      \        |     |     |     |
+        *        \      |     |     |     |
+        *          \    |     |     |     |
+        *            \  |     |     |     |
+        *              \|     |     |     |
+        *               O\    |     |     |
+        *                  \  |     |     |
+        *                    \|_____|_____|
+        *                     Q
+        *
+        *
+        * We want to get CS, which is the camera zoom
+        *
+        */
+    export function getZoom(focusBox: any, focusBoxHeight: any, FOV: any): any;
+    export function calculateTwoDProjections({ maps, width, height, camera }: {
+            maps: any;
+            width: any;
+            height: any;
+            camera: any;
+    }): any;
+    export function splitLine(startNode: any, endNode: any, segments: any): any[];
+    export function isObject(item: any): any;
+    export function cyrb53(str: any, seed?: number): number;
+    export function addMarginMultiplierToBoundingBox(bbox: any, multiplier: any): any;
+    export function getPrimaryLocationForPolygon(polygon: any, venue: any): any;
+    export function determineStartingMap(venue: any, options: any): any;
+}
+
+/**
+  * @type {any}
+  */
+let HoverLabel = function (container) {
+    let scope = this;
+    let hoverLabel = document.createElement('div');
+    hoverLabel.style.display = 'none!important';
+    hoverLabel.style.position = 'absolute';
+    hoverLabel.style.top = '0px';
+    hoverLabel.style.left = '0px';
+    hoverLabel.style.pointerEvents = 'none';
+    this.hovering = false;
+    let lastX;
+    let lastY;
+    container.appendChild(hoverLabel);
+    this.show = function (textLabel) {
+        if (!scope.hovering) {
+            scope.setPosition(lastX, lastY);
+        }
+        scope.hovering = true;
+        hoverLabel.style.removeProperty('display');
+        hoverLabel.textContent = textLabel.toString();
+        hoverLabel.className = textLabel.hoverLabelClass;
+    };
+    this.hide = function () {
+        if (scope.hovering) {
+            scope.hovering = false;
+            hoverLabel.style.setProperty('display', 'none', 'important');
+            hoverLabel.textContent = '';
+        }
+    };
+    this.setZIndex = function (z) {
+        hoverLabel.style.zIndex = z;
+    };
+    this.setPosition = function (x, y) {
+        lastX = x;
+        lastY = y;
+        if (!scope.hovering)
+            return;
+        if (y - hoverLabel.clientHeight > 0) {
+            y = y - hoverLabel.clientHeight;
+            if (x + hoverLabel.clientWidth > container.clientWidth) {
+                x = x - hoverLabel.clientWidth;
+            }
+        }
+        else {
+            x = x - hoverLabel.clientWidth - 10;
+        }
+        hoverLabel.style.transform = 'translate(' + x + 'px, ' + y + 'px)';
+    };
+    this.destroy = function () {
+        container.removeChild(hoverLabel);
+    };
+};
+HoverLabel.MODES = {
+    NONE: 1,
+    NO_TEXT_LABEL_ONLY: 2,
+    ALL: 3
+};
+export default HoverLabel;
+
+precision mediump float;
+
+uniform sampler2D textureLabel;
+
+varying vec2 vUV;
+varying vec3 vColor;
+
+void main() {
+    gl_FragColor = texture2D(textureLabel, vUV);
+    gl_FragColor.rgb = vColor;
+}
+
+attribute vec2 position;
+attribute vec3 origin;
+attribute vec2 size;
+attribute float rotation;
+attribute vec4 uv;
+attribute vec3 color;
+
+uniform mat4 projectionMatrix;
+uniform mat4 viewMatrix;
+uniform mat4 modelMatrix;
+
+varying vec2 vUV;
+varying vec3 vColor;
+
+void main() {
+    vec4 mapDirectionVector = vec4(0, 1, 0, 0) * viewMatrix * modelMatrix;
+    float mapDirection = atan(mapDirectionVector.y, mapDirectionVector.x);
+
+    float cosRotation = cos(rotation);
+    float sinRotation = sin(rotation);
+
+    mat4 rotationMatrix = mat4(
+        vec4(cosRotation, -sinRotation, 0.0, 0.0),
+        vec4(sinRotation, cosRotation, 0.0, 0.0),
+        vec4(0.0, 0.0, 1.0, 0.0),
+        vec4(0.0, 0.0, 0.0, 1.0)
+    );
+
+    mat4 translate = mat4(
+        vec4(1, 0, 0, 0),
+        vec4(0, 1, 0, 0),
+        vec4(0, 0, 1, 0),
+        vec4(origin, 1)
+    );
+
+    gl_Position = projectionMatrix *
+                  viewMatrix *
+                  modelMatrix *
+                  translate *
+                  rotationMatrix *
+                  (vec4(position * size - vec2(0, size.y / 2.0), 0, 1));
+
+
+    vec2 uvStart = uv.xy;
+    vec2 uvSize = uv.zw;
+
+    if (sin(mapDirection + rotation) > 0.0) {
+        vUV = position * uvSize + vec2(uvStart.x, uvStart.y - uvSize.y);
+    } else {
+        vUV = (vec2(1, 1) - position) * uvSize + vec2(uvStart.x, uvStart.y - uvSize.y);		
+    }
+
+    vColor = color;
+}
+
+declare module '@mappedin/mappedin-js/renderer/MapView.Scene' {
+    import { MappedinMap } from '@mappedin/mappedin-js/get-venue';
+    import { ICore } from '@mappedin/mappedin-js/renderer/Core.interface';
+    import MapObject from '@mappedin/mappedin-js/renderer/internal/Mappedin.MapObject';
+    import { TSceneTransitionOptions } from '@mappedin/mappedin-js/renderer/MapView.SceneManager';
+    class MapViewScene {
+        #private;
+        maps: MappedinMap[];
+        object: any;
+        currentMap: MappedinMap;
+        mapObjects: Map<MappedinMap['id'], MapObject>;
+        constructor(maps: MappedinMap[], core: ICore);
+        /**
+          * Determine each maps position and rotation relative to the refernce map
+          */
+        determineMapPositionAndRotation(map: MappedinMap): {
+            position: any[];
+            scale: number[];
+            rotation: number[];
+        };
+        /** Render scene */
+        render(map: MappedinMap, transitionOptions?: TSceneTransitionOptions, isStartingScene?: boolean): Promise<void>;
+    }
+    export default MapViewScene;
+}
+