bruce-cesium 7.1.6 → 7.1.7

package/dist/bruce-cesium.es5.js

@@ -1,6 +1,6 @@
 import * as Cesium from 'cesium';
-import { Cartographic, ColorMaterialProperty, Entity, Color, ConstantProperty, CallbackProperty, Primitive, Cesium3DTileFeature, ShaderSource, Cartesian3, Math as Math$1, Ellipsoid, Transforms, Matrix4, Geometry, GeometryAttribute, ComponentDatatype, PrimitiveType, BoundingSphere, GeometryPipeline, sampleTerrain, Texture, PixelFormat, Sampler, TextureWrap, TextureMinificationFilter, TextureMagnificationFilter, VertexArray, BufferUsage, ShaderProgram, RenderState, BlendingState, DrawCommand, Pass, Cartesian2, DistanceDisplayCondition, JulianDate, Quaternion, HeadingPitchRoll, ClassificationType, ArcType, HeightReference, CornerType, ShadowMode, ConstantPositionProperty, HorizontalOrigin, VerticalOrigin, ColorBlendMode, Model, ImageMaterialProperty, PolygonHierarchy, PolylineGraphics, Rectangle, SceneTransforms, NearFarScalar, Matrix3, KmlDataSource, GeoJsonDataSource, SceneMode, Cesium3DTileStyle, HeadingPitchRange, Ion, IonResource, Cesium3DTileColorBlendMode, Cesium3DTileset, EllipsoidTerrainProvider, IonImageryProvider, createWorldImagery, createWorldImageryAsync, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, UrlTemplateImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, TileMapServiceImageryProvider, CesiumTerrainProvider, Intersect, EllipsoidGeodesic, sampleTerrainMostDetailed, defined, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics, PolylineDashMaterialProperty, OrthographicFrustum, EasingFunction, PolygonPipeline, GeometryInstance, CustomDataSource, CesiumInspector, ClockRange, ScreenSpaceEventHandler, ScreenSpaceEventType, Fullscreen, CzmlDataSource } from 'cesium';
-import { Cartes, Entity as Entity$1, ENVIRONMENT, Calculator, Carto, EntityTag, EntityType, Geometry as Geometry$1, ObjectUtils, Style, Api, ClientFile, LRUCache, MenuItem, ProjectView, ProjectViewBookmark, Tileset, ZoomControl, EntityLod, Bounds, Color as Color$1, BruceEvent, EntityCoords, DataLab, DelayQueue, BruceApi, EntityHistoricData, AccountConcept, RecordChangeFeed, EntityRelation, ProgramKey, EntitySource, ProjectViewLegacyTile, ProjectViewTile, Camera, Account, AccountLimits, Session, UrlUtils, EntityAttachment, EntityAttachmentType, EntityAttribute, MathUtils, ProjectViewBookmarkGroup, EntityRelationType } from 'bruce-models';
+import { Cartographic, ColorMaterialProperty, Entity, Color, ConstantProperty, CallbackProperty, Primitive, Cesium3DTileFeature, ShaderSource, Cartesian3, Math as Math$1, Ellipsoid, Transforms, Matrix4, Geometry, GeometryAttribute, ComponentDatatype, PrimitiveType, BoundingSphere, GeometryPipeline, sampleTerrain, Texture, PixelFormat, Sampler, TextureWrap, TextureMinificationFilter, TextureMagnificationFilter, VertexArray, BufferUsage, ShaderProgram, RenderState, BlendingState, DrawCommand, Pass, Cartesian2, DistanceDisplayCondition, HeightReference, ColorBlendMode, HeadingPitchRoll, ShadowMode, ClassificationType, Model, HorizontalOrigin, VerticalOrigin, ConstantPositionProperty, JulianDate, Quaternion, ArcType, CornerType, ImageMaterialProperty, PolygonHierarchy, PolylineGraphics, Rectangle, SceneTransforms, NearFarScalar, Matrix3, KmlDataSource, GeoJsonDataSource, SceneMode, Cesium3DTileStyle, HeadingPitchRange, Ion, IonResource, Cesium3DTileColorBlendMode, EllipsoidTerrainProvider, IonImageryProvider, createWorldImagery, createWorldImageryAsync, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, UrlTemplateImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, TileMapServiceImageryProvider, CesiumTerrainProvider, Cesium3DTileset, OrthographicFrustum, EasingFunction, Intersect, CustomDataSource, EllipsoidGeodesic, sampleTerrainMostDetailed, defined, PolygonPipeline, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics, PolylineDashMaterialProperty, CesiumInspector, ClockRange, GeometryInstance, ScreenSpaceEventHandler, ScreenSpaceEventType, Fullscreen, CzmlDataSource } from 'cesium';
+import { Cartes, Entity as Entity$1, ProjectViewTile, ENVIRONMENT, Calculator, ClientFile, EntityLod, EntityTag, EntityType, LRUCache, ObjectUtils, Style, Api, Carto, Geometry as Geometry$1, MenuItem, ProjectView, ProjectViewBookmark, Tileset, ZoomControl, Bounds, Color as Color$1, BruceEvent, EntityCoords, DataLab, DelayQueue, EntityHistoricData, AccountConcept, RecordChangeFeed, BruceApi, EntityRelation, ProgramKey, EntitySource, ProjectViewLegacyTile, Camera, Account, AccountLimits, Session, UrlUtils, EntityAttachment, EntityAttachmentType, EntityAttribute, MathUtils, ProjectViewBookmarkGroup, EntityRelationType } from 'bruce-models';
 
 /**
  * Ensures a number is returned from a given value.
@@ -2674,184 +2674,909 @@ var CesiumEntityStyler;
     CesiumEntityStyler.Unhighlight = Unhighlight;
 })(CesiumEntityStyler || (CesiumEntityStyler = {}));
 
+function OnNextCRender(viewer, callback) {
+    const removal = viewer.scene.postRender.addEventListener(() => {
+        removal();
+        callback();
+    });
+}
+function GetCValue(viewer, obj) {
+    if (obj === null || obj === void 0 ? void 0 : obj.getValue) {
+        let date = viewer.scene.lastRenderTime;
+        if (!date) {
+            date = viewer.clock.currentTime;
+        }
+        return obj.getValue(date);
+    }
+    return obj;
+}
+/*
+ * Marks an EntityCollection as one this library created and fully controls (a menu item's own data source).
+ */
+const OWNED_CCOLLECTION_KEY = "_bruceOwnedCollection";
+function MarkCCollectionOwned(collection) {
+    if (collection) {
+        collection[OWNED_CCOLLECTION_KEY] = true;
+    }
+}
+function IsCCollectionOwned(collection) {
+    return Boolean(collection && collection[OWNED_CCOLLECTION_KEY]);
+}
 /**
- * Describes a Nextspace provided UI widget.
+ * Runs a bulk collection mutation with every given collection's events suspended, so Cesium raises one
+ * collectionChanged per collection for the whole pass instead of one per entity.
+ *
+ * Takes a set of collections rather than assuming `viewer.entities`, because managed visuals live in their menu
+ * item's own data source: suspending the wrong collection silently does nothing.
+ * @param collections Duplicates and empty entries are ignored.
+ * @param run
  */
