vesium 1.0.1-beta.44 → 1.0.1-beta.46

package/dist/index.iife.js

@@ -1,18 +1,1519 @@
-var Vesium = function(exports, core, shared) {
+var Vesium = function(exports, core, cesium, vue) {
   "use strict";
-  Object.keys(core).forEach((k) => {
-    if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-      enumerable: true,
-      get: () => core[k]
-    });
-  });
-  Object.keys(shared).forEach((k) => {
-    if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-      enumerable: true,
-      get: () => shared[k]
-    });
-  });
+  const CREATE_VIEWER_INJECTION_KEY = Symbol("CREATE_VIEWER_INJECTION_KEY");
+  const CREATE_VIEWER_COLLECTION = /* @__PURE__ */ new WeakMap();
+  function createViewer(...args) {
+    const viewer = vue.shallowRef();
+    const readonlyViewer = vue.shallowReadonly(viewer);
+    vue.provide(CREATE_VIEWER_INJECTION_KEY, readonlyViewer);
+    const scope = vue.getCurrentScope();
+    if (scope) {
+      CREATE_VIEWER_COLLECTION.set(scope, readonlyViewer);
+    }
+    const canvas = vue.computed(() => {
+      var _a;
+      return (_a = viewer.value) == null ? void 0 : _a.canvas;
+    });
+    core.useMutationObserver(document == null ? void 0 : document.body, () => {
+      if (canvas.value && !(document == null ? void 0 : document.body.contains(canvas.value))) {
+        viewer.value = void 0;
+      }
+    }, {
+      childList: true,
+      subtree: true
+    });
+    vue.watchEffect((onCleanup) => {
+      const [arg1, arg2] = args;
+      const value = vue.toRaw(vue.toValue(arg1));
+      if (value instanceof cesium.Viewer) {
+        viewer.value = vue.markRaw(value);
+      } else if (value) {
+        const element = value;
+        const options = arg2;
+        viewer.value = new cesium.Viewer(element, options);
+        onCleanup(() => {
+          var _a, _b;
+          return !((_a = viewer.value) == null ? void 0 : _a.isDestroyed()) && ((_b = viewer.value) == null ? void 0 : _b.destroy());
+        });
+      } else {
+        viewer.value = void 0;
+      }
+    });
+    core.tryOnScopeDispose(() => {
+      viewer.value = void 0;
+    });
+    return vue.computed(() => {
+      var _a;
+      return ((_a = viewer.value) == null ? void 0 : _a.isDestroyed()) ? void 0 : viewer.value;
+    });
+  }
+  const toString = Object.prototype.toString;
+  function isDef(val) {
+    return typeof val !== "undefined";
+  }
+  function isBoolean(val) {
+    return typeof val === "boolean";
+  }
+  function isFunction(val) {
+    return typeof val === "function";
+  }
+  function isNumber(val) {
+    return typeof val === "number";
+  }
+  function isString(val) {
+    return typeof val === "string";
+  }
+  function isObject(val) {
+    return toString.call(val) === "[object Object]";
+  }
+  function isWindow(val) {
+    return typeof window !== "undefined" && toString.call(val) === "[object Window]";
+  }
+  function isPromise(val) {
+    return !!val && (typeof val === "object" || typeof val === "function") && typeof val.then === "function";
+  }
+  function isElement(val) {
+    return !!(val && val.nodeName && val.nodeType === 1);
+  }
+  const isArray = Array.isArray;
+  function isBase64(val) {
+    const reg = /^\s*data:([a-z]+\/[\d+.a-z-]+(;[a-z-]+=[\da-z-]+)?)?(;base64)?,([\s\w!$%&'()*+,./:;=?@~-]*?)\s*$/i;
+    return reg.test(val);
+  }
+  function assertError(condition, error) {
+    if (condition) {
+      throw new Error(error);
+    }
+  }
+  function cesiumEquals(left, right) {
+    return left === right || isFunction(left == null ? void 0 : left.equals) && left.equals(right) || isFunction(right == null ? void 0 : right.equals) && right.equals(left);
+  }
+  function isCesiumConstant(value) {
+    return !cesium.defined(value) || !!value.isConstant;
+  }
+  function canvasCoordToCartesian(canvasCoord, scene, mode = "auto") {
+    if (mode === "pickPosition") {
+      return scene.pickPosition(canvasCoord);
+    } else if (mode === "globePick") {
+      const ray = scene.camera.getPickRay(canvasCoord);
+      return ray && scene.globe.pick(ray, scene);
+    } else {
+      if (scene.globe.depthTestAgainstTerrain) {
+        return scene.pickPosition(canvasCoord);
+      }
+      const position1 = scene.pickPosition(canvasCoord);
+      const ray = scene.camera.getPickRay(canvasCoord);
+      const position2 = ray && scene.globe.pick(ray, scene);
+      if (!position1) {
+        return position2;
+      }
+      const height1 = (position1 && cesium.Ellipsoid.WGS84.cartesianToCartographic(position1).height) ?? 0;
+      const height2 = (position2 && cesium.Ellipsoid.WGS84.cartesianToCartographic(position2).height) ?? 0;
+      return height1 < height2 ? position1 : position2;
+    }
+  }
+  function cartesianToCanvasCoord(position, scene) {
+    return scene.cartesianToCanvasCoordinates(position);
+  }
+  function toCoord(position, options = {}) {
+    if (!position) {
+      return void 0;
+    }
+    const { type = "Array", alt = false } = options;
+    let longitude, latitude, height;
+    if (position instanceof cesium.Cartesian3) {
+      const cartographic = cesium.Ellipsoid.WGS84.cartesianToCartographic(position);
+      longitude = cesium.Math.toDegrees(cartographic.longitude);
+      latitude = cesium.Math.toDegrees(cartographic.latitude);
+      height = cartographic.height;
+    } else if (position instanceof cesium.Cartographic) {
+      const cartographic = position;
+      longitude = cesium.Math.toDegrees(cartographic.longitude);
+      latitude = cesium.Math.toDegrees(cartographic.latitude);
+      height = cartographic.height;
+    } else if (Array.isArray(position)) {
+      longitude = cesium.Math.toDegrees(position[0]);
+      latitude = cesium.Math.toDegrees(position[1]);
+      height = position[2];
+    } else {
+      longitude = position.longitude;
+      latitude = position.latitude;
+      height = position.height;
+    }
+    if (type === "Array") {
+      return alt ? [longitude, latitude, height] : [longitude, latitude];
+    } else {
+      return alt ? { longitude, latitude, height } : { longitude, latitude };
+    }
+  }
+  function dmsEncode(degrees, precision = 3) {
+    const str = `${degrees}`;
+    let i = str.indexOf(".");
+    const d = i < 0 ? str : str.slice(0, Math.max(0, i));
+    let m = "0";
+    let s = "0";
+    if (i > 0) {
+      m = `0${str.slice(Math.max(0, i))}`;
+      m = `${+m * 60}`;
+      i = m.indexOf(".");
+      if (i > 0) {
+        s = `0${m.slice(Math.max(0, i))}`;
+        m = m.slice(0, Math.max(0, i));
+        s = `${+s * 60}`;
+        i = s.indexOf(".");
+        s = s.slice(0, Math.max(0, i + 4));
+        s = (+s).toFixed(precision);
+      }
+    }
+    return `${Math.abs(+d)}°${+m}′${+s}″`;
+  }
+  function dmsDecode(dmsCode) {
+    const [dd, msStr] = dmsCode.split("°") ?? [];
+    const [mm, sStr] = (msStr == null ? void 0 : msStr.split("′")) ?? [];
+    const ss = sStr == null ? void 0 : sStr.split("″")[0];
+    const d = Number(dd) || 0;
+    const m = (Number(mm) || 0) / 60;
+    const s = (Number(ss) || 0) / 60 / 60;
+    const degrees = d + m + s;
+    if (degrees === 0) {
+      return 0;
+    } else {
+      let res = degrees;
+      if (["W", "w", "S", "s"].includes(dmsCode[dmsCode.length - 1])) {
+        res = -res;
+      }
+      return res;
+    }
+  }
+  function degreesToDms(position, precision = 3) {
+    const coord = toCoord(position, { alt: true });
+    if (!coord) {
+      return;
+    }
+    const [longitude, latitude, height] = coord;
+    const x = dmsEncode(longitude, precision);
+    const y = dmsEncode(latitude, precision);
+    return [`${x}${longitude > 0 ? "E" : "W"}`, `${y}${latitude > 0 ? "N" : "S"}`, height];
+  }
+  function dmsToDegrees(dms) {
+    const [x, y, height] = dms;
+    const longitude = dmsDecode(x);
+    const latitude = dmsDecode(y);
+    return [longitude, latitude, Number(height) || 0];
+  }
+  class CesiumMaterial extends cesium.Material {
+    constructor(options) {
+      super(options);
+    }
+  }
+  function getMaterialCache(type) {
+    return cesium.Material._materialCache.getMaterial(type);
+  }
+  function addMaterialCache(type, material) {
+    return cesium.Material._materialCache.addMaterial(type, material);
+  }
+  function resolvePick(pick = {}) {
+    const { primitive, id, primitiveCollection, collection } = pick;
+    const entityCollection = id && id.entityCollection || null;
+    const dataSource = entityCollection && entityCollection.owner || null;
+    const ids = Array.isArray(id) ? id : [id].filter(Boolean);
+    return [
+      ...ids,
+      primitive,
+      primitiveCollection,
+      collection,
+      entityCollection,
+      dataSource
+    ].filter((e) => !!e);
+  }
+  function pickHitGraphic(pick, graphic) {
+    if (!Array.isArray(graphic) || !graphic.length) {
+      return false;
+    }
+    const elements = resolvePick(pick);
+    if (!elements.length) {
+      return false;
+    }
+    return elements.some((element) => graphic.includes(element));
+  }
+  function isProperty(value) {
+    return value && isFunction(value.getValue);
+  }
+  function toPropertyValue(value, time) {
+    return isProperty(value) ? value.getValue(time) : value;
+  }
+  function toProperty(value, isConstant = false) {
+    return isProperty(value) ? value : isFunction(value) ? new cesium.CallbackProperty(value, isConstant) : new cesium.ConstantProperty(value);
+  }
+  function createPropertyField(scope, field, maybeProperty, readonly) {
+    let removeOwnerListener;
+    const ownerBinding = (value) => {
+      var _a;
+      removeOwnerListener == null ? void 0 : removeOwnerListener();
+      if (cesium.defined(value == null ? void 0 : value.definitionChanged)) {
+        removeOwnerListener = (_a = value == null ? void 0 : value.definitionChanged) == null ? void 0 : _a.addEventListener(() => {
+          scope.definitionChanged.raiseEvent(scope, field, value, value);
+        });
+      }
+    };
+    const privateField = `_${field}`;
+    const property = toProperty(maybeProperty);
+    scope[privateField] = property;
+    ownerBinding(property);
+    if (readonly) {
+      Object.defineProperty(scope, field, {
+        get() {
+          return scope[privateField];
+        }
+      });
+    } else {
+      Object.defineProperty(scope, field, {
+        get() {
+          return scope[privateField];
+        },
+        set(value) {
+          const previous = scope[privateField];
+          if (scope[privateField] !== value) {
+            scope[privateField] = value;
+            ownerBinding(value);
+            if (cesium.defined(scope.definitionChanged)) {
+              scope.definitionChanged.raiseEvent(scope, field, value, previous);
+            }
+          }
+        }
+      });
+    }
+  }
+  function createCesiumAttribute(scope, key, value, options = {}) {
+    const allowToProperty = !!options.toProperty;
+    const shallowClone = !!options.shallowClone;
+    const changedEventKey = options.changedEventKey || "definitionChanged";
+    const changedEvent = Reflect.get(scope, changedEventKey);
+    const privateKey = `_${String(key)}`;
+    const attribute = allowToProperty ? toProperty(value) : value;
+    Reflect.set(scope, privateKey, attribute);
+    const obj = {
+      get() {
+        const value2 = Reflect.get(scope, privateKey);
+        if (shallowClone) {
+          return Array.isArray(value2) ? [...value2] : { ...value2 };
+        } else {
+          return value2;
+        }
+      }
+    };
+    let previousListener;
+    const serial = (property, previous) => {
+      var _a;
+      previousListener == null ? void 0 : previousListener();
+      previousListener = (_a = property == null ? void 0 : property.definitionChanged) == null ? void 0 : _a.addEventListener(() => {
+        changedEvent == null ? void 0 : changedEvent.raiseEvent.bind(changedEvent)(scope, key, property, previous);
+      });
+    };
+    if (!options.readonly) {
+      if (allowToProperty && isProperty(value)) {
+        serial(value);
+      }
+      obj.set = (value2) => {
+        if (allowToProperty && !isProperty(value2)) {
+          throw new Error(`The value of ${String(key)} must be a Cesium.Property object`);
+        }
+        const previous = Reflect.get(scope, privateKey);
+        if (previous !== value2) {
+          Reflect.set(scope, privateKey, value2);
+          changedEvent == null ? void 0 : changedEvent.raiseEvent.bind(changedEvent)(scope, key, value2, previous);
+          if (allowToProperty) {
+            serial(value2);
+          }
+        }
+      };
+    }
+    Object.defineProperty(scope, key, obj);
+  }
+  function createCesiumProperty(scope, key, value, options = {}) {
+    return createCesiumAttribute(scope, key, value, { ...options, toProperty: true });
+  }
+  function throttle(callback, delay = 100, trailing = true, leading = false) {
+    const restList = [];
+    let tracked = false;
+    const trigger = async () => {
+      await core.promiseTimeout(delay);
+      tracked = false;
+      if (leading) {
+        try {
+          callback(...restList[0]);
+        } catch (error) {
+          console.error(error);
+        }
+      }
+      if (trailing && (!leading || restList.length > 1)) {
+        try {
+          callback(...restList[restList.length - 1]);
+        } catch (error) {
+          console.error(error);
+        }
+      }
+      restList.length = 0;
+    };
+    return (...rest) => {
+      if (restList.length < 2) {
+        restList.push(rest);
+      } else {
+        restList[1] = rest;
+      }
+      if (!tracked) {
+        tracked = true;
+        trigger();
+      }
+    };
+  }
+  function toCartesian3(position) {
+    if (!position) {
+      return void 0;
+    }
+    if (position instanceof cesium.Cartesian3) {
+      return position.clone();
+    } else if (position instanceof cesium.Cartographic) {
+      return cesium.Ellipsoid.WGS84.cartographicToCartesian(position);
+    } else if (Array.isArray(position)) {
+      return cesium.Cartesian3.fromDegrees(position[0], position[1], position[2]);
+    } else {
+      return cesium.Cartesian3.fromDegrees(position.longitude, position.latitude, position.height);
+    }
+  }
+  function toCartographic(position) {
+    if (!position) {
+      return void 0;
+    }
+    if (position instanceof cesium.Cartesian3) {
+      return cesium.Ellipsoid.WGS84.cartesianToCartographic(position);
+    } else if (position instanceof cesium.Cartographic) {
+      return position.clone();
+    } else if (Array.isArray(position)) {
+      return cesium.Cartographic.fromDegrees(position[0], position[1], position[2]);
+    } else {
+      return cesium.Cartographic.fromDegrees(position.longitude, position.latitude, position.height);
+    }
+  }
+  function tryRun(fn) {
+    return (...args) => {
+      try {
+        return fn == null ? void 0 : fn(...args);
+      } catch (error) {
+        console.error(error);
+      }
+    };
+  }
+  function arrayDiff(list, oldList) {
+    const oldListSet = new Set(oldList);
+    const added = list.filter((obj) => !oldListSet.has(obj));
+    const newListSet = new Set(list);
+    const removed = (oldList == null ? void 0 : oldList.filter((obj) => !newListSet.has(obj))) ?? [];
+    return { added, removed };
+  }
+  async function toPromiseValue(source, options = {}) {
+    try {
+      const { raw = true } = options;
+      let value;
+      if (isFunction(source)) {
+        value = await source();
+      } else {
+        const result = vue.toValue(source);
+        value = isPromise(result) ? await result : result;
+      }
+      return raw ? vue.toRaw(value) : value;
+    } catch (error) {
+      console.error(error);
+      throw error;
+    }
+  }
+  function useCesiumEventListener(event, listener, options = {}) {
+    const isActive = vue.toRef(options.isActive ?? true);
+    const cleanup = vue.watchEffect((onCleanup) => {
+      const _event = vue.toValue(event);
+      const events = Array.isArray(_event) ? _event : [_event];
+      if (events) {
+        if (events.length && isActive.value) {
+          const stopFns = events.map((event2) => {
+            const e = vue.toValue(event2);
+            return e == null ? void 0 : e.addEventListener(listener, e);
+          });
+          onCleanup(() => stopFns.forEach((stop) => stop == null ? void 0 : stop()));
+        }
+      }
+    });
+    core.tryOnScopeDispose(cleanup.stop);
+    return cleanup.stop;
+  }
+  function useViewer() {
+    const scope = vue.getCurrentScope();
+    const instanceViewer = scope ? CREATE_VIEWER_COLLECTION.get(scope) : void 0;
+    if (instanceViewer) {
+      return instanceViewer;
+    } else {
+      const injectViewer = vue.inject(CREATE_VIEWER_INJECTION_KEY);
+      if (!injectViewer) {
+        throw new Error(
+          "The `Viewer` instance injected by `createViewer` was not found in the current component or its ancestor components. Have you called `createViewer`?"
+        );
+      }
+      return injectViewer;
+    }
+  }
+  function useCameraState(options = {}) {
+    let getCamera = options.camera;
+    if (!getCamera) {
+      const viewer = useViewer();
+      getCamera = () => {
+        var _a;
+        return (_a = viewer.value) == null ? void 0 : _a.scene.camera;
+      };
+    }
+    const camera = vue.computed(() => vue.toValue(getCamera));
+    const event = vue.computed(() => {
+      var _a;
+      const eventField = vue.toValue(options.event) || "changed";
+      return (_a = camera.value) == null ? void 0 : _a[eventField];
+    });
+    const changedSymbol = core.refThrottled(
+      vue.shallowRef(Symbol("camera change")),
+      options.delay ?? 8,
+      true,
+      false
+    );
+    const setChangedSymbol = () => {
+      changedSymbol.value = Symbol("camera change");
+    };
+    vue.watch(camera, () => setChangedSymbol());
+    useCesiumEventListener(event, () => setChangedSymbol());
+    return {
+      camera,
+      position: vue.computed(() => {
+        var _a, _b;
+        return changedSymbol.value ? (_b = (_a = camera.value) == null ? void 0 : _a.position) == null ? void 0 : _b.clone() : void 0;
+      }),
+      direction: vue.computed(() => {
+        var _a, _b;
+        return changedSymbol.value ? (_b = (_a = camera.value) == null ? void 0 : _a.direction) == null ? void 0 : _b.clone() : void 0;
+      }),
+      up: vue.computed(() => {
+        var _a, _b;
+        return changedSymbol.value ? (_b = (_a = camera.value) == null ? void 0 : _a.up) == null ? void 0 : _b.clone() : void 0;
+      }),
+      right: vue.computed(() => {
+        var _a, _b;
+        return changedSymbol.value ? (_b = (_a = camera.value) == null ? void 0 : _a.right) == null ? void 0 : _b.clone() : void 0;
+      }),
+      positionCartographic: vue.computed(() => {
+        var _a, _b;
+        return changedSymbol.value ? (_b = (_a = camera.value) == null ? void 0 : _a.positionCartographic) == null ? void 0 : _b.clone() : void 0;
+      }),
+      positionWC: vue.computed(() => {
+        var _a, _b;
+        return changedSymbol.value ? (_b = (_a = camera.value) == null ? void 0 : _a.positionWC) == null ? void 0 : _b.clone() : void 0;
+      }),
+      directionWC: vue.computed(() => {
+        var _a, _b;
+        return changedSymbol.value ? (_b = (_a = camera.value) == null ? void 0 : _a.directionWC) == null ? void 0 : _b.clone() : void 0;
+      }),
+      upWC: vue.computed(() => {
+        var _a, _b;
+        return changedSymbol.value ? (_b = (_a = camera.value) == null ? void 0 : _a.directionWC) == null ? void 0 : _b.clone() : void 0;
+      }),
+      rightWC: vue.computed(() => {
+        var _a, _b;
+        return changedSymbol.value ? (_b = (_a = camera.value) == null ? void 0 : _a.directionWC) == null ? void 0 : _b.clone() : void 0;
+      }),
+      viewRectangle: vue.computed(() => {
+        var _a;
+        return changedSymbol.value ? (_a = camera.value) == null ? void 0 : _a.computeViewRectangle() : void 0;
+      }),
+      heading: vue.computed(() => {
+        var _a;
+        return changedSymbol.value ? (_a = camera.value) == null ? void 0 : _a.heading : void 0;
+      }),
+      pitch: vue.computed(() => {
+        var _a;
+        return changedSymbol.value ? (_a = camera.value) == null ? void 0 : _a.pitch : void 0;
+      }),
+      roll: vue.computed(() => {
+        var _a;
+        return changedSymbol.value ? (_a = camera.value) == null ? void 0 : _a.roll : void 0;
+      }),
+      level: vue.computed(() => {
+        var _a, _b;
+        return changedSymbol.value && ((_b = (_a = camera.value) == null ? void 0 : _a.positionCartographic) == null ? void 0 : _b.height) ? computeLevel(camera.value.positionCartographic.height) : void 0;
+      })
+    };
+  }
+  const A = 40487.57;
+  const B = 7096758e-11;
+  const C = 91610.74;
+  const D = -40467.74;
+  function computeLevel(height) {
+    return D + (A - D) / (1 + (height / C) ** B);
+  }
+  function useCesiumFps(options = {}) {
+    const { delay = 100 } = options;
+    const viewer = useViewer();
+    const p = vue.shallowRef(performance.now());
+    useCesiumEventListener(
+      () => {
+        var _a;
+        return (_a = viewer.value) == null ? void 0 : _a.scene.postRender;
+      },
+      () => p.value = performance.now()
+    );
+    const interval = vue.ref(0);
+    core.watchThrottled(p, (value, oldValue) => {
+      interval.value = value - oldValue;
+    }, {
+      throttle: delay
+    });
+    const fps = vue.computed(() => {
+      return 1e3 / interval.value;
+    });
+    return {
+      interval: vue.readonly(interval),
+      fps
+    };
+  }
+  function useCollectionScope(addFn, removeFn, removeScopeArgs) {
+    const scope = vue.shallowReactive(/* @__PURE__ */ new Set());
+    const add = (instance, ...args) => {
+      const result = addFn(instance, ...args);
+      if (isPromise(result)) {
+        return new Promise((resolve, reject) => {
+          result.then((i) => {
+            scope.add(i);
+            resolve(i);
+          }).catch((error) => reject(error));
+        });
+      } else {
+        scope.add(result);
+        return result;
+      }
+    };
+    const remove = (instance, ...args) => {
+      scope.delete(instance);
+      return removeFn(instance, ...args);
+    };
+    const removeWhere = (predicate, ...args) => {
+      scope.forEach((instance) => {
+        if (predicate(instance)) {
+          remove(instance, ...args);
+        }
+      });
+    };
+    const removeScope = (...args) => {
+      scope.forEach((instance) => {
+        remove(instance, ...args);
+      });
+    };
+    core.tryOnScopeDispose(() => removeScope(...removeScopeArgs));
+    return {
+      scope: vue.shallowReadonly(scope),
+      add,
+      remove,
+      removeWhere,
+      removeScope
+    };
+  }
+  function useDataSource(dataSources, options = {}) {
+    const {
+      destroyOnRemove,
+      collection,
+      isActive = true,
+      evaluating
+    } = options;
+    const result = core.computedAsync(
+      () => toPromiseValue(dataSources),
+      void 0,
+      {
+        evaluating
+      }
+    );
+    const viewer = useViewer();
+    vue.watchEffect((onCleanup) => {
+      var _a;
+      const _isActive = vue.toValue(isActive);
+      if (_isActive) {
+        const list = Array.isArray(result.value) ? [...result.value] : [result.value];
+        const _collection = collection ?? ((_a = viewer.value) == null ? void 0 : _a.dataSources);
+        list.forEach((item) => item && (_collection == null ? void 0 : _collection.add(item)));
+        onCleanup(() => {
+          const destroy = vue.toValue(destroyOnRemove);
+          !(_collection == null ? void 0 : _collection.isDestroyed()) && list.forEach((dataSource) => dataSource && (_collection == null ? void 0 : _collection.remove(dataSource, destroy)));
+        });
+      }
+    });
+    return result;
+  }
+  function useDataSourceScope(options = {}) {
+    const { collection: _collection, destroyOnRemove } = options;
+    const viewer = useViewer();
+    const collection = vue.computed(() => {
+      var _a;
+      return vue.toValue(_collection) ?? ((_a = viewer.value) == null ? void 0 : _a.dataSources);
+    });
+    const addFn = (dataSource) => {
+      if (!collection.value) {
+        throw new Error("collection is not defined");
+      }
+      return collection.value.add(dataSource);
+    };
+    const removeFn = (dataSource, destroy) => {
+      var _a;
+      return !!((_a = collection.value) == null ? void 0 : _a.remove(dataSource, destroy));
+    };
+    const { scope, add, remove, removeWhere, removeScope } = useCollectionScope(addFn, removeFn, [destroyOnRemove]);
+    return {
+      scope,
+      add,
+      remove,
+      removeWhere,
+      removeScope
+    };
+  }
+  function useElementOverlay(target, position, options = {}) {
+    const {
+      referenceWindow,
+      horizontal = "center",
+      vertical = "bottom",
+      offset = { x: 0, y: 0 }
+    } = options;
+    const cartesian3 = vue.computed(() => toCartesian3(vue.toValue(position)));
+    const viewer = useViewer();
+    const coord = vue.shallowRef();
+    useCesiumEventListener(
+      () => {
+        var _a;
+        return (_a = viewer.value) == null ? void 0 : _a.scene.postRender;
+      },
+      () => {
+        var _a;
+        if (!((_a = viewer.value) == null ? void 0 : _a.scene)) {
+          return;
+        }
+        if (!cartesian3.value) {
+          coord.value = void 0;
+        } else {
+          const reslut = cartesianToCanvasCoord(cartesian3.value, viewer.value.scene);
+          coord.value = !cesium.Cartesian2.equals(reslut, coord.value) ? reslut : coord.value;
+        }
+      }
+    );
+    const canvasBounding = core.useElementBounding(() => {
+      var _a;
+      return (_a = viewer.value) == null ? void 0 : _a.canvas.parentElement;
+    });
+    const targetBounding = core.useElementBounding(target);
+    const finalOffset = vue.computed(() => {
+      const _offset = vue.toValue(offset);
+      let x2 = (_offset == null ? void 0 : _offset.x) ?? 0;
+      const _horizontal = vue.toValue(horizontal);
+      if (_horizontal === "center") {
+        x2 -= targetBounding.width.value / 2;
+      } else if (_horizontal === "right") {
+        x2 -= targetBounding.width.value;
+      }
+      let y2 = (_offset == null ? void 0 : _offset.y) ?? 0;
+      const _vertical = vue.toValue(vertical);
+      if (_vertical === "center") {
+        y2 -= targetBounding.height.value / 2;
+      } else if (_vertical === "bottom") {
+        y2 -= targetBounding.height.value;
+      }
+      return {
+        x: x2,
+        y: y2
+      };
+    });
+    const location = vue.computed(() => {
+      var _a, _b;
+      const data = {
+        x: ((_a = coord.value) == null ? void 0 : _a.x) ?? 0,
+        y: ((_b = coord.value) == null ? void 0 : _b.y) ?? 0
+      };
+      if (vue.toValue(referenceWindow)) {
+        data.x += canvasBounding.x.value;
+        data.y += canvasBounding.y.value;
+      }
+      return {
+        x: finalOffset.value.x + data.x,
+        y: finalOffset.value.y + data.y
+      };
+    });
+    const x = vue.computed(() => location.value.x);
+    const y = vue.computed(() => location.value.y);
+    const style = vue.computed(() => {
+      var _a, _b;
+      return { left: `${(_a = x.value) == null ? void 0 : _a.toFixed(2)}px`, top: `${(_b = y.value) == null ? void 0 : _b.toFixed(2)}px` };
+    });
+    vue.watchEffect(() => {
+      var _a, _b, _c, _d;
+      const element = vue.toValue(target);
+      if (element && vue.toValue(options.applyStyle ?? true)) {
+        (_b = (_a = element.style) == null ? void 0 : _a.setProperty) == null ? void 0 : _b.call(_a, "left", style.value.left);
+        (_d = (_c = element.style) == null ? void 0 : _c.setProperty) == null ? void 0 : _d.call(_c, "top", style.value.top);
+      }
+    });
+    return {
+      x,
+      y,
+      style
+    };
+  }
+  function useEntity(data, options = {}) {
+    const { collection, isActive = true, evaluating } = options;
+    const result = core.computedAsync(
+      () => toPromiseValue(data),
+      [],
+      {
+        evaluating
+      }
+    );
+    const viewer = useViewer();
+    vue.watchEffect((onCleanup) => {
+      var _a;
+      const _isActive = vue.toValue(isActive);
+      if (_isActive) {
+        const list = Array.isArray(result.value) ? [...result.value] : [result.value];
+        const _collection = collection ?? ((_a = viewer.value) == null ? void 0 : _a.entities);
+        list.forEach((item) => item && (_collection == null ? void 0 : _collection.add(item)));
+        onCleanup(() => {
+          list.forEach((item) => item && (_collection == null ? void 0 : _collection.remove(item)));
+        });
+      }
+    });
+    return result;
+  }
+  function useEntityScope(options = {}) {
+    const { collection: _collection } = options;
+    const viewer = useViewer();
+    const collection = vue.computed(() => {
+      var _a;
+      return vue.toValue(_collection) ?? ((_a = viewer.value) == null ? void 0 : _a.entities);
+    });
+    const addFn = (entity) => {
+      if (!collection.value) {
+        throw new Error("collection is not defined");
+      }
+      if (!collection.value.contains(entity)) {
+        collection.value.add(entity);
+      }
+      return entity;
+    };
+    const removeFn = (entity) => {
+      var _a;
+      return !!((_a = collection.value) == null ? void 0 : _a.remove(entity));
+    };
+    const { scope, add, remove, removeWhere, removeScope } = useCollectionScope(addFn, removeFn, []);
+    return {
+      scope,
+      add,
+      remove,
+      removeWhere,
+      removeScope
+    };
+  }
+  const pickCache = /* @__PURE__ */ new WeakMap();
+  function useScenePick(windowPosition, options = {}) {
+    const { width = 3, height = 3, throttled = 8 } = options;
+    const isActive = vue.toRef(options.isActive ?? true);
+    const viewer = useViewer();
+    const position = core.refThrottled(vue.computed(() => {
+      var _a;
+      return (_a = vue.toValue(windowPosition)) == null ? void 0 : _a.clone();
+    }), throttled, false, true);
+    const pick = vue.shallowRef();
+    vue.watchEffect(() => {
+      var _a;
+      if (viewer.value && position.value && isActive.value) {
+        const cache = pickCache.get(viewer.value);
+        if (cache && cache[0].equals(position.value)) {
+          pick.value = cache[1];
+        } else {
+          pickCache.set(viewer.value, [position.value.clone(), pick.value]);
+          pick.value = (_a = viewer.value) == null ? void 0 : _a.scene.pick(
+            position.value,
+            vue.toValue(width),
+            vue.toValue(height)
+          );
+        }
+      }
+    });
+    return pick;
+  }
+  function useScreenSpaceEventHandler(type, inputAction, options = {}) {
+    const { modifier } = options;
+    const viewer = useViewer();
+    const isActive = vue.toRef(options.isActive ?? true);
+    const handler = vue.computed(() => {
+      var _a, _b;
+      if ((_b = (_a = viewer.value) == null ? void 0 : _a.cesiumWidget) == null ? void 0 : _b.canvas) {
+        return new cesium.ScreenSpaceEventHandler(viewer.value.cesiumWidget.canvas);
+      }
+    });
+    const cleanup1 = vue.watch(handler, (_value, previous) => {
+      var _a;
+      ((_a = viewer.value) == null ? void 0 : _a.cesiumWidget) && (previous == null ? void 0 : previous.destroy());
+    });
+    const cleanup2 = vue.watchEffect((onCleanup) => {
+      const typeValue = vue.toValue(type);
+      const modifierValue = vue.toValue(modifier);
+      const handlerValue = vue.toValue(handler);
+      if (!handlerValue || !isActive.value || !inputAction) {
+        return;
+      }
+      if (isDef(typeValue)) {
+        handlerValue.setInputAction(inputAction, typeValue, modifierValue);
+        onCleanup(() => handlerValue.removeInputAction(typeValue, modifierValue));
+      }
+    });
+    const stop = () => {
+      cleanup1();
+      cleanup2();
+    };
+    core.tryOnScopeDispose(stop);
+    return stop;
+  }
+  function useDrag(listener) {
+    const position = vue.shallowRef();
+    const pick = useScenePick(position);
+    const motionEvent = vue.shallowRef();
+    const dragging = vue.ref(false);
+    const viewer = useViewer();
+    const cameraLocked = vue.ref(false);
+    vue.watch(cameraLocked, (cameraLocked2) => {
+      viewer.value && (viewer.value.scene.screenSpaceCameraController.enableRotate = !cameraLocked2);
+    });
+    const lockCamera = () => {
+      cameraLocked.value = true;
+    };
+    const execute = (pick2, startPosition, endPosition) => {
+      listener({
+        event: {
+          startPosition: startPosition.clone(),
+          endPosition: endPosition.clone()
+        },
+        pick: pick2,
+        dragging: dragging.value,
+        lockCamera
+      });
+      vue.nextTick(() => {
+        if (!dragging.value && cameraLocked.value) {
+          cameraLocked.value = false;
+        }
+      });
+    };
+    const stopLeftDownWatch = useScreenSpaceEventHandler(
+      cesium.ScreenSpaceEventType.LEFT_DOWN,
+      (event) => {
+        dragging.value = true;
+        position.value = event.position.clone();
+      }
+    );
+    const stopMouseMoveWatch = useScreenSpaceEventHandler(
+      cesium.ScreenSpaceEventType.MOUSE_MOVE,
+      throttle(({ startPosition, endPosition }) => {
+        var _a;
+        motionEvent.value = {
+          startPosition: ((_a = motionEvent.value) == null ? void 0 : _a.endPosition.clone()) || startPosition.clone(),
+          endPosition: endPosition.clone()
+        };
+      }, 8, false, true)
+    );
+    vue.watch([pick, motionEvent], ([pick2, motionEvent2]) => {
+      if (pick2 && motionEvent2) {
+        const { startPosition, endPosition } = motionEvent2;
+        dragging.value && execute(pick2, startPosition, endPosition);
+      }
+    });
+    const stopLeftUpWatch = useScreenSpaceEventHandler(
+      cesium.ScreenSpaceEventType.LEFT_UP,
+      (event) => {
+        dragging.value = false;
+        if (pick.value && motionEvent.value) {
+          execute(pick.value, motionEvent.value.endPosition, event.position);
+        }
+        position.value = void 0;
+        motionEvent.value = void 0;
+      }
+    );
+    const stop = () => {
+      stopLeftDownWatch();
+      stopMouseMoveWatch();
+      stopLeftUpWatch();
+    };
+    core.tryOnScopeDispose(stop);
+    return stop;
+  }
+  function useHover(listener) {
+    const motionEvent = vue.shallowRef();
+    const pick = useScenePick(() => {
+      var _a;
+      return (_a = motionEvent.value) == null ? void 0 : _a.endPosition;
+    });
+    const execute = (pick2, startPosition, endPosition, hovering) => {
+      listener({
+        event: {
+          startPosition: startPosition.clone(),
+          endPosition: endPosition.clone()
+        },
+        pick: pick2,
+        hovering
+      });
+    };
+    useScreenSpaceEventHandler(
+      cesium.ScreenSpaceEventType.MOUSE_MOVE,
+      ({ startPosition, endPosition }) => {
+        var _a, _b;
+        if (!startPosition.equals((_a = motionEvent.value) == null ? void 0 : _a.startPosition) || !endPosition.equals((_b = motionEvent.value) == null ? void 0 : _b.endPosition)) {
+          motionEvent.value = { startPosition: startPosition.clone(), endPosition: endPosition.clone() };
+        }
+      }
+    );
+    vue.watch([pick, motionEvent], ([pick2, motionEvent2]) => {
+      if (pick2 && motionEvent2) {
+        const { startPosition, endPosition } = motionEvent2;
+        execute(pick2, startPosition, endPosition, true);
+      }
+    });
+    vue.watch(pick, (pick2, prevPick) => {
+      if (prevPick && motionEvent.value) {
+        const { startPosition, endPosition } = motionEvent.value;
+        execute(prevPick, startPosition, endPosition, false);
+      }
+    });
+  }
+  const EVENT_TYPE_RECORD = {
+    LEFT_DOWN: cesium.ScreenSpaceEventType.LEFT_DOWN,
+    LEFT_UP: cesium.ScreenSpaceEventType.LEFT_UP,
+    LEFT_CLICK: cesium.ScreenSpaceEventType.LEFT_CLICK,
+    LEFT_DOUBLE_CLICK: cesium.ScreenSpaceEventType.LEFT_DOUBLE_CLICK,
+    RIGHT_DOWN: cesium.ScreenSpaceEventType.RIGHT_DOWN,
+    RIGHT_UP: cesium.ScreenSpaceEventType.RIGHT_UP,
+    RIGHT_CLICK: cesium.ScreenSpaceEventType.RIGHT_CLICK,
+    MIDDLE_DOWN: cesium.ScreenSpaceEventType.MIDDLE_DOWN,
+    MIDDLE_UP: cesium.ScreenSpaceEventType.MIDDLE_UP,
+    MIDDLE_CLICK: cesium.ScreenSpaceEventType.MIDDLE_CLICK
+  };
+  function usePositioned(type, listener) {
+    const screenEvent = EVENT_TYPE_RECORD[type];
+    const viewer = useViewer();
+    useScreenSpaceEventHandler(screenEvent, (event) => {
+      var _a;
+      const position = event.position;
+      const pick = (_a = viewer.value) == null ? void 0 : _a.scene.pick(position);
+      pick && position && listener({ event: { position }, pick });
+    });
+  }
+  const GLOBAL_GRAPHIC_SYMBOL = Symbol("GLOBAL_GRAPHIC_SYMBOL");
+  const POSITIONED_EVENT_TYPES = [
+    "LEFT_DOWN",
+    "LEFT_UP",
+    "LEFT_CLICK",
+    "LEFT_DOUBLE_CLICK",
+    "RIGHT_DOWN",
+    "RIGHT_UP",
+    "RIGHT_CLICK",
+    "MIDDLE_DOWN",
+    "MIDDLE_UP",
+    "MIDDLE_CLICK"
+  ];
+  function useGraphicEvent() {
+    const collection = /* @__PURE__ */ new WeakMap();
+    const cursorCollection = /* @__PURE__ */ new WeakMap();
+    const dragCursorCollection = /* @__PURE__ */ new WeakMap();
+    const removeGraphicEvent = (graphic, type, listener) => {
+      var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s;
+      const _graphic = graphic === "global" ? GLOBAL_GRAPHIC_SYMBOL : graphic;
+      (_b = (_a = collection == null ? void 0 : collection.get(_graphic)) == null ? void 0 : _a.get(type)) == null ? void 0 : _b.delete(listener);
+      (_d = (_c = cursorCollection == null ? void 0 : cursorCollection.get(_graphic)) == null ? void 0 : _c.get(type)) == null ? void 0 : _d.delete(listener);
+      if (((_f = (_e = collection == null ? void 0 : collection.get(_graphic)) == null ? void 0 : _e.get(type)) == null ? void 0 : _f.size) === 0) {
+        collection.get(_graphic).delete(type);
+      }
+      if (((_g = collection.get(_graphic)) == null ? void 0 : _g.size) === 0) {
+        collection.delete(_graphic);
+      }
+      (_i = (_h = cursorCollection == null ? void 0 : cursorCollection.get(_graphic)) == null ? void 0 : _h.get(type)) == null ? void 0 : _i.delete(listener);
+      if (((_k = (_j = cursorCollection == null ? void 0 : cursorCollection.get(_graphic)) == null ? void 0 : _j.get(type)) == null ? void 0 : _k.size) === 0) {
+        (_l = cursorCollection == null ? void 0 : cursorCollection.get(_graphic)) == null ? void 0 : _l.delete(type);
+      }
+      if (((_m = cursorCollection == null ? void 0 : cursorCollection.get(_graphic)) == null ? void 0 : _m.size) === 0) {
+        cursorCollection == null ? void 0 : cursorCollection.delete(_graphic);
+      }
+      (_o = (_n = dragCursorCollection == null ? void 0 : dragCursorCollection.get(_graphic)) == null ? void 0 : _n.get(type)) == null ? void 0 : _o.delete(listener);
+      if (((_q = (_p = dragCursorCollection == null ? void 0 : dragCursorCollection.get(_graphic)) == null ? void 0 : _p.get(type)) == null ? void 0 : _q.size) === 0) {
+        (_r = dragCursorCollection == null ? void 0 : dragCursorCollection.get(_graphic)) == null ? void 0 : _r.delete(type);
+      }
+      if (((_s = dragCursorCollection == null ? void 0 : dragCursorCollection.get(_graphic)) == null ? void 0 : _s.size) === 0) {
+        dragCursorCollection == null ? void 0 : dragCursorCollection.delete(_graphic);
+      }
+    };
+    const addGraphicEvent = (graphic, type, listener, options = {}) => {
+      const _graphic = graphic === "global" ? GLOBAL_GRAPHIC_SYMBOL : graphic;
+      collection.get(_graphic) ?? collection.set(_graphic, /* @__PURE__ */ new Map());
+      const eventTypeMap = collection.get(_graphic);
+      eventTypeMap.get(type) ?? eventTypeMap.set(type, /* @__PURE__ */ new Set());
+      const listeners = eventTypeMap.get(type);
+      listeners.add(listener);
+      let { cursor = "pointer", dragCursor } = options;
+      if (isDef(cursor)) {
+        const _cursor = isFunction(cursor) ? cursor : () => cursor;
+        cursorCollection.get(_graphic) ?? cursorCollection.set(_graphic, /* @__PURE__ */ new Map());
+        cursorCollection.get(_graphic).get(type) ?? cursorCollection.get(_graphic).set(type, /* @__PURE__ */ new Map());
+        cursorCollection.get(_graphic).get(type).set(listener, _cursor);
+      }
+      if (type === "DRAG") {
+        dragCursor ?? (dragCursor = (event) => (event == null ? void 0 : event.dragging) ? "crosshair" : void 0);
+      }
+      if (isDef(dragCursor)) {
+        const _dragCursor = isFunction(dragCursor) ? dragCursor : () => dragCursor;
+        dragCursorCollection.get(_graphic) ?? dragCursorCollection.set(_graphic, /* @__PURE__ */ new Map());
+        dragCursorCollection.get(_graphic).get(type) ?? dragCursorCollection.get(_graphic).set(type, /* @__PURE__ */ new Map());
+        dragCursorCollection.get(_graphic).get(type).set(listener, _dragCursor);
+      }
+      return () => removeGraphicEvent(graphic, type, listener);
+    };
+    const clearGraphicEvent = (graphic, type) => {
+      var _a, _b, _c, _d, _e, _f;
+      const _graphic = graphic === "global" ? GLOBAL_GRAPHIC_SYMBOL : graphic;
+      if (type === "all") {
+        collection.delete(_graphic);
+        cursorCollection.delete(_graphic);
+        dragCursorCollection.delete(_graphic);
+        return;
+      }
+      (_a = collection.get(_graphic)) == null ? void 0 : _a.delete(type);
+      if (((_b = collection.get(_graphic)) == null ? void 0 : _b.size) === 0) {
+        collection.delete(_graphic);
+      }
+      (_c = cursorCollection == null ? void 0 : cursorCollection.get(_graphic)) == null ? void 0 : _c.delete(type);
+      (_d = dragCursorCollection == null ? void 0 : dragCursorCollection.get(_graphic)) == null ? void 0 : _d.delete(type);
+      if (((_e = cursorCollection == null ? void 0 : cursorCollection.get(_graphic)) == null ? void 0 : _e.size) === 0) {
+        cursorCollection == null ? void 0 : cursorCollection.delete(_graphic);
+      }
+      if (((_f = dragCursorCollection == null ? void 0 : dragCursorCollection.get(_graphic)) == null ? void 0 : _f.size) === 0) {
+        dragCursorCollection == null ? void 0 : dragCursorCollection.delete(_graphic);
+      }
+    };
+    for (const type of POSITIONED_EVENT_TYPES) {
+      usePositioned(type, (event) => {
+        const graphics = resolvePick(event.pick);
+        graphics.concat(GLOBAL_GRAPHIC_SYMBOL).forEach((graphic) => {
+          var _a, _b;
+          (_b = (_a = collection.get(graphic)) == null ? void 0 : _a.get(type)) == null ? void 0 : _b.forEach((fn) => {
+            var _a2;
+            return (_a2 = tryRun(fn)) == null ? void 0 : _a2(event);
+          });
+        });
+      });
+    }
+    const dragging = vue.ref(false);
+    const viewer = useViewer();
+    useHover((event) => {
+      const graphics = resolvePick(event.pick).concat(GLOBAL_GRAPHIC_SYMBOL);
+      graphics.forEach((graphic) => {
+        var _a, _b, _c;
+        (_b = (_a = collection.get(graphic)) == null ? void 0 : _a.get("HOVER")) == null ? void 0 : _b.forEach((fn) => {
+          var _a2;
+          return (_a2 = tryRun(fn)) == null ? void 0 : _a2(event);
+        });
+        if (!dragging.value) {
+          (_c = cursorCollection.get(graphic)) == null ? void 0 : _c.forEach((map) => {
+            map.forEach((fn) => {
+              var _a2, _b2;
+              const cursor = event.hovering ? tryRun(fn)(event) : "";
+              (_b2 = (_a2 = viewer.value) == null ? void 0 : _a2.canvas.style) == null ? void 0 : _b2.setProperty("cursor", cursor);
+            });
+          });
+        }
+      });
+    });
+    useDrag((event) => {
+      const graphics = resolvePick(event.pick).concat(GLOBAL_GRAPHIC_SYMBOL);
+      dragging.value = event.dragging;
+      graphics.forEach((graphic) => {
+        var _a, _b, _c;
+        (_b = (_a = collection.get(graphic)) == null ? void 0 : _a.get("DRAG")) == null ? void 0 : _b.forEach((fn) => tryRun(fn)(event));
+        (_c = dragCursorCollection.get(graphic)) == null ? void 0 : _c.forEach((map) => {
+          map.forEach((fn) => {
+            var _a2, _b2;
+            const cursor = event.dragging ? tryRun(fn)(event) : "";
+            (_b2 = (_a2 = viewer.value) == null ? void 0 : _a2.canvas.style) == null ? void 0 : _b2.setProperty("cursor", cursor);
+          });
+        });
+      });
+    });
+    return {
+      addGraphicEvent,
+      removeGraphicEvent,
+      clearGraphicEvent
+    };
+  }
+  function useImageryLayer(data, options = {}) {
+    const {
+      destroyOnRemove,
+      collection,
+      isActive = true,
+      evaluating
+    } = options;
+    const result = core.computedAsync(
+      () => toPromiseValue(data),
+      [],
+      {
+        evaluating
+      }
+    );
+    const viewer = useViewer();
+    vue.watchEffect((onCleanup) => {
+      var _a;
+      const _isActive = vue.toValue(isActive);
+      if (_isActive) {
+        const list = Array.isArray(result.value) ? [...result.value] : [result.value];
+        const _collection = collection ?? ((_a = viewer.value) == null ? void 0 : _a.imageryLayers);
+        if (collection == null ? void 0 : collection.isDestroyed()) {
+          return;
+        }
+        list.forEach((item) => {
+          if (!item) {
+            console.warn("ImageryLayer is undefined");
+            return;
+          }
+          if (item == null ? void 0 : item.isDestroyed()) {
+            console.warn("ImageryLayer is destroyed");
+            return;
+          }
+          _collection == null ? void 0 : _collection.add(item);
+        });
+        onCleanup(() => {
+          const destroy = vue.toValue(destroyOnRemove);
+          list.forEach((item) => item && (_collection == null ? void 0 : _collection.remove(item, destroy)));
+        });
+      }
+    });
+    return result;
+  }
+  function useImageryLayerScope(options = {}) {
+    const { collection: _collection, destroyOnRemove } = options;
+    const viewer = useViewer();
+    const collection = vue.computed(() => {
+      var _a;
+      return vue.toValue(_collection) ?? ((_a = viewer.value) == null ? void 0 : _a.imageryLayers);
+    });
+    const addFn = (imageryLayer, index) => {
+      if (!collection.value) {
+        throw new Error("collection is not defined");
+      }
+      collection.value.add(imageryLayer, index);
+      return imageryLayer;
+    };
+    const removeFn = (imageryLayer, destroy) => {
+      var _a;
+      return !!((_a = collection.value) == null ? void 0 : _a.remove(imageryLayer, destroy));
+    };
+    const { scope, add, remove, removeWhere, removeScope } = useCollectionScope(addFn, removeFn, [destroyOnRemove]);
+    return {
+      scope,
+      add,
+      remove,
+      removeWhere,
+      removeScope
+    };
+  }
+  function usePostProcessStage(data, options = {}) {
+    const {
+      collection,
+      isActive = true,
+      evaluating
+    } = options;
+    const result = core.computedAsync(
+      () => toPromiseValue(data),
+      void 0,
+      {
+        evaluating
+      }
+    );
+    const viewer = useViewer();
+    vue.watchEffect((onCleanup) => {
+      if (!viewer.value) {
+        return;
+      }
+      const _isActive = vue.toValue(isActive);
+      if (_isActive) {
+        const list = Array.isArray(result.value) ? [...result.value] : [result.value];
+        const _collection = collection ?? viewer.value.scene.postProcessStages;
+        list.forEach((item) => item && _collection.add(item));
+        onCleanup(() => {
+          list.forEach((item) => item && _collection.remove(item));
+        });
+      }
+    });
+    return result;
+  }
+  function usePostProcessStageScope(options = {}) {
+    const { collection: _collection } = options;
+    const viewer = useViewer();
+    const collection = vue.computed(() => {
+      var _a;
+      return vue.toValue(_collection) ?? ((_a = viewer.value) == null ? void 0 : _a.postProcessStages);
+    });
+    const addFn = (postProcessStage) => {
+      if (!collection.value) {
+        throw new Error("collection is not defined");
+      }
+      return collection.value.add(postProcessStage);
+    };
+    const removeFn = (postProcessStage) => {
+      var _a;
+      return !!((_a = collection.value) == null ? void 0 : _a.remove(postProcessStage));
+    };
+    const { scope, add, remove, removeWhere, removeScope } = useCollectionScope(addFn, removeFn, []);
+    return {
+      scope,
+      add,
+      remove,
+      removeWhere,
+      removeScope
+    };
+  }
+  function usePrimitive(data, options = {}) {
+    const {
+      collection,
+      isActive = true,
+      evaluating
+    } = options;
+    const result = core.computedAsync(
+      () => toPromiseValue(data),
+      void 0,
+      {
+        evaluating
+      }
+    );
+    const viewer = useViewer();
+    vue.watchEffect((onCleanup) => {
+      var _a, _b;
+      const _isActive = vue.toValue(isActive);
+      if (_isActive) {
+        const list = Array.isArray(result.value) ? [...result.value] : [result.value];
+        const _collection = collection === "ground" ? (_a = viewer.value) == null ? void 0 : _a.scene.groundPrimitives : collection ?? ((_b = viewer.value) == null ? void 0 : _b.scene.primitives);
+        list.forEach((item) => item && (_collection == null ? void 0 : _collection.add(item)));
+        onCleanup(() => {
+          !(_collection == null ? void 0 : _collection.isDestroyed()) && list.forEach((item) => item && (_collection == null ? void 0 : _collection.remove(item)));
+        });
+      }
+    });
+    return result;
+  }
+  function usePrimitiveScope(options = {}) {
+    const { collection: _collection } = options;
+    const viewer = useViewer();
+    const collection = vue.computed(() => {
+      var _a;
+      return vue.toValue(_collection) ?? ((_a = viewer.value) == null ? void 0 : _a.scene.primitives);
+    });
+    const addFn = (primitive) => {
+      if (!collection.value) {
+        throw new Error("collection is not defined");
+      }
+      return collection.value.add(primitive);
+    };
+    const removeFn = (primitive) => {
+      var _a;
+      return !!((_a = collection.value) == null ? void 0 : _a.remove(primitive));
+    };
+    const { scope, add, remove, removeWhere, removeScope } = useCollectionScope(addFn, removeFn, []);
+    return {
+      scope,
+      add,
+      remove,
+      removeWhere,
+      removeScope
+    };
+  }
+  const distances = [
+    0.01,
+    0.05,
+    0.1,
+    0.5,
+    1,
+    2,
+    3,
+    5,
+    10,
+    20,
+    30,
+    50,
+    100,
+    200,
+    300,
+    500,
+    1e3,
+    2e3,
+    3e3,
+    5e3,
+    1e4,
+    2e4,
+    3e4,
+    5e4,
+    1e5,
+    2e5,
+    3e5,
+    5e5,
+    1e6,
+    2e6,
+    3e6,
+    5e6,
+    1e7,
+    2e7,
+    3e7,
+    5e7
+  ].reverse();
+  function useScaleBar(options = {}) {
+    const { maxPixel = 80, delay = 8 } = options;
+    const maxPixelRef = vue.computed(() => vue.toValue(maxPixel));
+    const viewer = useViewer();
+    const canvasSize = core.useElementSize(() => {
+      var _a;
+      return (_a = viewer.value) == null ? void 0 : _a.canvas;
+    });
+    const pixelDistance = vue.ref();
+    const setPixelDistance = async () => {
+      var _a;
+      await vue.nextTick();
+      const scene = (_a = viewer.value) == null ? void 0 : _a.scene;
+      if (!scene) {
+        return;
+      }
+      const left = scene.camera.getPickRay(new cesium.Cartesian2(Math.floor(canvasSize.width.value / 2), canvasSize.height.value - 1));
+      const right = scene.camera.getPickRay(new cesium.Cartesian2(Math.floor(1 + canvasSize.width.value / 2), canvasSize.height.value - 1));
+      if (!left || !right) {
+        return;
+      }
+      const leftPosition = scene.globe.pick(left, scene);
+      const rightPosition = scene.globe.pick(right, scene);
+      if (!leftPosition || !rightPosition) {
+        return;
+      }
+      const leftCartographic = scene.globe.ellipsoid.cartesianToCartographic(leftPosition);
+      const rightCartographic = scene.globe.ellipsoid.cartesianToCartographic(rightPosition);
+      const geodesic = new cesium.EllipsoidGeodesic(leftCartographic, rightCartographic);
+      pixelDistance.value = geodesic.surfaceDistance;
+    };
+    core.watchImmediate(viewer, () => setPixelDistance());
+    useCesiumEventListener(
+      () => {
+        var _a;
+        return (_a = viewer.value) == null ? void 0 : _a.camera.changed;
+      },
+      throttle(setPixelDistance, delay)
+    );
+    const distance = vue.computed(() => {
+      if (pixelDistance.value) {
+        return distances.find((item) => pixelDistance.value * maxPixelRef.value > item);
+      }
+    });
+    const width = vue.computed(() => {
+      if (distance.value && pixelDistance.value) {
+        const value = distance.value / pixelDistance.value;
+        return value;
+      }
+      return 0;
+    });
+    const distanceText = vue.computed(() => {
+      if (distance.value) {
+        return distance.value > 1e3 ? `${distance.value / 1e3 || 0}km` : `${distance.value || 0}m`;
+      }
+    });
+    return {
+      pixelDistance: vue.readonly(pixelDistance),
+      width,
+      distance,
+      distanceText
+    };
+  }
+  function useSceneDrillPick(windowPosition, options = {}) {
+    const { width = 3, height = 3, limit, throttled = 8, isActive = true } = options;
+    const viewer = useViewer();
+    const position = core.refThrottled(vue.computed(() => vue.toValue(windowPosition)), throttled, false, true);
+    const pick = vue.computed(() => {
+      var _a;
+      if (position.value && vue.toValue(isActive)) {
+        return (_a = viewer.value) == null ? void 0 : _a.scene.drillPick(
+          position.value,
+          vue.toValue(limit),
+          vue.toValue(width),
+          vue.toValue(height)
+        );
+      }
+    });
+    return pick;
+  }
+  exports.CREATE_VIEWER_COLLECTION = CREATE_VIEWER_COLLECTION;
+  exports.CREATE_VIEWER_INJECTION_KEY = CREATE_VIEWER_INJECTION_KEY;
+  exports.CesiumMaterial = CesiumMaterial;
+  exports.addMaterialCache = addMaterialCache;
+  exports.arrayDiff = arrayDiff;
+  exports.assertError = assertError;
+  exports.canvasCoordToCartesian = canvasCoordToCartesian;
+  exports.cartesianToCanvasCoord = cartesianToCanvasCoord;
+  exports.cesiumEquals = cesiumEquals;
+  exports.createCesiumAttribute = createCesiumAttribute;
+  exports.createCesiumProperty = createCesiumProperty;
+  exports.createPropertyField = createPropertyField;
+  exports.createViewer = createViewer;
+  exports.degreesToDms = degreesToDms;
+  exports.dmsDecode = dmsDecode;
+  exports.dmsEncode = dmsEncode;
+  exports.dmsToDegrees = dmsToDegrees;
+  exports.getMaterialCache = getMaterialCache;
+  exports.isArray = isArray;
+  exports.isBase64 = isBase64;
+  exports.isBoolean = isBoolean;
+  exports.isCesiumConstant = isCesiumConstant;
+  exports.isDef = isDef;
+  exports.isElement = isElement;
+  exports.isFunction = isFunction;
+  exports.isNumber = isNumber;
+  exports.isObject = isObject;
+  exports.isPromise = isPromise;
+  exports.isProperty = isProperty;
+  exports.isString = isString;
+  exports.isWindow = isWindow;
+  exports.pickHitGraphic = pickHitGraphic;
+  exports.resolvePick = resolvePick;
+  exports.throttle = throttle;
+  exports.toCartesian3 = toCartesian3;
+  exports.toCartographic = toCartographic;
+  exports.toCoord = toCoord;
+  exports.toPromiseValue = toPromiseValue;
+  exports.toProperty = toProperty;
+  exports.toPropertyValue = toPropertyValue;
+  exports.tryRun = tryRun;
+  exports.useCameraState = useCameraState;
+  exports.useCesiumEventListener = useCesiumEventListener;
+  exports.useCesiumFps = useCesiumFps;
+  exports.useCollectionScope = useCollectionScope;
+  exports.useDataSource = useDataSource;
+  exports.useDataSourceScope = useDataSourceScope;
+  exports.useElementOverlay = useElementOverlay;
+  exports.useEntity = useEntity;
+  exports.useEntityScope = useEntityScope;
+  exports.useGraphicEvent = useGraphicEvent;
+  exports.useImageryLayer = useImageryLayer;
+  exports.useImageryLayerScope = useImageryLayerScope;
+  exports.usePostProcessStage = usePostProcessStage;
+  exports.usePostProcessStageScope = usePostProcessStageScope;
+  exports.usePrimitive = usePrimitive;
+  exports.usePrimitiveScope = usePrimitiveScope;
+  exports.useScaleBar = useScaleBar;
+  exports.useSceneDrillPick = useSceneDrillPick;
+  exports.useScenePick = useScenePick;
+  exports.useScreenSpaceEventHandler = useScreenSpaceEventHandler;
+  exports.useViewer = useViewer;
   Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
   return exports;
-}({}, VesiumCore, VesiumShared);
+}({}, VueUse, Cesium, Vue);
 //# sourceMappingURL=index.iife.js.map