bruce-cesium 7.1.6 → 7.1.7

package/dist/bruce-cesium.umd.js

@@ -2668,185 +2668,909 @@
         CesiumEntityStyler.Unhighlight = Unhighlight;
     })(exports.CesiumEntityStyler || (exports.CesiumEntityStyler = {}));
 
-    (function (Widget) {
-        class AWidget {
-            get WidgetId() {
-                return this.widgetId;
-            }
-            get Viewer() {
-                return this._viewer;
-            }
-            get Container() {
-                return this._container;
-            }
-            get Element() {
-                return this._element;
+    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;
             }
-            constructor(params) {
-                this.widgetId = BModels.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);
-                }
+            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);
             }
-            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;
-    })(exports.Widget || (exports.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;
     }
-
-    (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 Cesium.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 Cesium.ColorMaterialProperty || material instanceof Cesium.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 Cesium.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 Cesium.ConstantProperty(value);
+        return true;
+    }
+    function ColorToCColor(color) {
+        return new Cesium.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 (!BModels.Cartes.IsEqualCartes3(posA, posB)) {
+                return false;
             }
         }
-        WidgetControlViewBar.AControl = AControl;
-    })(exports.WidgetControlViewBar || (exports.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 exports.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 (Cesium.Fullscreen.enabled) {
-                if (Cesium.Fullscreen.fullscreen) {
-                    Cesium.Fullscreen.exitFullscreen();
-                }
-                else {
-                    Cesium.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 exports.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);
+    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;
+    (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,
+                    });
+                }
             }
-            if (this._results && this._results.parentElement) {
-                this._results.parentElement.removeChild(this._results);
+            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"
+            };
         }
-        Toggle() {
-            if (this.Disposed) {
-                return;
+        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
+                        });
+                    }
+                }
             }