-var Widget;
-(function (Widget) {
-    class AWidget {
-        get WidgetId() {
-            return this.widgetId;
-        }
-        get Viewer() {
-            return this._viewer;
-        }
-        get Container() {
-            return this._container;
-        }
-        get Element() {
-            return this._element;
-        }
-        constructor(params) {
-            this.widgetId = ObjectUtils.UId();
-            let { viewer, container, manager } = params;
-            // A host app can pass an undefined viewer (eg. mid-teardown); fall back to
-            // no container rather than crashing on viewer.container.
-            if (!container && viewer) {
-                container = viewer.container;
-            }
-            this._viewer = viewer;
-            this._manager = manager;
-            this._container = container;
-            this._apiGetters = params.apiGetters;
-            if (viewer) {
-                markViewerWithWidget(viewer, this.widgetId, this);
-            }
+function WithSuspendedCCollections(collections, run) {
+    const unique = [];
+    for (const collection of collections) {
+        if (collection && unique.indexOf(collection) === -1) {
+            unique.push(collection);
         }
-        Dispose() {
-            if (this._element && this._element.parentElement) {
-                this._element.parentElement.removeChild(this._element);
+    }
+    for (const collection of unique) {
+        collection.suspendEvents();
+    }
+    try {
+        return run();
+    }
+    finally {
+        for (const collection of unique) {
+            try {
+                collection.resumeEvents();
             }
-            if (this._viewer) {
-                unmarkViewerWithWidget(this._viewer, this.widgetId, this);
+            catch (e) {
+                console.error(e);
             }
         }
     }
-    Widget.AWidget = AWidget;
-    function GetWidgets(viewer) {
-        if (viewer && viewer["_nextspaceWidgets"]) {
-            return Object.values(viewer["_nextspaceWidgets"]);
-        }
-        return [];
+}
+/**
+ * Returns the collection a graphic belongs to, falling back to the viewer's own when it has never been added.
+ * @param viewer
+ * @param entity
+ */
+function GetCEntityCollection(viewer, entity) {
+    const owner = entity === null || entity === void 0 ? void 0 : entity.entityCollection;
+    return owner ? owner : viewer === null || viewer === void 0 ? void 0 : viewer.entities;
+}
+/**
+ * Returns whether a graphic is currently in the scene, looking in whichever collection owns it.
+ * @param viewer
+ * @param entity
+ */
+function IsCEntityInScene(viewer, entity) {
+    const collection = GetCEntityCollection(viewer, entity);
+    return Boolean(collection && entity && collection.contains(entity));
+}
+/**
+ * Removes a graphic from whichever collection owns it. Returns whether it removed anything.
+ * @param viewer
+ * @param entity
+ */
+function RemoveCEntityFromScene(viewer, entity) {
+    var _a;
+    if (!entity) {
+        return false;
     }
-    Widget.GetWidgets = GetWidgets;
-})(Widget || (Widget = {}));
-function markViewerWithWidget(viewer, widgetId, widget) {
-    if (!viewer["_nextspaceWidgets"]) {
-        viewer["_nextspaceWidgets"] = {};
+    const collection = GetCEntityCollection(viewer, entity);
+    if (collection === null || collection === void 0 ? void 0 : collection.contains(entity)) {
+        return collection.remove(entity);
     }
-    viewer["_nextspaceWidgets"][widgetId] = widget;
+    // A stale owner reference and the graphic ended up in the viewer's collection anyway.
+    if (collection !== (viewer === null || viewer === void 0 ? void 0 : viewer.entities) && ((_a = viewer === null || viewer === void 0 ? void 0 : viewer.entities) === null || _a === void 0 ? void 0 : _a.contains(entity))) {
+        return viewer.entities.remove(entity);
+    }
+    return false;
 }
-function unmarkViewerWithWidget(viewer, widgetId, widget) {
-    if (viewer["_nextspaceWidgets"]) {
-        delete viewer["_nextspaceWidgets"][widgetId];
+/**
+ * Adds a graphic back into whichever collection owns it, or the viewer's if it has no owner yet.
+ * @param viewer
+ * @param entity
+ */
+function AddCEntityToScene(viewer, entity, fallbackCollection) {
+    if (!entity) {
+        return false;
+    }
+    // An existing owner always wins, so a graphic is never migrated out from under whoever holds it.
+    const owner = entity.entityCollection;
+    const collection = owner ? owner : (fallbackCollection ? fallbackCollection : viewer === null || viewer === void 0 ? void 0 : viewer.entities);
+    if (!collection || collection.contains(entity)) {
+        return false;
     }
+    collection.add(entity);
+    return true;
 }
-
-var WidgetControlViewBar;
-(function (WidgetControlViewBar) {
-    class AControl {
-        get WidgetViewBar() {
-            return this._widget;
-        }
-        get Container() {
-            return this._container;
+/**
+ * Returns whether toggling `show` on these graphics is safe, rather than having to add/remove them from the
+ * entity collection to hide them.
+ *
+ * Toggling show is far cheaper than re-adding the graphic to the viewer however a Cesium bug means we can't always use it.
+ * See: https://github.com/CesiumGS/cesium/issues/9370
+ * @param parts The graphic and any sibling graphics, eg. from EntityUtils.GatherEntity.
+ */
+function CanToggleShowSafely(parts) {
+    if (!(parts === null || parts === void 0 ? void 0 : parts.length)) {
+        return false;
+    }
+    for (const part of parts) {
+        if (!(part instanceof Entity)) {
+            // Not an Entity, so not something whose `show` we can drive.
+            return false;
         }
-        get Element() {
-            return this._element;
+        if (part.polyline && isTruthyCValue(part.polyline.clampToGround)) {
+            return false;
         }
-        get Disposed() {
-            return this._disposed;
+        const materialGraphics = [part.polygon, part.corridor, part.ellipse, part.rectangle, part.wall, part.polylineVolume];
+        for (const graphic of materialGraphics) {
+            if (graphic && !isPlainColorMaterial(graphic.material)) {
+                return false;
+            }
         }
-        get Enabled() {
-            return this._enabled;
+    }
+    return true;
+}
+/**
+ * Returns whether a material is a plain colour, which is what keeps a graphic out of Cesium's per-material batches.
+ * Anything unrecognised counts as not plain, so callers stay on the conservative side.
+ * @param material
+ */
+function isPlainColorMaterial(material) {
+    if (material == null) {
+        // Cesium defaults an absent material to white, a plain colour.
+        return true;
+    }
+    return material instanceof ColorMaterialProperty || material instanceof Color;
+}
+/**
+ * Resolves a possibly-property boolean without needing a viewer clock, treating anything undeterminable as true
+ * so callers stay on the conservative side.
+ * @param value
+ */
+function isTruthyCValue(value) {
+    if (value == null) {
+        return false;
+    }
+    if (typeof value.getValue === "function") {
+        if (value instanceof ConstantProperty) {
+            return Boolean(value.valueOf());
         }
-        constructor(params) {
-            this._disposed = false;
-            this._enabled = false;
-            let { container, widget, element } = params;
-            this._widget = widget;
-            this._container = container;
-            this._element = element;
+        // A non-constant property could be true at any moment, so assume it is.
+        return true;
+    }
+    return Boolean(value);
+}
+/**
+ * Returns if two resolved Cesium property values are equal, using the value's own equals() when it has one.
+ * @param a
+ * @param b
+ */
+function AreCValuesEqual(a, b) {
+    if (a === b) {
+        return true;
+    }
+    // One side is null/undefined and the other isn't.
+    if (a == null || b == null) {
+        return false;
+    }
+    if (typeof a.equals === "function") {
+        return a.equals(b) === true;
+    }
+    return false;
+}
+/**
+ * Wraps a value in a ConstantProperty and assigns it to a graphic's property, but only when the resolved
+ * value actually differs. Returns whether it assigned.
+ * @param params
+ */
+function SetCPropIfChanged(params) {
+    const { viewer, graphic, property, value, compare } = params;
+    if (!graphic) {
+        return false;
+    }
+    const oldValue = GetCValue(viewer, graphic[property]);
+    const isEqual = compare ? compare(oldValue, value) : AreCValuesEqual(oldValue, value);
+    if (isEqual) {
+        return false;
+    }
+    graphic[property] = new ConstantProperty(value);
+    return true;
+}
+function ColorToCColor(color) {
+    return new Color(color.red ? color.red / 255 : 0, color.green ? color.green / 255 : 0, color.blue ? color.blue / 255 : 0, color.alpha);
+}
+/**
+ * Removes duplicate points in a row and returns a new array.
+ * Passed array is not mutated.
+ * @param posses
+ */
+function CullDuplicateCPosses(posses) {
+    const newPosses = [];
+    let lastPos = null;
+    for (let i = 0; i < posses.length; i++) {
+        const pos = posses[i];
+        // Avoiding 'Cesium.Cartesian3.equals' because passed data might be just a json blob in certain cases.
+        if (pos && (!lastPos || (pos.x != lastPos.x || pos.y != lastPos.y || pos.z != lastPos.z))) {
+            newPosses.push(pos);
+            lastPos = pos;
         }
-        Toggle() {
+    }
+    return newPosses;
+}
+/**
+ * Returns if the given positions are equal.
+ * @param a
+ * @param b
+ */
+function CompareCPosses(a, b) {
+    // Same reference.
+    if (a == b) {
+        return true;
+    }
+    // Different lengths or one is null.
+    if ((!a || !b) || (a.length != b.length)) {
+        return false;
+    }
+    for (let i = 0; i < a.length; i++) {
+        const posA = a[i];
+        const posB = b[i];
+        // Null detected.
+        if (!posA || !posB) {
+            return false;
         }
-        Dispose() {
-            this._disposed = true;
+        // Position values don't match.
+        if (!Cartes.IsEqualCartes3(posA, posB)) {
+            return false;
         }
     }
-    WidgetControlViewBar.AControl = AControl;
-})(WidgetControlViewBar || (WidgetControlViewBar = {}));
-
+    return true;
+}
 /**
- * The fullscreen control is a simple toggle.
- * There is no HTML element. However we do swap the icon based on the toggle state.
+ * Returns if the given polygon hierarchies are equal.
+ * @param a
+ * @param b
  */
-class WidgetControlViewBarFullscreen extends WidgetControlViewBar.AControl {
-    constructor(params) {
-        super(params);
+function CompareCPolygonHierarchies(a, b) {
+    // Same reference.
+    if (a == b) {
+        return true;
     }
-    Dispose() {
-        super.Dispose();
+    // Different lengths or one is null.
+    if ((!a || !b) || (a.positions.length != b.positions.length)) {
+        return false;
     }
-    Toggle() {
-        if (this.Disposed) {
-            return;
-        }
-        super.Toggle();
-        // Toggle fullscreen.
-        this._enabled = false;
-        if (Fullscreen.enabled) {
-            if (Fullscreen.fullscreen) {
-                Fullscreen.exitFullscreen();
-            }
-            else {
-                Fullscreen.requestFullscreen(document.body);
-                this._enabled = true;
-            }
+    // Positions don't match.
+    if (!CompareCPosses(a.positions, b.positions)) {
+        return false;
+    }
+    const holes = a.holes;
+    const bHoles = b.holes;
+    // Number of holes don't match.
+    if (holes.length != bHoles.length) {
+        return false;
+    }
+    for (let i = 0; i < holes.length; i++) {
+        // Hole positions don't match.
+        if (!CompareCPosses(holes[i].positions, bHoles[i].positions)) {
+            return false;
         }
     }
+    return true;
 }
 
-class WidgetControlViewBarSearch extends WidgetControlViewBar.AControl {
-    constructor(params) {
-        super(params);
-        this.STYLESHEET_ID = "nextspace-control-view-bar-searchbar-stylesheet";
-        this._generateStyles();
-        this._generateElement();
+const CESIUM_INSPECTOR_KEY = "_nextspace_inspector";
+const CESIUM_TIMELINE_KEY = "_nextspace_timeline";
+const CESIUM_TIMELINE_LIVE_KEY = "_nextspace_timeline_live";
+const CESIUM_TIMELINE_LIVE_PADDING_KEY = "_nextspace_timeline_live_padding";
+const CESIUM_TIMELINE_INTERVAL_KEY = "_nextspace_timeline_interval";
+const CESIUM_MODEL_SPACE_KEY = "_nextspace_model_space";
+const DEFAULT_LIVE_PADDING_SECONDS = 30 * 60;
+const DEFAULT_BRIGHTNESS_SHIFT = 0.2;
+var ViewUtils;
+(function (ViewUtils) {
+    function GatherLegacyMapTiles(params) {
+        const viewer = params.viewer;
+        const collection = viewer.imageryLayers;
+        const tiles = [];
+        for (let i = 0; i < collection.length; i++) {
+            const layer = collection.get(i);
+            if (layer._bName) {
+                tiles.push({
+                    alpha: layer.alpha,
+                    brightness: layer.brightness,
+                    contrast: layer.contrast,
+                    hue: layer.hue,
+                    saturation: layer.saturation,
+                    gamma: layer.gamma,
+                    title: layer._bName,
+                });
+            }
+        }
+        return {
+            imagery: tiles.reverse()
+        };
     }
-    Dispose() {
-        super.Dispose();
-        if (this._element && this._element.parentElement) {
-            this._element.parentElement.removeChild(this._element);
+    ViewUtils.GatherLegacyMapTiles = GatherLegacyMapTiles;
+    function GatherLegacyTerrainTile(params) {
+        const viewer = params.viewer;
+        const enabled = viewer.terrainProvider;
+        if (enabled === null || enabled === void 0 ? void 0 : enabled._bName) {
+            return {
+                terrain: enabled._bName
+            };
         }
-        if (this._results && this._results.parentElement) {
-            this._results.parentElement.removeChild(this._results);
+        return {
+            terrain: "flatterrain"
+        };
+    }
+    ViewUtils.GatherLegacyTerrainTile = GatherLegacyTerrainTile;
+    function GatherMapTiles(params) {
+        const viewer = params.viewer;
+        const imagery = viewer.imageryLayers;
+        const tiles = [];
+        for (let i = 0; i < imagery.length; i++) {
+            const provider = imagery.get(i);
+            if (provider._bMeta) {
+                const idCombo = provider._bMeta.accountId + provider._bMeta.tilesetId;
+                if (!tiles.find(x => x.accountId + x.tilesetId === idCombo)) {
+                    tiles.push({
+                        accountId: provider._bMeta.accountId,
+                        tilesetId: provider._bMeta.tilesetId,
+                        alpha: provider.alpha,
+                        brightness: provider.brightness,
+                        contrast: provider.contrast,
+                        hue: provider.hue,
+                        saturation: provider.saturation,
+                        gamma: provider.gamma
+                    });
+                }
+            }
         }
+        return {
+            imagery: tiles
+        };
     }
-    Toggle() {
-        if (this.Disposed) {
-            return;
+    ViewUtils.GatherMapTiles = GatherMapTiles;
+    function GatherTerrainTile(params) {
+        const viewer = params.viewer;
+        const provider = viewer.terrainProvider;
+        if (provider === null || provider === void 0 ? void 0 : provider._bMeta) {
+            return {
+                terrain: {
+                    accountId: provider._bMeta.accountId,
+                    tilesetId: provider._bMeta.tilesetId,
+                }
+            };
         }
-        super.Toggle();
-        this._enabled = !this._enabled;
-        if (this._enabled) {
-            this._display();
+        else if (provider instanceof EllipsoidTerrainProvider) {
+            return {
+                terrain: {
+                    tilesetId: ProjectViewTile.EDefaultTerrain.FlatTerrain,
+                    accountId: null
+                }
+            };
         }
-        else {
-            this._hide();
+        return null;
+    }
+    ViewUtils.GatherTerrainTile = GatherTerrainTile;
+    function SetTerrainWireframeStatus(params) {
+        if (!params.viewer[CESIUM_INSPECTOR_KEY]) {
+            const InspectorClass = CesiumInspector;
+            if (InspectorClass) {
+                const inspector = new InspectorClass(document.createElement("div"), params.viewer.scene);
+                inspector.container.style.display = "none";
+                params.viewer[CESIUM_INSPECTOR_KEY] = inspector;
+                params.viewer.scene.requestRender();
+            }
+        }
+        if (params.viewer[CESIUM_INSPECTOR_KEY]) {
+            params.viewer[CESIUM_INSPECTOR_KEY].viewModel.wireframe = params.status;
         }
     }
-    _generateStyles() {
-        if (document.getElementById(this.STYLESHEET_ID)) {
-            return;
+    ViewUtils.SetTerrainWireframeStatus = SetTerrainWireframeStatus;
+    function GetTerrainWireframeStatus(params) {
+        var _a, _b;
+        if (!params.viewer[CESIUM_INSPECTOR_KEY]) {
+            return false;
         }
-        const style = document.createElement("style");
-        style.id = this.STYLESHEET_ID;
-        style.innerHTML = `
-            .NextspaceSearchBar {
-                display: flex;
-                box-sizing: border-box;
-                height: 100%;
-                font-family: sans-serif;
-            }
-
-            .NextspaceSearchBar * {
-                box-sizing: border-box;
-            }
-
-            .NextspaceSearchBar[is-opened="true"] .NextspaceSearchBarContent {
-                display: flex;
+        return (_b = (_a = params.viewer[CESIUM_INSPECTOR_KEY]) === null || _a === void 0 ? void 0 : _a.viewModel) === null || _b === void 0 ? void 0 : _b.wireframe;
+    }
+    ViewUtils.GetTerrainWireframeStatus = GetTerrainWireframeStatus;
+    /**
+     * Changes between perspective and orthographic view.
+     * When Cesium stops being bad at picking positions in 2d mode we'll use the flat earth mode instead.
+     * @param params
+     */
+    function Set2dStatus(params) {
+        const { viewer, status: is2d, moveCamera } = params;
+        const curLens2d = viewer.camera.frustum instanceof OrthographicFrustum;
+        if (curLens2d && !is2d) {
+            OnNextCRender(viewer, () => {
+                viewer.camera.switchToPerspectiveFrustum();
+                viewer.scene.screenSpaceCameraController.enableTilt = true;
+            });
+            viewer.scene.requestRender();
+        }
+        else if (!curLens2d && is2d) {
+            OnNextCRender(viewer, () => {
+                viewer.camera.switchToOrthographicFrustum();
+                viewer.scene.screenSpaceCameraController.enableTilt = false;
+            });
+            if (moveCamera != false) {
+                try {
+                    // Face camera downwards to make it look 2d.
+                    // We want to try make it look at the center-point of the current view.
+                    // If center cannot be calculated then we'll simply raise the camera and face it downwards.
+                    const scene = viewer.scene;
+                    const windowPosition = new Cartesian2(scene.canvas.clientWidth / 2, scene.canvas.clientHeight / 2);
+                    const ray = viewer.camera.getPickRay(windowPosition);
+                    const intersection = scene.globe.pick(ray, scene);
+                    let center;
+                    if (defined(intersection)) {
+                        center = Cartographic.fromCartesian(intersection);
+                    }
+                    // Use current camera position if we can't calculate the center.
+                    else {
+                        center = Cartographic.fromCartesian(viewer.camera.position);
+                        center.height = 0;
+                    }
+                    center.height = viewer.camera.positionCartographic.height + 100;
+                    viewer.camera.setView({
+                        destination: Cartographic.toCartesian(center),
+                        orientation: {
+                            heading: 0.0,
+                            pitch: Math$1.toRadians(-90.0),
+                            roll: 0.0
+                        }
+                    });
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }
+            viewer.scene.requestRender();
+        }
+    }
+    ViewUtils.Set2dStatus = Set2dStatus;
+    function Get2dStatus(params) {
+        const { viewer } = params;
+        return viewer.camera.frustum instanceof OrthographicFrustum;
+    }
+    ViewUtils.Get2dStatus = Get2dStatus;
+    function SetLockedCameraStatus(params) {
+        const { viewer, status } = params;
+        const scene = viewer === null || viewer === void 0 ? void 0 : viewer.scene;
+        if (!scene) {
+            return;
+        }
+        if (status) {
+            scene.screenSpaceCameraController.enableInputs = false;
+            scene.screenSpaceCameraController.enableTranslate = false;
+            scene.screenSpaceCameraController.enableZoom = false;
+            scene.screenSpaceCameraController.enableRotate = false;
+            scene.screenSpaceCameraController.enableTilt = false;
+        }
+        else {
+            scene.screenSpaceCameraController.enableInputs = true;
+            scene.screenSpaceCameraController.enableTranslate = true;
+            scene.screenSpaceCameraController.enableZoom = true;
+            scene.screenSpaceCameraController.enableRotate = true;
+            if (!ViewUtils.Get2dStatus({ viewer })) {
+                scene.screenSpaceCameraController.enableTilt = true;
+            }
+        }
+        viewer.scene.requestRender();
+    }
+    ViewUtils.SetLockedCameraStatus = SetLockedCameraStatus;
+    function GetLockedCameraStatus(params) {
+        var _a;
+        const scene = (_a = params.viewer) === null || _a === void 0 ? void 0 : _a.scene;
+        if (!scene) {
+            return false;
+        }
+        return !scene.screenSpaceCameraController.enableTranslate;
+    }
+    ViewUtils.GetLockedCameraStatus = GetLockedCameraStatus;
+    /**
+     * Returns the current camera time and related settings.
+     * @param params
+     * @returns
+     */
+    function GetTimeDetails(params) {
+        const { viewer } = params;
+        const clock = viewer.clock;
+        return {
+            animationSpeed: clock.multiplier,
+            isAnimating: clock.shouldAnimate,
+            startTime: clock.startTime,
+            startTimeIso: clock.startTime.toString(),
+            currentTime: clock.currentTime,
+            currentTimeIso: clock.currentTime.toString(),
+            stopTime: clock.stopTime,
+            stopTimeIso: clock.stopTime.toString(),
+            areCesiumValues: clock[CESIUM_TIMELINE_KEY] != true,
+            isLive: clock[CESIUM_TIMELINE_LIVE_KEY] == true,
+            livePaddingSeconds: clock[CESIUM_TIMELINE_LIVE_PADDING_KEY] || DEFAULT_LIVE_PADDING_SECONDS
+        };
+    }
+    ViewUtils.GetTimeDetails = GetTimeDetails;
+    /**
+     * Sets the Cesium clock values.
+     * If a value is not provided, then 'areCesiumValues' checked to see if the values are Cesium values.
+     * If they're currently Cesium set values then our defaults are used.
+     * @param params
+     */
+    function SetTimeDetails(params) {
+        let { viewer, animationSpeed, isAnimating, startTime, currentTime, stopTime, startTimeIso, stopTimeIso, currentTimeIso, isLive, livePaddingSeconds } = params;
+        const clock = viewer.clock;
+        if (startTime) {
+            clock.startTime = startTime;
+        }
+        else if (startTimeIso) {
+            const startDate = JulianDate.fromIso8601(startTimeIso);
+            if (startDate) {
+                clock.startTime = startDate;
+            }
+        }
+        if (currentTime) {
+            clock.currentTime = currentTime;
+        }
+        else if (currentTimeIso) {
+            const currentDate = JulianDate.fromIso8601(currentTimeIso);
+            if (currentDate) {
+                clock.currentTime = currentDate;
+            }
+        }
+        if (stopTime) {
+            clock.stopTime = stopTime;
+        }
+        else if (stopTimeIso) {
+            const stopDate = JulianDate.fromIso8601(stopTimeIso);
+            if (stopDate) {
+                clock.stopTime = stopDate;
+            }
+        }
+        clock.clockRange = ClockRange.LOOP_STOP;
+        const areCesiumValues = clock[CESIUM_TIMELINE_KEY] != true;
+        if (areCesiumValues) {
+            if (isNaN(animationSpeed) || animationSpeed == null) {
+                animationSpeed = 1;
+            }
+            if (isAnimating == null) {
+                isAnimating = false;
+            }
+            if (isLive == null) {
+                isLive = false;
+            }
+            if (livePaddingSeconds == null) {
+                livePaddingSeconds = DEFAULT_LIVE_PADDING_SECONDS;
+            }
+        }
+        if (!isNaN(animationSpeed) && animationSpeed != null) {
+            clock.multiplier = animationSpeed;
+        }
+        if (isAnimating != null) {
+            clock.shouldAnimate = isAnimating;
+        }
+        viewer.scene.requestRender();
+        clock[CESIUM_TIMELINE_KEY] = true;
+        if (livePaddingSeconds != null) {
+            clock[CESIUM_TIMELINE_LIVE_PADDING_KEY] = livePaddingSeconds || DEFAULT_LIVE_PADDING_SECONDS;
+        }
+        if (isLive != null) {
+            clock[CESIUM_TIMELINE_LIVE_KEY] = params.isLive == true;
+        }
+        if (clock[CESIUM_TIMELINE_LIVE_KEY]) {
+            startLive(viewer);
+        }
+        else {
+            stopLive(viewer);
+        }
+    }
+    ViewUtils.SetTimeDetails = SetTimeDetails;
+    function startLive(viewer) {
+        const doUpdate = () => {
+            if (!viewer || viewer.isDestroyed() || !viewer.scene) {
+                stopLive(viewer);
+                return;
+            }
+            // Get the current settings.
+            const tDetails = GetTimeDetails({ viewer });
+            const clock = viewer.clock;
+            if (clock) {
+                clock.shouldAnimate = true;
+                clock.multiplier = 1;
+                clock.currentTime = JulianDate.now();
+                clock.startTime = JulianDate.addSeconds(clock.currentTime, -tDetails.livePaddingSeconds, new JulianDate());
+                clock.stopTime = JulianDate.addSeconds(clock.currentTime, tDetails.livePaddingSeconds, new JulianDate());
+                clock.clockRange = ClockRange.UNBOUNDED;
+            }
+        };
+        if (viewer[CESIUM_TIMELINE_INTERVAL_KEY]) {
+            doUpdate();
+            return;
+        }
+        // We'll start an interval that occasionally updates the Cesium clock to stay in the desired settings.
+        // Since it moves live (1 second per second), we don't have to worry about the ranges being out of date quickly.
+        viewer[CESIUM_TIMELINE_INTERVAL_KEY] = setInterval(() => {
+            doUpdate();
+        }, 800);
+        viewer[CESIUM_TIMELINE_LIVE_KEY] = true;
+        // Initial update.
+        doUpdate();
+    }
+    function stopLive(viewer) {
+        if (!viewer) {
+            return;
+        }
+        let interval = viewer[CESIUM_TIMELINE_INTERVAL_KEY];
+        if (interval) {
+            clearInterval(interval);
+            viewer[CESIUM_TIMELINE_INTERVAL_KEY] = null;
+        }
+        viewer[CESIUM_TIMELINE_LIVE_KEY] = false;
+    }
+    /**
+     * Brightens a scene's atmosphere, using whichever control the host app's CesiumJS exposes.
+     * @param viewer the viewer to brighten. Safe to call with null.
+     * @param shift -1 to 1, where 0 or less leaves CesiumJS's own defaults alone.
+     */
+    function ApplyDefaultBrightness(viewer, shift = DEFAULT_BRIGHTNESS_SHIFT) {
+        const scene = viewer === null || viewer === void 0 ? void 0 : viewer.scene;
+        if (!scene || !(shift > 0)) {
+            return;
+        }
+        // Atmosphere settings moved from Globe onto Scene, and the sky keeps its own copy, so each is
+        // probed rather than version checked: host apps bring their own CesiumJS.
+        const SCENE = scene;
+        if (SCENE.atmosphere && typeof SCENE.atmosphere.brightnessShift === "number") {
+            SCENE.atmosphere.brightnessShift = shift;
+        }
+        if (SCENE.globe && typeof SCENE.globe.atmosphereBrightnessShift === "number") {
+            SCENE.globe.atmosphereBrightnessShift = shift;
+        }
+        if (SCENE.skyAtmosphere && typeof SCENE.skyAtmosphere.brightnessShift === "number") {
+            SCENE.skyAtmosphere.brightnessShift = shift;
+        }
+    }
+    ViewUtils.ApplyDefaultBrightness = ApplyDefaultBrightness;
+    function SetGlobeDetails(params) {
+        let { viewer, hidden, baseColor } = params;
+        const scene = viewer === null || viewer === void 0 ? void 0 : viewer.scene;
+        if (!(scene === null || scene === void 0 ? void 0 : scene.globe)) {
+            return;
+        }
+        if (hidden == null) {
+            hidden = !scene.globe.show;
+        }
+        else {
+            scene.globe.show = !hidden;
+        }
+        if (baseColor == null) {
+            baseColor = scene.globe.baseColor;
+        }
+        // When globe is off, we'll also hide the stars/moon.
+        // We also grab the globe color and apply it to the sky.
+        if (hidden && GetModelSpace(viewer)) {
+            scene.skyBox.show = false;
+            scene.skyAtmosphere.show = false;
+            scene.sun.show = false;
+            scene.moon.show = false;
+            scene.backgroundColor = baseColor.clone();
+        }
+        else {
+            scene.skyBox.show = true;
+            scene.skyAtmosphere.show = true;
+            scene.sun.show = true;
+            scene.moon.show = true;
+            scene.backgroundColor = Color.BLACK;
+        }
+        scene.globe.baseColor = baseColor;
+    }
+    ViewUtils.SetGlobeDetails = SetGlobeDetails;
+    function SetModelSpace(viewer, modelSpace) {
+        if (!viewer) {
+            return;
+        }
+        if (viewer[CESIUM_MODEL_SPACE_KEY] === modelSpace) {
+            return;
+        }
+        viewer[CESIUM_MODEL_SPACE_KEY] = modelSpace;
+        // Reload globe since we display it differently between the two modes.
+        SetGlobeDetails({ viewer });
+    }
+    ViewUtils.SetModelSpace = SetModelSpace;
+    function GetModelSpace(viewer) {
+        if (!viewer) {
+            return false;
+        }
+        return Boolean(viewer[CESIUM_MODEL_SPACE_KEY]);
+    }
+    ViewUtils.GetModelSpace = GetModelSpace;
+})(ViewUtils || (ViewUtils = {}));
+
+/**
+ * Describes a Nextspace provided UI widget.
+ */
+var Widget;
+(function (Widget) {
+    class AWidget {
+        get WidgetId() {
+            return this.widgetId;
+        }
+        get Viewer() {
+            return this._viewer;
+        }
+        get Container() {
+            return this._container;
+        }
+        get Element() {
+            return this._element;
+        }
+        constructor(params) {
+            this.widgetId = ObjectUtils.UId();
+            let { viewer, container, manager } = params;
+            // A host app can pass an undefined viewer (eg. mid-teardown); fall back to
+            // no container rather than crashing on viewer.container.
+            if (!container && viewer) {
+                container = viewer.container;
+            }
+            this._viewer = viewer;
+            this._manager = manager;
+            this._container = container;
+            this._apiGetters = params.apiGetters;
+            if (viewer) {
+                markViewerWithWidget(viewer, this.widgetId, this);
+            }
+        }
+        Dispose() {
+            if (this._element && this._element.parentElement) {
+                this._element.parentElement.removeChild(this._element);
+            }
+            if (this._viewer) {
+                unmarkViewerWithWidget(this._viewer, this.widgetId, this);
+            }
+        }
+    }
+    Widget.AWidget = AWidget;
+    function GetWidgets(viewer) {
+        if (viewer && viewer["_nextspaceWidgets"]) {
+            return Object.values(viewer["_nextspaceWidgets"]);
+        }
+        return [];
+    }
+    Widget.GetWidgets = GetWidgets;
+})(Widget || (Widget = {}));
+function markViewerWithWidget(viewer, widgetId, widget) {
+    if (!viewer["_nextspaceWidgets"]) {
+        viewer["_nextspaceWidgets"] = {};
+    }
+    viewer["_nextspaceWidgets"][widgetId] = widget;
+}
+function unmarkViewerWithWidget(viewer, widgetId, widget) {
+    if (viewer["_nextspaceWidgets"]) {
+        delete viewer["_nextspaceWidgets"][widgetId];
+    }
+}
+
+var WidgetControlViewBar;
+(function (WidgetControlViewBar) {
+    class AControl {
+        get WidgetViewBar() {
+            return this._widget;
+        }
+        get Container() {
+            return this._container;
+        }
+        get Element() {
+            return this._element;
+        }
+        get Disposed() {
+            return this._disposed;
+        }
+        get Enabled() {
+            return this._enabled;
+        }
+        constructor(params) {
+            this._disposed = false;
+            this._enabled = false;
+            let { container, widget, element } = params;
+            this._widget = widget;
+            this._container = container;
+            this._element = element;
+        }
+        Toggle() {
+        }
+        Dispose() {
+            this._disposed = true;
+        }
+    }
+    WidgetControlViewBar.AControl = AControl;
+})(WidgetControlViewBar || (WidgetControlViewBar = {}));
+
+/**
+ * The fullscreen control is a simple toggle.
+ * There is no HTML element. However we do swap the icon based on the toggle state.
+ */
+class WidgetControlViewBarFullscreen extends WidgetControlViewBar.AControl {
+    constructor(params) {
+        super(params);
+    }
+    Dispose() {
+        super.Dispose();
+    }
+    Toggle() {
+        if (this.Disposed) {
+            return;
+        }
+        super.Toggle();
+        // Toggle fullscreen.
+        this._enabled = false;
+        if (Fullscreen.enabled) {
+            if (Fullscreen.fullscreen) {
+                Fullscreen.exitFullscreen();
+            }
+            else {
+                Fullscreen.requestFullscreen(document.body);
+                this._enabled = true;
+            }
+        }
+    }
+}
+
+class WidgetControlViewBarSearch extends WidgetControlViewBar.AControl {
+    constructor(params) {
+        super(params);
+        this.STYLESHEET_ID = "nextspace-control-view-bar-searchbar-stylesheet";
+        this._generateStyles();
+        this._generateElement();
+    }
+    Dispose() {
+        super.Dispose();
+        if (this._element && this._element.parentElement) {
+            this._element.parentElement.removeChild(this._element);
+        }
+        if (this._results && this._results.parentElement) {
+            this._results.parentElement.removeChild(this._results);
+        }
+    }
+    Toggle() {
+        if (this.Disposed) {
+            return;
+        }
+        super.Toggle();
+        this._enabled = !this._enabled;
+        if (this._enabled) {
+            this._display();
+        }
+        else {
+            this._hide();
+        }
+    }
+    _generateStyles() {
+        if (document.getElementById(this.STYLESHEET_ID)) {
+            return;
+        }
+        const style = document.createElement("style");
+        style.id = this.STYLESHEET_ID;
+        style.innerHTML = `
+            .NextspaceSearchBar {
+                display: flex;
+                box-sizing: border-box;
+                height: 100%;
+                font-family: sans-serif;
+            }
+
+            .NextspaceSearchBar * {
+                box-sizing: border-box;
+            }
+
+            .NextspaceSearchBar[is-opened="true"] .NextspaceSearchBarContent {
+                display: flex;
                 width: 260px;
             }
 
@@ -3564,1123 +4289,423 @@ var SimplifyGeometry;
                 for (let i = 0; i < geometry.Polygon.length; i++) {
                     const polygon = geometry.Polygon[i];
                     count += Geometry$1.ParsePoints(polygon.LinearRing).length;
-                }
-            }
-            else if (geometry.LineString) {
-                count += Geometry$1.ParsePoints(geometry.LineString).length;
-            }
-            else if (geometry.Point) {
-                count += 1;
-            }
-        };
-        traverse(geometry);
-        return count;
-    }
-    SimplifyGeometry.CountPoints = CountPoints;
-    /**
-     * Simplifies input geometry.
-     * This will turn it into GeoJSON, run it through turf, then back to Bruce geometry.
-     * @param geometry
-     */
-    function Simplify(entityId, geometry, tolerance) {
-        var _a;
-        if (!geometry || !isTurfAvailable() || !turf.simplify) {
-            return geometry;
-        }
-        const original = geometry;
-        // Convert to geojson so that we can interact with turf.
-        const gFeature = Geometry$1.ToGeoJsonFeature({
-            geometry: geometry
-        });
-        // Unkink the geometry.
-        // This removes overlapping polygons before we start merging and simplifying.
-        // Commented out because it has crashes and doesn't handle holes.
-        untangleFeature(gFeature);
-        // Union the geometry.
-        // This merges overlapping polygons.
-        unionFeature(gFeature);
-        // Simplify the geometry.
-        if (tolerance > 0) {
-            gFeature.geometry = turf.simplify(gFeature.geometry, {
-                tolerance: tolerance,
-                highQuality: true,
-                mutate: true
-            });
-        }
-        // Converting back to Bruce geometry.
-        const simplified = (_a = Geometry$1.FromGeoJson({
-            geoJson: gFeature
-        })) === null || _a === void 0 ? void 0 : _a.geometry;
-        // A polygon we cannot vouch for is worse than an unsimplified one, so fall back instead of shipping it.
-        if (!simplified || !isSafeToRender(simplified)) {
-            return original;
-        }
-        return simplified;
-    }
-    SimplifyGeometry.Simplify = Simplify;
-    /**
-     * Whether a simplified geometry still describes something a renderer can triangulate.
-     * @param geometry the simplification result.
-     * @returns false when any polygon has a collapsed ring, a hole outside its outer ring, or a hole
-     * wound the same way as its outer ring.
-     */
-    function IsSafeToRender(geometry) {
-        return isSafeToRender(geometry);
-    }
-    SimplifyGeometry.IsSafeToRender = IsSafeToRender;
-})(SimplifyGeometry || (SimplifyGeometry = {}));
-// A ring needs three distinct corners plus the closing repeat before it encloses any area.
-const MIN_RING_POSITIONS = 4;
-function isSafeToRender(geometry) {
-    let safe = true;
-    const check = (g) => {
-        if (!safe) {
-            return;
-        }
-        if (g === null || g === void 0 ? void 0 : g.MultiGeometry) {
-            g.MultiGeometry.forEach(check);
-            return;
-        }
-        if (!(g === null || g === void 0 ? void 0 : g.Polygon) || g.Polygon.length === 0) {
-            return;
-        }
-        let outer = null;
-        let outerIsClockwise = false;
-        for (let i = 0; i < g.Polygon.length; i++) {
-            const points = Geometry$1.ParsePoints(g.Polygon[i].LinearRing);
-            if (!points || points.length < MIN_RING_POSITIONS) {
-                safe = false;
-                return;
-            }
-            const clockwise = signedRingArea(points) < 0;
-            if (g.Polygon[i].Facing !== "in") {
-                outer = points;
-                outerIsClockwise = clockwise;
-                continue;
-            }
-            // A hole with no outer ring ahead of it cannot be subtracted from anything.
-            if (!outer) {
-                safe = false;
-                return;
-            }
-            if (clockwise === outerIsClockwise) {
-                safe = false;
-                return;
-            }
-            for (let j = 0; j < points.length; j++) {
-                if (!isPointInRing(points[j], outer)) {
-                    safe = false;
-                    return;
-                }
-            }
-        }
-    };
-    check(geometry);
-    return safe;
-}
-function signedRingArea(points) {
-    let sum = 0;
-    for (let i = 0; i < points.length; i++) {
-        const a = points[i];
-        const b = points[(i + 1) % points.length];
-        sum += a.longitude * b.latitude - b.longitude * a.latitude;
-    }
-    return sum / 2;
-}
-function isPointInRing(point, ring) {
-    let inside = false;
-    for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
-        const a = ring[i];
-        const b = ring[j];
-        if ((a.latitude > point.latitude) !== (b.latitude > point.latitude)
-            && point.longitude < (b.longitude - a.longitude) * (point.latitude - a.latitude) / (b.latitude - a.latitude) + a.longitude) {
-            inside = !inside;
-        }
-    }
-    return inside;
-}
-/**
- * Runs through all found polygons and runs unkink through turf on them.
- * @param feature
- */
-function untangleFeature(feature) {
-    // Collection to add to because the result might be multiple from an unkink.
-    const collection = {
-        geometries: [],
-        type: "GeometryCollection"
-    };
-    // Runs a dedupe and unkink on the coordinates.
-    // Returns if the coordinates were added to the collection.
-    const processCoordinates = (coords) => {
-        try {
-            // Dedupe the coordinates to avoid issues with unkink.
-            coords = dedupeCoordinates(coords);
-            const outer = [];
-            let inner = [];
-            // We'll unkink each ring separately as this is killing the holes when it is done as a whole.
-            // So we'll do it separate then recombine.
-            for (let i = 0; i < coords.length; i++) {
-                const ring = coords[i];
-                const unkink = turf.unkinkPolygon({
-                    type: "Polygon",
-                    coordinates: [ring]
-                });
-                if (unkink.type == "FeatureCollection") {
-                    let target = i == 0 ? outer : inner;
-                    for (let j = 0; j < unkink.features.length; j++) {
-                        const unkinked = unkink.features[j].geometry.coordinates;
-                        if (unkinked.length > 0) {
-                            target.push(unkinked[0]);
-                        }
-                    }
-                }
-                else {
-                    console.error("Unexpected unkink result.", unkink);
-                }
-            }
-            // Recreate the rings and reapply to the collection.
-            if (outer.length > 0) {
-                // Unkinking a self touching boundary splits it into pieces. Keeping whichever piece
-                // happened to come back first can discard most of the shape, so keep the biggest one.
-                let keep = outer[0];
-                if (outer.length > 1) {
-                    let best = Math.abs(ringArea(keep));
-                    for (let i = 1; i < outer.length; i++) {
-                        const area = Math.abs(ringArea(outer[i]));
-                        if (area > best) {
-                            best = area;
-                            keep = outer[i];
-                        }
-                    }
-                }
-                const combinedCoords = [keep];
-                for (let i = 0; i < inner.length; i++) {
-                    // A hole belonging to a piece that was just discarded is no longer inside anything,
-                    // and a hole crossing the boundary is what tears the fill.
-                    if (isRingInsideRing(inner[i], keep)) {
-                        combinedCoords.push(inner[i]);
-                    }
-                }
-                // Add the combined coordinates to the collection
-                const polygon = {
-                    type: "Polygon",
-                    coordinates: combinedCoords
-                };
-                // Ensure right-hand rule is followed.
-                ensureRightHandRule(polygon);
-                // Add to the collection.
-                collection.geometries.push(polygon);
-                return true;
-            }
-        }
-        catch (e) {
-            // console.error("Failed to unkink polygon.", e);
-        }
-        return false;
-    };
-    const processGeometry = (geometry) => {
-        let added = false;
-        if (geometry.type == "Polygon") {
-            added = processCoordinates(geometry.coordinates);
-        }
-        else if (geometry.type == "MultiPolygon") {
-            for (let i = 0; i < geometry.coordinates.length; i++) {
-                added = processCoordinates(geometry.coordinates[i]) || added;
-            }
-        }
-        if (!added) {
-            // Adding original since we can't unkink it.
-            collection.geometries.push(geometry);
-        }
-    };
-    if (feature.geometry.type == "GeometryCollection") {
-        feature.geometry.geometries.forEach((geometry) => {
-            processGeometry(geometry);
-        });
-    }
-    else {
-        processGeometry(feature.geometry);
-    }
-    // Re-assign the geometry.
-    if (collection.geometries.length == 1) {
-        feature.geometry = collection.geometries[0];
-    }
-    else {
-        feature.geometry = collection;
-    }
-}
-/**
- * Runs through all found polygons and unions them using turf.
- * Failed unions are ignored and the original is kept.
- * @param feature
- */
-function unionFeature(feature) {
-    // Collection to add to because the result might be multiple from an unkink.
-    const collection = {
-        geometries: [],
-        type: "GeometryCollection"
-    };
-    // We'll turn each geometry into a feature and union them.
-    const tmpCollection = {
-        features: [],
-        type: "FeatureCollection"
-    };
-    if (feature.geometry.type == "GeometryCollection") {
-        feature.geometry.geometries.forEach((geometry) => {
-            if (geometry.type == "Polygon") {
-                tmpCollection.features.push({
-                    type: "Feature",
-                    geometry: geometry,
-                    properties: {}
-                });
-            }
-            else if (geometry.type == "MultiPolygon") {
-                for (let i = 0; i < geometry.coordinates.length; i++) {
-                    tmpCollection.features.push({
-                        type: "Feature",
-                        geometry: {
-                            type: "Polygon",
-                            coordinates: geometry.coordinates[i]
-                        },
-                        properties: {}
-                    });
-                }
-            }
-            // Only focusing on polygons.
-            else {
-                collection.geometries.push(geometry);
-            }
-        });
-    }
-    else if (feature.geometry.type == "Polygon") {
-        tmpCollection.features.push({
-            type: "Feature",
-            geometry: feature.geometry,
-            properties: {}
-        });
-    }
-    else if (feature.geometry.type == "MultiPolygon") {
-        for (let i = 0; i < feature.geometry.coordinates.length; i++) {
-            tmpCollection.features.push({
-                type: "Feature",
-                geometry: {
-                    type: "Polygon",
-                    coordinates: feature.geometry.coordinates[i]
-                },
-                properties: {}
-            });
-        }
-    }
-    // No polygons to union.
-    // Need at least 2 to union.
-    if (tmpCollection.features.length < 2) {
-        return;
-    }
-    // Now we'll union them.
-    try {
-        const union = turf.union(tmpCollection);
-        if (union.geometry.type == "Polygon") {
-            collection.geometries.push(union.geometry);
-        }
-        else if (union.geometry.type == "MultiPolygon") {
-            for (let i = 0; i < union.geometry.coordinates.length; i++) {
-                collection.geometries.push({
-                    type: "Polygon",
-                    coordinates: union.geometry.coordinates[i]
-                });
-            }
-        }
-        else {
-            // Returning early because the result is unexpected.
-            return;
-        }
-    }
-    catch (e) {
-        // console.error("Failed to union polygons.", e);
-        return;
-    }
-    // Re-assign the geometry.
-    if (collection.geometries.length == 1) {
-        feature.geometry = collection.geometries[0];
-    }
-    else {
-        feature.geometry = collection;
-    }
-}
-function ringArea(ring) {
-    let sum = 0;
-    for (let i = 0; i < ring.length; i++) {
-        const a = ring[i];
-        const b = ring[(i + 1) % ring.length];
-        sum += a[0] * b[1] - b[0] * a[1];
-    }
-    return sum / 2;
-}
-function isRingInsideRing(inner, outer) {
-    for (let i = 0; i < inner.length; i++) {
-        let inside = false;
-        for (let a = 0, b = outer.length - 1; a < outer.length; b = a++) {
-            if ((outer[a][1] > inner[i][1]) !== (outer[b][1] > inner[i][1])
-                && inner[i][0] < (outer[b][0] - outer[a][0]) * (inner[i][1] - outer[a][1]) / (outer[b][1] - outer[a][1]) + outer[a][0]) {
-                inside = !inside;
-            }
-        }
-        if (!inside) {
-            return false;
-        }
-    }
-    return true;
-}
-function dedupeCoordinates(inputCoords) {
-    return inputCoords.map(ring => {
-        if (ring.length < 2) {
-            return ring;
-        }
-        const dedupeCoords = [];
-        const uniqueCoords = new Set();
-        // Dedupe the points.
-        ring.forEach(coord => {
-            const key = coord.join(',');
-            if (!uniqueCoords.has(key)) {
-                uniqueCoords.add(key);
-                dedupeCoords.push(coord);
-            }
-        });
-        // Make sure the last point matches the first.
-        if (dedupeCoords.length > 1) {
-            if (dedupeCoords[0][0] != dedupeCoords[dedupeCoords.length - 1][0] ||
-                dedupeCoords[0][1] != dedupeCoords[dedupeCoords.length - 1][1]) {
-                dedupeCoords.push(dedupeCoords[0]);
-            }
-        }
-        return dedupeCoords;
-    });
-}
-function ensureRightHandRule(polygon) {
-    // Ensure the outer ring follows the right-hand rule
-    if (polygon.coordinates.length > 0) {
-        const outerRing = polygon.coordinates[0];
-        if (isClockwise(outerRing)) {
-            polygon.coordinates[0] = outerRing.reverse();
-        }
-    }
-    // Ensure any inner rings (holes) follow the right-hand rule
-    for (let i = 1; i < polygon.coordinates.length; i++) {
-        const innerRing = polygon.coordinates[i];
-        if (!isClockwise(innerRing)) {
-            polygon.coordinates[i] = innerRing.reverse();
-        }
-    }
-}
-function isClockwise(ring) {
-    let sum = 0;
-    for (let i = 0; i < ring.length - 1; i++) {
-        const p1 = ring[i];
-        const p2 = ring[i + 1];
-        sum += (p2[0] - p1[0]) * (p2[1] + p1[1]);
-    }
-    return sum > 0;
-}
-
-function OnNextCRender(viewer, callback) {
-    const removal = viewer.scene.postRender.addEventListener(() => {
-        removal();
-        callback();
-    });
-}
-function GetCValue(viewer, obj) {
-    if (obj === null || obj === void 0 ? void 0 : obj.getValue) {
-        let date = viewer.scene.lastRenderTime;
-        if (!date) {
-            date = viewer.clock.currentTime;
-        }
-        return obj.getValue(date);
-    }
-    return obj;
-}
-/*
- * Marks an EntityCollection as one this library created and fully controls (a menu item's own data source).
- */
-const OWNED_CCOLLECTION_KEY = "_bruceOwnedCollection";
-function MarkCCollectionOwned(collection) {
-    if (collection) {
-        collection[OWNED_CCOLLECTION_KEY] = true;
-    }
-}
-function IsCCollectionOwned(collection) {
-    return Boolean(collection && collection[OWNED_CCOLLECTION_KEY]);
-}
-/**
- * Runs a bulk collection mutation with every given collection's events suspended, so Cesium raises one
- * collectionChanged per collection for the whole pass instead of one per entity.
- *
- * Takes a set of collections rather than assuming `viewer.entities`, because managed visuals live in their menu
- * item's own data source: suspending the wrong collection silently does nothing.
- * @param collections Duplicates and empty entries are ignored.
- * @param run
- */
-function WithSuspendedCCollections(collections, run) {
-    const unique = [];
-    for (const collection of collections) {
-        if (collection && unique.indexOf(collection) === -1) {
-            unique.push(collection);
-        }
-    }
-    for (const collection of unique) {
-        collection.suspendEvents();
-    }
-    try {
-        return run();
-    }
-    finally {
-        for (const collection of unique) {
-            try {
-                collection.resumeEvents();
-            }
-            catch (e) {
-                console.error(e);
-            }
-        }
-    }
-}
-/**
- * Returns the collection a graphic belongs to, falling back to the viewer's own when it has never been added.
- * @param viewer
- * @param entity
- */
-function GetCEntityCollection(viewer, entity) {
-    const owner = entity === null || entity === void 0 ? void 0 : entity.entityCollection;
-    return owner ? owner : viewer === null || viewer === void 0 ? void 0 : viewer.entities;
-}
-/**
- * Returns whether a graphic is currently in the scene, looking in whichever collection owns it.
- * @param viewer
- * @param entity
- */
-function IsCEntityInScene(viewer, entity) {
-    const collection = GetCEntityCollection(viewer, entity);
-    return Boolean(collection && entity && collection.contains(entity));
-}
-/**
- * Removes a graphic from whichever collection owns it. Returns whether it removed anything.
- * @param viewer
- * @param entity
- */
-function RemoveCEntityFromScene(viewer, entity) {
-    var _a;
-    if (!entity) {
-        return false;
-    }
-    const collection = GetCEntityCollection(viewer, entity);
-    if (collection === null || collection === void 0 ? void 0 : collection.contains(entity)) {
-        return collection.remove(entity);
-    }
-    // A stale owner reference and the graphic ended up in the viewer's collection anyway.
-    if (collection !== (viewer === null || viewer === void 0 ? void 0 : viewer.entities) && ((_a = viewer === null || viewer === void 0 ? void 0 : viewer.entities) === null || _a === void 0 ? void 0 : _a.contains(entity))) {
-        return viewer.entities.remove(entity);
-    }
-    return false;
-}
-/**
- * Adds a graphic back into whichever collection owns it, or the viewer's if it has no owner yet.
- * @param viewer
- * @param entity
- */
-function AddCEntityToScene(viewer, entity, fallbackCollection) {
-    if (!entity) {
-        return false;
-    }
-    // An existing owner always wins, so a graphic is never migrated out from under whoever holds it.
-    const owner = entity.entityCollection;
-    const collection = owner ? owner : (fallbackCollection ? fallbackCollection : viewer === null || viewer === void 0 ? void 0 : viewer.entities);
-    if (!collection || collection.contains(entity)) {
-        return false;
-    }
-    collection.add(entity);
-    return true;
-}
-/**
- * Returns whether toggling `show` on these graphics is safe, rather than having to add/remove them from the
- * entity collection to hide them.
- *
- * Toggling show is far cheaper than re-adding the graphic to the viewer however a Cesium bug means we can't always use it.
- * See: https://github.com/CesiumGS/cesium/issues/9370
- * @param parts The graphic and any sibling graphics, eg. from EntityUtils.GatherEntity.
- */
-function CanToggleShowSafely(parts) {
-    if (!(parts === null || parts === void 0 ? void 0 : parts.length)) {
-        return false;
-    }
-    for (const part of parts) {
-        if (!(part instanceof Entity)) {
-            // Not an Entity, so not something whose `show` we can drive.
-            return false;
-        }
-        if (part.polyline && isTruthyCValue(part.polyline.clampToGround)) {
-            return false;
-        }
-        const materialGraphics = [part.polygon, part.corridor, part.ellipse, part.rectangle, part.wall, part.polylineVolume];
-        for (const graphic of materialGraphics) {
-            if (graphic && !isPlainColorMaterial(graphic.material)) {
-                return false;
-            }
-        }
-    }
-    return true;
-}
-/**
- * Returns whether a material is a plain colour, which is what keeps a graphic out of Cesium's per-material batches.
- * Anything unrecognised counts as not plain, so callers stay on the conservative side.
- * @param material
- */
-function isPlainColorMaterial(material) {
-    if (material == null) {
-        // Cesium defaults an absent material to white, a plain colour.
-        return true;
-    }
-    return material instanceof ColorMaterialProperty || material instanceof Color;
-}
-/**
- * Resolves a possibly-property boolean without needing a viewer clock, treating anything undeterminable as true
- * so callers stay on the conservative side.
- * @param value
- */
-function isTruthyCValue(value) {
-    if (value == null) {
-        return false;
-    }
-    if (typeof value.getValue === "function") {
-        if (value instanceof ConstantProperty) {
-            return Boolean(value.valueOf());
-        }
-        // A non-constant property could be true at any moment, so assume it is.
-        return true;
-    }
-    return Boolean(value);
-}
-/**
- * Returns if two resolved Cesium property values are equal, using the value's own equals() when it has one.
- * @param a
- * @param b
- */
-function AreCValuesEqual(a, b) {
-    if (a === b) {
-        return true;
-    }
-    // One side is null/undefined and the other isn't.
-    if (a == null || b == null) {
-        return false;
-    }
-    if (typeof a.equals === "function") {
-        return a.equals(b) === true;
-    }
-    return false;
-}
-/**
- * Wraps a value in a ConstantProperty and assigns it to a graphic's property, but only when the resolved
- * value actually differs. Returns whether it assigned.
- * @param params
- */
-function SetCPropIfChanged(params) {
-    const { viewer, graphic, property, value, compare } = params;
-    if (!graphic) {
-        return false;
-    }
-    const oldValue = GetCValue(viewer, graphic[property]);
-    const isEqual = compare ? compare(oldValue, value) : AreCValuesEqual(oldValue, value);
-    if (isEqual) {
-        return false;
-    }
-    graphic[property] = new ConstantProperty(value);
-    return true;
-}
-function ColorToCColor(color) {
-    return new Color(color.red ? color.red / 255 : 0, color.green ? color.green / 255 : 0, color.blue ? color.blue / 255 : 0, color.alpha);
-}
-/**
- * Removes duplicate points in a row and returns a new array.
- * Passed array is not mutated.
- * @param posses
- */
-function CullDuplicateCPosses(posses) {
-    const newPosses = [];
-    let lastPos = null;
-    for (let i = 0; i < posses.length; i++) {
-        const pos = posses[i];
-        // Avoiding 'Cesium.Cartesian3.equals' because passed data might be just a json blob in certain cases.
-        if (pos && (!lastPos || (pos.x != lastPos.x || pos.y != lastPos.y || pos.z != lastPos.z))) {
-            newPosses.push(pos);
-            lastPos = pos;
-        }
-    }
-    return newPosses;
-}
-/**
- * Returns if the given positions are equal.
- * @param a
- * @param b
- */
-function CompareCPosses(a, b) {
-    // Same reference.
-    if (a == b) {
-        return true;
-    }
-    // Different lengths or one is null.
-    if ((!a || !b) || (a.length != b.length)) {
-        return false;
-    }
-    for (let i = 0; i < a.length; i++) {
-        const posA = a[i];
-        const posB = b[i];
-        // Null detected.
-        if (!posA || !posB) {
-            return false;
-        }
-        // Position values don't match.
-        if (!Cartes.IsEqualCartes3(posA, posB)) {
-            return false;
-        }
-    }
-    return true;
-}
-/**
- * Returns if the given polygon hierarchies are equal.
- * @param a
- * @param b
- */
-function CompareCPolygonHierarchies(a, b) {
-    // Same reference.
-    if (a == b) {
-        return true;
-    }
-    // Different lengths or one is null.
-    if ((!a || !b) || (a.positions.length != b.positions.length)) {
-        return false;
-    }
-    // Positions don't match.
-    if (!CompareCPosses(a.positions, b.positions)) {
-        return false;
-    }
-    const holes = a.holes;
-    const bHoles = b.holes;
-    // Number of holes don't match.
-    if (holes.length != bHoles.length) {
-        return false;
-    }
-    for (let i = 0; i < holes.length; i++) {
-        // Hole positions don't match.
-        if (!CompareCPosses(holes[i].positions, bHoles[i].positions)) {
-            return false;
-        }
-    }
-    return true;
-}
-
-const CESIUM_INSPECTOR_KEY = "_nextspace_inspector";
-const CESIUM_TIMELINE_KEY = "_nextspace_timeline";
-const CESIUM_TIMELINE_LIVE_KEY = "_nextspace_timeline_live";
-const CESIUM_TIMELINE_LIVE_PADDING_KEY = "_nextspace_timeline_live_padding";
-const CESIUM_TIMELINE_INTERVAL_KEY = "_nextspace_timeline_interval";
-const CESIUM_MODEL_SPACE_KEY = "_nextspace_model_space";
-const DEFAULT_LIVE_PADDING_SECONDS = 30 * 60;
-var ViewUtils;
-(function (ViewUtils) {
-    function GatherLegacyMapTiles(params) {
-        const viewer = params.viewer;
-        const collection = viewer.imageryLayers;
-        const tiles = [];
-        for (let i = 0; i < collection.length; i++) {
-            const layer = collection.get(i);
-            if (layer._bName) {
-                tiles.push({
-                    alpha: layer.alpha,
-                    brightness: layer.brightness,
-                    contrast: layer.contrast,
-                    hue: layer.hue,
-                    saturation: layer.saturation,
-                    gamma: layer.gamma,
-                    title: layer._bName,
-                });
-            }
-        }
-        return {
-            imagery: tiles.reverse()
-        };
-    }
-    ViewUtils.GatherLegacyMapTiles = GatherLegacyMapTiles;
-    function GatherLegacyTerrainTile(params) {
-        const viewer = params.viewer;
-        const enabled = viewer.terrainProvider;
-        if (enabled === null || enabled === void 0 ? void 0 : enabled._bName) {
-            return {
-                terrain: enabled._bName
-            };
-        }
-        return {
-            terrain: "flatterrain"
-        };
-    }
-    ViewUtils.GatherLegacyTerrainTile = GatherLegacyTerrainTile;
-    function GatherMapTiles(params) {
-        const viewer = params.viewer;
-        const imagery = viewer.imageryLayers;
-        const tiles = [];
-        for (let i = 0; i < imagery.length; i++) {
-            const provider = imagery.get(i);
-            if (provider._bMeta) {
-                const idCombo = provider._bMeta.accountId + provider._bMeta.tilesetId;
-                if (!tiles.find(x => x.accountId + x.tilesetId === idCombo)) {
-                    tiles.push({
-                        accountId: provider._bMeta.accountId,
-                        tilesetId: provider._bMeta.tilesetId,
-                        alpha: provider.alpha,
-                        brightness: provider.brightness,
-                        contrast: provider.contrast,
-                        hue: provider.hue,
-                        saturation: provider.saturation,
-                        gamma: provider.gamma
-                    });
-                }
-            }
-        }
-        return {
-            imagery: tiles
-        };
-    }
-    ViewUtils.GatherMapTiles = GatherMapTiles;
-    function GatherTerrainTile(params) {
-        const viewer = params.viewer;
-        const provider = viewer.terrainProvider;
-        if (provider === null || provider === void 0 ? void 0 : provider._bMeta) {
-            return {
-                terrain: {
-                    accountId: provider._bMeta.accountId,
-                    tilesetId: provider._bMeta.tilesetId,
-                }
-            };
-        }
-        else if (provider instanceof EllipsoidTerrainProvider) {
-            return {
-                terrain: {
-                    tilesetId: ProjectViewTile.EDefaultTerrain.FlatTerrain,
-                    accountId: null
-                }
-            };
-        }
-        return null;
-    }
-    ViewUtils.GatherTerrainTile = GatherTerrainTile;
-    function SetTerrainWireframeStatus(params) {
-        if (!params.viewer[CESIUM_INSPECTOR_KEY]) {
-            const InspectorClass = CesiumInspector;
-            if (InspectorClass) {
-                const inspector = new InspectorClass(document.createElement("div"), params.viewer.scene);
-                inspector.container.style.display = "none";
-                params.viewer[CESIUM_INSPECTOR_KEY] = inspector;
-                params.viewer.scene.requestRender();
-            }
-        }
-        if (params.viewer[CESIUM_INSPECTOR_KEY]) {
-            params.viewer[CESIUM_INSPECTOR_KEY].viewModel.wireframe = params.status;
-        }
-    }
-    ViewUtils.SetTerrainWireframeStatus = SetTerrainWireframeStatus;
-    function GetTerrainWireframeStatus(params) {
-        var _a, _b;
-        if (!params.viewer[CESIUM_INSPECTOR_KEY]) {
-            return false;
-        }
-        return (_b = (_a = params.viewer[CESIUM_INSPECTOR_KEY]) === null || _a === void 0 ? void 0 : _a.viewModel) === null || _b === void 0 ? void 0 : _b.wireframe;
-    }
-    ViewUtils.GetTerrainWireframeStatus = GetTerrainWireframeStatus;
-    /**
-     * Changes between perspective and orthographic view.
-     * When Cesium stops being bad at picking positions in 2d mode we'll use the flat earth mode instead.
-     * @param params
-     */
-    function Set2dStatus(params) {
-        const { viewer, status: is2d, moveCamera } = params;
-        const curLens2d = viewer.camera.frustum instanceof OrthographicFrustum;
-        if (curLens2d && !is2d) {
-            OnNextCRender(viewer, () => {
-                viewer.camera.switchToPerspectiveFrustum();
-                viewer.scene.screenSpaceCameraController.enableTilt = true;
-            });
-            viewer.scene.requestRender();
-        }
-        else if (!curLens2d && is2d) {
-            OnNextCRender(viewer, () => {
-                viewer.camera.switchToOrthographicFrustum();
-                viewer.scene.screenSpaceCameraController.enableTilt = false;
-            });
-            if (moveCamera != false) {
-                try {
-                    // Face camera downwards to make it look 2d.
-                    // We want to try make it look at the center-point of the current view.
-                    // If center cannot be calculated then we'll simply raise the camera and face it downwards.
-                    const scene = viewer.scene;
-                    const windowPosition = new Cartesian2(scene.canvas.clientWidth / 2, scene.canvas.clientHeight / 2);
-                    const ray = viewer.camera.getPickRay(windowPosition);
-                    const intersection = scene.globe.pick(ray, scene);
-                    let center;
-                    if (defined(intersection)) {
-                        center = Cartographic.fromCartesian(intersection);
-                    }
-                    // Use current camera position if we can't calculate the center.
-                    else {
-                        center = Cartographic.fromCartesian(viewer.camera.position);
-                        center.height = 0;
-                    }
-                    center.height = viewer.camera.positionCartographic.height + 100;
-                    viewer.camera.setView({
-                        destination: Cartographic.toCartesian(center),
-                        orientation: {
-                            heading: 0.0,
-                            pitch: Math$1.toRadians(-90.0),
-                            roll: 0.0
-                        }
-                    });
-                }
-                catch (e) {
-                    console.error(e);
-                }
-            }
-            viewer.scene.requestRender();
-        }
-    }
-    ViewUtils.Set2dStatus = Set2dStatus;
-    function Get2dStatus(params) {
-        const { viewer } = params;
-        return viewer.camera.frustum instanceof OrthographicFrustum;
-    }
-    ViewUtils.Get2dStatus = Get2dStatus;
-    function SetLockedCameraStatus(params) {
-        const { viewer, status } = params;
-        const scene = viewer === null || viewer === void 0 ? void 0 : viewer.scene;
-        if (!scene) {
-            return;
-        }
-        if (status) {
-            scene.screenSpaceCameraController.enableInputs = false;
-            scene.screenSpaceCameraController.enableTranslate = false;
-            scene.screenSpaceCameraController.enableZoom = false;
-            scene.screenSpaceCameraController.enableRotate = false;
-            scene.screenSpaceCameraController.enableTilt = false;
-        }
-        else {
-            scene.screenSpaceCameraController.enableInputs = true;
-            scene.screenSpaceCameraController.enableTranslate = true;
-            scene.screenSpaceCameraController.enableZoom = true;
-            scene.screenSpaceCameraController.enableRotate = true;
-            if (!ViewUtils.Get2dStatus({ viewer })) {
-                scene.screenSpaceCameraController.enableTilt = true;
-            }
-        }
-        viewer.scene.requestRender();
-    }
-    ViewUtils.SetLockedCameraStatus = SetLockedCameraStatus;
-    function GetLockedCameraStatus(params) {
-        var _a;
-        const scene = (_a = params.viewer) === null || _a === void 0 ? void 0 : _a.scene;
-        if (!scene) {
-            return false;
-        }
-        return !scene.screenSpaceCameraController.enableTranslate;
-    }
-    ViewUtils.GetLockedCameraStatus = GetLockedCameraStatus;
-    /**
-     * Returns the current camera time and related settings.
-     * @param params
-     * @returns
-     */
-    function GetTimeDetails(params) {
-        const { viewer } = params;
-        const clock = viewer.clock;
-        return {
-            animationSpeed: clock.multiplier,
-            isAnimating: clock.shouldAnimate,
-            startTime: clock.startTime,
-            startTimeIso: clock.startTime.toString(),
-            currentTime: clock.currentTime,
-            currentTimeIso: clock.currentTime.toString(),
-            stopTime: clock.stopTime,
-            stopTimeIso: clock.stopTime.toString(),
-            areCesiumValues: clock[CESIUM_TIMELINE_KEY] != true,
-            isLive: clock[CESIUM_TIMELINE_LIVE_KEY] == true,
-            livePaddingSeconds: clock[CESIUM_TIMELINE_LIVE_PADDING_KEY] || DEFAULT_LIVE_PADDING_SECONDS
+                }
+            }
+            else if (geometry.LineString) {
+                count += Geometry$1.ParsePoints(geometry.LineString).length;
+            }
+            else if (geometry.Point) {
+                count += 1;
+            }
         };
+        traverse(geometry);
+        return count;
     }
-    ViewUtils.GetTimeDetails = GetTimeDetails;
+    SimplifyGeometry.CountPoints = CountPoints;
     /**
-     * Sets the Cesium clock values.
-     * If a value is not provided, then 'areCesiumValues' checked to see if the values are Cesium values.
-     * If they're currently Cesium set values then our defaults are used.
-     * @param params
+     * Simplifies input geometry.
+     * This will turn it into GeoJSON, run it through turf, then back to Bruce geometry.
+     * @param geometry
      */
-    function SetTimeDetails(params) {
-        let { viewer, animationSpeed, isAnimating, startTime, currentTime, stopTime, startTimeIso, stopTimeIso, currentTimeIso, isLive, livePaddingSeconds } = params;
-        const clock = viewer.clock;
-        if (startTime) {
-            clock.startTime = startTime;
+    function Simplify(entityId, geometry, tolerance) {
+        var _a;
+        if (!geometry || !isTurfAvailable() || !turf.simplify) {
+            return geometry;
         }
-        else if (startTimeIso) {
-            const startDate = JulianDate.fromIso8601(startTimeIso);
-            if (startDate) {
-                clock.startTime = startDate;
-            }
+        const original = geometry;
+        // Convert to geojson so that we can interact with turf.
+        const gFeature = Geometry$1.ToGeoJsonFeature({
+            geometry: geometry
+        });
+        // Unkink the geometry.
+        // This removes overlapping polygons before we start merging and simplifying.
+        // Commented out because it has crashes and doesn't handle holes.
+        untangleFeature(gFeature);
+        // Union the geometry.
+        // This merges overlapping polygons.
+        unionFeature(gFeature);
+        // Simplify the geometry.
+        if (tolerance > 0) {
+            gFeature.geometry = turf.simplify(gFeature.geometry, {
+                tolerance: tolerance,
+                highQuality: true,
+                mutate: true
+            });
         }
-        if (currentTime) {
-            clock.currentTime = currentTime;
+        // Converting back to Bruce geometry.
+        const simplified = (_a = Geometry$1.FromGeoJson({
+            geoJson: gFeature
+        })) === null || _a === void 0 ? void 0 : _a.geometry;
+        // A polygon we cannot vouch for is worse than an unsimplified one, so fall back instead of shipping it.
+        if (!simplified || !isSafeToRender(simplified)) {
+            return original;
         }
-        else if (currentTimeIso) {
-            const currentDate = JulianDate.fromIso8601(currentTimeIso);
-            if (currentDate) {
-                clock.currentTime = currentDate;
-            }
+        return simplified;
+    }
+    SimplifyGeometry.Simplify = Simplify;
+    /**
+     * Whether a simplified geometry still describes something a renderer can triangulate.
+     * @param geometry the simplification result.
+     * @returns false when any polygon has a collapsed ring, a hole outside its outer ring, or a hole
+     * wound the same way as its outer ring.
+     */
+    function IsSafeToRender(geometry) {
+        return isSafeToRender(geometry);
+    }
+    SimplifyGeometry.IsSafeToRender = IsSafeToRender;
+})(SimplifyGeometry || (SimplifyGeometry = {}));
+// A ring needs three distinct corners plus the closing repeat before it encloses any area.
+const MIN_RING_POSITIONS = 4;
+function isSafeToRender(geometry) {
+    let safe = true;
+    const check = (g) => {
+        if (!safe) {
+            return;
         }
-        if (stopTime) {
-            clock.stopTime = stopTime;
+        if (g === null || g === void 0 ? void 0 : g.MultiGeometry) {
+            g.MultiGeometry.forEach(check);
+            return;
         }
-        else if (stopTimeIso) {
-            const stopDate = JulianDate.fromIso8601(stopTimeIso);
-            if (stopDate) {
-                clock.stopTime = stopDate;
-            }
+        if (!(g === null || g === void 0 ? void 0 : g.Polygon) || g.Polygon.length === 0) {
+            return;
         }
-        clock.clockRange = ClockRange.LOOP_STOP;
-        const areCesiumValues = clock[CESIUM_TIMELINE_KEY] != true;
-        if (areCesiumValues) {
-            if (isNaN(animationSpeed) || animationSpeed == null) {
-                animationSpeed = 1;
+        let outer = null;
+        let outerIsClockwise = false;
+        for (let i = 0; i < g.Polygon.length; i++) {
+            const points = Geometry$1.ParsePoints(g.Polygon[i].LinearRing);
+            if (!points || points.length < MIN_RING_POSITIONS) {
+                safe = false;
+                return;
             }
-            if (isAnimating == null) {
-                isAnimating = false;
+            const clockwise = signedRingArea(points) < 0;
+            if (g.Polygon[i].Facing !== "in") {
+                outer = points;
+                outerIsClockwise = clockwise;
+                continue;
             }
-            if (isLive == null) {
-                isLive = false;
+            // A hole with no outer ring ahead of it cannot be subtracted from anything.
+            if (!outer) {
+                safe = false;
+                return;
             }
-            if (livePaddingSeconds == null) {
-                livePaddingSeconds = DEFAULT_LIVE_PADDING_SECONDS;
+            if (clockwise === outerIsClockwise) {
+                safe = false;
+                return;
+            }
+            for (let j = 0; j < points.length; j++) {
+                if (!isPointInRing(points[j], outer)) {
+                    safe = false;
+                    return;
+                }
             }
         }
-        if (!isNaN(animationSpeed) && animationSpeed != null) {
-            clock.multiplier = animationSpeed;
+    };
+    check(geometry);
+    return safe;
+}
+function signedRingArea(points) {
+    let sum = 0;
+    for (let i = 0; i < points.length; i++) {
+        const a = points[i];
+        const b = points[(i + 1) % points.length];
+        sum += a.longitude * b.latitude - b.longitude * a.latitude;
+    }
+    return sum / 2;
+}
+function isPointInRing(point, ring) {
+    let inside = false;
+    for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
+        const a = ring[i];
+        const b = ring[j];
+        if ((a.latitude > point.latitude) !== (b.latitude > point.latitude)
+            && point.longitude < (b.longitude - a.longitude) * (point.latitude - a.latitude) / (b.latitude - a.latitude) + a.longitude) {
+            inside = !inside;
         }
-        if (isAnimating != null) {
-            clock.shouldAnimate = isAnimating;
+    }
+    return inside;
+}
+/**
+ * Runs through all found polygons and runs unkink through turf on them.
+ * @param feature
+ */
+function untangleFeature(feature) {
+    // Collection to add to because the result might be multiple from an unkink.
+    const collection = {
+        geometries: [],
+        type: "GeometryCollection"
+    };
+    // Runs a dedupe and unkink on the coordinates.
+    // Returns if the coordinates were added to the collection.
+    const processCoordinates = (coords) => {
+        try {
+            // Dedupe the coordinates to avoid issues with unkink.
+            coords = dedupeCoordinates(coords);
+            const outer = [];
+            let inner = [];
+            // We'll unkink each ring separately as this is killing the holes when it is done as a whole.
+            // So we'll do it separate then recombine.
+            for (let i = 0; i < coords.length; i++) {
+                const ring = coords[i];
+                const unkink = turf.unkinkPolygon({
+                    type: "Polygon",
+                    coordinates: [ring]
+                });
+                if (unkink.type == "FeatureCollection") {
+                    let target = i == 0 ? outer : inner;
+                    for (let j = 0; j < unkink.features.length; j++) {
+                        const unkinked = unkink.features[j].geometry.coordinates;
+                        if (unkinked.length > 0) {
+                            target.push(unkinked[0]);
+                        }
+                    }
+                }
+                else {
+                    console.error("Unexpected unkink result.", unkink);
+                }
+            }
+            // Recreate the rings and reapply to the collection.
+            if (outer.length > 0) {
+                // Unkinking a self touching boundary splits it into pieces. Keeping whichever piece
+                // happened to come back first can discard most of the shape, so keep the biggest one.
+                let keep = outer[0];
+                if (outer.length > 1) {
+                    let best = Math.abs(ringArea(keep));
+                    for (let i = 1; i < outer.length; i++) {
+                        const area = Math.abs(ringArea(outer[i]));
+                        if (area > best) {
+                            best = area;
+                            keep = outer[i];
+                        }
+                    }
+                }
+                const combinedCoords = [keep];
+                for (let i = 0; i < inner.length; i++) {
+                    // A hole belonging to a piece that was just discarded is no longer inside anything,
+                    // and a hole crossing the boundary is what tears the fill.
+                    if (isRingInsideRing(inner[i], keep)) {
+                        combinedCoords.push(inner[i]);
+                    }
+                }
+                // Add the combined coordinates to the collection
+                const polygon = {
+                    type: "Polygon",
+                    coordinates: combinedCoords
+                };
+                // Ensure right-hand rule is followed.
+                ensureRightHandRule(polygon);
+                // Add to the collection.
+                collection.geometries.push(polygon);
+                return true;
+            }
         }
-        viewer.scene.requestRender();
-        clock[CESIUM_TIMELINE_KEY] = true;
-        if (livePaddingSeconds != null) {
-            clock[CESIUM_TIMELINE_LIVE_PADDING_KEY] = livePaddingSeconds || DEFAULT_LIVE_PADDING_SECONDS;
+        catch (e) {
+            // console.error("Failed to unkink polygon.", e);
         }
-        if (isLive != null) {
-            clock[CESIUM_TIMELINE_LIVE_KEY] = params.isLive == true;
+        return false;
+    };
+    const processGeometry = (geometry) => {
+        let added = false;
+        if (geometry.type == "Polygon") {
+            added = processCoordinates(geometry.coordinates);
         }
-        if (clock[CESIUM_TIMELINE_LIVE_KEY]) {
-            startLive(viewer);
+        else if (geometry.type == "MultiPolygon") {
+            for (let i = 0; i < geometry.coordinates.length; i++) {
+                added = processCoordinates(geometry.coordinates[i]) || added;
+            }
         }
-        else {
-            stopLive(viewer);
+        if (!added) {
+            // Adding original since we can't unkink it.
+            collection.geometries.push(geometry);
         }
+    };
+    if (feature.geometry.type == "GeometryCollection") {
+        feature.geometry.geometries.forEach((geometry) => {
+            processGeometry(geometry);
+        });
     }
-    ViewUtils.SetTimeDetails = SetTimeDetails;
-    function startLive(viewer) {
-        const doUpdate = () => {
-            if (!viewer || viewer.isDestroyed() || !viewer.scene) {
-                stopLive(viewer);
-                return;
+    else {
+        processGeometry(feature.geometry);
+    }
+    // Re-assign the geometry.
+    if (collection.geometries.length == 1) {
+        feature.geometry = collection.geometries[0];
+    }
+    else {
+        feature.geometry = collection;
+    }
+}
+/**
+ * Runs through all found polygons and unions them using turf.
+ * Failed unions are ignored and the original is kept.
+ * @param feature
+ */
+function unionFeature(feature) {
+    // Collection to add to because the result might be multiple from an unkink.
+    const collection = {
+        geometries: [],
+        type: "GeometryCollection"
+    };
+    // We'll turn each geometry into a feature and union them.
+    const tmpCollection = {
+        features: [],
+        type: "FeatureCollection"
+    };
+    if (feature.geometry.type == "GeometryCollection") {
+        feature.geometry.geometries.forEach((geometry) => {
+            if (geometry.type == "Polygon") {
+                tmpCollection.features.push({
+                    type: "Feature",
+                    geometry: geometry,
+                    properties: {}
+                });
             }
-            // Get the current settings.
-            const tDetails = GetTimeDetails({ viewer });
-            const clock = viewer.clock;
-            if (clock) {
-                clock.shouldAnimate = true;
-                clock.multiplier = 1;
-                clock.currentTime = JulianDate.now();
-                clock.startTime = JulianDate.addSeconds(clock.currentTime, -tDetails.livePaddingSeconds, new JulianDate());
-                clock.stopTime = JulianDate.addSeconds(clock.currentTime, tDetails.livePaddingSeconds, new JulianDate());
-                clock.clockRange = ClockRange.UNBOUNDED;
+            else if (geometry.type == "MultiPolygon") {
+                for (let i = 0; i < geometry.coordinates.length; i++) {
+                    tmpCollection.features.push({
+                        type: "Feature",
+                        geometry: {
+                            type: "Polygon",
+                            coordinates: geometry.coordinates[i]
+                        },
+                        properties: {}
+                    });
+                }
             }
-        };
-        if (viewer[CESIUM_TIMELINE_INTERVAL_KEY]) {
-            doUpdate();
-            return;
-        }
-        // We'll start an interval that occasionally updates the Cesium clock to stay in the desired settings.
-        // Since it moves live (1 second per second), we don't have to worry about the ranges being out of date quickly.
-        viewer[CESIUM_TIMELINE_INTERVAL_KEY] = setInterval(() => {
-            doUpdate();
-        }, 800);
-        viewer[CESIUM_TIMELINE_LIVE_KEY] = true;
-        // Initial update.
-        doUpdate();
+            // Only focusing on polygons.
+            else {
+                collection.geometries.push(geometry);
+            }
+        });
     }
-    function stopLive(viewer) {
-        if (!viewer) {
-            return;
-        }
-        let interval = viewer[CESIUM_TIMELINE_INTERVAL_KEY];
-        if (interval) {
-            clearInterval(interval);
-            viewer[CESIUM_TIMELINE_INTERVAL_KEY] = null;
+    else if (feature.geometry.type == "Polygon") {
+        tmpCollection.features.push({
+            type: "Feature",
+            geometry: feature.geometry,
+            properties: {}
+        });
+    }
+    else if (feature.geometry.type == "MultiPolygon") {
+        for (let i = 0; i < feature.geometry.coordinates.length; i++) {
+            tmpCollection.features.push({
+                type: "Feature",
+                geometry: {
+                    type: "Polygon",
+                    coordinates: feature.geometry.coordinates[i]
+                },
+                properties: {}
+            });
         }
-        viewer[CESIUM_TIMELINE_LIVE_KEY] = false;
     }
-    function SetGlobeDetails(params) {
-        let { viewer, hidden, baseColor } = params;
-        const scene = viewer === null || viewer === void 0 ? void 0 : viewer.scene;
-        if (!(scene === null || scene === void 0 ? void 0 : scene.globe)) {
-            return;
+    // No polygons to union.
+    // Need at least 2 to union.
+    if (tmpCollection.features.length < 2) {
+        return;
+    }
+    // Now we'll union them.
+    try {
+        const union = turf.union(tmpCollection);
+        if (union.geometry.type == "Polygon") {
+            collection.geometries.push(union.geometry);
         }
-        if (hidden == null) {
-            hidden = !scene.globe.show;
+        else if (union.geometry.type == "MultiPolygon") {
+            for (let i = 0; i < union.geometry.coordinates.length; i++) {
+                collection.geometries.push({
+                    type: "Polygon",
+                    coordinates: union.geometry.coordinates[i]
+                });
+            }
         }
         else {
-            scene.globe.show = !hidden;
-        }
-        if (baseColor == null) {
-            baseColor = scene.globe.baseColor;
+            // Returning early because the result is unexpected.
+            return;
         }
-        // When globe is off, we'll also hide the stars/moon.
-        // We also grab the globe color and apply it to the sky.
-        if (hidden && GetModelSpace(viewer)) {
-            scene.skyBox.show = false;
-            scene.skyAtmosphere.show = false;
-            scene.sun.show = false;
-            scene.moon.show = false;
-            scene.backgroundColor = baseColor.clone();
+    }
+    catch (e) {
+        // console.error("Failed to union polygons.", e);
+        return;
+    }
+    // Re-assign the geometry.
+    if (collection.geometries.length == 1) {
+        feature.geometry = collection.geometries[0];
+    }
+    else {
+        feature.geometry = collection;
+    }
+}
+function ringArea(ring) {
+    let sum = 0;
+    for (let i = 0; i < ring.length; i++) {
+        const a = ring[i];
+        const b = ring[(i + 1) % ring.length];
+        sum += a[0] * b[1] - b[0] * a[1];
+    }
+    return sum / 2;
+}
+function isRingInsideRing(inner, outer) {
+    for (let i = 0; i < inner.length; i++) {
+        let inside = false;
+        for (let a = 0, b = outer.length - 1; a < outer.length; b = a++) {
+            if ((outer[a][1] > inner[i][1]) !== (outer[b][1] > inner[i][1])
+                && inner[i][0] < (outer[b][0] - outer[a][0]) * (inner[i][1] - outer[a][1]) / (outer[b][1] - outer[a][1]) + outer[a][0]) {
+                inside = !inside;
+            }
         }
-        else {
-            scene.skyBox.show = true;
-            scene.skyAtmosphere.show = true;
-            scene.sun.show = true;
-            scene.moon.show = true;
-            scene.backgroundColor = Color.BLACK;
+        if (!inside) {
+            return false;
         }
-        scene.globe.baseColor = baseColor;
     }
-    ViewUtils.SetGlobeDetails = SetGlobeDetails;
-    function SetModelSpace(viewer, modelSpace) {
-        if (!viewer) {
-            return;
+    return true;
+}
+function dedupeCoordinates(inputCoords) {
+    return inputCoords.map(ring => {
+        if (ring.length < 2) {
+            return ring;
         }
-        if (viewer[CESIUM_MODEL_SPACE_KEY] === modelSpace) {
-            return;
+        const dedupeCoords = [];
+        const uniqueCoords = new Set();
+        // Dedupe the points.
+        ring.forEach(coord => {
+            const key = coord.join(',');
+            if (!uniqueCoords.has(key)) {
+                uniqueCoords.add(key);
+                dedupeCoords.push(coord);
+            }
+        });
+        // Make sure the last point matches the first.
+        if (dedupeCoords.length > 1) {
+            if (dedupeCoords[0][0] != dedupeCoords[dedupeCoords.length - 1][0] ||
+                dedupeCoords[0][1] != dedupeCoords[dedupeCoords.length - 1][1]) {
+                dedupeCoords.push(dedupeCoords[0]);
+            }
+        }
+        return dedupeCoords;
+    });
+}
+function ensureRightHandRule(polygon) {
+    // Ensure the outer ring follows the right-hand rule
+    if (polygon.coordinates.length > 0) {
+        const outerRing = polygon.coordinates[0];
+        if (isClockwise(outerRing)) {
+            polygon.coordinates[0] = outerRing.reverse();
         }
-        viewer[CESIUM_MODEL_SPACE_KEY] = modelSpace;
-        // Reload globe since we display it differently between the two modes.
-        SetGlobeDetails({ viewer });
     }
-    ViewUtils.SetModelSpace = SetModelSpace;
-    function GetModelSpace(viewer) {
-        if (!viewer) {
-            return false;
+    // Ensure any inner rings (holes) follow the right-hand rule
+    for (let i = 1; i < polygon.coordinates.length; i++) {
+        const innerRing = polygon.coordinates[i];
+        if (!isClockwise(innerRing)) {
+            polygon.coordinates[i] = innerRing.reverse();
         }
-        return Boolean(viewer[CESIUM_MODEL_SPACE_KEY]);
     }
-    ViewUtils.GetModelSpace = GetModelSpace;
-})(ViewUtils || (ViewUtils = {}));
+}
+function isClockwise(ring) {
+    let sum = 0;
+    for (let i = 0; i < ring.length - 1; i++) {
+        const p1 = ring[i];
+        const p2 = ring[i + 1];
+        sum += (p2[0] - p1[0]) * (p2[1] + p1[1]);
+    }
+    return sum > 0;
+}
 
 /*
  * Lets something decide WHEN a `show` flag is honoured, without owning WHAT it should be.
@@ -29042,6 +29067,7 @@ async function renderNavigator(iteration, params, bookmark, view, getters) {
         light.color = Color.fromCssColorString(lighting.color);
         light.intensity = EnsureNumber(lighting.intensity);
     }
+    ViewUtils.ApplyDefaultBrightness(viewer, EnsureNumber(lighting.brightnessShift, DEFAULT_BRIGHTNESS_SHIFT));
     let quality = bSettings === null || bSettings === void 0 ? void 0 : bSettings.quality;
     if (quality == null) {
         quality = (_x = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _x === void 0 ? void 0 : _x.quality;
@@ -35235,6 +35261,8 @@ var ViewerUtils;
                 viewer
             });
         }
+        // Newer cesium is much dimmer by default so we shift brightness a bit.
+        ViewUtils.ApplyDefaultBrightness(viewer);
         backgroundRendering(viewer);
         // Capturing the destroy call to destroy all widgets.
         const olDestroy = viewer.destroy;
@@ -43509,7 +43537,7 @@ var StyleUtils;
     StyleUtils.ApplyTypeStyle = ApplyTypeStyle;
 })(StyleUtils || (StyleUtils = {}));
 
-const VERSION = "7.1.6";
+const VERSION = "7.1.7";
 /**
  * Updates the environment instance used by bruce-cesium to one specified.
  * This can be used to ensure that the instance a parent is referencing is shared between bruce-cesium, bruce-models, and the parent app.
@@ -43526,5 +43554,5 @@ const getENVIRONMENT = () => {
     return ENVIRONMENT;
 };
 
-export { VERSION, setENVIRONMENT, getENVIRONMENT, CesiumAnimatedInOut, DisplacedSurfacePrimitive, CesiumAnimatedProperty, isStyleChanged, isOutlineChanged$1 as isOutlineChanged, StyleEffective, EntityRenderEngine, EntityRenderEngineModel3d, EntityRenderEnginePoint, EntityRenderEnginePolygon, EntityRenderEnginePolyline, MenuItemCreator, MenuItemManager, CesiumParabola, EntityLabel, LiveCursor, SharedGetters, DataSourceStaticKmlManager, DataLabRenderManager, EntitiesIdsRenderManager, EntitiesLoadedRenderManager, EntitiesRenderManager, EntityRenderManager, AssemblyRenderManager, GoogleSearchRenderManager, RelationsRenderManager, RenderManager, TilesetArbRenderManager, TilesetCadRenderManager, TilesetEntitiesRenderManager, TilesetGooglePhotosRenderManager, TilesetOsmRenderManager, TilesetPointcloudRenderManager, TileRenderEngine, createTileset, TilesetRenderEngine, ViewRenderEngine, VisualRegisterCuller, VisualsRegister, XGridsRenderEngine, CesiumEntityStyler, DrawingUtils, EntityUtils, MeasureUtils, StyleUtils, CESIUM_INSPECTOR_KEY, CESIUM_TIMELINE_KEY, CESIUM_TIMELINE_LIVE_KEY, CESIUM_TIMELINE_LIVE_PADDING_KEY, CESIUM_TIMELINE_INTERVAL_KEY, CESIUM_MODEL_SPACE_KEY, DEFAULT_LIVE_PADDING_SECONDS, ViewUtils, CesiumViewMonitor, ViewGroundArea, ViewerEventTracker, ViewerUtils, Draw3dPolygon, Draw3dPolyline, MeasureCreator, Walkthrough, WidgetControlViewBar, WidgetControlViewBarSearch, WidgetLeftPanelTab, WidgetLeftPanelTabBookmarks, WidgetLeftPanelTabDashboard, EMenuItemState, WidgetLeftPanelTabMenuItems, Widget, VIEWER_BOOKMARKS_WIDGET_KEY, WidgetBookmarks, WidgetBranding, WidgetCursorBar, WidgetEmbeddedInfoView, WidgetInfoView, VIEWER_LEFT_PANEL_WIDGET_KEY, VIEWER_LEFT_PANEL_CSS_VAR_LEFT, WidgetLeftPanel, WidgetNavCompass$$1 as WidgetNavCompass, VIEWER_VIEW_BAR_WIDGET_KEY, WidgetViewBar };
+export { VERSION, setENVIRONMENT, getENVIRONMENT, CesiumAnimatedInOut, DisplacedSurfacePrimitive, CesiumAnimatedProperty, isStyleChanged, isOutlineChanged$1 as isOutlineChanged, StyleEffective, EntityRenderEngine, EntityRenderEngineModel3d, EntityRenderEnginePoint, EntityRenderEnginePolygon, EntityRenderEnginePolyline, MenuItemCreator, MenuItemManager, CesiumParabola, EntityLabel, LiveCursor, SharedGetters, DataSourceStaticKmlManager, DataLabRenderManager, EntitiesIdsRenderManager, EntitiesLoadedRenderManager, EntitiesRenderManager, EntityRenderManager, AssemblyRenderManager, GoogleSearchRenderManager, RelationsRenderManager, RenderManager, TilesetArbRenderManager, TilesetCadRenderManager, TilesetEntitiesRenderManager, TilesetGooglePhotosRenderManager, TilesetOsmRenderManager, TilesetPointcloudRenderManager, TileRenderEngine, createTileset, TilesetRenderEngine, ViewRenderEngine, VisualRegisterCuller, VisualsRegister, XGridsRenderEngine, CesiumEntityStyler, DrawingUtils, EntityUtils, MeasureUtils, StyleUtils, CESIUM_INSPECTOR_KEY, CESIUM_TIMELINE_KEY, CESIUM_TIMELINE_LIVE_KEY, CESIUM_TIMELINE_LIVE_PADDING_KEY, CESIUM_TIMELINE_INTERVAL_KEY, CESIUM_MODEL_SPACE_KEY, DEFAULT_LIVE_PADDING_SECONDS, DEFAULT_BRIGHTNESS_SHIFT, ViewUtils, CesiumViewMonitor, ViewGroundArea, ViewerEventTracker, ViewerUtils, Draw3dPolygon, Draw3dPolyline, MeasureCreator, Walkthrough, WidgetControlViewBar, WidgetControlViewBarSearch, WidgetLeftPanelTab, WidgetLeftPanelTabBookmarks, WidgetLeftPanelTabDashboard, EMenuItemState, WidgetLeftPanelTabMenuItems, Widget, VIEWER_BOOKMARKS_WIDGET_KEY, WidgetBookmarks, WidgetBranding, WidgetCursorBar, WidgetEmbeddedInfoView, WidgetInfoView, VIEWER_LEFT_PANEL_WIDGET_KEY, VIEWER_LEFT_PANEL_CSS_VAR_LEFT, WidgetLeftPanel, WidgetNavCompass$$1 as WidgetNavCompass, VIEWER_VIEW_BAR_WIDGET_KEY, WidgetViewBar };
 //# sourceMappingURL=bruce-cesium.es5.js.map