bruce-cesium 5.9.7 → 5.9.8

package/dist/bruce-cesium.es5.js

@@ -1,6 +1,6 @@
-import { BruceEvent, Cartes, Entity as Entity$1, ProjectViewTile, Carto, Geometry, MathUtils, LRUCache, Api, Calculator, ClientFile, EntityTag, EntityType, ObjectUtils, Style, DelayQueue, EntityLod, Bounds, ZoomControl, EntityRelationType, ENVIRONMENT, EntityHistoricData, Tileset, EntityCoords, DataLab, EntitySource, MenuItem, EntityRelation, ProgramKey, ProjectView, ProjectViewBookmark, Camera, ProjectViewLegacyTile, EntityAttachment, EntityAttachmentType, EntityAttribute, AbstractApi, Session } from 'bruce-models';
+import { BruceEvent, Cartes, Entity as Entity$1, ProjectViewTile, Carto, Geometry, MathUtils, LRUCache, Api, Calculator, ClientFile, EntityTag, EntityType, ObjectUtils, Style, DelayQueue, EntityLod, Bounds, ZoomControl, EntityRelationType, ENVIRONMENT, EntityHistoricData, Tileset, EntityCoords, DataLab, EntitySource, MenuItem, EntityRelation, ProgramKey, ProjectView, ProjectViewBookmark, ProjectViewLegacyTile, Camera, Session, EntityAttachment, EntityAttachmentType, EntityAttribute, AbstractApi } from 'bruce-models';
 import * as Cesium from 'cesium';
-import { Cartographic, Cartesian2, Math as Math$1, Cartesian3, CallbackProperty, Color, HeightReference, Rectangle, JulianDate, Entity, DistanceDisplayCondition, ClassificationType, ArcType, CornerType, ShadowMode, ConstantProperty, ConstantPositionProperty, HorizontalOrigin, VerticalOrigin, ColorBlendMode, HeadingPitchRoll, Transforms, Model, PolygonHierarchy, PolylineGraphics, ColorMaterialProperty, Primitive, Cesium3DTileFeature, SceneMode, GeoJsonDataSource, Cesium3DTileStyle, HeadingPitchRange, Cesium3DTileColorBlendMode, Ion, KmlDataSource, Quaternion, Matrix3, Matrix4, OrthographicFrustum, EasingFunction, NearFarScalar, SceneTransforms, Cesium3DTileset, IonResource, EllipsoidTerrainProvider, CesiumInspector, defined, ClockRange, EllipsoidGeodesic, sampleTerrainMostDetailed, PolygonPipeline, IonImageryProvider, createWorldImagery, createWorldImageryAsync, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, UrlTemplateImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, TileMapServiceImageryProvider, CesiumTerrainProvider, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics, PolylineDashMaterialProperty, ScreenSpaceEventHandler, ScreenSpaceEventType, BoundingSphere, GeometryInstance, CzmlDataSource, Intersect, Fullscreen } from 'cesium';
+import { Cartographic, Cartesian2, Math as Math$1, Cartesian3, CallbackProperty, Color, HeightReference, Rectangle, Entity, DistanceDisplayCondition, ClassificationType, ArcType, CornerType, ShadowMode, ConstantProperty, ConstantPositionProperty, JulianDate, HorizontalOrigin, VerticalOrigin, PolygonHierarchy, PolylineGraphics, ColorMaterialProperty, ColorBlendMode, HeadingPitchRoll, Transforms, Model, Primitive, Cesium3DTileFeature, SceneMode, GeoJsonDataSource, HeadingPitchRange, Ion, Cesium3DTileStyle, Cesium3DTileColorBlendMode, KmlDataSource, Quaternion, Matrix3, Matrix4, SceneTransforms, EllipsoidTerrainProvider, CesiumInspector, OrthographicFrustum, defined, ClockRange, EllipsoidGeodesic, sampleTerrainMostDetailed, Cesium3DTileset, PolygonPipeline, IonResource, IonImageryProvider, createWorldImagery, createWorldImageryAsync, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, UrlTemplateImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, TileMapServiceImageryProvider, CesiumTerrainProvider, EasingFunction, NearFarScalar, ScreenSpaceEventHandler, ScreenSpaceEventType, BoundingSphere, GeometryInstance, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics, PolylineDashMaterialProperty, CzmlDataSource, Intersect, Fullscreen } from 'cesium';
 
 const TIME_LAG = 300;
 const POSITION_CHECK_TIMER = 950;