-            super.Toggle();
-            this._enabled = !this._enabled;
-            if (this._enabled) {
-                this._display();
+            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 {
-                this._hide();
+            else if (provider instanceof Cesium.EllipsoidTerrainProvider) {
+                return {
+                    terrain: {
+                        tilesetId: BModels.ProjectViewTile.EDefaultTerrain.FlatTerrain,
+                        accountId: null
+                    }
+                };
             }
+            return null;
         }
-        _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;
+        ViewUtils.GatherTerrainTile = GatherTerrainTile;
+        function SetTerrainWireframeStatus(params) {
+            if (!params.viewer[CESIUM_INSPECTOR_KEY]) {
+                const InspectorClass = Cesium.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();
+                }
             }
-
-            .NextspaceSearchBar * {
-                box-sizing: border-box;
+            if (params.viewer[CESIUM_INSPECTOR_KEY]) {
+                params.viewer[CESIUM_INSPECTOR_KEY].viewModel.wireframe = params.status;
             }
-
-            .NextspaceSearchBar[is-opened="true"] .NextspaceSearchBarContent {
-                display: flex;
-                width: 260px;
+        }
+        ViewUtils.SetTerrainWireframeStatus = SetTerrainWireframeStatus;
+        function GetTerrainWireframeStatus(params) {
+            var _a, _b;
+            if (!params.viewer[CESIUM_INSPECTOR_KEY]) {
+                return false;
             }
-
-            .NextspaceSearchBarContent {
-                flex-grow: 0;
-                flex-shrink: 0;
+            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 Cesium.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 Cesium.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 (Cesium.defined(intersection)) {
+                            center = Cesium.Cartographic.fromCartesian(intersection);
+                        }
+                        // Use current camera position if we can't calculate the center.
+                        else {
+                            center = Cesium.Cartographic.fromCartesian(viewer.camera.position);
+                            center.height = 0;
+                        }
+                        center.height = viewer.camera.positionCartographic.height + 100;
+                        viewer.camera.setView({
+                            destination: Cesium.Cartographic.toCartesian(center),
+                            orientation: {
+                                heading: 0.0,
+                                pitch: Cesium.Math.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 Cesium.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 = Cesium.JulianDate.fromIso8601(startTimeIso);
+                if (startDate) {
+                    clock.startTime = startDate;
+                }
+            }
+            if (currentTime) {
+                clock.currentTime = currentTime;
+            }
+            else if (currentTimeIso) {
+                const currentDate = Cesium.JulianDate.fromIso8601(currentTimeIso);
+                if (currentDate) {
+                    clock.currentTime = currentDate;
+                }
+            }
+            if (stopTime) {
+                clock.stopTime = stopTime;
+            }
+            else if (stopTimeIso) {
+                const stopDate = Cesium.JulianDate.fromIso8601(stopTimeIso);
+                if (stopDate) {
+                    clock.stopTime = stopDate;
+                }
+            }
+            clock.clockRange = Cesium.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 = Cesium.JulianDate.now();
+                    clock.startTime = Cesium.JulianDate.addSeconds(clock.currentTime, -tDetails.livePaddingSeconds, new Cesium.JulianDate());
+                    clock.stopTime = Cesium.JulianDate.addSeconds(clock.currentTime, tDetails.livePaddingSeconds, new Cesium.JulianDate());
+                    clock.clockRange = Cesium.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 = Cesium.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;
+    })(exports.ViewUtils || (exports.ViewUtils = {}));
+
+    (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 = BModels.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;
+    })(exports.Widget || (exports.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];
+        }
+    }
+
+    (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;
+    })(exports.WidgetControlViewBar || (exports.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 exports.WidgetControlViewBar.AControl {
+        constructor(params) {
+            super(params);
+        }
+        Dispose() {
+            super.Dispose();
+        }
+        Toggle() {
+            if (this.Disposed) {
+                return;
+            }
+            super.Toggle();
+            // Toggle fullscreen.
+            this._enabled = false;
+            if (Cesium.Fullscreen.enabled) {
+                if (Cesium.Fullscreen.fullscreen) {
+                    Cesium.Fullscreen.exitFullscreen();
+                }
+                else {
+                    Cesium.Fullscreen.requestFullscreen(document.body);
+                    this._enabled = true;
+                }
+            }
+        }
+    }
+
+    class WidgetControlViewBarSearch extends exports.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;
+            }
+
+            .NextspaceSearchBarContent {
+                flex-grow: 0;
+                flex-shrink: 0;
                 overflow: hidden;
                 transition: .3s ease;
                 width: 0;
@@ -3553,1122 +4277,423 @@
                     for (let i = 0; i < geometry.Polygon.length; i++) {
                         const polygon = geometry.Polygon[i];
                         count += BModels.Geometry.ParsePoints(polygon.LinearRing).length;
-                    }
-                }
-                else if (geometry.LineString) {
-                    count += BModels.Geometry.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 = BModels.Geometry.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 = BModels.Geometry.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 = BModels.Geometry.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 Cesium.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 Cesium.ColorMaterialProperty || material instanceof Cesium.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 Cesium.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 Cesium.ConstantProperty(value);
-        return true;
-    }
-    function ColorToCColor(color) {
-        return new Cesium.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 (!BModels.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;
-    (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 Cesium.EllipsoidTerrainProvider) {
-                return {
-                    terrain: {
-                        tilesetId: BModels.ProjectViewTile.EDefaultTerrain.FlatTerrain,
-                        accountId: null
-                    }
-                };
-            }
-            return null;
-        }
-        ViewUtils.GatherTerrainTile = GatherTerrainTile;
-        function SetTerrainWireframeStatus(params) {
-            if (!params.viewer[CESIUM_INSPECTOR_KEY]) {
-                const InspectorClass = Cesium.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 Cesium.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 Cesium.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 (Cesium.defined(intersection)) {
-                            center = Cesium.Cartographic.fromCartesian(intersection);
-                        }
-                        // Use current camera position if we can't calculate the center.
-                        else {
-                            center = Cesium.Cartographic.fromCartesian(viewer.camera.position);
-                            center.height = 0;
-                        }
-                        center.height = viewer.camera.positionCartographic.height + 100;
-                        viewer.camera.setView({
-                            destination: Cesium.Cartographic.toCartesian(center),
-                            orientation: {
-                                heading: 0.0,
-                                pitch: Cesium.Math.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 Cesium.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 += BModels.Geometry.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 = Cesium.JulianDate.fromIso8601(startTimeIso);
-                if (startDate) {
-                    clock.startTime = startDate;
-                }
+            const original = geometry;
+            // Convert to geojson so that we can interact with turf.
+            const gFeature = BModels.Geometry.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 = BModels.Geometry.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 = Cesium.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 = Cesium.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 = Cesium.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 = BModels.Geometry.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 = Cesium.JulianDate.now();
-                    clock.startTime = Cesium.JulianDate.addSeconds(clock.currentTime, -tDetails.livePaddingSeconds, new Cesium.JulianDate());
-                    clock.stopTime = Cesium.JulianDate.addSeconds(clock.currentTime, tDetails.livePaddingSeconds, new Cesium.JulianDate());
-                    clock.clockRange = Cesium.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 = Cesium.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;
-    })(exports.ViewUtils || (exports.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.
@@ -28952,6 +28977,7 @@
             light.color = Cesium.Color.fromCssColorString(lighting.color);
             light.intensity = EnsureNumber(lighting.intensity);
         }
+        exports.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;
@@ -35137,6 +35163,8 @@
                     viewer
                 });
             }
+            // Newer cesium is much dimmer by default so we shift brightness a bit.
+            exports.ViewUtils.ApplyDefaultBrightness(viewer);
             backgroundRendering(viewer);
             // Capturing the destroy call to destroy all widgets.
             const olDestroy = viewer.destroy;
@@ -43376,7 +43404,7 @@ void main() {
         StyleUtils.ApplyTypeStyle = ApplyTypeStyle;
     })(exports.StyleUtils || (exports.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.
@@ -43407,6 +43435,7 @@ void main() {
     exports.CESIUM_TIMELINE_INTERVAL_KEY = CESIUM_TIMELINE_INTERVAL_KEY;
     exports.CESIUM_MODEL_SPACE_KEY = CESIUM_MODEL_SPACE_KEY;
     exports.DEFAULT_LIVE_PADDING_SECONDS = DEFAULT_LIVE_PADDING_SECONDS;
+    exports.DEFAULT_BRIGHTNESS_SHIFT = DEFAULT_BRIGHTNESS_SHIFT;
     exports.Draw3dPolygon = Draw3dPolygon;
     exports.Draw3dPolyline = Draw3dPolyline;
     exports.WidgetControlViewBarSearch = WidgetControlViewBarSearch;