yi-map-web 1.0.0

package/dist/yi-map-web.umd.cjs

@@ -0,0 +1,2128 @@
+const vue_1 = require('vue');
+const vue = vue_1.default || vue_1;
+(function(global, factory) {
+  typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("vue"), require("mars3d")) : typeof define === "function" && define.amd ? define(["exports", "vue", "mars3d"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global.YiMap = {}, global.Vue, global.mars3d));
+})(this, function(exports2, vue, mars3d) {
+  "use strict";
+  function _interopNamespaceDefault(e) {
+    const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+    if (e) {
+      for (const k in e) {
+        if (k !== "default") {
+          const d = Object.getOwnPropertyDescriptor(e, k);
+          Object.defineProperty(n, k, d.get ? d : {
+            enumerable: true,
+            get: () => e[k]
+          });
+        }
+      }
+    }
+    n.default = e;
+    return Object.freeze(n);
+  }
+  const mars3d__namespace = /* @__PURE__ */ _interopNamespaceDefault(mars3d);
+  class CameraList extends mars3d__namespace.TaskItem {
+    // 进入，激活开始处理事务
+    _activateWork() {
+      this._map.setCameraViewList(this.options.list);
+    }
+    // 暂停(非必须)
+    _pauseWork() {
+      this._disableWork();
+    }
+  }
+  mars3d__namespace.thing.Task.register("cameraList", CameraList);
+  class CameraView extends mars3d__namespace.TaskItem {
+    // 进入，激活开始处理事务
+    _activateWork() {
+      this._map.setCameraView(this.options.center, { duration: this._duration });
+    }
+    // 离开，释放相关对象
+    _disableWork() {
+      this._map.cancelFlyTo();
+    }
+  }
+  mars3d__namespace.thing.Task.register("camera", CameraView);
+  class MapRotate extends mars3d__namespace.TaskItem {
+    constructor(options = {}) {
+      super(options);
+      this._speed = this.options.speed || 0.01;
+      this._center = this.options.center || { lat: 29.093038, lng: 108.804459, alt: 233212327e-1, heading: 0, pitch: -90 };
+    }
+    // 进入，激活开始处理事务
+    _activateWork() {
+      this._map.setCameraView(this._center, {
+        duration: 1,
+        complete: () => {
+          this._map.on(mars3d__namespace.EventType.clockTick, this._map_onClockTick, this);
+        }
+      });
+    }
+    // 离开，释放相关对象
+    _disableWork() {
+      this._map.off(mars3d__namespace.EventType.clockTick, this._map_onClockTick, this);
+    }
+    _map_onClockTick() {
+      if (this.isPause) {
+        return;
+      }
+      this._map.scene.camera.rotate(mars3d__namespace.Cesium.Cartesian3.UNIT_Z, this._speed);
+    }
+  }
+  mars3d__namespace.thing.Task.register("mapRotate", MapRotate);
+  class PointRotate extends mars3d__namespace.TaskItem {
+    // 进入，激活开始处理事务
+    _activateWork() {
+      if (this.options.center) {
+        this._map.setCameraView(this.options.center, { duration: 0 });
+      }
+      if (this.options.autoStop) {
+        delete this.options.autoStopAngle;
+      }
+      if (this.options.isRotateOut) {
+        this._rotateOut = new mars3d__namespace.thing.RotateOut(this.options);
+        this._map.addThing(this._rotateOut);
+      } else {
+        this._rotatePoint = new mars3d__namespace.thing.RotatePoint(this.options);
+        this._map.addThing(this._rotatePoint);
+      }
+      if (this.options.isRotateOut) {
+        this._rotateOut.start();
+      } else {
+        this._rotatePoint.start(this.options.point);
+      }
+    }
+    // 离开，释放相关对象
+    _disableWork() {
+      if (this._rotatePoint) {
+        this._rotatePoint.stop();
+        this._rotatePoint.destroy();
+        delete this._rotatePoint;
+      }
+      if (this._rotateOut) {
+        this._rotateOut.stop();
+        this._rotateOut.destroy();
+        delete this._rotateOut;
+      }
+    }
+  }
+  mars3d__namespace.thing.Task.register("pointRotate", PointRotate);
+  class RouteLine extends mars3d__namespace.TaskItem {
+    // constructor(options) {
+    //   super(options)
+    // }
+    // 进入，激活开始处理事务
+    _activateWork() {
+      this._graphicLayer = new mars3d__namespace.layer.GraphicLayer();
+      this._map.addLayer(this._graphicLayer);
+      const fixedRoute = new mars3d__namespace.graphic.FixedRoute(this.options.route);
+      this._graphicLayer.addGraphic(fixedRoute);
+      this._fixedRoute = fixedRoute;
+      fixedRoute.start();
+    }
+    // 暂停(非必须)
+    _pauseWork(options) {
+      if (this._fixedRoute) {
+        this._fixedRoute.pause();
+      }
+    }
+    // 继续(非必须)
+    _proceedWork() {
+      if (this._fixedRoute) {
+        this._fixedRoute.proceed();
+      }
+    }
+    // 离开，释放相关对象
+    _disableWork() {
+      if (this._fixedRoute) {
+        this._fixedRoute.stop();
+        delete this._fixedRoute;
+      }
+      if (this._graphicLayer) {
+        this._graphicLayer.destroy();
+        delete this._graphicLayer;
+      }
+    }
+  }
+  mars3d__namespace.thing.Task.register("routeLine", RouteLine);
+  class ZoomIn extends mars3d__namespace.TaskItem {
+    // 进入，激活开始处理事务
+    _activateWork() {
+      this._map.zoomIn(this.options.relativeAmount);
+    }
+  }
+  mars3d__namespace.thing.Task.register("zoomIn", ZoomIn);
+  class ZoomOut extends mars3d__namespace.TaskItem {
+    // 进入，激活开始处理事务
+    _activateWork() {
+      this._map.zoomOut(this.options.relativeAmount);
+    }
+  }
+  mars3d__namespace.thing.Task.register("zoomOut", ZoomOut);
+  class FlickerEntity extends mars3d__namespace.TaskItem {
+    // 进入，激活开始处理事务
+    _activateWork() {
+      const layer = this._map.getLayerById(this.options.layerId);
+      if (layer) {
+        layer.show = true;
+        layer.readyPromise.then(() => {
+          this._graphic = layer.getGraphicById(this.options.graphicId);
+          if (this._graphic) {
+            this._graphic.show = true;
+            this._graphic.startFlicker({
+              time: this._duration,
+              step: this.options.step,
+              maxAlpha: this.options.maxAlpha,
+              color: this.options.color
+            });
+          }
+        });
+      }
+    }
+    // 离开，释放相关对象
+    _disableWork() {
+      if (this._graphic) {
+        this._graphic.stopFlicker();
+      }
+    }
+  }
+  mars3d__namespace.thing.Task.register("flickerEntity", FlickerEntity);
+  class CanvasBillboard extends mars3d__namespace.graphic.BillboardPrimitive {
+    /**
+     * 文字
+     * @type {string}
+     */
+    get text() {
+      return this.style.text;
+    }
+    set text(val) {
+      this.style.text = val;
+      this.label.text = val;
+    }
+    /**
+     * 对象添加到图层前创建一些对象的钩子方法，
+     * 只会调用一次
+     * @return {Promise<object>}  无
+     * @private
+     */
+    _addedHook(style) {
+      style.image = "//data.mars3d.cn/img/marker/bg/textPnl.png";
+      style.label = {
+        ...style,
+        text: this.style.text,
+        font_size: 55,
+        color: style.textColor ?? "#ffffff",
+        hasPixelOffset: true,
+        pixelOffsetX: 0,
+        pixelOffsetY: -36 * (style.scale ?? 1)
+      };
+      if (style.scaleByDistance) {
+        style.label.pixelOffsetScaleByDistance = style.scaleByDistance;
+      }
+      super._addedHook(style);
+    }
+  }
+  mars3d__namespace.GraphicUtil.register("canvasBillboard", CanvasBillboard);
+  const _hoisted_1$5 = ["id"];
+  const _sfc_main$7 = /* @__PURE__ */ vue.defineComponent({
+    __name: "mars-map",
+    props: {
+      mapKey: { default: "default" },
+      url: { default: void 0 },
+      options: { default: void 0 }
+    },
+    emits: ["onload"],
+    setup(__props, { emit: __emit }) {
+      const props = __props;
+      let map;
+      const withKeyId = vue.computed(() => `mars3d-container-${props.mapKey}`);
+      const emit = __emit;
+      const initMars3d = async () => {
+        let mapOptions;
+        if (props.url) {
+          mapOptions = await mars3d__namespace.Util.fetchJson({ url: props.url });
+          if (props.options) {
+            mapOptions = mars3d__namespace.Util.merge(mapOptions, vue.toRaw(props.options));
+          }
+        } else if (props.options) {
+          mapOptions = vue.toRaw(props.options);
+        }
+        mars3d__namespace.Util.showCopyright = false;
+        map = new mars3d__namespace.Map(withKeyId.value, mapOptions);
+        if (mars3d__namespace.Util.isPCBroswer()) {
+          map.zoomFactor = 2;
+          if (window.navigator.userAgent.toLowerCase().indexOf("msie") >= 0) {
+            map.viewer.targetFrameRate = 20;
+            map.scene.requestRenderMode = false;
+          }
+        } else {
+          map.zoomFactor = 5;
+          map.scene.requestRenderMode = false;
+          map.scene.fog.enabled = false;
+          map.scene.skyAtmosphere.show = false;
+          map.scene.globe.showGroundAtmosphere = false;
+        }
+        if (map.viewer.sceneModePicker) {
+          map.viewer.sceneModePicker.viewModel.duration = 0;
+        }
+        if (map.mars3dLogo) {
+          map.mars3dLogo.show = false;
+        }
+        setTimeout(() => {
+          const logoElements = document.getElementsByClassName("mars3d-logo");
+          for (let i = 0; i < logoElements.length; i++) {
+            logoElements[i].remove();
+          }
+        }, 100);
+        emit("onload", map);
+      };
+      vue.onMounted(() => {
+        initMars3d();
+      });
+      vue.onUnmounted(() => {
+        if (map) {
+          map.destroy();
+          map = null;
+        }
+      });
+      return (_ctx, _cache) => {
+        return vue.openBlock(), vue.createElementBlock("div", {
+          id: withKeyId.value,
+          class: "mars3d-container"
+        }, null, 8, _hoisted_1$5);
+      };
+    }
+  });
+  const _hoisted_1$4 = { class: "panel-content" };
+  const _hoisted_2$3 = { class: "menu-group" };
+  const _hoisted_3$3 = ["title", "onClick"];
+  const _hoisted_4$3 = { class: "menu-group" };
+  const _hoisted_5$2 = ["title", "onClick"];
+  const _sfc_main$6 = /* @__PURE__ */ vue.defineComponent({
+    __name: "ToolbarPanel",
+    props: {
+      activeDrawType: {}
+    },
+    emits: ["toolActivate", "clear"],
+    setup(__props, { emit: __emit }) {
+      const emit = __emit;
+      const isCollapsed = vue.ref(false);
+      const toggleCollapse = () => {
+        isCollapsed.value = !isCollapsed.value;
+      };
+      const activateTool = (tool) => {
+        emit("toolActivate", tool);
+      };
+      const emitClear = () => {
+        emit("clear");
+      };
+      const measureTools = [
+        {
+          tool: "measureDistance",
+          title: "测量距离",
+          iconClasses: ["fa", "fa-arrows-alt-h"]
+          // 水平双向箭头，更准确表达距离
+        },
+        {
+          tool: "measureArea",
+          title: "测量面积",
+          iconClasses: ["fa", "fa-vector-square"]
+          // 矢量方块，更几何感、专业感
+        },
+        {
+          tool: "measureHeight",
+          title: "测量高度差",
+          iconClasses: ["fa", "fa-arrows-alt-v"]
+          // 垂直双向箭头，清晰表达高度
+        },
+        {
+          tool: "measureAngle",
+          title: "测量角度",
+          iconClasses: ["fa-solid", "fa-compass-drafting"]
+          // 绘图圆规图标，专业表达角度测量
+        }
+      ];
+      const drawTools = [
+        {
+          tool: "drawPoint",
+          title: "点标记",
+          iconClasses: ["fa", "fa-map-marker"],
+          // 地图标记点，比空心圆更直观
+          drawType: "point"
+        },
+        {
+          tool: "drawLine",
+          title: "线标记",
+          iconClasses: ["fa", "fa-slash"],
+          // 斜线比短横线更像"线"的概念
+          drawType: "polyline"
+        },
+        {
+          tool: "drawPolygon",
+          title: "面标记",
+          iconClasses: ["fa-solid", "fa-draw-polygon"],
+          // 多边形绘制图标，语义明确
+          drawType: "polygon"
+        },
+        {
+          tool: "drawCircle",
+          title: "圆标记",
+          iconClasses: ["fa", "fa-circle"],
+          // 实心圆表示圆
+          drawType: "circle"
+        },
+        {
+          tool: "drawRectangle",
+          title: "矩形标记",
+          iconClasses: ["fa-regular", "fa-square"],
+          // 空心方块，与圆标记风格统一
+          drawType: "rectangle"
+        },
+        {
+          tool: "drawFreePolygon",
+          title: "自由多边形",
+          iconClasses: ["fa", "fa-pencil"],
+          // 铅笔表示自由绘制
+          drawType: "freePolygon"
+        }
+      ];
+      return (_ctx, _cache) => {
+        return vue.openBlock(), vue.createElementBlock("div", {
+          class: vue.normalizeClass(["toolbar-panel", { collapsed: isCollapsed.value }])
+        }, [
+          vue.createElementVNode("div", {
+            class: "panel-header",
+            onClick: toggleCollapse
+          }, [
+            vue.createElementVNode("i", {
+              class: vue.normalizeClass([
+                "toggle-icon",
+                "fa",
+                isCollapsed.value ? "fa-chevron-down" : "fa-chevron-up"
+              ])
+            }, null, 2)
+          ]),
+          vue.withDirectives(vue.createElementVNode("div", _hoisted_1$4, [
+            vue.createElementVNode("div", _hoisted_2$3, [
+              (vue.openBlock(), vue.createElementBlock(vue.Fragment, null, vue.renderList(measureTools, (item) => {
+                return vue.createElementVNode("div", {
+                  key: item.tool,
+                  class: "menu-item",
+                  title: item.title,
+                  onClick: ($event) => activateTool(item.tool)
+                }, [
+                  vue.createElementVNode("i", {
+                    class: vue.normalizeClass(item.iconClasses)
+                  }, null, 2)
+                ], 8, _hoisted_3$3);
+              }), 64))
+            ]),
+            _cache[2] || (_cache[2] = vue.createElementVNode("div", { class: "divider" }, null, -1)),
+            vue.createElementVNode("div", _hoisted_4$3, [
+              (vue.openBlock(), vue.createElementBlock(vue.Fragment, null, vue.renderList(drawTools, (item) => {
+                return vue.createElementVNode("div", {
+                  key: item.tool,
+                  class: vue.normalizeClass(["menu-item", { active: __props.activeDrawType === item.drawType }]),
+                  title: item.title,
+                  onClick: ($event) => activateTool(item.tool)
+                }, [
+                  vue.createElementVNode("i", {
+                    class: vue.normalizeClass(item.iconClasses)
+                  }, null, 2)
+                ], 10, _hoisted_5$2);
+              }), 64)),
+              _cache[1] || (_cache[1] = vue.createElementVNode("div", { class: "divider" }, null, -1)),
+              vue.createElementVNode("div", {
+                class: "menu-item",
+                title: "清除全部",
+                onClick: emitClear
+              }, [..._cache[0] || (_cache[0] = [
+                vue.createElementVNode("i", { class: "fa-solid fa-trash-can" }, null, -1)
+              ])])
+            ])
+          ], 512), [
+            [vue.vShow, !isCollapsed.value]
+          ])
+        ], 2);
+      };
+    }
+  });
+  const _export_sfc = (sfc, props) => {
+    const target = sfc.__vccOpts || sfc;
+    for (const [key, val] of props) {
+      target[key] = val;
+    }
+    return target;
+  };
+  const ToolbarPanel = /* @__PURE__ */ _export_sfc(_sfc_main$6, [["__scopeId", "data-v-f9e69b7a"]]);
+  const _hoisted_1$3 = {
+    key: 0,
+    class: "vision-popup"
+  };
+  const _hoisted_2$2 = { class: "popup-header" };
+  const _hoisted_3$2 = { class: "popup-content" };
+  const _hoisted_4$2 = ["onClick"];
+  const _sfc_main$5 = /* @__PURE__ */ vue.defineComponent({
+    __name: "VisionPanel",
+    props: {
+      circleFlyActive: { type: Boolean },
+      flyToActive: { type: Boolean },
+      firstPersonActive: { type: Boolean },
+      keyboardNavigateActive: { type: Boolean }
+    },
+    emits: ["visionExecute"],
+    setup(__props, { emit: __emit }) {
+      const props = __props;
+      const emit = __emit;
+      const popupVisible = vue.ref(false);
+      const togglePopup = () => {
+        popupVisible.value = !popupVisible.value;
+      };
+      const execute = (action) => {
+        emit("visionExecute", action);
+      };
+      const visionItems = [
+        {
+          action: "circleFly",
+          icon: "fa-refresh",
+          label: "环绕飞行",
+          activeLabel: "关闭环绕飞行",
+          activeProp: "circleFlyActive"
+        },
+        {
+          action: "flyTo",
+          icon: "fa-location-arrow",
+          label: "移动到此处",
+          activeProp: "flyToActive"
+        },
+        {
+          action: "firstPerson",
+          icon: "fa-user",
+          label: "开启第一视角",
+          activeLabel: "关闭第一视角",
+          activeProp: "firstPersonActive"
+        },
+        {
+          action: "keyboardNavigate",
+          icon: "fa-keyboard-o",
+          label: "开启键盘漫游",
+          activeLabel: "关闭键盘漫游",
+          activeProp: "keyboardNavigateActive"
+        }
+      ];
+      const isActive = (item) => item.activeProp ? !!props[item.activeProp] : false;
+      const getLabel = (item) => isActive(item) && item.activeLabel ? item.activeLabel : item.label;
+      return (_ctx, _cache) => {
+        return vue.openBlock(), vue.createElementBlock(vue.Fragment, null, [
+          vue.createElementVNode("div", {
+            class: "vision-button",
+            title: "视觉功能",
+            onClick: togglePopup
+          }, [..._cache[1] || (_cache[1] = [
+            vue.createElementVNode("i", { class: "fa fa-eye" }, null, -1)
+          ])]),
+          vue.createVNode(vue.Transition, { name: "vision-fade" }, {
+            default: vue.withCtx(() => [
+              popupVisible.value ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_1$3, [
+                vue.createElementVNode("div", _hoisted_2$2, [
+                  _cache[2] || (_cache[2] = vue.createElementVNode("span", null, "视觉功能", -1)),
+                  vue.createElementVNode("i", {
+                    class: "fa fa-times close-icon",
+                    onClick: _cache[0] || (_cache[0] = ($event) => popupVisible.value = false)
+                  })
+                ]),
+                vue.createElementVNode("div", _hoisted_3$2, [
+                  (vue.openBlock(), vue.createElementBlock(vue.Fragment, null, vue.renderList(visionItems, (item) => {
+                    return vue.createElementVNode("div", {
+                      key: item.action,
+                      class: vue.normalizeClass(["popup-item", { active: isActive(item) }]),
+                      onClick: ($event) => execute(item.action)
+                    }, [
+                      vue.createElementVNode("i", {
+                        class: vue.normalizeClass(["fa", item.icon])
+                      }, null, 2),
+                      vue.createElementVNode("span", null, vue.toDisplayString(getLabel(item)), 1)
+                    ], 10, _hoisted_4$2);
+                  }), 64))
+                ])
+              ])) : vue.createCommentVNode("", true)
+            ]),
+            _: 1
+          })
+        ], 64);
+      };
+    }
+  });
+  const VisionPanel = /* @__PURE__ */ _export_sfc(_sfc_main$5, [["__scopeId", "data-v-4fc03fe1"]]);
+  function useMap() {
+    const Cesium = mars3d__namespace.Cesium;
+    const mapRef = vue.shallowRef(null);
+    const graphicLayer = vue.shallowRef(null);
+    const measureLayer = vue.shallowRef(null);
+    const selectedGraphic = vue.ref(null);
+    const lastClickPosition = vue.ref(null);
+    function initMap(map) {
+      mapRef.value = map;
+      const gLayer = new mars3d__namespace.layer.GraphicLayer();
+      map.addLayer(gLayer);
+      graphicLayer.value = gLayer;
+      const mLayer = new mars3d__namespace.layer.GraphicLayer();
+      map.addLayer(mLayer);
+      measureLayer.value = mLayer;
+      map.on(mars3d__namespace.EventType.click, (event) => {
+        if (event.lnglat) {
+          lastClickPosition.value = event.lnglat;
+        } else if (event.cartesian) {
+          const carto = Cesium.Ellipsoid.WGS84.cartesianToCartographic(event.cartesian);
+          lastClickPosition.value = {
+            lng: Cesium.Math.toDegrees(carto.longitude),
+            lat: Cesium.Math.toDegrees(carto.latitude),
+            alt: carto.height > 0 ? carto.height : 5e3
+          };
+        }
+      });
+      gLayer.on(mars3d__namespace.EventType.click, (event) => {
+        selectedGraphic.value = event.graphic;
+      });
+      gLayer.on(mars3d__namespace.EventType.mouseOver, (event) => {
+        if (!selectedGraphic.value) {
+          selectedGraphic.value = event.graphic;
+        }
+      });
+      gLayer.on(mars3d__namespace.EventType.mouseOut, (event) => {
+        if (selectedGraphic.value === event.graphic) {
+          selectedGraphic.value = null;
+        }
+      });
+    }
+    function destroyMap() {
+      if (mapRef.value) {
+        mapRef.value.destroy();
+        mapRef.value = null;
+      }
+    }
+    function addGraphic(graphic) {
+      var _a;
+      (_a = graphicLayer.value) == null ? void 0 : _a.addGraphic(graphic);
+    }
+    function addThing(thing) {
+      var _a;
+      (_a = mapRef.value) == null ? void 0 : _a.addThing(thing);
+    }
+    return {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      map: mapRef,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      graphicLayer,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      measureLayer,
+      selectedGraphic,
+      lastClickPosition,
+      initMap,
+      destroyMap,
+      addGraphic,
+      addThing
+    };
+  }
+  function useMeasure(mapContext) {
+    const measureThing = vue.shallowRef(null);
+    function initMeasure() {
+      const map = mapContext.map.value;
+      const layer = mapContext.measureLayer.value;
+      if (!map || !layer) return;
+      const m = new mars3d__namespace.thing.Measure({ graphicLayer: layer });
+      map.addThing(m);
+      measureThing.value = m;
+    }
+    function measureDistance(style) {
+      var _a;
+      (_a = measureThing.value) == null ? void 0 : _a.distance({
+        style: { color: "#3388ff", width: 3, ...style }
+      });
+    }
+    function measureArea(style) {
+      var _a;
+      (_a = measureThing.value) == null ? void 0 : _a.area({
+        style: { color: "#3388ff", opacity: 0.5, ...style }
+      });
+    }
+    function measureHeight(style) {
+      var _a;
+      (_a = measureThing.value) == null ? void 0 : _a.height({
+        style: { color: "#3388ff", width: 3, ...style }
+      });
+    }
+    function measureAngle(style) {
+      var _a;
+      (_a = measureThing.value) == null ? void 0 : _a.angle({
+        style: { color: "#3388ff", width: 3, ...style }
+      });
+    }
+    function clearMeasure() {
+      var _a, _b;
+      (_a = measureThing.value) == null ? void 0 : _a.clear();
+      (_b = mapContext.measureLayer.value) == null ? void 0 : _b.clear();
+    }
+    return {
+      measureThing,
+      initMeasure,
+      measureDistance,
+      measureArea,
+      measureHeight,
+      measureAngle,
+      clearMeasure
+    };
+  }
+  function useDraw(mapContext) {
+    const currentDraw = vue.shallowRef(null);
+    const activeDrawType = vue.ref(null);
+    function getLayer() {
+      return mapContext.measureLayer.value;
+    }
+    function startDraw(type, style, drawType) {
+      const layer = getLayer();
+      if (!layer) return;
+      stopDraw();
+      currentDraw.value = layer.startDraw({ type, style });
+      activeDrawType.value = drawType;
+    }
+    function drawPoint(style) {
+      startDraw("point", { pixelSize: 10, color: "#ff0000", ...style }, "point");
+    }
+    function drawLine(style) {
+      startDraw("polyline", { width: 3, color: "#3388ff", ...style }, "polyline");
+    }
+    function drawPolygon(style) {
+      startDraw("polygon", { color: "#3388ff", opacity: 0.5, ...style }, "polygon");
+    }
+    function drawCircle(style) {
+      startDraw("circle", { radius: 1e3, color: "#00ff00", opacity: 0.3, ...style }, "circle");
+    }
+    function drawRectangle(style) {
+      startDraw("rectangle", { color: "#3388ff", opacity: 0.5, ...style }, "rectangle");
+    }
+    function drawFreePolygon(style) {
+      startDraw(
+        "polygon",
+        { color: "#3388ff", opacity: 0.5, clampToGround: true, ...style },
+        "freePolygon"
+      );
+    }
+    function stopDraw() {
+      var _a;
+      if (currentDraw.value) {
+        (_a = getLayer()) == null ? void 0 : _a.stopDraw();
+        currentDraw.value = null;
+      }
+      activeDrawType.value = null;
+    }
+    function clearDraw() {
+      var _a;
+      stopDraw();
+      (_a = getLayer()) == null ? void 0 : _a.clear();
+    }
+    return {
+      currentDraw,
+      activeDrawType,
+      drawPoint,
+      drawLine,
+      drawPolygon,
+      drawCircle,
+      drawRectangle,
+      drawFreePolygon,
+      stopDraw,
+      clearDraw
+    };
+  }
+  function useVision(mapContext) {
+    const circleFlyActive = vue.ref(false);
+    const firstPersonActive = vue.ref(false);
+    const keyboardActive = vue.ref(false);
+    const flyToActive = vue.ref(false);
+    const rotatePoint = vue.shallowRef(null);
+    const firstPersonRoam = vue.shallowRef(null);
+    const keyboardRoam = vue.shallowRef(null);
+    let initialCameraView = null;
+    function getMap() {
+      return mapContext.map.value;
+    }
+    function toggleCircleFly() {
+      const map = getMap();
+      if (!map) return;
+      if (rotatePoint.value) {
+        if (rotatePoint.value.isStart) {
+          rotatePoint.value.stop();
+        }
+        map.removeThing(rotatePoint.value);
+        rotatePoint.value = null;
+        circleFlyActive.value = false;
+        return;
+      }
+      const center = map.getCenter();
+      const rp = new mars3d__namespace.thing.RotatePoint({ distance: 5e3, time: 30 });
+      map.addThing(rp);
+      rp.start(center);
+      rotatePoint.value = rp;
+      circleFlyActive.value = true;
+    }
+    function flyTo() {
+      const map = getMap();
+      if (!map) return;
+      flyToActive.value = true;
+      const done = () => setTimeout(() => {
+        flyToActive.value = false;
+      }, 2e3);
+      const pos = mapContext.lastClickPosition.value;
+      if (pos) {
+        const target = { ...pos, alt: pos.alt > 0 ? pos.alt : 5e3 };
+        map.setCameraView(target, { duration: 2, complete: done });
+      } else {
+        map.flyHome({ duration: 2 });
+        done();
+      }
+    }
+    function toggleFirstPerson() {
+      const map = getMap();
+      if (!map) return;
+      if (!firstPersonRoam.value) {
+        const roam = new mars3d__namespace.thing.FirstPersonRoam({});
+        map.addThing(roam);
+        initialCameraView = map.getCameraView();
+        roam.enabled = true;
+        firstPersonRoam.value = roam;
+        firstPersonActive.value = true;
+      } else {
+        const roam = firstPersonRoam.value;
+        roam.enabled = !roam.enabled;
+        firstPersonActive.value = roam.enabled;
+        if (!roam.enabled && initialCameraView) {
+          map.setCameraView(initialCameraView, { duration: 1 });
+        } else if (roam.enabled) {
+          initialCameraView = map.getCameraView();
+        }
+      }
+    }
+    function toggleKeyboardNavigate() {
+      const map = getMap();
+      if (!map) return;
+      if (!keyboardRoam.value) {
+        const roam = new mars3d__namespace.thing.KeyboardRoam({});
+        map.addThing(roam);
+        roam.enabled = true;
+        keyboardRoam.value = roam;
+        keyboardActive.value = true;
+      } else {
+        const roam = keyboardRoam.value;
+        roam.enabled = !roam.enabled;
+        keyboardActive.value = roam.enabled;
+      }
+    }
+    return {
+      // 状态
+      circleFlyActive,
+      firstPersonActive,
+      keyboardActive,
+      flyToActive,
+      // 方法
+      toggleCircleFly,
+      flyTo,
+      toggleFirstPerson,
+      toggleKeyboardNavigate
+    };
+  }
+  const _hoisted_1$2 = { class: "mars-map-container" };
+  const _sfc_main$4 = /* @__PURE__ */ vue.defineComponent({
+    __name: "MarsMapContainer",
+    props: {
+      configUrl: { default: "config/config.json" },
+      mapKey: { default: "default" },
+      hideToolbar: { type: Boolean, default: false },
+      hideVision: { type: Boolean, default: false }
+    },
+    emits: ["onload"],
+    setup(__props, { expose: __expose, emit: __emit }) {
+      const emit = __emit;
+      const mapCtx = useMap();
+      const measure = useMeasure(mapCtx);
+      const draw = useDraw(mapCtx);
+      const vision = useVision(mapCtx);
+      vue.provide("mapContext", mapCtx);
+      vue.provide("measureContext", measure);
+      vue.provide("drawContext", draw);
+      vue.provide("visionContext", vision);
+      function onMapLoad(map) {
+        mapCtx.initMap(map);
+        measure.initMeasure();
+        emit("onload", map);
+      }
+      function handleToolActivate(tool) {
+        switch (tool) {
+          case "measureDistance":
+            measure.measureDistance();
+            break;
+          case "measureArea":
+            measure.measureArea();
+            break;
+          case "measureHeight":
+            measure.measureHeight();
+            break;
+          case "measureAngle":
+            measure.measureAngle();
+            break;
+          case "drawPoint":
+            draw.drawPoint();
+            break;
+          case "drawLine":
+            draw.drawLine();
+            break;
+          case "drawPolygon":
+            draw.drawPolygon();
+            break;
+          case "drawCircle":
+            draw.drawCircle();
+            break;
+          case "drawRectangle":
+            draw.drawRectangle();
+            break;
+          case "drawFreePolygon":
+            draw.drawFreePolygon();
+            break;
+        }
+      }
+      function handleClear() {
+        measure.clearMeasure();
+        draw.clearDraw();
+      }
+      function handleVisionExecute(action) {
+        switch (action) {
+          case "circleFly":
+            vision.toggleCircleFly();
+            break;
+          case "flyTo":
+            vision.flyTo();
+            break;
+          case "firstPerson":
+            vision.toggleFirstPerson();
+            break;
+          case "keyboardNavigate":
+            vision.toggleKeyboardNavigate();
+            break;
+        }
+      }
+      __expose({
+        map: mapCtx.map,
+        graphicLayer: mapCtx.graphicLayer,
+        measureLayer: mapCtx.measureLayer,
+        selectedGraphic: mapCtx.selectedGraphic,
+        lastClickPosition: mapCtx.lastClickPosition,
+        addGraphic: mapCtx.addGraphic,
+        addThing: mapCtx.addThing,
+        measure,
+        draw,
+        vision
+      });
+      return (_ctx, _cache) => {
+        return vue.openBlock(), vue.createElementBlock("div", _hoisted_1$2, [
+          vue.createVNode(_sfc_main$7, {
+            url: __props.configUrl,
+            "map-key": __props.mapKey,
+            onOnload: onMapLoad
+          }, null, 8, ["url", "map-key"]),
+          !__props.hideToolbar ? (vue.openBlock(), vue.createBlock(ToolbarPanel, {
+            key: 0,
+            "active-draw-type": vue.unref(draw).activeDrawType.value,
+            onToolActivate: handleToolActivate,
+            onClear: handleClear
+          }, null, 8, ["active-draw-type"])) : vue.createCommentVNode("", true),
+          !__props.hideVision ? (vue.openBlock(), vue.createBlock(VisionPanel, {
+            key: 1,
+            "circle-fly-active": vue.unref(vision).circleFlyActive.value,
+            "fly-to-active": vue.unref(vision).flyToActive.value,
+            "first-person-active": vue.unref(vision).firstPersonActive.value,
+            "keyboard-navigate-active": vue.unref(vision).keyboardActive.value,
+            onVisionExecute: handleVisionExecute
+          }, null, 8, ["circle-fly-active", "fly-to-active", "first-person-active", "keyboard-navigate-active"])) : vue.createCommentVNode("", true),
+          vue.renderSlot(_ctx.$slots, "default", {}, void 0, true)
+        ]);
+      };
+    }
+  });
+  const MarsMapContainer = /* @__PURE__ */ _export_sfc(_sfc_main$4, [["__scopeId", "data-v-9c769713"]]);
+  const CATEGORY_ICON = {
+    default: "//data.mars3d.cn/img/marker/mark-blue.png",
+    warning: "//data.mars3d.cn/img/marker/mark-red.png",
+    info: "//data.mars3d.cn/img/marker/mark-green.png"
+  };
+  let _idCounter$1 = 1;
+  function usePoiMarker(mapCtx) {
+    const poiLayer = vue.shallowRef(null);
+    const poiList = vue.ref([]);
+    const activePoiId = vue.ref(null);
+    function initPoiLayer() {
+      const map = mapCtx.map.value;
+      if (!map) return;
+      const layer = new mars3d__namespace.layer.GraphicLayer();
+      map.addLayer(layer);
+      poiLayer.value = layer;
+      layer.on(mars3d__namespace.EventType.click, (e) => {
+        var _a, _b;
+        const poiId = (_b = (_a = e.graphic) == null ? void 0 : _a.attr) == null ? void 0 : _b.poiId;
+        if (poiId) selectPoi(poiId);
+      });
+    }
+    function addPoi(params) {
+      const layer = poiLayer.value;
+      if (!layer) return null;
+      const id = `poi-${_idCounter$1++}`;
+      const graphic = new mars3d__namespace.graphic.BillboardEntity({
+        position: [params.lng, params.lat, params.alt],
+        style: {
+          image: CATEGORY_ICON[params.category],
+          scale: 1,
+          horizontalOrigin: mars3d__namespace.Cesium.HorizontalOrigin.CENTER,
+          verticalOrigin: mars3d__namespace.Cesium.VerticalOrigin.BOTTOM,
+          clampToGround: false,
+          // 标注文字
+          label: {
+            text: params.name,
+            font_size: 14,
+            color: "#ffffff",
+            outline: true,
+            outlineColor: "#333333",
+            outlineWidth: 2,
+            pixelOffset: new mars3d__namespace.Cesium.Cartesian2(0, -40),
+            visibleDepth: false
+          }
+        },
+        // popup 弹窗（点击标注时自动展示）
+        popup: buildPopupHtml(params),
+        attr: { poiId: id, name: params.name }
+      });
+      layer.addGraphic(graphic);
+      const poi = { ...params, id, graphic };
+      poiList.value.push(poi);
+      return poi;
+    }
+    function removePoi(id) {
+      var _a;
+      const idx = poiList.value.findIndex((p) => p.id === id);
+      if (idx === -1) return;
+      const poi = poiList.value[idx];
+      poi.graphic && ((_a = poiLayer.value) == null ? void 0 : _a.removeGraphic(poi.graphic));
+      poiList.value.splice(idx, 1);
+      if (activePoiId.value === id) activePoiId.value = null;
+    }
+    function selectPoi(id, flyTo = false) {
+      activePoiId.value = id;
+      const poi = poiList.value.find((p) => p.id === id);
+      if (!poi) return;
+      poiList.value.forEach((p) => {
+        if (p.graphic) {
+          p.graphic.style.scale = p.id === id ? 1.4 : 1;
+        }
+      });
+      if (flyTo) flyToPoi(id);
+    }
+    function updatePoiName(id, newName) {
+      var _a, _b, _c;
+      const poi = poiList.value.find((p) => p.id === id);
+      if (!poi) return;
+      poi.name = newName;
+      if (poi.graphic) {
+        poi.graphic.attr = { ...poi.graphic.attr, name: newName };
+        poi.graphic.popup = buildPopupHtml(poi);
+        if ((_a = poi.graphic.style) == null ? void 0 : _a.label) {
+          poi.graphic.style.label.text = newName;
+        }
+        (_c = (_b = poi.graphic).closePopup) == null ? void 0 : _c.call(_b);
+      }
+    }
+    function flyToPoi(id) {
+      const poi = poiList.value.find((p) => p.id === id);
+      if (!poi || !mapCtx.map.value) return;
+      const map = mapCtx.map.value;
+      const baseAlt = poi.alt > 1 ? poi.alt : 50;
+      const flyAlt = baseAlt + 1500;
+      map.setCameraView({ lng: poi.lng, lat: poi.lat, alt: flyAlt }, { duration: 1.5 });
+    }
+    function clearAll() {
+      var _a;
+      (_a = poiLayer.value) == null ? void 0 : _a.clear();
+      poiList.value = [];
+      activePoiId.value = null;
+    }
+    const isAddMode = vue.ref(false);
+    let _clickHandler = null;
+    function toggleAddMode(onAdded, defaultName = "新标注", category = "default") {
+      const map = mapCtx.map.value;
+      if (!map) return;
+      if (isAddMode.value) {
+        if (_clickHandler) {
+          map.off(mars3d__namespace.EventType.click, _clickHandler);
+          _clickHandler = null;
+        }
+        isAddMode.value = false;
+      } else {
+        isAddMode.value = true;
+        _clickHandler = (e) => {
+          let lng, lat, alt;
+          if (e.lnglat) {
+            lng = e.lnglat.lng;
+            lat = e.lnglat.lat;
+            alt = e.lnglat.alt ?? 0;
+          } else if (e.cartesian) {
+            const carto = mars3d__namespace.Cesium.Cartographic.fromCartesian(e.cartesian);
+            lng = mars3d__namespace.Cesium.Math.toDegrees(carto.longitude);
+            lat = mars3d__namespace.Cesium.Math.toDegrees(carto.latitude);
+            alt = carto.height > 0 ? carto.height : 50;
+          } else {
+            return;
+          }
+          const finalAlt = alt > 1 ? alt : 50;
+          const poi = addPoi({
+            name: `${defaultName} ${_idCounter$1}`,
+            lng,
+            lat,
+            alt: finalAlt,
+            category
+          });
+          if (poi) onAdded == null ? void 0 : onAdded(poi);
+          toggleAddMode();
+        };
+        map.on(mars3d__namespace.EventType.click, _clickHandler);
+      }
+    }
+    return {
+      poiLayer,
+      poiList,
+      activePoiId,
+      isAddMode,
+      initPoiLayer,
+      addPoi,
+      removePoi,
+      selectPoi,
+      flyToPoi,
+      updatePoiName,
+      clearAll,
+      toggleAddMode
+    };
+  }
+  function buildPopupHtml(poi) {
+    return `
+    <div style="padding:8px 12px;min-width:160px;">
+      <div style="font-size:15px;font-weight:bold;margin-bottom:6px;color:#fff;">${poi.name}</div>
+      <div style="font-size:12px;color:#adc6e5;line-height:1.8;">
+        <div>经度：${poi.lng.toFixed(6)}</div>
+        <div>纬度：${poi.lat.toFixed(6)}</div>
+        <div>高度：${poi.alt.toFixed(1)} m</div>
+        ${poi.description ? `<div style="margin-top:4px;">${poi.description}</div>` : ""}
+      </div>
+    </div>
+  `;
+  }
+  const _sfc_main$3 = /* @__PURE__ */ vue.defineComponent({
+    __name: "PoiMarkerLayer",
+    setup(__props, { expose: __expose }) {
+      const mapCtx = vue.inject("mapContext");
+      if (!mapCtx) throw new Error("[PoiMarkerLayer] 必须放置在 MarsMapContainer 内部");
+      const poi = usePoiMarker(mapCtx);
+      const stopWatch = vue.watch(
+        () => mapCtx.map.value,
+        (map) => {
+          if (map) {
+            poi.initPoiLayer();
+            stopWatch();
+          }
+        },
+        { immediate: true }
+      );
+      vue.onUnmounted(() => {
+        poi.clearAll();
+      });
+      vue.provide("poiContext", poi);
+      __expose(poi);
+      return (_ctx, _cache) => {
+        return vue.renderSlot(_ctx.$slots, "default");
+      };
+    }
+  });
+  const _hoisted_1$1 = {
+    key: 0,
+    class: "collapsed-icon-wrap"
+  };
+  const _hoisted_2$1 = { class: "poi-count poi-count--collapsed" };
+  const _hoisted_3$1 = { class: "poi-panel__title" };
+  const _hoisted_4$1 = { class: "poi-count" };
+  const _hoisted_5$1 = { class: "poi-panel__body" };
+  const _hoisted_6$1 = { class: "poi-panel__toolbar" };
+  const _hoisted_7$1 = ["disabled"];
+  const _hoisted_8$1 = { class: "poi-panel__filter" };
+  const _hoisted_9$1 = ["onClick"];
+  const _hoisted_10$1 = { class: "poi-panel__list" };
+  const _hoisted_11$1 = ["onClick"];
+  const _hoisted_12$1 = { class: "poi-item__info" };
+  const _hoisted_13$1 = ["onDblclick"];
+  const _hoisted_14$1 = { class: "poi-item__coord" };
+  const _hoisted_15$1 = { class: "poi-item__actions" };
+  const _hoisted_16$1 = ["onClick"];
+  const _hoisted_17$1 = ["onClick"];
+  const _hoisted_18$1 = ["onClick"];
+  const _hoisted_19$1 = {
+    key: 0,
+    class: "poi-panel__empty"
+  };
+  const _sfc_main$2 = /* @__PURE__ */ vue.defineComponent({
+    __name: "PoiMarkerPanel",
+    setup(__props) {
+      const poi = vue.inject("poiContext");
+      if (!poi) throw new Error("[PoiMarkerPanel] 必须与 PoiMarkerLayer 同级使用");
+      const isCollapsed = vue.ref(true);
+      const toggleCollapse = () => {
+        isCollapsed.value = !isCollapsed.value;
+      };
+      const panelEl = vue.ref(null);
+      const isDragging = vue.ref(false);
+      const pos = vue.reactive({ x: 10, y: 10 });
+      let dragStartX = 0;
+      let dragStartY = 0;
+      let origX = 0;
+      let origY = 0;
+      function startDrag(e) {
+        isDragging.value = true;
+        dragStartX = e.clientX;
+        dragStartY = e.clientY;
+        origX = pos.x;
+        origY = pos.y;
+        document.addEventListener("mousemove", onDrag);
+        document.addEventListener("mouseup", stopDrag);
+      }
+      function onDrag(e) {
+        if (!isDragging.value) return;
+        pos.x = origX + (e.clientX - dragStartX);
+        pos.y = origY + (e.clientY - dragStartY);
+      }
+      function stopDrag() {
+        isDragging.value = false;
+        document.removeEventListener("mousemove", onDrag);
+        document.removeEventListener("mouseup", stopDrag);
+      }
+      const categories = [
+        { value: "all", label: "全部", icon: "fa-list", color: "#aaa" },
+        { value: "default", label: "普通", icon: "fa-map-marker", color: "#3ea6ff" },
+        {
+          value: "warning",
+          label: "警告",
+          icon: "fa-exclamation-triangle",
+          color: "#ff6b6b"
+        },
+        { value: "info", label: "信息", icon: "fa-info-circle", color: "#52c41a" }
+      ];
+      const activeCategory = vue.ref("all");
+      const filteredList = vue.computed(() => {
+        if (activeCategory.value === "all") return poi.poiList.value;
+        return poi.poiList.value.filter((p) => p.category === activeCategory.value);
+      });
+      const getCategoryColor = (cat) => {
+        const map = {
+          default: "#3ea6ff",
+          warning: "#ff6b6b",
+          info: "#52c41a"
+        };
+        return map[cat] ?? "#aaa";
+      };
+      const addCategory = vue.ref("default");
+      function toggleAdd() {
+        poi.toggleAddMode(
+          void 0,
+          // onAdded 回调（可按需传）
+          "标注点",
+          addCategory.value
+        );
+      }
+      function onSelect(id) {
+        poi.selectPoi(id, true);
+      }
+      function onFlyTo(id) {
+        poi.flyToPoi(id);
+      }
+      function onRemove(id) {
+        poi.removePoi(id);
+      }
+      const editingId = vue.ref(null);
+      const editName = vue.ref("");
+      const editInputEl = vue.ref(null);
+      function startEdit(item) {
+        editingId.value = item.id;
+        editName.value = item.name;
+        setTimeout(() => {
+          var _a;
+          return (_a = editInputEl.value) == null ? void 0 : _a.select();
+        }, 30);
+      }
+      function saveEdit() {
+        if (editingId.value && editName.value.trim()) {
+          poi.updatePoiName(editingId.value, editName.value.trim());
+        }
+        cancelEdit();
+      }
+      function cancelEdit() {
+        editingId.value = null;
+        editName.value = "";
+      }
+      function confirmClear() {
+        if (window.confirm(`确认清空全部 ${poi.poiList.value.length} 个标注？`)) {
+          poi.clearAll();
+        }
+      }
+      return (_ctx, _cache) => {
+        return vue.openBlock(), vue.createElementBlock("div", {
+          ref_key: "panelEl",
+          ref: panelEl,
+          class: vue.normalizeClass(["poi-panel", { collapsed: isCollapsed.value }]),
+          style: vue.normalizeStyle(
+            !isCollapsed.value ? { left: pos.x + "px", top: pos.y + "px" } : { left: pos.x + "px", top: pos.y + "px" }
+          )
+        }, [
+          vue.createElementVNode("div", {
+            class: vue.normalizeClass(["poi-panel__header", { "is-dragging": isDragging.value }]),
+            onMousedown: vue.withModifiers(startDrag, ["prevent"]),
+            onClick: _cache[0] || (_cache[0] = ($event) => isDragging.value ? null : toggleCollapse())
+          }, [
+            isCollapsed.value ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_1$1, [
+              _cache[3] || (_cache[3] = vue.createElementVNode("i", { class: "fa fa-map-marker collapsed-icon" }, null, -1)),
+              vue.createElementVNode("span", _hoisted_2$1, vue.toDisplayString(filteredList.value.length), 1)
+            ])) : (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 1 }, [
+              vue.createElementVNode("span", _hoisted_3$1, [
+                _cache[4] || (_cache[4] = vue.createElementVNode("i", { class: "fa fa-map-marker" }, null, -1)),
+                _cache[5] || (_cache[5] = vue.createTextVNode(" POI 标注管理 ", -1)),
+                vue.createElementVNode("span", _hoisted_4$1, vue.toDisplayString(filteredList.value.length), 1)
+              ]),
+              _cache[6] || (_cache[6] = vue.createElementVNode("i", { class: "fa fa-chevron-left collapse-icon" }, null, -1))
+            ], 64))
+          ], 34),
+          vue.withDirectives(vue.createElementVNode("div", _hoisted_5$1, [
+            vue.createElementVNode("div", _hoisted_6$1, [
+              vue.createElementVNode("button", {
+                class: vue.normalizeClass(["btn", { "btn--active": vue.unref(poi).isAddMode.value }]),
+                onClick: toggleAdd
+              }, [
+                vue.createElementVNode("i", {
+                  class: vue.normalizeClass(["fa", vue.unref(poi).isAddMode.value ? "fa-times" : "fa-plus"])
+                }, null, 2),
+                vue.createTextVNode(" " + vue.toDisplayString(vue.unref(poi).isAddMode.value ? "取消添加" : "点击地图添加"), 1)
+              ], 2),
+              vue.createElementVNode("button", {
+                class: "btn btn--danger",
+                onClick: confirmClear,
+                disabled: vue.unref(poi).poiList.value.length === 0
+              }, [..._cache[7] || (_cache[7] = [
+                vue.createElementVNode("i", { class: "fa fa-trash-o" }, null, -1),
+                vue.createTextVNode(" 清空 ", -1)
+              ])], 8, _hoisted_7$1)
+            ]),
+            vue.createElementVNode("div", _hoisted_8$1, [
+              (vue.openBlock(), vue.createElementBlock(vue.Fragment, null, vue.renderList(categories, (cat) => {
+                return vue.createElementVNode("span", {
+                  key: cat.value,
+                  class: vue.normalizeClass(["filter-tag", { active: activeCategory.value === cat.value }]),
+                  onClick: ($event) => activeCategory.value = cat.value
+                }, [
+                  vue.createElementVNode("i", {
+                    class: vue.normalizeClass(["fa", cat.icon]),
+                    style: vue.normalizeStyle({ color: cat.color })
+                  }, null, 6),
+                  vue.createTextVNode(" " + vue.toDisplayString(cat.label), 1)
+                ], 10, _hoisted_9$1);
+              }), 64))
+            ]),
+            vue.createElementVNode("div", _hoisted_10$1, [
+              vue.createVNode(vue.TransitionGroup, { name: "poi-list" }, {
+                default: vue.withCtx(() => [
+                  (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(filteredList.value, (item) => {
+                    return vue.openBlock(), vue.createElementBlock("div", {
+                      key: item.id,
+                      class: vue.normalizeClass(["poi-item", { "poi-item--active": vue.unref(poi).activePoiId.value === item.id }]),
+                      onClick: ($event) => onSelect(item.id)
+                    }, [
+                      vue.createElementVNode("span", {
+                        class: "poi-item__dot",
+                        style: vue.normalizeStyle({ background: getCategoryColor(item.category) })
+                      }, null, 4),
+                      vue.createElementVNode("div", _hoisted_12$1, [
+                        editingId.value === item.id ? vue.withDirectives((vue.openBlock(), vue.createElementBlock("input", {
+                          key: 0,
+                          class: "poi-item__name-input",
+                          "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => editName.value = $event),
+                          onKeydown: [
+                            vue.withKeys(saveEdit, ["enter"]),
+                            vue.withKeys(cancelEdit, ["escape"])
+                          ],
+                          onClick: _cache[2] || (_cache[2] = vue.withModifiers(() => {
+                          }, ["stop"])),
+                          ref_for: true,
+                          ref_key: "editInputEl",
+                          ref: editInputEl
+                        }, null, 544)), [
+                          [vue.vModelText, editName.value]
+                        ]) : (vue.openBlock(), vue.createElementBlock("div", {
+                          key: 1,
+                          class: "poi-item__name",
+                          onDblclick: vue.withModifiers(($event) => startEdit(item), ["stop"])
+                        }, vue.toDisplayString(item.name), 41, _hoisted_13$1)),
+                        vue.createElementVNode("div", _hoisted_14$1, vue.toDisplayString(item.lng.toFixed(4)) + ", " + vue.toDisplayString(item.lat.toFixed(4)), 1)
+                      ]),
+                      vue.createElementVNode("div", _hoisted_15$1, [
+                        vue.createElementVNode("button", {
+                          class: "icon-btn",
+                          title: "编辑名称",
+                          onClick: vue.withModifiers(($event) => startEdit(item), ["stop"])
+                        }, [..._cache[8] || (_cache[8] = [
+                          vue.createElementVNode("i", { class: "fa fa-pencil" }, null, -1)
+                        ])], 8, _hoisted_16$1),
+                        vue.createElementVNode("button", {
+                          class: "icon-btn",
+                          title: "飞行定位",
+                          onClick: vue.withModifiers(($event) => onFlyTo(item.id), ["stop"])
+                        }, [..._cache[9] || (_cache[9] = [
+                          vue.createElementVNode("i", { class: "fa fa-crosshairs" }, null, -1)
+                        ])], 8, _hoisted_17$1),
+                        vue.createElementVNode("button", {
+                          class: "icon-btn icon-btn--danger",
+                          title: "删除",
+                          onClick: vue.withModifiers(($event) => onRemove(item.id), ["stop"])
+                        }, [..._cache[10] || (_cache[10] = [
+                          vue.createElementVNode("i", { class: "fa fa-times" }, null, -1)
+                        ])], 8, _hoisted_18$1)
+                      ])
+                    ], 10, _hoisted_11$1);
+                  }), 128))
+                ]),
+                _: 1
+              }),
+              filteredList.value.length === 0 ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_19$1, [
+                _cache[11] || (_cache[11] = vue.createElementVNode("i", { class: "fa fa-map-o" }, null, -1)),
+                vue.createElementVNode("p", null, vue.toDisplayString(vue.unref(poi).isAddMode.value ? "请在地图上点击添加标注" : "暂无标注数据"), 1)
+              ])) : vue.createCommentVNode("", true)
+            ])
+          ], 512), [
+            [vue.vShow, !isCollapsed.value]
+          ])
+        ], 6);
+      };
+    }
+  });
+  const PoiMarkerPanel = /* @__PURE__ */ _export_sfc(_sfc_main$2, [["__scopeId", "data-v-b2f25973"]]);
+  let _idCounter = 1;
+  function useTrack(mapCtx) {
+    const trackLayer = vue.shallowRef(null);
+    const trackList = vue.ref([]);
+    const activeTrackId = vue.ref(null);
+    const isPlaying = vue.ref(false);
+    const currentTime = vue.ref(0);
+    const playbackSpeed = vue.ref(1);
+    const playbackProgress = vue.ref(0);
+    const isRealtimeMode = vue.ref(false);
+    const activeRealtimeId = vue.ref(null);
+    let _playInterval = null;
+    function initTrackLayer() {
+      const map = mapCtx.map.value;
+      if (!map) return;
+      const layer = new mars3d__namespace.layer.GraphicLayer();
+      map.addLayer(layer);
+      trackLayer.value = layer;
+    }
+    function _buildLineGraphic(track) {
+      const layer = trackLayer.value;
+      if (!layer) return null;
+      const positions = track.points.map((p) => [p.lng, p.lat, p.alt]);
+      const line = new mars3d__namespace.graphic.PolylinePrimitive({
+        positions,
+        style: {
+          color: mars3d__namespace.Cesium.Color.fromCssColorString("#3ea6ff"),
+          width: 3,
+          opacity: 0.9,
+          clampToGround: false
+        },
+        attr: { trackId: track.id }
+      });
+      layer.addGraphic(line);
+      return line;
+    }
+    function _appendRealtimeLine(track, fromIdx, toIdx) {
+      const layer = trackLayer.value;
+      if (!layer || toIdx <= fromIdx) return;
+      const positions = track.points.slice(fromIdx, toIdx + 1).map((p) => [p.lng, p.lat, p.alt]);
+      const segment = new mars3d__namespace.graphic.PolylinePrimitive({
+        positions,
+        style: {
+          color: mars3d__namespace.Cesium.Color.fromCssColorString("#ff6b35"),
+          width: 4,
+          opacity: 1,
+          clampToGround: false
+        }
+      });
+      layer.addGraphic(segment);
+      if (!track.realtimeLineSegments) {
+        track.realtimeLineSegments = [];
+      }
+      track.realtimeLineSegments.push(segment);
+    }
+    function _updateRealtimeMarker(track) {
+      const layer = trackLayer.value;
+      if (!layer) return;
+      const lastPoint = track.points[track.realtimeDrawnIdx];
+      if (!lastPoint) return;
+      if (track.realtimePoint) {
+        track.realtimePoint.position = [lastPoint.lng, lastPoint.lat, lastPoint.alt];
+      } else {
+        const marker = new mars3d__namespace.graphic.BillboardEntity({
+          position: [lastPoint.lng, lastPoint.lat, lastPoint.alt],
+          style: {
+            image: "//data.mars3d.cn/img/marker/mark-blue.png",
+            scale: 1.2,
+            horizontalOrigin: mars3d__namespace.Cesium.HorizontalOrigin.CENTER,
+            verticalOrigin: mars3d__namespace.Cesium.VerticalOrigin.BOTTOM
+          }
+        });
+        layer.addGraphic(marker);
+        track.realtimePoint = marker;
+      }
+    }
+    function addTrack(points, name = "轨迹") {
+      const layer = trackLayer.value;
+      if (!layer) return null;
+      const id = `track-${_idCounter++}`;
+      const track = { id, name, points };
+      track.lineGraphic = _buildLineGraphic(track);
+      trackList.value.push(track);
+      return track;
+    }
+    function startRealtime(name = "实时轨迹") {
+      if (activeRealtimeId.value) stopRealtime();
+      const layer = trackLayer.value;
+      if (!layer) return null;
+      const id = `realtime-${_idCounter++}`;
+      const track = {
+        id,
+        name,
+        points: [],
+        realtimeDrawnIdx: -1
+      };
+      trackLayer.value = layer;
+      trackList.value.push(track);
+      activeRealtimeId.value = id;
+      isRealtimeMode.value = true;
+      return track;
+    }
+    function pushRealtimePoint(id, lng, lat, alt = 0) {
+      const track = trackList.value.find((t) => t.id === id);
+      if (!track) return;
+      const point = {
+        time: Date.now(),
+        lng,
+        lat,
+        alt
+      };
+      track.points.push(point);
+      track.realtimeDrawnIdx = track.points.length - 1;
+      if (track.points.length === 1) {
+        track.lineGraphic = _buildLineGraphic(track);
+        _updateRealtimeMarker(track);
+      } else {
+        _appendRealtimeLine(track, track.points.length - 2, track.points.length - 1);
+        _updateRealtimeMarker(track);
+      }
+      if (mapCtx.map.value) {
+        mapCtx.map.value.flyToPoint(
+          [lng, lat, alt + 50],
+          { radius: 500, duration: 0.5 }
+        );
+      }
+    }
+    function stopRealtime(id) {
+      var _a;
+      const targetId = id ?? activeRealtimeId.value;
+      if (!targetId) return;
+      const track = trackList.value.find((t) => t.id === targetId);
+      if (track) {
+        track.realtimeDrawnIdx = void 0;
+        if (track.realtimePoint) {
+          (_a = trackLayer.value) == null ? void 0 : _a.removeGraphic(track.realtimePoint);
+          track.realtimePoint = void 0;
+        }
+      }
+      if (activeRealtimeId.value === targetId) {
+        activeRealtimeId.value = null;
+        isRealtimeMode.value = false;
+      }
+    }
+    function play(trackId) {
+      const id = trackId ?? activeTrackId.value;
+      if (!id) return;
+      const track = trackList.value.find((t) => t.id === id);
+      if (!track || track.points.length < 2) return;
+      if (activeTrackId.value !== id) {
+        selectTrack(id);
+      }
+      isPlaying.value = true;
+      _clearPlayInterval();
+      const start = track.points[0].time;
+      const end = track.points[track.points.length - 1].time;
+      _playInterval = setInterval(() => {
+        const track2 = trackList.value.find((t) => t.id === activeTrackId.value);
+        if (!track2 || !isPlaying.value) return;
+        const elapsed = Date.now() - (track2._playStartTime ?? Date.now());
+        const total = end - start;
+        const progress = Math.min(elapsed / total, 1);
+        currentTime.value = start + progress * total;
+        playbackProgress.value = progress * 100;
+        const targetIdx = Math.floor(progress * (track2.points.length - 1));
+        _updatePlaybackLine(track2, targetIdx);
+      }, 60);
+    }
+    function _updatePlaybackLine(track, toIdx) {
+      var _a;
+      const layer = trackLayer.value;
+      if (!layer) return;
+      if (track.lineGraphic) {
+        layer.removeGraphic(track.lineGraphic);
+      }
+      const positions = track.points.slice(0, toIdx + 1).map((p) => [p.lng, p.lat, p.alt]);
+      track.lineGraphic = new mars3d__namespace.graphic.PolylinePrimitive({
+        positions,
+        style: {
+          color: mars3d__namespace.Cesium.Color.fromCssColorString("#00ff88"),
+          width: 4,
+          opacity: 1,
+          clampToGround: false
+        }
+      });
+      layer.addGraphic(track.lineGraphic);
+      const pt = track.points[toIdx];
+      (_a = mapCtx.map.value) == null ? void 0 : _a.flyToPoint(
+        [pt.lng, pt.lat, pt.alt + 200],
+        { radius: 300, duration: 0 }
+      );
+    }
+    function pause() {
+      isPlaying.value = false;
+      _clearPlayInterval();
+    }
+    function stop() {
+      isPlaying.value = false;
+      playbackProgress.value = 0;
+      currentTime.value = 0;
+      _clearPlayInterval();
+      const track = trackList.value.find((t) => t.id === activeTrackId.value);
+      if (track && trackLayer.value) {
+        if (track.lineGraphic) trackLayer.value.removeGraphic(track.lineGraphic);
+        track.lineGraphic = _buildLineGraphic(track);
+      }
+    }
+    function setSpeed(speed) {
+      playbackSpeed.value = speed;
+      if (isPlaying.value) {
+        pause();
+        play();
+      }
+    }
+    function seek(progress) {
+      const track = trackList.value.find((t) => t.id === activeTrackId.value);
+      if (!track) return;
+      const targetIdx = Math.floor(progress / 100 * (track.points.length - 1));
+      currentTime.value = track.points[targetIdx].time;
+      playbackProgress.value = progress;
+      _updatePlaybackLine(track, targetIdx);
+    }
+    function selectTrack(id) {
+      activeTrackId.value = id;
+      stop();
+    }
+    function flyToTrack(id) {
+      const track = trackList.value.find((t) => t.id === id);
+      if (!track || !mapCtx.map.value) return;
+      const first = track.points[0];
+      mapCtx.map.value.flyToPoint(
+        [first.lng, first.lat, first.alt + 2e3],
+        { radius: 3e3, duration: 1.5 }
+      );
+    }
+    function removeTrack(id) {
+      var _a, _b;
+      const idx = trackList.value.findIndex((t) => t.id === id);
+      if (idx === -1) return;
+      const track = trackList.value[idx];
+      if (track.lineGraphic) (_a = trackLayer.value) == null ? void 0 : _a.removeGraphic(track.lineGraphic);
+      if (track.realtimePoint) (_b = trackLayer.value) == null ? void 0 : _b.removeGraphic(track.realtimePoint);
+      if (track.realtimeLineSegments) {
+        track.realtimeLineSegments.forEach((seg) => {
+          var _a2;
+          (_a2 = trackLayer.value) == null ? void 0 : _a2.removeGraphic(seg);
+        });
+      }
+      trackList.value.splice(idx, 1);
+      if (activeTrackId.value === id) {
+        activeTrackId.value = null;
+        stop();
+      }
+      if (activeRealtimeId.value === id) {
+        activeRealtimeId.value = null;
+        isRealtimeMode.value = false;
+      }
+    }
+    function clearAll() {
+      var _a;
+      stop();
+      stopRealtime();
+      (_a = trackLayer.value) == null ? void 0 : _a.clear();
+      trackList.value = [];
+      activeTrackId.value = null;
+    }
+    function _clearPlayInterval() {
+      if (_playInterval) {
+        clearInterval(_playInterval);
+        _playInterval = null;
+      }
+    }
+    return {
+      trackLayer,
+      trackList,
+      activeTrackId,
+      isPlaying,
+      currentTime,
+      playbackSpeed,
+      playbackProgress,
+      isRealtimeMode,
+      activeRealtimeId,
+      initTrackLayer,
+      addTrack,
+      startRealtime,
+      pushRealtimePoint,
+      stopRealtime,
+      play,
+      pause,
+      stop,
+      setSpeed,
+      seek,
+      selectTrack,
+      flyToTrack,
+      removeTrack,
+      clearAll
+    };
+  }
+  const _sfc_main$1 = /* @__PURE__ */ vue.defineComponent({
+    __name: "TrackLayer",
+    setup(__props, { expose: __expose }) {
+      const mapCtx = vue.inject("mapContext");
+      if (!mapCtx) throw new Error("[TrackLayer] 必须放置在 MarsMapContainer 内部");
+      const track = useTrack(mapCtx);
+      const stopWatch = vue.watch(
+        () => mapCtx.map.value,
+        (map) => {
+          if (map) {
+            track.initTrackLayer();
+            stopWatch();
+          }
+        },
+        { immediate: true }
+      );
+      vue.onUnmounted(() => {
+        track.clearAll();
+      });
+      vue.provide("trackContext", track);
+      __expose(track);
+      return (_ctx, _cache) => {
+        return vue.renderSlot(_ctx.$slots, "default");
+      };
+    }
+  });
+  const _hoisted_1 = {
+    key: 0,
+    class: "collapsed-icon-wrap"
+  };
+  const _hoisted_2 = { class: "track-badge" };
+  const _hoisted_3 = { class: "track-panel__title" };
+  const _hoisted_4 = { class: "track-count" };
+  const _hoisted_5 = { class: "track-panel__body" };
+  const _hoisted_6 = { class: "track-panel__toolbar" };
+  const _hoisted_7 = ["disabled"];
+  const _hoisted_8 = {
+    key: 0,
+    class: "track-panel__playback"
+  };
+  const _hoisted_9 = { class: "playback__track-name" };
+  const _hoisted_10 = { class: "playback__controls" };
+  const _hoisted_11 = { class: "playback__speed" };
+  const _hoisted_12 = { class: "speed-btns" };
+  const _hoisted_13 = ["onClick"];
+  const _hoisted_14 = { class: "playback__timeline" };
+  const _hoisted_15 = { class: "time-label" };
+  const _hoisted_16 = ["value"];
+  const _hoisted_17 = { class: "time-label" };
+  const _hoisted_18 = {
+    key: 1,
+    class: "track-panel__realtime-hint"
+  };
+  const _hoisted_19 = { class: "realtime-count" };
+  const _hoisted_20 = { class: "track-panel__list" };
+  const _hoisted_21 = ["onClick"];
+  const _hoisted_22 = { class: "track-item__info" };
+  const _hoisted_23 = { class: "track-item__name" };
+  const _hoisted_24 = { class: "track-item__meta" };
+  const _hoisted_25 = {
+    key: 0,
+    class: "realtime-tag"
+  };
+  const _hoisted_26 = { class: "track-item__actions" };
+  const _hoisted_27 = ["onClick"];
+  const _hoisted_28 = ["onClick"];
+  const _hoisted_29 = {
+    key: 0,
+    class: "track-panel__empty"
+  };
+  const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+    __name: "TrackPanel",
+    setup(__props) {
+      const track = vue.inject("trackContext");
+      if (!track) throw new Error("[TrackPanel] 必须与 TrackLayer 同级使用");
+      const isCollapsed = vue.ref(true);
+      const isDragging = vue.ref(false);
+      const pos = vue.reactive({ x: 10, y: 80 });
+      let dragStartX = 0, dragStartY = 0, origX = 0, origY = 0;
+      function toggleCollapse() {
+        isCollapsed.value = !isCollapsed.value;
+      }
+      function startDrag(e) {
+        isDragging.value = true;
+        dragStartX = e.clientX;
+        dragStartY = e.clientY;
+        origX = pos.x;
+        origY = pos.y;
+        document.addEventListener("mousemove", onDrag);
+        document.addEventListener("mouseup", stopDrag);
+      }
+      function onDrag(e) {
+        if (!isDragging.value) return;
+        pos.x = origX + (e.clientX - dragStartX);
+        pos.y = origY + (e.clientY - dragStartY);
+      }
+      function stopDrag() {
+        isDragging.value = false;
+        document.removeEventListener("mousemove", onDrag);
+        document.removeEventListener("mouseup", stopDrag);
+      }
+      function onSelectTrack(id) {
+        if (track.activeTrackId.value === id) return;
+        track.selectTrack(id);
+        track.stop();
+      }
+      const activeTrackName = vue.computed(() => {
+        const t = track.trackList.value.find(
+          (x) => x.id === track.activeTrackId.value
+        );
+        return (t == null ? void 0 : t.name) ?? "";
+      });
+      const trackMaxTime = vue.computed(() => {
+        const t = track.trackList.value.find(
+          (x) => x.id === track.activeTrackId.value
+        );
+        if (!t || t.points.length < 2) return 0;
+        return t.points[t.points.length - 1].time;
+      });
+      const speedOptions = [1, 2, 4, 8];
+      function onSeek(e) {
+        const val = parseFloat(e.target.value);
+        track.seek(val);
+      }
+      function formatTime(ts) {
+        if (!ts) return "00:00";
+        const d = new Date(ts);
+        return `${String(d.getMinutes()).padStart(2, "0")}:${String(d.getSeconds()).padStart(2, "0")}`;
+      }
+      function addDemoTrack() {
+        const baseLng = 116.3974;
+        const baseLat = 39.909;
+        const points = [];
+        let t = Date.now();
+        let heading = Math.random() * Math.PI * 2;
+        const STEP = 20;
+        for (let i = 0; i < STEP; i++) {
+          t += 5e3 + Math.random() * 5e3;
+          heading += (Math.random() - 0.5) * (Math.PI / 6);
+          const stepLng = baseLng + Math.cos(heading) * 4e-3;
+          const stepLat = baseLat + Math.sin(heading) * 2e-3;
+          const alt = 30 + Math.sin(i / STEP * Math.PI) * 80;
+          points.push({ time: t, lng: stepLng, lat: stepLat, alt });
+        }
+        track.addTrack(points, `轨迹 ${_counter++}`);
+      }
+      let _counter = 1;
+      let _realtimeTimer = null;
+      let _currentRealtimeId = null;
+      function toggleRealtime() {
+        if (track.isRealtimeMode.value) {
+          stopRealtime();
+        } else {
+          startRealtime();
+        }
+      }
+      function startRealtime() {
+        var _a;
+        const id = (_a = track.startRealtime(`实时轨迹 ${_counter++}`)) == null ? void 0 : _a.id;
+        if (!id) return;
+        _currentRealtimeId = id;
+        const CENTER_LNG = 116.397;
+        const CENTER_LAT = 39.908;
+        const RADIUS_LNG = 4e-3;
+        const RADIUS_LAT = 3e-3;
+        const TOTAL_POINTS = 36;
+        const ANGLE_STEP = 2 * Math.PI / TOTAL_POINTS;
+        let angle = Math.random() * 2 * Math.PI;
+        let pushCount = 0;
+        _realtimeTimer = setInterval(() => {
+          pushCount++;
+          const lng = CENTER_LNG + Math.cos(angle) * RADIUS_LNG;
+          const lat = CENTER_LAT + Math.sin(angle) * RADIUS_LAT;
+          const alt = 40 + Math.sin(angle * 3) * 20;
+          track.pushRealtimePoint(id, lng, lat, alt);
+          angle += ANGLE_STEP;
+          if (pushCount >= TOTAL_POINTS) {
+            stopRealtime();
+          }
+        }, 800);
+      }
+      function stopRealtime() {
+        if (_realtimeTimer) {
+          clearInterval(_realtimeTimer);
+          _realtimeTimer = null;
+        }
+        if (_currentRealtimeId) {
+          track.stopRealtime(_currentRealtimeId);
+          _currentRealtimeId = null;
+        }
+      }
+      const realtimePointCount = vue.computed(() => {
+        const t = track.trackList.value.find((x) => x.id === _currentRealtimeId);
+        return (t == null ? void 0 : t.points.length) ?? 0;
+      });
+      function confirmClear() {
+        if (window.confirm(`确认清空全部 ${track.trackList.value.length} 条轨迹？`)) {
+          stopRealtime();
+          track.clearAll();
+        }
+      }
+      return (_ctx, _cache) => {
+        return vue.openBlock(), vue.createElementBlock("div", {
+          class: vue.normalizeClass(["track-panel", { collapsed: isCollapsed.value }]),
+          style: vue.normalizeStyle({ left: pos.x + "px", top: pos.y + "px" })
+        }, [
+          vue.createElementVNode("div", {
+            class: vue.normalizeClass(["track-panel__header", { "is-dragging": isDragging.value }]),
+            onMousedown: vue.withModifiers(startDrag, ["prevent"]),
+            onClick: _cache[0] || (_cache[0] = ($event) => isDragging.value ? null : toggleCollapse())
+          }, [
+            isCollapsed.value ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_1, [
+              _cache[4] || (_cache[4] = vue.createElementVNode("i", { class: "fa fa-share-alt collapsed-icon" }, null, -1)),
+              vue.createElementVNode("span", _hoisted_2, vue.toDisplayString(vue.unref(track).trackList.value.length), 1)
+            ])) : (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 1 }, [
+              vue.createElementVNode("span", _hoisted_3, [
+                _cache[5] || (_cache[5] = vue.createElementVNode("i", { class: "fa fa-share-alt" }, null, -1)),
+                _cache[6] || (_cache[6] = vue.createTextVNode(" 轨迹管理 ", -1)),
+                vue.createElementVNode("span", _hoisted_4, vue.toDisplayString(vue.unref(track).trackList.value.length), 1)
+              ]),
+              _cache[7] || (_cache[7] = vue.createElementVNode("i", { class: "fa fa-chevron-left collapse-icon" }, null, -1))
+            ], 64))
+          ], 34),
+          vue.withDirectives(vue.createElementVNode("div", _hoisted_5, [
+            vue.createElementVNode("div", _hoisted_6, [
+              vue.createElementVNode("button", {
+                class: "btn btn--primary",
+                onClick: addDemoTrack
+              }, [..._cache[8] || (_cache[8] = [
+                vue.createElementVNode("i", { class: "fa fa-plus" }, null, -1),
+                vue.createTextVNode(" 历史轨迹 ", -1)
+              ])]),
+              vue.createElementVNode("button", {
+                class: vue.normalizeClass(["btn", vue.unref(track).isRealtimeMode.value ? "btn--active" : "btn--info"]),
+                onClick: toggleRealtime
+              }, [
+                vue.createElementVNode("i", {
+                  class: vue.normalizeClass(["fa", vue.unref(track).isRealtimeMode.value ? "fa-stop" : "fa-bolt"])
+                }, null, 2),
+                vue.createTextVNode(" " + vue.toDisplayString(vue.unref(track).isRealtimeMode.value ? "停止推送" : "实时轨迹"), 1)
+              ], 2),
+              vue.createElementVNode("button", {
+                class: "btn btn--danger",
+                onClick: confirmClear,
+                disabled: vue.unref(track).trackList.value.length === 0
+              }, [..._cache[9] || (_cache[9] = [
+                vue.createElementVNode("i", { class: "fa fa-trash-o" }, null, -1)
+              ])], 8, _hoisted_7)
+            ]),
+            vue.unref(track).activeTrackId.value ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_8, [
+              vue.createElementVNode("div", _hoisted_9, [
+                _cache[10] || (_cache[10] = vue.createElementVNode("i", { class: "fa fa-road" }, null, -1)),
+                vue.createTextVNode(" " + vue.toDisplayString(activeTrackName.value) + " ", 1),
+                _cache[11] || (_cache[11] = vue.createElementVNode("span", { class: "playback__mode-badge" }, "历史回放", -1))
+              ]),
+              vue.createElementVNode("div", _hoisted_10, [
+                vue.createElementVNode("button", {
+                  class: "ctrl-btn",
+                  onClick: _cache[1] || (_cache[1] = ($event) => vue.unref(track).stop())
+                }, [..._cache[12] || (_cache[12] = [
+                  vue.createElementVNode("i", { class: "fa fa-stop" }, null, -1)
+                ])]),
+                vue.createElementVNode("button", {
+                  class: "ctrl-btn ctrl-btn--play",
+                  onClick: _cache[2] || (_cache[2] = ($event) => vue.unref(track).isPlaying.value ? vue.unref(track).pause() : vue.unref(track).play())
+                }, [
+                  vue.createElementVNode("i", {
+                    class: vue.normalizeClass(["fa", vue.unref(track).isPlaying.value ? "fa-pause" : "fa-play"])
+                  }, null, 2)
+                ]),
+                vue.createElementVNode("button", {
+                  class: "ctrl-btn",
+                  onClick: _cache[3] || (_cache[3] = ($event) => vue.unref(track).play())
+                }, [..._cache[13] || (_cache[13] = [
+                  vue.createElementVNode("i", { class: "fa fa-refresh" }, null, -1)
+                ])])
+              ]),
+              vue.createElementVNode("div", _hoisted_11, [
+                _cache[14] || (_cache[14] = vue.createElementVNode("span", { class: "speed-label" }, "倍速", -1)),
+                vue.createElementVNode("div", _hoisted_12, [
+                  (vue.openBlock(), vue.createElementBlock(vue.Fragment, null, vue.renderList(speedOptions, (s) => {
+                    return vue.createElementVNode("button", {
+                      key: s,
+                      class: vue.normalizeClass(["speed-btn", { active: vue.unref(track).playbackSpeed.value === s }]),
+                      onClick: ($event) => vue.unref(track).setSpeed(s)
+                    }, vue.toDisplayString(s) + "x ", 11, _hoisted_13);
+                  }), 64))
+                ])
+              ]),
+              vue.createElementVNode("div", _hoisted_14, [
+                vue.createElementVNode("span", _hoisted_15, vue.toDisplayString(formatTime(vue.unref(track).currentTime.value)), 1),
+                vue.createElementVNode("input", {
+                  type: "range",
+                  class: "progress-slider",
+                  min: "0",
+                  max: "100",
+                  step: "0.1",
+                  value: vue.unref(track).playbackProgress.value,
+                  onInput: onSeek
+                }, null, 40, _hoisted_16),
+                vue.createElementVNode("span", _hoisted_17, vue.toDisplayString(formatTime(trackMaxTime.value)), 1)
+              ])
+            ])) : vue.createCommentVNode("", true),
+            vue.unref(track).isRealtimeMode.value && !vue.unref(track).activeTrackId.value ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_18, [
+              _cache[17] || (_cache[17] = vue.createElementVNode("div", { class: "realtime-pulse" }, [
+                vue.createElementVNode("i", { class: "fa fa-bolt" }),
+                vue.createTextVNode(" 实时推送中 "),
+                vue.createElementVNode("span", { class: "blink-dot" })
+              ], -1)),
+              vue.createElementVNode("div", _hoisted_19, [
+                _cache[15] || (_cache[15] = vue.createTextVNode(" 已推送 ", -1)),
+                vue.createElementVNode("strong", null, vue.toDisplayString(realtimePointCount.value), 1),
+                _cache[16] || (_cache[16] = vue.createTextVNode(" 个坐标点 ", -1))
+              ])
+            ])) : vue.createCommentVNode("", true),
+            vue.createElementVNode("div", _hoisted_20, [
+              vue.createVNode(vue.TransitionGroup, { name: "track-list" }, {
+                default: vue.withCtx(() => [
+                  (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(track).trackList.value, (item) => {
+                    return vue.openBlock(), vue.createElementBlock("div", {
+                      key: item.id,
+                      class: vue.normalizeClass(["track-item", {
+                        "track-item--active": vue.unref(track).activeTrackId.value === item.id,
+                        "track-item--realtime": item.id.startsWith("realtime")
+                      }]),
+                      onClick: ($event) => onSelectTrack(item.id)
+                    }, [
+                      vue.createElementVNode("span", {
+                        class: "track-item__bar",
+                        style: vue.normalizeStyle({
+                          background: item.id.startsWith("realtime") ? "#ff6b35" : "#3ea6ff"
+                        })
+                      }, null, 4),
+                      vue.createElementVNode("div", _hoisted_22, [
+                        vue.createElementVNode("div", _hoisted_23, [
+                          vue.createElementVNode("i", {
+                            class: vue.normalizeClass([
+                              "fa",
+                              item.id.startsWith("realtime") ? "fa-bolt" : "fa-road"
+                            ])
+                          }, null, 2),
+                          vue.createTextVNode(" " + vue.toDisplayString(item.name), 1)
+                        ]),
+                        vue.createElementVNode("div", _hoisted_24, [
+                          vue.createTextVNode(vue.toDisplayString(item.points.length) + " 个点 ", 1),
+                          item.id.startsWith("realtime") ? (vue.openBlock(), vue.createElementBlock("span", _hoisted_25, "实时")) : vue.createCommentVNode("", true)
+                        ])
+                      ]),
+                      vue.createElementVNode("div", _hoisted_26, [
+                        vue.createElementVNode("button", {
+                          class: "icon-btn",
+                          title: "飞行",
+                          onClick: vue.withModifiers(($event) => vue.unref(track).flyToTrack(item.id), ["stop"])
+                        }, [..._cache[18] || (_cache[18] = [
+                          vue.createElementVNode("i", { class: "fa fa-crosshairs" }, null, -1)
+                        ])], 8, _hoisted_27),
+                        vue.createElementVNode("button", {
+                          class: "icon-btn icon-btn--danger",
+                          title: "删除",
+                          onClick: vue.withModifiers(($event) => vue.unref(track).removeTrack(item.id), ["stop"])
+                        }, [..._cache[19] || (_cache[19] = [
+                          vue.createElementVNode("i", { class: "fa fa-times" }, null, -1)
+                        ])], 8, _hoisted_28)
+                      ])
+                    ], 10, _hoisted_21);
+                  }), 128))
+                ]),
+                _: 1
+              }),
+              vue.unref(track).trackList.value.length === 0 ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_29, [..._cache[20] || (_cache[20] = [
+                vue.createElementVNode("i", { class: "fa fa-map-o" }, null, -1),
+                vue.createElementVNode("p", null, "暂无轨迹数据", -1)
+              ])])) : vue.createCommentVNode("", true)
+            ])
+          ], 512), [
+            [vue.vShow, !isCollapsed.value]
+          ])
+        ], 6);
+      };
+    }
+  });
+  const TrackPanel = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-3e019b92"]]);
+  const components = {
+    MarsMapContainer,
+    ToolbarPanel,
+    VisionPanel,
+    PoiMarkerLayer: _sfc_main$3,
+    PoiMarkerPanel,
+    TrackLayer: _sfc_main$1,
+    TrackPanel
+  };
+  const YiMap = {
+    install(app, options) {
+      const prefix = (options == null ? void 0 : options.prefix) ?? "";
+      for (const [name, component] of Object.entries(components)) {
+        app.component(prefix ? `${prefix}${name}` : name, component);
+      }
+    }
+  };
+  exports2.MarsMapContainer = MarsMapContainer;
+  exports2.PoiMarkerLayer = _sfc_main$3;
+  exports2.PoiMarkerPanel = PoiMarkerPanel;
+  exports2.ToolbarPanel = ToolbarPanel;
+  exports2.TrackLayer = _sfc_main$1;
+  exports2.TrackPanel = TrackPanel;
+  exports2.VisionPanel = VisionPanel;
+  exports2.default = YiMap;
+  exports2.useDraw = useDraw;
+  exports2.useMap = useMap;
+  exports2.useMeasure = useMeasure;
+  exports2.usePoiMarker = usePoiMarker;
+  exports2.useTrack = useTrack;
+  exports2.useVision = useVision;
+  Object.defineProperties(exports2, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+});
+//# sourceMappingURL=yi-map-web.umd.cjs.map