@@ -1144,19 +1144,18 @@ var CesiumAnimatedProperty;
      */
     class AnimatePositionSeries {
         constructor(params) {
-            // Animation state.
-            this.currentAnimatedPos = null;
-            this.actualTargetPos = null;
-            this.animationStartPos = null;
-            this.animationStartTime = null;
-            this.animationDuration = 350;
-            // Cached data for performance.
+            this.currentPos = null;
+            this.currentVelocity = new Cartesian3(0, 0, 0);
+            this.smoothingFactor = 0.5;
+            this.positionHistory = [];
+            this.maxHistorySize = 10;
+            this.averageSpeed = 0;
+            this.averageTimeInterval = 0;
+            this.lastUpdateTime = null;
             this.lastDesiredPosIndex = -1;
             this.lastDesiredNextIndex = -1;
-            // Series data for rendering path
             this.lastCalcSeriesPos3d = [];
             this.lastCalcSeriesTime = null;
-            // Orientation cache.
             this.lastCalcOrient = null;
             this.lastCalcOrientTime = null;
             this.viewer = params.viewer;
@@ -1165,25 +1164,23 @@ var CesiumAnimatedProperty;
             this.roll = params.roll || 0;
             this.processHeadings();
             this.sortPositions();
-            // Initialize animation from starting position if provided.
-            if (params.animateFromPos3d) {
-                this.animationStartPos = params.animateFromPos3d;
-                const currentTime = Date.now();
-                const providedTime = params.animateFromPos3dTimeStart || 0;
-                // Check if the provided timestamp is stale.
-                if (!providedTime || (currentTime - providedTime) >= this.animationDuration) {
-                    this.animationStartTime = currentTime;
-                }
-                else {
-                    this.animationStartTime = providedTime;
-                }
-            }
         }
         AddPosition(pos) {
             if (!pos || !pos.pos3d || !pos.dateTime) {
                 console.warn("Invalid position provided to AnimatePositionSeries.");
                 return;
             }
+            const now = Date.now();
+            const posTime = pos.dateTime.getTime();
+            this.positionHistory.push({
+                pos: pos.pos3d.clone(),
+                time: posTime,
+                realTime: now
+            });
+            if (this.positionHistory.length > this.maxHistorySize) {
+                this.positionHistory.shift();
+            }
+            this.analyzeMovementPatterns();
             this.positions.push(pos);
             this.processHeadings();
             this.sortPositions();
@@ -1194,12 +1191,70 @@ var CesiumAnimatedProperty;
             this.roll = roll;
             this.invalidateCache();
         }
-        GetAnimateFromDateTime() {
-            return this.animationStartTime;
-        }
         GetPositions() {
             return this.positions;
         }
+        analyzeMovementPatterns() {
+            if (this.positionHistory.length < 2) {
+                return;
+            }
+            let totalDistance = 0;
+            let totalTimeSpan = 0;
+            let totalRealTimeSpan = 0;
+            let validSegments = 0;
+            for (let i = 1; i < this.positionHistory.length; i++) {
+                const prev = this.positionHistory[i - 1];
+                const curr = this.positionHistory[i];
+                const distance = Cartesian3.distance(prev.pos, curr.pos);
+                const timeSpan = Math.abs(curr.time - prev.time) / 1000.0;
+                const realTimeSpan = Math.abs(curr.realTime - prev.realTime) / 1000.0;
+                if (distance > 0.1 && timeSpan > 0.01) {
+                    totalDistance += distance;
+                    totalTimeSpan += timeSpan;
+                    totalRealTimeSpan += realTimeSpan;
+                    validSegments++;
+                }
+            }
+            if (validSegments > 0) {
+                this.averageSpeed = totalDistance / totalTimeSpan;
+                this.averageTimeInterval = totalRealTimeSpan / validSegments;
+                this.averageSpeed = Math.max(0.1, Math.min(this.averageSpeed, 1000));
+                this.averageTimeInterval = Math.max(0.01, Math.min(this.averageTimeInterval, 10));
+            }
+        }
+        calculateExpectedPosition(viewerTimeMs) {
+            const desired = this.calculateDesiredPosition(viewerTimeMs);
+            if (!desired.position) {
+                return { position: null, timeDelta: 0 };
+            }
+            let timeDelta = 0;
+            if (this.positionHistory.length >= 2) {
+                // Calculate how far behind we are based on viewer time vs real time.
+                const now = Date.now();
+                const timeDiffFromNow = (viewerTimeMs - now) / 1000.0;
+                // Negative means we're behind, positive means ahead.
+                timeDelta = timeDiffFromNow;
+            }
+            return { position: desired.position, timeDelta };
+        }
+        calculateAutonomousSpeed(distanceToTarget, timeDelta) {
+            let baseSpeed = this.averageSpeed || 50;
+            let speedMultiplier = 1.0;
+            // Calculate speed multiplier based on distance and time lag.
+            if (distanceToTarget > 50) {
+                speedMultiplier *= Math.min(100.0, distanceToTarget / 10.0);
+            }
+            else if (distanceToTarget > 10) {
+                const distanceMultiplier = Math.min(20.0, 1.0 + (distanceToTarget / 5.0));
+                speedMultiplier *= distanceMultiplier;
+            }
+            else if (Math.abs(timeDelta) > 0.1) {
+                const timeLagMultiplier = Math.max(0.1, 1.0 - (timeDelta * 5.0));
+                speedMultiplier *= Math.min(50.0, timeLagMultiplier);
+            }
+            // Minimum 10% speed.
+            return Math.max(baseSpeed * 0.1, baseSpeed * speedMultiplier);
+        }
         sortPositions() {
             if (this.positions.length > 0) {
                 this.positions.sort((a, b) => a.dateTime.getTime() - b.dateTime.getTime());
@@ -1209,10 +1264,6 @@ var CesiumAnimatedProperty;
             this.lastCalcSeriesTime = null;
             this.lastCalcOrientTime = null;
         }
-        /**
-         * Pre-process headings in the series.
-         * If all are null or 0, then we assume all are null.
-         */
         processHeadings() {
             if (!this.positions || this.positions.length === 0) {
                 return;
@@ -1234,15 +1285,10 @@ var CesiumAnimatedProperty;
         easeInOutQuad(t) {
             return t < 0.5 ? 2 * t * t : 1 - Math.pow(-2 * t + 2, 2) / 2;
         }
-        /**
-         * Calculate the desired position based on current time without any animation smoothing.
-         */
         calculateDesiredPosition(timeMs) {
-            // No positions available.
             if (!this.positions || this.positions.length === 0) {
                 return { position: null, lastIndex: -1, nextIndex: -1 };
             }
-            // Only one position..
             if (this.positions.length === 1) {
                 return {
                     position: this.positions[0].pos3d || null,
@@ -1250,7 +1296,6 @@ var CesiumAnimatedProperty;
                     nextIndex: 0
                 };
             }
-            // Before first position - use first two positions for orientation.
             if (timeMs <= this.positions[0].dateTime.getTime()) {
                 return {
                     position: this.positions[0].pos3d || null,
@@ -1258,7 +1303,6 @@ var CesiumAnimatedProperty;
                     nextIndex: Math.min(1, this.positions.length - 1)
                 };
             }
-            // After last position - use last two positions for orientation.
             const lastIdx = this.positions.length - 1;
             if (timeMs >= this.positions[lastIdx].dateTime.getTime()) {
                 return {
@@ -1267,12 +1311,10 @@ var CesiumAnimatedProperty;
                     nextIndex: lastIdx
                 };
             }
-            // Find positions to interpolate between.
             for (let i = 0; i < this.positions.length - 1; i++) {
                 const current = this.positions[i];
                 const next = this.positions[i + 1];
                 if (timeMs >= current.dateTime.getTime() && timeMs < next.dateTime.getTime()) {
-                    // Exact match on current position - still use current and next for orientation.
                     if (timeMs === current.dateTime.getTime()) {
                         return {
                             position: current.pos3d || null,
@@ -1280,7 +1322,6 @@ var CesiumAnimatedProperty;
                             nextIndex: i + 1
                         };
                     }
-                    // Interpolate between current and next.
                     if (!current.pos3d || !next.pos3d) {
                         return {
                             position: current.pos3d || next.pos3d || null,
@@ -1307,16 +1348,12 @@ var CesiumAnimatedProperty;
                     }
                 }
             }
-            // Fallback to last position with previous position for orientation.
             return {
                 position: this.positions[lastIdx].pos3d || null,
                 lastIndex: Math.max(0, lastIdx - 1),
                 nextIndex: lastIdx
             };
         }
-        /**
-         * Main method to get the current position based on time.
-         */
         GetValue() {
             let viewerTime = this.viewer.scene.lastRenderTime;
             if (!viewerTime) {
@@ -1324,88 +1361,46 @@ var CesiumAnimatedProperty;
             }
             const viewerTimeMs = JulianDate.toDate(viewerTime).getTime();
             const currentRealTimeMs = Date.now();
-            // Calculate the desired position based on time.
-            const desired = this.calculateDesiredPosition(viewerTimeMs);
-            if (!desired.position) {
-                this.currentAnimatedPos = null;
-                this.actualTargetPos = null;
+            const expected = this.calculateExpectedPosition(viewerTimeMs);
+            if (!expected.position) {
+                this.currentPos = null;
+                this.currentVelocity = new Cartesian3(0, 0, 0);
                 return new Cartesian3();
             }
+            const desired = this.calculateDesiredPosition(viewerTimeMs);
             this.lastDesiredPosIndex = desired.lastIndex;
             this.lastDesiredNextIndex = desired.nextIndex;
-            // Determine the desired position without interpolation.
-            let discreteTarget;
-            if (desired.lastIndex === desired.nextIndex) {
-                discreteTarget = this.positions[desired.lastIndex].pos3d;
-            }
-            // Use the next position as the target.
-            else {
-                discreteTarget = this.positions[desired.nextIndex].pos3d;
-            }
-            // Check if we have a new actual target
-            const actualTargetChanged = !this.actualTargetPos || !Cartesian3.equals(this.actualTargetPos, discreteTarget);
-            // First time or no previous position - start here.
-            if (!this.currentAnimatedPos) {
-                if (this.animationStartPos) {
-                    this.actualTargetPos = discreteTarget;
-                    const progress = this.getAnimationProgress(currentRealTimeMs, this.animationStartTime);
-                    // Animation from start position complete.
-                    if (progress >= 1.0) {
-                        this.currentAnimatedPos = desired.position;
-                        this.animationStartPos = null;
-                        this.animationStartTime = null;
-                        return desired.position;
-                    }
-                    // Still animating from initial position.
-                    else {
-                        const easedProgress = this.easeInOutQuad(progress);
-                        this.currentAnimatedPos = Cartesian3.lerp(this.animationStartPos, desired.position, easedProgress, new Cartesian3());
-                        return this.currentAnimatedPos;
-                    }
-                }
-                // No initial animation needed.
-                else {
-                    this.currentAnimatedPos = desired.position;
-                    this.actualTargetPos = discreteTarget;
-                    return desired.position;
-                }
-            }
-            // Target changed.
-            if (actualTargetChanged) {
-                this.animationStartPos = this.currentAnimatedPos;
-                this.animationStartTime = currentRealTimeMs;
-                this.actualTargetPos = discreteTarget;
-            }
-            // Continue or start animation to target if we have an active animation.
-            if (this.animationStartPos && this.animationStartTime) {
-                const progress = this.getAnimationProgress(currentRealTimeMs, this.animationStartTime);
-                // Animation complete.
-                if (progress >= 1.0) {
-                    this.currentAnimatedPos = desired.position;
-                    this.animationStartPos = null;
-                    this.animationStartTime = null;
-                    return desired.position;
-                }
-                // Continue animation to interpolated position.
-                else {
-                    const easedProgress = this.easeInOutQuad(progress);
-                    this.currentAnimatedPos = Cartesian3.lerp(this.animationStartPos, desired.position, easedProgress, new Cartesian3());
-                    return this.currentAnimatedPos;
-                }
-            }
-            // No active animation - follow interpolated path directly.
-            this.currentAnimatedPos = desired.position;
-            return desired.position;
+            if (!this.currentPos) {
+                this.currentPos = expected.position.clone();
+                this.currentVelocity = new Cartesian3(0, 0, 0);
+                this.lastUpdateTime = currentRealTimeMs;
+                return this.currentPos;
+            }
+            const deltaTime = this.lastUpdateTime ? (currentRealTimeMs - this.lastUpdateTime) / 1000.0 : 0.016;
+            this.lastUpdateTime = currentRealTimeMs;
+            const clampedDeltaTime = Math.min(deltaTime, 0.1);
+            const targetDistance = Cartesian3.distance(this.currentPos, expected.position);
+            if (targetDistance < 0.5) {
+                this.currentPos = expected.position.clone();
+                this.currentVelocity = new Cartesian3(0, 0, 0);
+                return this.currentPos;
+            }
+            // Check if we're really far behind and need to teleport.
+            if (targetDistance > 500) {
+                this.currentPos = expected.position.clone();
+                this.currentVelocity = new Cartesian3(0, 0, 0);
+                return this.currentPos;
+            }
+            const direction = Cartesian3.subtract(expected.position, this.currentPos, new Cartesian3());
+            Cartesian3.normalize(direction, direction);
+            const targetSpeed = this.calculateAutonomousSpeed(targetDistance, expected.timeDelta);
+            const targetVelocity = Cartesian3.multiplyByScalar(direction, targetSpeed, new Cartesian3());
+            this.currentVelocity = Cartesian3.lerp(this.currentVelocity, targetVelocity, this.smoothingFactor, new Cartesian3());
+            const velocityDelta = Cartesian3.multiplyByScalar(this.currentVelocity, clampedDeltaTime, new Cartesian3());
+            this.currentPos = Cartesian3.add(this.currentPos, velocityDelta, new Cartesian3());
+            return this.currentPos;
         }
-        getAnimationProgress(currentTime, startTime) {
-            const elapsed = currentTime - startTime;
-            return Math.min(elapsed / this.animationDuration, 1.0);
-        }
-        /**
-         * Returns a series of positions to use for rendering the path.
-         */
         GetSeries() {
-            // Update at 30 fps.
             let doUpdate = this.lastCalcSeriesTime == null;
             if (!doUpdate && this.lastCalcSeriesTime && (new Date().getTime() - this.lastCalcSeriesTime) > 1000 / 30) {
                 doUpdate = true;
@@ -1413,33 +1408,27 @@ var CesiumAnimatedProperty;
             if (!doUpdate) {
                 return this.lastCalcSeriesPos3d;
             }
-            // Ensure position indices are up-to-date.
             this.GetValue();
             let now = this.viewer.scene.lastRenderTime;
             if (!now) {
                 now = this.viewer.clock.currentTime;
             }
             const nowDate = JulianDate.toDate(now);
-            // Get total duration.
             if (!this.positions || this.positions.length < 2) {
                 this.lastCalcSeriesTime = nowDate.getTime();
                 this.lastCalcSeriesPos3d = [];
                 return [];
             }
             const totalDuration = this.positions[this.positions.length - 1].dateTime.getTime() - this.positions[0].dateTime.getTime();
-            // Percentage of the polyline to be visible before and after each point.
-            const visibilityPercentage = 0.05; // 5%
+            const visibilityPercentage = 0.05;
             const visibilityDuration = totalDuration * visibilityPercentage;
-            // Gather positions that fall within the visibility duration.
             const newPosses = [];
             for (let i = 0; i < this.positions.length; i++) {
                 const pos = this.positions[i];
                 if (!pos.pos3d) {
                     continue;
                 }
-                let add = nowDate >= new Date(pos.dateTime.getTime() - visibilityDuration / 2) &&
-                    nowDate <= new Date(pos.dateTime.getTime() + visibilityDuration / 2);
-                // Also include the segment we're currently traversing.
+                let add = nowDate >= new Date(pos.dateTime.getTime() - visibilityDuration / 2) && nowDate <= new Date(pos.dateTime.getTime() + visibilityDuration / 2);
                 if (!add && this.lastDesiredPosIndex > -1 && this.lastDesiredNextIndex > -1) {
                     add = i >= this.lastDesiredPosIndex && i <= this.lastDesiredNextIndex;
                 }
@@ -1451,11 +1440,7 @@ var CesiumAnimatedProperty;
             this.lastCalcSeriesPos3d = newPosses;
             return newPosses;
         }
-        /**
-         * Returns the orientation based on current position and heading.
-         */
         GetOrient() {
-            // Update at 30 fps.
             let doUpdate = this.lastCalcOrientTime == null;
             if (!doUpdate && this.lastCalcOrientTime && (new Date().getTime() - this.lastCalcOrientTime) > 1000 / 30) {
                 doUpdate = true;
@@ -1463,26 +1448,34 @@ var CesiumAnimatedProperty;
             if (!doUpdate && this.lastCalcOrient) {
                 return this.lastCalcOrient;
             }
-            // Default quaternion to return if we can't calculate.
             const defaultQuaternion = new Quaternion();
             if (!this.positions || this.positions.length === 0) {
                 return defaultQuaternion;
             }
-            // Ensure position is up-to-date.
             const currentPosition = this.GetValue();
             if (!currentPosition) {
                 return defaultQuaternion;
             }
-            let now = this.viewer.scene.lastRenderTime;
-            if (!now) {
-                now = this.viewer.clock.currentTime;
-            }
-            const nowTime = JulianDate.toDate(now).getTime();
             try {
-                // Get current position indices.
+                const velocityMagnitude = Cartesian3.magnitude(this.currentVelocity);
+                const minimumSpeedForVelocityOrientation = Math.max(1.0, this.averageSpeed * 0.1);
+                if (velocityMagnitude > minimumSpeedForVelocityOrientation) {
+                    const normalizedVelocity = Cartesian3.normalize(this.currentVelocity, new Cartesian3());
+                    const rotationMatrix = Transforms.rotationMatrixFromPositionVelocity(currentPosition, normalizedVelocity);
+                    const quaternion = Quaternion.fromRotationMatrix(rotationMatrix);
+                    const hpr = new HeadingPitchRoll(0, Math$1.toRadians(this.pitch), Math$1.toRadians(this.roll));
+                    const pitchRollQuaternion = Quaternion.fromHeadingPitchRoll(hpr);
+                    this.lastCalcOrient = Quaternion.multiply(quaternion, pitchRollQuaternion, new Quaternion());
+                    this.lastCalcOrientTime = Date.now();
+                    return this.lastCalcOrient;
+                }
+                let now = this.viewer.scene.lastRenderTime;
+                if (!now) {
+                    now = this.viewer.clock.currentTime;
+                }
+                const nowTime = JulianDate.toDate(now).getTime();
                 const lastIndex = this.lastDesiredPosIndex;
                 const nextIndex = this.lastDesiredNextIndex;
-                // Invalid indices.
                 if (lastIndex < 0 || nextIndex < 0 ||
                     lastIndex >= this.positions.length || nextIndex >= this.positions.length) {
                     return this.lastCalcOrient || defaultQuaternion;
@@ -1492,74 +1485,53 @@ var CesiumAnimatedProperty;
                 if (!lastPos || !nextPos) {
                     return this.lastCalcOrient || defaultQuaternion;
                 }
-                // Single position case - use its heading if available.
                 if (lastIndex === nextIndex) {
                     if (lastPos.heading !== null) {
                         this.lastCalcOrient = Transforms.headingPitchRollQuaternion(currentPosition, new HeadingPitchRoll(Math$1.toRadians(lastPos.heading), Math$1.toRadians(this.pitch), Math$1.toRadians(this.roll)));
                         this.lastCalcOrientTime = Date.now();
                         return this.lastCalcOrient;
                     }
-                    // No heading data and single position, return previous or default.
                     return this.lastCalcOrient || defaultQuaternion;
                 }
-                // Two different positions - we can calculate orientation.
-                // Use explicit heading values if available.
                 if (lastPos.heading !== null && nextPos.heading !== null) {
-                    // Calculate interpolated heading.
                     let deltaHeading = nextPos.heading - lastPos.heading;
-                    // Handle wrap-around between 359° and 0°.
                     if (deltaHeading > 180) {
                         deltaHeading -= 360;
                     }
                     else if (deltaHeading < -180) {
                         deltaHeading += 360;
                     }
-                    // Calculate interpolation factor.
                     let factor = 0;
                     if (lastPos.dateTime.getTime() !== nextPos.dateTime.getTime()) {
-                        factor = (nowTime - lastPos.dateTime.getTime()) /
-                            (nextPos.dateTime.getTime() - lastPos.dateTime.getTime());
+                        factor = (nowTime - lastPos.dateTime.getTime()) / (nextPos.dateTime.getTime() - lastPos.dateTime.getTime());
                         factor = Math.max(0, Math.min(1, factor));
                     }
-                    // Apply easing for smoother rotation.
                     factor = this.easeInOutQuad(factor);
-                    // Calculate final heading.
                     let interpolatedHeading = lastPos.heading + factor * deltaHeading;
                     interpolatedHeading = (interpolatedHeading + 360) % 360;
-                    // Create quaternion from heading, pitch, roll.
                     this.lastCalcOrient = Transforms.headingPitchRollQuaternion(currentPosition, new HeadingPitchRoll(Math$1.toRadians(interpolatedHeading), Math$1.toRadians(this.pitch), Math$1.toRadians(this.roll)));
                 }
-                // Calculate heading from position changes if heading data not available.
                 else {
                     if (!lastPos.pos3d || !nextPos.pos3d) {
                         return this.lastCalcOrient || defaultQuaternion;
                     }
-                    // Flatten positions to avoid altitude-related heading changes.
                     const adjustedPointPrev = Cartographic.fromCartesian(lastPos.pos3d);
                     const adjustedPos3dPrev = Cartesian3.fromRadians(adjustedPointPrev.longitude, adjustedPointPrev.latitude, 0);
                     const adjustedPointNext = Cartographic.fromCartesian(nextPos.pos3d);
                     const adjustedPos3dNext = Cartesian3.fromRadians(adjustedPointNext.longitude, adjustedPointNext.latitude, 0);
-                    // Skip if positions are too close (less than 5cm).
                     const distance = Cartesian3.distance(adjustedPos3dPrev, adjustedPos3dNext);
                     if (distance < 0.05) {
                         return this.lastCalcOrient || defaultQuaternion;
                     }
-                    // Calculate direction vector.
                     const direction = Cartesian3.subtract(adjustedPos3dNext, adjustedPos3dPrev, new Cartesian3());
-                    // Skip if no movement.
                     if (direction.x === 0 && direction.y === 0 && direction.z === 0) {
                         return this.lastCalcOrient || defaultQuaternion;
                     }
-                    // Normalize the direction vector.
                     Cartesian3.normalize(direction, direction);
-                    // Calculate rotation based on movement direction.
                     const rotationMatrix = Transforms.rotationMatrixFromPositionVelocity(currentPosition, direction);
-                    // Convert to quaternion.
                     const quaternion = Quaternion.fromRotationMatrix(rotationMatrix);
-                    // Add pitch and roll adjustments.
                     const hpr = new HeadingPitchRoll(0, Math$1.toRadians(this.pitch), Math$1.toRadians(this.roll));
                     const pitchRollQuaternion = Quaternion.fromHeadingPitchRoll(hpr);
-                    // Combine quaternions.
                     this.lastCalcOrient = Quaternion.multiply(quaternion, pitchRollQuaternion, new Quaternion());
                 }
             }
@@ -1570,6 +1542,52 @@ var CesiumAnimatedProperty;
             this.lastCalcOrientTime = Date.now();
             return this.lastCalcOrient;
         }
+        GetCurrentVelocity() {
+            return this.currentVelocity ? this.currentVelocity.clone() : new Cartesian3(0, 0, 0);
+        }
+        SupplementSeries(newSeries) {
+            if (!newSeries || newSeries.length === 0) {
+                return;
+            }
+            for (const pos of newSeries) {
+                if (!pos || !pos.pos3d || !pos.dateTime) {
+                    continue;
+                }
+                const existingIndex = this.positions.findIndex(p => p.dateTime.getTime() === pos.dateTime.getTime());
+                if (existingIndex >= 0) {
+                    this.positions[existingIndex] = pos;
+                }
+                else {
+                    this.AddPosition(pos);
+                }
+            }
+        }
+        UpdatePositionForDateTime(pos3d, dateTime, heading) {
+            if (!pos3d || !dateTime) {
+                return;
+            }
+            const existingIndex = this.positions.findIndex(p => p.dateTime.getTime() === dateTime.getTime());
+            const newPos = {
+                pos3d: pos3d,
+                dateTime: dateTime,
+                heading: heading !== undefined ? heading : null
+            };
+            if (existingIndex >= 0) {
+                this.positions[existingIndex] = newPos;
+                this.processHeadings();
+                this.sortPositions();
+                this.invalidateCache();
+            }
+            else {
+                this.AddPosition(newPos);
+            }
+        }
+        HasPositionForDateTime(dateTime) {
+            return this.positions.some(p => p.dateTime.getTime() === dateTime.getTime());
+        }
+        GetPositionCount() {
+            return this.positions.length;
+        }
     }
     CesiumAnimatedProperty.AnimatePositionSeries = AnimatePositionSeries;
     function GetSeriesPossesForHistoricEntity(viewer, dataHeightRef, heightRef, historic) {
@@ -5452,7 +5470,7 @@ var EntityRenderEnginePoint;
      * @returns
      */
     async function Render(params) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
         const entity = params.entity;
         if (!params.entityHistoric) {
             params.entityHistoric = [];
@@ -5653,39 +5671,69 @@ var EntityRenderEnginePoint;
                         // Unset width/height.
                         cEntity.billboard.width = undefined;
                         cEntity.billboard.height = undefined;
+                        const pos3d = EntityUtils.GetPos({
+                            viewer: params.viewer,
+                            entity,
+                            recordHeightRef: heightRef,
+                            returnHeightRef: heightRef,
+                            allowRendered: false
+                        });
                         const prevPos3d = GetCValue(params.viewer, cEntity.position);
-                        let prevStartTime = null;
                         if (cEntity.position && cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"]) {
-                            prevStartTime = cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"].GetAnimateFromDateTime();
-                        }
-                        // If we have a series of time-based positions then we'll animate as time changes.
-                        const series = CesiumAnimatedProperty.GetSeriesPossesForHistoricEntity(params.viewer, heightRef, heightRef, params.entityHistoric);
-                        if (series.length > 1) {
-                            animatePosition = new CesiumAnimatedProperty.AnimatePositionSeries({
-                                posses: series,
-                                viewer: params.viewer,
-                                animateFromPos3d: prevPos3d,
-                                animateFromPos3dTimeStart: prevStartTime
-                            });
-                            cEntity.position = new CallbackProperty(() => animatePosition.GetValue(), false);
-                            cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"] = animatePosition;
+                            animatePosition = cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"];
+                            const animateSeries = animatePosition;
+                            const series = CesiumAnimatedProperty.GetSeriesPossesForHistoricEntity(params.viewer, heightRef, heightRef, params.entityHistoric);
+                            if (series.length) {
+                                animateSeries.SupplementSeries(series);
+                            }
+                            const dateTimeStr = (_d = (_c = entity.Bruce.Outline) === null || _c === void 0 ? void 0 : _c.find(x => !!x.DateTime)) === null || _d === void 0 ? void 0 : _d.DateTime;
+                            const dateTime = dateTimeStr ? new Date(dateTimeStr) : null;
+                            if (dateTime) {
+                                animateSeries.UpdatePositionForDateTime(pos3d, dateTime);
+                            }
+                            // We don't have a date-stamped incoming position.
+                            if (!dateTime && !series.length) {
+                                animatePosition = null;
+                            }
                         }
-                        else {
-                            const pos3d = EntityUtils.GetPos({
-                                viewer: params.viewer,
-                                entity,
-                                recordHeightRef: heightRef,
-                                returnHeightRef: heightRef,
-                                allowRendered: false
-                            });
-                            if (!prevPos3d || !Cartesian3.equals(prevPos3d, pos3d)) {
-                                animatePosition = new CesiumAnimatedProperty.AnimatePosition({
-                                    durationMs: 200,
-                                    targetPos3d: pos3d,
-                                    viewer: params.viewer,
-                                    startPos3d: prevPos3d
+                        if (!animatePosition) {
+                            // If we've loaded a set of series positions then we'll animate through them.
+                            const series = CesiumAnimatedProperty.GetSeriesPossesForHistoricEntity(params.viewer, heightRef, heightRef, params.entityHistoric);
+                            if (series.length > 1) {
+                                animatePosition = new CesiumAnimatedProperty.AnimatePositionSeries({
+                                    posses: series,
+                                    viewer: params.viewer
                                 });
                                 cEntity.position = new CallbackProperty(() => animatePosition.GetValue(), false);
+                                cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"] = animatePosition;
+                            }
+                            else {
+                                const dateTimeStr = (_f = (_e = entity.Bruce.Outline) === null || _e === void 0 ? void 0 : _e.find(x => !!x.DateTime)) === null || _f === void 0 ? void 0 : _f.DateTime;
+                                const dateTime = dateTimeStr ? new Date(dateTimeStr) : null;
+                                const posChanged = !prevPos3d || !Cartesian3.equals(prevPos3d, pos3d);
+                                if (posChanged) {
+                                    let posses = [];
+                                    const isLive = ViewUtils.GetTimeDetails({ viewer: params.viewer }).isLive;
+                                    if (prevPos3d && isLive) {
+                                        posses.push({
+                                            pos3d: prevPos3d,
+                                            // Guess so that we can determine a direction of movement right away :)
+                                            dateTime: new Date(dateTime.getTime() - 1000),
+                                            heading: null
+                                        });
+                                    }
+                                    posses.push({
+                                        pos3d: pos3d,
+                                        dateTime: dateTime,
+                                        heading: null
+                                    });
+                                    animatePosition = new CesiumAnimatedProperty.AnimatePositionSeries({
+                                        posses: posses,
+                                        viewer: params.viewer
+                                    });
+                                    cEntity.position = new CallbackProperty(() => animatePosition.GetValue(), false);
+                                    cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"] = animatePosition;
+                                }
                             }
                         }
                         // We'll use "SetDefaultColor" to updating the internal reference and to allow for an animation.
@@ -5984,39 +6032,52 @@ var EntityRenderEnginePoint;
                 cEntity.billboard.heightReference = new ConstantProperty(heightRef);
                 cEntity.billboard.distanceDisplayCondition = new ConstantProperty(EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance));
                 cEntity.billboard.disableDepthTestDistance = new ConstantProperty(disableDepthTest ? Number.POSITIVE_INFINITY : undefined);
+                const pos3d = EntityUtils.GetPos({
+                    viewer: params.viewer,
+                    entity,
+                    recordHeightRef: heightRef,
+                    returnHeightRef: heightRef,
+                    allowRendered: false
+                });
                 const prevPos3d = GetCValue(params.viewer, cEntity.position);
-                let prevStartTime = null;
                 if (cEntity.position && cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"]) {
-                    prevStartTime = cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"].GetAnimateFromDateTime();
-                }
-                // If we have a series of time-based positions then we'll animate as time changes.
-                const series = CesiumAnimatedProperty.GetSeriesPossesForHistoricEntity(params.viewer, heightRef, heightRef, params.entityHistoric);
-                if (series.length > 1) {
-                    animatePosition = new CesiumAnimatedProperty.AnimatePositionSeries({
-                        posses: series,
-                        viewer: params.viewer,
-                        animateFromPos3d: prevPos3d,
-                        animateFromPos3dTimeStart: prevStartTime
-                    });
-                    cEntity.position = new CallbackProperty(() => animatePosition.GetValue(), false);
-                    cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"] = animatePosition;
-                }
-                else {
-                    const pos3d = EntityUtils.GetPos({
-                        viewer: params.viewer,
-                        entity,
-                        recordHeightRef: heightRef,
-                        returnHeightRef: heightRef,
-                        allowRendered: false
-                    });
-                    if (!prevPos3d || !Cartesian3.equals(prevPos3d, pos3d)) {
-                        animatePosition = new CesiumAnimatedProperty.AnimatePosition({
-                            durationMs: 200,
-                            targetPos3d: pos3d,
-                            viewer: params.viewer,
-                            startPos3d: prevPos3d
+                    animatePosition = cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"];
+                    const animateSeries = animatePosition;
+                    const series = CesiumAnimatedProperty.GetSeriesPossesForHistoricEntity(params.viewer, heightRef, heightRef, params.entityHistoric);
+                    if (series.length) {
+                        animateSeries.SupplementSeries(series);
+                    }
+                    const dateTimeStr = (_h = (_g = entity.Bruce.Outline) === null || _g === void 0 ? void 0 : _g.find(x => !!x.DateTime)) === null || _h === void 0 ? void 0 : _h.DateTime;
+                    const dateTime = dateTimeStr ? new Date(dateTimeStr) : null;
+                    if (dateTime) {
+                        animateSeries.UpdatePositionForDateTime(pos3d, dateTime);
+                    }
+                    // We don't have a date-stamped incoming position.
+                    if (!dateTime && !series.length) {
+                        animatePosition = null;
+                    }
+                }
+                if (!animatePosition) {
+                    // If we have a series of time-based positions then we'll animate as time changes.
+                    const series = CesiumAnimatedProperty.GetSeriesPossesForHistoricEntity(params.viewer, heightRef, heightRef, params.entityHistoric);
+                    if (series.length > 1) {
+                        animatePosition = new CesiumAnimatedProperty.AnimatePositionSeries({
+                            posses: series,
+                            viewer: params.viewer
                         });
                         cEntity.position = new CallbackProperty(() => animatePosition.GetValue(), false);
+                        cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"] = animatePosition;
+                    }
+                    else {
+                        if (!prevPos3d || !Cartesian3.equals(prevPos3d, pos3d)) {
+                            animatePosition = new CesiumAnimatedProperty.AnimatePosition({
+                                durationMs: 200,
+                                targetPos3d: pos3d,
+                                viewer: params.viewer,
+                                startPos3d: prevPos3d
+                            });
+                            cEntity.position = new CallbackProperty(() => animatePosition.GetValue(), false);
+                        }
                     }
                 }
                 // We'll use "SetDefaultColor" to updating the internal reference and to allow for an animation.
@@ -6035,7 +6096,7 @@ var EntityRenderEnginePoint;
         // Generate a polyline 'track' for the historic data.
         // We do this for historic data that exists and is moving.
         if (shouldShowTrack && animatePosition && animatePosition instanceof CesiumAnimatedProperty.AnimatePositionSeries && animatePosition.GetSeries) {
-            const lStyle = (_d = (_c = params.fullStyle) === null || _c === void 0 ? void 0 : _c.polylineStyle) !== null && _d !== void 0 ? _d : {};
+            const lStyle = (_k = (_j = params.fullStyle) === null || _j === void 0 ? void 0 : _j.polylineStyle) !== null && _k !== void 0 ? _k : {};
             const bColor = lStyle.lineColor ? Calculator.GetColor(lStyle.lineColor, entity, params.tags) : null;
             const cColor = bColor ? ColorToCColor(bColor) : Color.fromCssColorString("rgba(255, 193, 7, 0.8)");
             let width = lStyle.lineWidth ? EnsureNumber(Calculator.GetNumber(lStyle.lineWidth, entity, params.tags)) : 2;
@@ -7055,7 +7116,7 @@ var EntityRenderEngineModel3d;
      * @returns
      */
     function Render(params) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c, _d, _e, _f;
         const entity = params.entity;
         if (!params.entityHistoric) {
             params.entityHistoric = [];
@@ -7247,40 +7308,41 @@ var EntityRenderEngineModel3d;
             cEntity.model.colorBlendAmount = new ConstantProperty(blendAmount);
             cEntity.model.colorBlendMode = new ConstantProperty(blendMode);
             cEntity.model.distanceDisplayCondition = new ConstantProperty(EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance));
-            let prevStartTime = null;
             if (cEntity.position && cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"]) {
-                prevStartTime = cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"].GetAnimateFromDateTime();
-            }
-            // If we've loaded a set of series positions then we'll animate through them.
-            const series = CesiumAnimatedProperty.GetSeriesPossesForHistoricEntity(params.viewer, heightRef, heightRef, params.entityHistoric);
-            if (series.length > 1) {
-                animatePosition = new CesiumAnimatedProperty.AnimatePositionSeries({
-                    posses: series,
-                    viewer: params.viewer,
-                    pitch: pitch,
-                    roll: roll,
-                    animateFromPos3d: prevPos3d,
-                    animateFromPos3dTimeStart: prevStartTime
-                });
-                cEntity.position = new CallbackProperty(() => animatePosition.GetValue(), false);
-                cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"] = animatePosition;
-            }
-            else {
+                animatePosition = cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"];
+                const animateSeries = animatePosition;
+                const series = CesiumAnimatedProperty.GetSeriesPossesForHistoricEntity(params.viewer, heightRef, heightRef, params.entityHistoric);
+                if (series.length) {
+                    animateSeries.SupplementSeries(series);
+                }
                 const dateTimeStr = (_b = (_a = entity.Bruce.Outline) === null || _a === void 0 ? void 0 : _a.find(x => !!x.DateTime)) === null || _b === void 0 ? void 0 : _b.DateTime;
                 const dateTime = dateTimeStr ? new Date(dateTimeStr) : null;
-                const posChanged = !prevPos3d || !Cartesian3.equals(prevPos3d, pos3d);
-                if (posChanged) {
-                    if (cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"]) {
-                        const prevAnimatePosition = cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"];
-                        animatePosition = prevAnimatePosition;
-                        animatePosition.AddPosition({
-                            pos3d: pos3d,
-                            dateTime: dateTime,
-                            heading: !EnsureNumber(transform === null || transform === void 0 ? void 0 : transform.heading) ? null : heading
-                        });
-                        animatePosition.UpdatePitchRoll(pitch, roll);
-                    }
-                    else {
+                if (dateTime) {
+                    animateSeries.UpdatePositionForDateTime(pos3d, dateTime, !EnsureNumber(transform === null || transform === void 0 ? void 0 : transform.heading) ? null : heading);
+                }
+                // We don't have a date-stamped incoming position.
+                if (!dateTime && !series.length) {
+                    animatePosition = null;
+                }
+            }
+            if (!animatePosition) {
+                // If we've loaded a set of series positions then we'll animate through them.
+                const series = CesiumAnimatedProperty.GetSeriesPossesForHistoricEntity(params.viewer, heightRef, heightRef, params.entityHistoric);
+                if (series.length > 1) {
+                    animatePosition = new CesiumAnimatedProperty.AnimatePositionSeries({
+                        posses: series,
+                        viewer: params.viewer,
+                        pitch: pitch,
+                        roll: roll
+                    });
+                    cEntity.position = new CallbackProperty(() => animatePosition.GetValue(), false);
+                    cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"] = animatePosition;
+                }
+                else {
+                    const dateTimeStr = (_d = (_c = entity.Bruce.Outline) === null || _c === void 0 ? void 0 : _c.find(x => !!x.DateTime)) === null || _d === void 0 ? void 0 : _d.DateTime;
+                    const dateTime = dateTimeStr ? new Date(dateTimeStr) : null;
+                    const posChanged = !prevPos3d || !Cartesian3.equals(prevPos3d, pos3d);
+                    if (posChanged) {
                         let posses = [];
                         const isLive = ViewUtils.GetTimeDetails({ viewer: params.viewer }).isLive;
                         if (prevPos3d && isLive) {
@@ -7300,9 +7362,7 @@ var EntityRenderEngineModel3d;
                             posses: posses,
                             viewer: params.viewer,
                             pitch: pitch,
-                            roll: roll,
-                            animateFromPos3d: prevPos3d && !isLive ? prevPos3d : null,
-                            animateFromPos3dTimeStart: null
+                            roll: roll
                         });
                         cEntity.position = new CallbackProperty(() => animatePosition.GetValue(), false);
                         cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"] = animatePosition;
@@ -7455,7 +7515,7 @@ var EntityRenderEngineModel3d;
         // Generate a polyline 'track' for the historic data.
         // We do this for historic data that exists and is moving.
         if (shouldShowTrack && animatePosition && animatePosition instanceof CesiumAnimatedProperty.AnimatePositionSeries && animatePosition.GetSeries) {
-            const lStyle = (_d = (_c = params.fullStyle) === null || _c === void 0 ? void 0 : _c.polylineStyle) !== null && _d !== void 0 ? _d : {};
+            const lStyle = (_f = (_e = params.fullStyle) === null || _e === void 0 ? void 0 : _e.polylineStyle) !== null && _f !== void 0 ? _f : {};
             const bColor = lStyle.lineColor ? Calculator.GetColor(lStyle.lineColor, entity, params.tags) : null;
             const cColor = bColor ? ColorToCColor(bColor) : Color.fromCssColorString("rgba(255, 193, 7, 0.8)");
             let width = lStyle.lineWidth ? EnsureNumber(Calculator.GetNumber(lStyle.lineWidth, entity, params.tags)) : 2;
@@ -33249,7 +33309,7 @@ class WidgetViewBar extends Widget.AWidget {
     }
 }
 
-const VERSION = "5.9.7";
+const VERSION = "5.9.8";
 
 export { VERSION, CesiumViewMonitor, ViewerUtils, ViewerEventTracker, MenuItemManager, isOutlineChanged, EntityRenderEngine, EntityRenderEnginePoint, EntityRenderEnginePolyline, EntityRenderEnginePolygon, EntityRenderEngineModel3d, MenuItemCreator, VisualsRegister, RenderManager, EntitiesIdsRenderManager, DataLabRenderManager, EntitiesLoadedRenderManager, EntitiesRenderManager, EntityRenderManager, TilesetCadRenderManager, TilesetArbRenderManager, TilesetEntitiesRenderManager, TilesetOsmRenderManager, TilesetPointcloudRenderManager, TilesetGooglePhotosRenderManager, DataSourceStaticKmlManager, GoogleSearchRenderManager, AssemblyRenderManager, RelationsRenderManager, SharedGetters, CesiumParabola, EntityLabel, ViewRenderEngine, TileRenderEngine, TilesetRenderEngine, CESIUM_INSPECTOR_KEY, CESIUM_TIMELINE_KEY, CESIUM_TIMELINE_LIVE_KEY, CESIUM_TIMELINE_LIVE_PADDING_KEY, CESIUM_TIMELINE_INTERVAL_KEY, DEFAULT_LIVE_PADDING_SECONDS, ViewUtils, DrawingUtils, MeasureUtils, EntityUtils, CesiumEntityStyler, CesiumAnimatedProperty, CesiumAnimatedInOut, Draw3dPolygon, Draw3dPolyline, MeasureCreator, Walkthrough, Widget, VIEWER_BOOKMARKS_WIDGET_KEY, WidgetBookmarks, WidgetBranding, WidgetCursorBar, WidgetEmbeddedInfoView, WidgetInfoView, WidgetNavCompass$$1 as WidgetNavCompass, VIEWER_VIEW_BAR_WIDGET_KEY, WidgetViewBar, WidgetControlViewBar, WidgetControlViewBarSearch, VIEWER_LEFT_PANEL_WIDGET_KEY, VIEWER_LEFT_PANEL_CSS_VAR_LEFT, WidgetLeftPanel, WidgetLeftPanelTab, WidgetLeftPanelTabBookmarks };
 //# sourceMappingURL=bruce-cesium.es5.js.map