@vesium/plot 1.0.1-beta.50 → 1.0.1-beta.52

package/dist/index.mjs

@@ -1,1477 +1,3006 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import { JulianDate, Event, TimeInterval, Cartesian3, createGuid, Entity, PrimitiveCollection, CustomDataSource, ScreenSpaceEventType, Color, VerticalOrigin, HorizontalOrigin, Rectangle, CoplanarPolygonGeometry, VertexFormat, ClassificationType, CallbackProperty, ConstantPositionProperty, ConstantProperty, PolygonHierarchy, CallbackPositionProperty } from "cesium";
-import { assertError, useViewer, usePrimitive, useDataSource, useEntityScope, usePrimitiveScope, useScreenSpaceEventHandler, canvasCoordToCartesian, useCesiumEventListener, arrayDiff, isFunction, useGraphicEvent, pickHitGraphic, toCartographic, toCartesian3 } from "vesium";
-import { assert, watchArray, promiseTimeout, onKeyStroke } from "@vueuse/core";
-import { shallowRef, watch, computed, ref, watchEffect, toValue, nextTick, shallowReactive } from "vue";
-const _PlotScheme = class _PlotScheme {
-  constructor(options) {
-    /**
-     * 标绘类型。应当是全局唯一的字符串，会作为键名缓存
-     */
-    __publicField(this, "type");
-    /**
-     * 判断是否立即完成标绘.
-     * 每次控制点发生变变化时，执行该回调函数，返回`true`则完成标绘
-     */
-    __publicField(this, "complete");
-    /**
-     * 判断是否允许手动完成标绘。
-     * 每次控制点发生变变化时，执行该回调函数，返回`true`则后续左键双击即完成标绘
-     */
-    __publicField(this, "allowManualComplete");
-    /**
-     * 处于定义态时鼠标的样式
-     * @default 'crosshair'
-     */
-    __publicField(this, "definingCursor");
-    /**
-     * 当前标绘的框架点数据
-     */
-    __publicField(this, "skeletons");
-    /**
-     * 初始化时创建`Entity`的函数，创建后的`Entity`会作为配置项传入`render`中
-     */
-    __publicField(this, "initEntites");
-    /**
-     * 初始化时创建`Primitive`的函数，创建后的`Primitive`会作为配置项传入`render`中
-     */
-    __publicField(this, "initPrimitives");
-    /**
-     * 初始化时创建贴地`Primitive`的函数，创建后的`Primitive`会作为配置项传入`render`中
-     */
-    __publicField(this, "initGroundPrimitives");
-    /**
-     * 当标绘数据变化时，会触发`render`回调，返回的数据会被添加到cesium中
-     */
-    __publicField(this, "render");
-    var _a;
-    this.type = options.type;
-    this.complete = options.complete;
-    this.allowManualComplete = options.allowManualComplete;
-    this.definingCursor = options.definingCursor ?? "crosshair";
-    this.skeletons = ((_a = options.skeletons) == null ? void 0 : _a.map((item) => item())) ?? [];
-    this.initEntites = options.initEntites;
-    this.initPrimitives = options.initPrimitives;
-    this.initGroundPrimitives = options.initGroundPrimitives;
-    this.render = options.render;
-  }
-  /**
-   * 标绘方案缓存。
-   * 每次标绘时都会将`PlotScheme.type`作为键名缓存，
-   * 后续可用过`PlotScheme.getCache(type)`获取完整的`PlotScheme`配置。
-   */
-  static getCacheTypes() {
-    return [...this._record.keys()];
-  }
-  /**
-   * 通过`PlotScheme.type`获取缓存中的`PlotScheme`配置。
-   */
-  static getCache(type) {
-    return _PlotScheme._record.get(type);
-  }
-  /**
-   * 缓存标绘方案。
-   */
-  static setCache(scheme) {
-    assertError(!scheme.type, "`scheme.type` is required");
-    _PlotScheme._record.set(scheme.type, scheme);
-  }
-  /**
-   * 解析传入的maybeScheme，maybeScheme可能是一个完整的PlotScheme，也可能是缓存中的`PlotScheme.type`，并返回 PlotScheme 实例。
-   * 若传入的是`PlotScheme.type`字符串，并且缓存中不存在该标绘方案，则抛出错误。
-   */
-  static resolve(maybeScheme) {
-    if (typeof maybeScheme === "string") {
-      const _scheme = _PlotScheme.getCache(maybeScheme);
-      assert(!!_scheme, `scheme ${maybeScheme} not found`);
-      return _scheme;
-    } else if (!(maybeScheme instanceof _PlotScheme)) {
-      return new _PlotScheme(maybeScheme);
-    } else {
-      return maybeScheme;
-    }
-  }
+import { CallbackPositionProperty, CallbackProperty, Cartesian3, Cartographic, ClassificationType, Color, ConstantPositionProperty, ConstantProperty, CoplanarPolygonGeometry, CustomDataSource, Ellipsoid, Entity, Event, HorizontalOrigin, JulianDate, LabelGraphics, PerInstanceColorAppearance, PolygonGeometry, PolygonHierarchy, PolylineGraphics, PrimitiveCollection, Rectangle, ScreenSpaceEventType, TimeInterval, VertexFormat, VerticalOrigin, createGuid, sampleTerrainMostDetailed } from "cesium";
+import { arrayDiff, assertError, canvasCoordToCartesian, isFunction, pickHitGraphic, toCartesian3, toCartographic, toCoord, toProperty, toPropertyValue, useCesiumEventListener, useDataSource, useEntityScope, useGraphicEvent, usePrimitive, usePrimitiveScope, useScreenSpaceEventHandler, useViewer } from "vesium";
+import { assert, onKeyStroke, promiseTimeout, watchArray } from "@vueuse/core";
+import { computed, nextTick, ref, shallowReactive, shallowRef, toValue, watch, watchEffect } from "vue";
+import * as turf$1 from "@turf/turf";
+import * as turf from "@turf/turf";
+
+//#region usePlot/PlotScheme.ts
+var PlotScheme = class PlotScheme {
+	constructor(options) {
+		this.type = options.type;
+		this.complete = options.complete;
+		this.allowManualComplete = options.allowManualComplete;
+		this.definingCursor = options.definingCursor ?? "crosshair";
+		this.skeletons = options.skeletons?.map((item) => item()) ?? [];
+		this.initRender = options.initRender;
+		this.render = options.render;
+	}
+	/**
+	* 标绘类型。应当是全局唯一的字符串，会作为键名缓存
+	*/
+	type;
+	/**
+	* 判断是否立即完成标绘.
+	* 每次控制点发生变变化时，执行该回调函数，返回`true`则完成标绘
+	*/
+	complete;
+	/**
+	* 判断是否允许手动完成标绘。
+	* 每次控制点发生变变化时，执行该回调函数，返回`true`则后续左键双击即完成标绘
+	*/
+	allowManualComplete;
+	/**
+	* 处于定义态时鼠标的样式
+	* @default 'crosshair'
+	*/
+	definingCursor;
+	/**
+	* 当前标绘的框架点数据
+	*/
+	skeletons;
+	/**
+	* 初始化时创建贴地`Primitive`的函数，创建后的`Primitive`会作为配置项传入`render`中
+	*/
+	initRender;
+	/**
+	* 当标绘数据变化时，会触发`render`回调，返回的数据会被添加到cesium中
+	*/
+	render;
+	static _record = /* @__PURE__ */ new Map();
+	/**
+	* 标绘方案缓存。
+	* 每次标绘时都会将`PlotScheme.type`作为键名缓存，
+	* 后续可用过`PlotScheme.getCache(type)`获取完整的`PlotScheme`配置。
+	*/
+	static getCacheTypes() {
+		return [...this._record.keys()];
+	}
+	/**
+	* 通过`PlotScheme.type`获取缓存中的`PlotScheme`配置。
+	*/
+	static getCache(type) {
+		return PlotScheme._record.get(type);
+	}
+	/**
+	* 缓存标绘方案。
+	*/
+	static setCache(scheme) {
+		assertError(!scheme.type, "`scheme.type` is required");
+		PlotScheme._record.set(scheme.type, scheme);
+	}
+	/**
+	* 解析传入的maybeScheme，maybeScheme可能是一个完整的PlotScheme，也可能是缓存中的`PlotScheme.type`，并返回 PlotScheme 实例。
+	* 若传入的是`PlotScheme.type`字符串，并且缓存中不存在该标绘方案，则抛出错误。
+	*/
+	static resolve(maybeScheme) {
+		if (typeof maybeScheme === "string") {
+			const _scheme = PlotScheme.getCache(maybeScheme);
+			assert(!!_scheme, `scheme ${maybeScheme} not found`);
+			return _scheme;
+		} else if (!(maybeScheme instanceof PlotScheme)) return new PlotScheme(maybeScheme);
+		else return maybeScheme;
+	}
 };
-__publicField(_PlotScheme, "_record", /* @__PURE__ */ new Map());
-let PlotScheme = _PlotScheme;
-var SampledPlotStrategy = /* @__PURE__ */ ((SampledPlotStrategy2) => {
-  SampledPlotStrategy2[SampledPlotStrategy2["NEAR"] = 0] = "NEAR";
-  SampledPlotStrategy2[SampledPlotStrategy2["CYCLE"] = 1] = "CYCLE";
-  SampledPlotStrategy2[SampledPlotStrategy2["STRICT"] = 2] = "STRICT";
-  return SampledPlotStrategy2;
-})(SampledPlotStrategy || {});
+
+//#endregion
+//#region usePlot/SampledPlotProperty.ts
+let SampledPlotStrategy = /* @__PURE__ */ function(SampledPlotStrategy$1) {
+	SampledPlotStrategy$1[SampledPlotStrategy$1["NEAR"] = 0] = "NEAR";
+	SampledPlotStrategy$1[SampledPlotStrategy$1["CYCLE"] = 1] = "CYCLE";
+	SampledPlotStrategy$1[SampledPlotStrategy$1["STRICT"] = 2] = "STRICT";
+	return SampledPlotStrategy$1;
+}({});
+/**
+* 默认插值算法
+*
+* @param time 时间
+* @param previous 前一个数据点
+* @param next 后一个数据点
+* @param proportion 比例
+* @returns 插值结果
+*/
 const defaultInterpolationAlgorithm = (time, previous, next, proportion) => {
-  var _a, _b, _c;
-  if (proportion === 0) {
-    return {
-      time,
-      positions: (_a = previous.positions) == null ? void 0 : _a.map((item) => item.clone()),
-      derivative: previous.derivative
-    };
-  } else if (proportion === 1) {
-    return {
-      time,
-      positions: (_b = next.positions) == null ? void 0 : _b.map((item) => item.clone()),
-      derivative: previous.derivative
-    };
-  }
-  return {
-    time,
-    positions: (_c = next.positions) == null ? void 0 : _c.map((right, index) => {
-      var _a2;
-      const left = (_a2 = previous.positions) == null ? void 0 : _a2[index];
-      return !left ? right : Cartesian3.lerp(left, right, proportion, new Cartesian3());
-    }),
-    derivative: previous.derivative
-  };
+	if (proportion === 0) return {
+		time,
+		positions: previous.positions?.map((item) => item.clone()),
+		derivative: previous.derivative
+	};
+	else if (proportion === 1) return {
+		time,
+		positions: next.positions?.map((item) => item.clone()),
+		derivative: previous.derivative
+	};
+	return {
+		time,
+		positions: next.positions?.map((right, index) => {
+			const left = previous.positions?.[index];
+			return !left ? right : Cartesian3.lerp(left, right, proportion, new Cartesian3());
+		}),
+		derivative: previous.derivative
+	};
 };
-const _SampledPlotProperty = class _SampledPlotProperty {
-  constructor(options) {
-    __publicField(this, "strategy");
-    __publicField(this, "interpolationAlgorithm");
-    /**
-     * @internal
-     */
-    __publicField(this, "_times", []);
-    /**
-     * @internal
-     */
-    __publicField(this, "_sampleds", []);
-    /**
-     * @internal
-     */
-    __publicField(this, "_derivatives", []);
-    /**
-     * @internal
-     */
-    __publicField(this, "_definitionChanged", new Event());
-    var _a;
-    this.interpolationAlgorithm = options == null ? void 0 : options.interpolationAlgorithm;
-    this.strategy = (options == null ? void 0 : options.strategy) ?? 0;
-    (_a = options == null ? void 0 : options.packables) == null ? void 0 : _a.forEach((packable) => this.setSample(packable));
-    if (!this._times.length) {
-      this.setSample({
-        time: new JulianDate(0, 0),
-        positions: [],
-        derivative: void 0
-      });
-    }
-  }
-  get isConstant() {
-    return this._times.length === 0;
-  }
-  get definitionChanged() {
-    return this._definitionChanged;
-  }
-  /**
-   * 获取时间数组
-   *
-   * @returns 返回包含所有时间的 JulianDate 数组
-   */
-  getTimes() {
-    return this._times.map((t) => t.clone());
-  }
-  /**
-   * 根据给定的儒略日期获取时间索引范围及比例
-   *
-   * @param time 给定的儒略日期
-   * @returns 返回包含前一个索引、后一个索引及时间比例的对象，若不符合条件则返回undefined
-   * @internal
-   */
-  getIndexScope(time) {
-    if (!this._times.length) {
-      return;
-    }
-    const start = this._times[0];
-    const end = this._times[this._times.length - 1];
-    if (JulianDate.lessThan(time, start) || JulianDate.greaterThan(time, end)) {
-      switch (this.strategy) {
-        case 2: {
-          return;
-        }
-        case 0: {
-          time = JulianDate.lessThan(time, this._times[0]) ? this._times[0].clone() : this._times[this._times.length - 1].clone();
-          break;
-        }
-        case 1: {
-          const startMS = JulianDate.toDate(this._times[0]).getTime();
-          const endMS = JulianDate.toDate(this._times[this._times.length - 1]).getTime();
-          const duration = endMS - startMS;
-          const timeMS = JulianDate.toDate(time).getTime();
-          const diff = (timeMS - startMS) % duration;
-          const dete = new Date(startMS + diff);
-          time = JulianDate.fromDate(dete);
-          break;
-        }
-      }
-    }
-    const prevIndex = this._times.findIndex((t) => JulianDate.lessThanOrEquals(time, t));
-    const nextIndex = Math.min(prevIndex, this._times.length - 1);
-    const prevMs = JulianDate.toDate(this._times[prevIndex]).getTime();
-    const nextMs = JulianDate.toDate(this._times[nextIndex]).getTime();
-    const ms = JulianDate.toDate(time).getTime();
-    return {
-      prevIndex,
-      nextIndex,
-      proportion: (ms - prevMs) / (nextMs - prevMs) || 0
-    };
-  }
-  /**
-   * 根据给定的儒略日期（JulianDate）获取插值后的样本点数据。
-   *
-   * @param time 指定的儒略日期（JulianDate）。
-   * @param result 可选参数，用于存储结果的容器。如果未提供，则创建一个新的容器。
-   * @returns 插值后的样本点数据，存储在提供的或新创建的result容器中。
-   * @template D 数据类型。
-   */
-  getValue(time, result) {
-    var _a;
-    result ?? (result = { time });
-    Object.assign(result, {
-      time: time == null ? void 0 : time.clone(),
-      positions: void 0,
-      derivative: void 0
-    });
-    if (!time) {
-      result.time = this._times[0].clone();
-      result.positions = (_a = this._sampleds[0]) == null ? void 0 : _a.map((c) => c.clone(c));
-      result.derivative = this._derivatives[0];
-      return result;
-    }
-    const scope = this.getIndexScope(time);
-    if (!scope) {
-      return result;
-    }
-    result.time = time;
-    const { prevIndex, nextIndex, proportion } = scope;
-    const previous = {
-      time: this._times[prevIndex],
-      positions: this._sampleds[prevIndex],
-      derivative: this._derivatives[prevIndex]
-    };
-    const next = {
-      time: this._times[nextIndex],
-      positions: this._sampleds[nextIndex],
-      derivative: this._derivatives[nextIndex]
-    };
-    const packable = (this.interpolationAlgorithm || _SampledPlotProperty.defaultInterpolationAlgorithm)(time, previous, next, proportion);
-    Object.assign(result, packable);
-    return result;
-  }
-  /**
-   * 设置样本数据，如果传入的数据不含时间，则会存入时间最早的集合中
-   * @param value 样本数据对象，包含时间、位置和导数信息
-   */
-  setSample(value) {
-    var _a, _b;
-    const time = ((_a = value.time) == null ? void 0 : _a.clone()) ?? this._times[0].clone();
-    const positions = ((_b = value.positions) == null ? void 0 : _b.map((item) => item.clone())) ?? [];
-    const derivative = value.derivative;
-    const index = this._times.findIndex((t) => JulianDate.equals(time, t));
-    if (index !== -1) {
-      this._times[index] = time;
-      this._sampleds[index] = positions;
-      this._derivatives[index] = value.derivative;
-    } else if (this._times.length === 0) {
-      this._times[0] = time;
-      this._sampleds[0] = positions;
-      this._derivatives[0] = value.derivative;
-    } else if (JulianDate.lessThan(time, this._times[0])) {
-      this._times.splice(0, 0, time);
-      this._sampleds.splice(0, 0, positions);
-      this._derivatives.splice(0, 0, derivative);
-    } else if (JulianDate.greaterThan(time, this._times[this._times.length - 1])) {
-      this._times.push(time);
-      this._sampleds.push(positions);
-      this._derivatives.push(derivative);
-    }
-    this.definitionChanged.raiseEvent(this);
-  }
-  /**
-   * 设置样本数据
-   *
-   * @param values 样本数据数组，每个元素都是类型为SampledPlotPackable<D>的对象
-   */
-  setSamples(values) {
-    values.forEach((value) => this.setSample(value));
-  }
-  /**
-   * 从样本中移除指定时间点的数据
-   *
-   * @param time 需要移除的时间点，使用儒略日期表示
-   * @returns 如果成功移除，则返回 true；否则返回 false
-   */
-  removeSample(time) {
-    const index = this._times.findIndex((t) => t.equals(time));
-    if (index !== -1) {
-      this._sampleds.splice(index, 1);
-      this._derivatives.splice(index, 1);
-      const removed = this._times.splice(index, 1);
-      if (removed.length) {
-        this._definitionChanged.raiseEvent(this);
-        return true;
-      }
-    }
-    return false;
-  }
-  /**
-   * 从样本中移除指定时间间隔内的样本。
-   *
-   * @param interval 要移除样本的时间间隔
-   */
-  removeSamples(interval2) {
-    for (let i = 0; i < this._times.length; i++) {
-      const time = this._times[i];
-      TimeInterval.contains(interval2, time) && this.removeSample(time);
-    }
-  }
-  /**
-   * 判断两个property是否相等
-   */
-  equals(other) {
-    return other === this;
-  }
+/**
+* 标绘采样点数据。
+* 标绘采样点数据是一个时间序列数据，包含时间、位置和附带的额外数据。
+* 具体用法可参考 [Cesium.SampledProperty](https://cesium.com/learn/cesiumjs/ref-doc/SampledProperty.html)
+*/
+var SampledPlotProperty = class SampledPlotProperty {
+	constructor(options) {
+		this.interpolationAlgorithm = options?.interpolationAlgorithm;
+		this.strategy = options?.strategy ?? SampledPlotStrategy.NEAR;
+		options?.packables?.forEach((packable) => this.setSample(packable));
+		if (!this._times.length) this.setSample({
+			time: new JulianDate(0, 0),
+			positions: [],
+			derivative: void 0
+		});
+	}
+	static defaultInterpolationAlgorithm = defaultInterpolationAlgorithm;
+	strategy;
+	interpolationAlgorithm;
+	/**
+	* @internal
+	*/
+	_times = [];
+	/**
+	* @internal
+	*/
+	_sampleds = [];
+	/**
+	* @internal
+	*/
+	_derivatives = [];
+	get isConstant() {
+		return this._times.length === 0;
+	}
+	/**
+	* @internal
+	*/
+	_definitionChanged = new Event();
+	get definitionChanged() {
+		return this._definitionChanged;
+	}
+	/**
+	* 获取时间数组
+	*
+	* @returns 返回包含所有时间的 JulianDate 数组
+	*/
+	getTimes() {
+		return this._times.map((t) => t.clone());
+	}
+	/**
+	* 根据给定的儒略日期获取时间索引范围及比例
+	*
+	* @param time 给定的儒略日期
+	* @returns 返回包含前一个索引、后一个索引及时间比例的对象，若不符合条件则返回undefined
+	* @internal
+	*/
+	getIndexScope(time) {
+		if (!this._times.length) return;
+		const start = this._times[0];
+		const end = this._times[this._times.length - 1];
+		if (JulianDate.lessThan(time, start) || JulianDate.greaterThan(time, end)) switch (this.strategy) {
+			case SampledPlotStrategy.STRICT: return;
+			case SampledPlotStrategy.NEAR: {
+				time = JulianDate.lessThan(time, this._times[0]) ? this._times[0].clone() : this._times[this._times.length - 1].clone();
+				break;
+			}
+			case SampledPlotStrategy.CYCLE: {
+				const startMS = JulianDate.toDate(this._times[0]).getTime();
+				const endMS = JulianDate.toDate(this._times[this._times.length - 1]).getTime();
+				const duration = endMS - startMS;
+				const timeMS = JulianDate.toDate(time).getTime();
+				const diff = (timeMS - startMS) % duration;
+				const dete = new Date(startMS + diff);
+				time = JulianDate.fromDate(dete);
+				break;
+			}
+		}
+		const prevIndex = this._times.findIndex((t) => JulianDate.lessThanOrEquals(time, t));
+		const nextIndex = Math.min(prevIndex, this._times.length - 1);
+		const prevMs = JulianDate.toDate(this._times[prevIndex]).getTime();
+		const nextMs = JulianDate.toDate(this._times[nextIndex]).getTime();
+		const ms = JulianDate.toDate(time).getTime();
+		return {
+			prevIndex,
+			nextIndex,
+			proportion: (ms - prevMs) / (nextMs - prevMs) || 0
+		};
+	}
+	/**
+	* 根据给定的儒略日期（JulianDate）获取插值后的样本点数据。
+	*
+	* @param time 指定的儒略日期（JulianDate）。
+	* @param result 可选参数，用于存储结果的容器。如果未提供，则创建一个新的容器。
+	* @returns 插值后的样本点数据，存储在提供的或新创建的result容器中。
+	* @template D 数据类型。
+	*/
+	getValue(time, result) {
+		result ??= {
+			time,
+			positions: []
+		};
+		Object.assign(result, {
+			time: time?.clone(),
+			positions: [],
+			derivative: void 0
+		});
+		if (!time) {
+			result.time = this._times[0].clone();
+			result.positions = this._sampleds[0]?.map((c) => c.clone(c));
+			result.derivative = this._derivatives[0];
+			return result;
+		}
+		const scope = this.getIndexScope(time);
+		if (!scope) return result;
+		result.time = time;
+		const { prevIndex, nextIndex, proportion } = scope;
+		const previous = {
+			time: this._times[prevIndex],
+			positions: this._sampleds[prevIndex],
+			derivative: this._derivatives[prevIndex]
+		};
+		const next = {
+			time: this._times[nextIndex],
+			positions: this._sampleds[nextIndex],
+			derivative: this._derivatives[nextIndex]
+		};
+		const packable = (this.interpolationAlgorithm || SampledPlotProperty.defaultInterpolationAlgorithm)(time, previous, next, proportion);
+		Object.assign(result, packable);
+		return result;
+	}
+	/**
+	* 设置样本数据，如果传入的数据不含时间，则会存入时间最早的集合中
+	* @param value 样本数据对象，包含时间、位置和导数信息
+	*/
+	setSample(value) {
+		const time = value.time?.clone() ?? this._times[0].clone();
+		const positions = value.positions?.map((item) => item.clone()) ?? [];
+		const derivative = value.derivative;
+		const index = this._times.findIndex((t) => JulianDate.equals(time, t));
+		if (index !== -1) {
+			this._times[index] = time;
+			this._sampleds[index] = positions;
+			this._derivatives[index] = value.derivative;
+		} else if (this._times.length === 0) {
+			this._times[0] = time;
+			this._sampleds[0] = positions;
+			this._derivatives[0] = value.derivative;
+		} else if (JulianDate.lessThan(time, this._times[0])) {
+			this._times.splice(0, 0, time);
+			this._sampleds.splice(0, 0, positions);
+			this._derivatives.splice(0, 0, derivative);
+		} else if (JulianDate.greaterThan(time, this._times[this._times.length - 1])) {
+			this._times.push(time);
+			this._sampleds.push(positions);
+			this._derivatives.push(derivative);
+		}
+		this.definitionChanged.raiseEvent(this);
+	}
+	/**
+	* 设置样本数据
+	*
+	* @param values 样本数据数组，每个元素都是类型为SampledPlotPackable<D>的对象
+	*/
+	setSamples(values) {
+		values.forEach((value) => this.setSample(value));
+	}
+	/**
+	* 从样本中移除指定时间点的数据
+	*
+	* @param time 需要移除的时间点，使用儒略日期表示
+	* @returns 如果成功移除，则返回 true；否则返回 false
+	*/
+	removeSample(time) {
+		const index = this._times.findIndex((t) => t.equals(time));
+		if (index !== -1) {
+			this._sampleds.splice(index, 1);
+			this._derivatives.splice(index, 1);
+			const removed = this._times.splice(index, 1);
+			if (removed.length) {
+				this._definitionChanged.raiseEvent(this);
+				return true;
+			}
+		}
+		return false;
+	}
+	/**
+	* 从样本中移除指定时间间隔内的样本。
+	*
+	* @param interval 要移除样本的时间间隔
+	*/
+	removeSamples(interval$1) {
+		for (let i = 0; i < this._times.length; i++) {
+			const time = this._times[i];
+			TimeInterval.contains(interval$1, time) && this.removeSample(time);
+		}
+	}
+	/**
+	* 判断两个property是否相等
+	*/
+	equals(other) {
+		return other === this;
+	}
 };
-__publicField(_SampledPlotProperty, "defaultInterpolationAlgorithm", defaultInterpolationAlgorithm);
-let SampledPlotProperty = _SampledPlotProperty;
-class PlotFeature {
-  constructor(options) {
-    /**
-     * @internal
-     */
-    __publicField(this, "_id");
-    /**
-     * @internal
-     */
-    __publicField(this, "_scheme");
-    /**
-     * @internal
-     */
-    __publicField(this, "_definitionChanged");
-    /**
-     * @internal
-     */
-    __publicField(this, "_defining");
-    /**
-     * @internal
-     */
-    __publicField(this, "_disabled");
-    /**
-     * @internal
-     */
-    __publicField(this, "_sampled");
-    /**
-     * @internal
-     */
-    __publicField(this, "_entities");
-    /**
-     * @internal
-     */
-    __publicField(this, "_primitives");
-    /**
-     * @internal
-     */
-    __publicField(this, "_groundPrimitives");
-    /**
-     * @internal
-     */
-    __publicField(this, "_skeletons");
-    var _a, _b, _c, _d, _e, _f;
-    const { id, disabled = false, sampled } = options;
-    this._id = id || createGuid();
-    this._scheme = PlotScheme.resolve(options.scheme);
-    this._definitionChanged = new Event();
-    this._defining = true;
-    this._disabled = disabled;
-    this._sampled = sampled instanceof SampledPlotProperty ? sampled : new SampledPlotProperty(sampled);
-    this._sampled.definitionChanged.addEventListener((property) => this._definitionChanged.raiseEvent(this, "sampled", property, property), this);
-    this._entities = [...((_b = (_a = this._scheme).initEntites) == null ? void 0 : _b.call(_a)) ?? []];
-    this._primitives = [...((_d = (_c = this._scheme).initPrimitives) == null ? void 0 : _d.call(_c)) ?? []];
-    this._groundPrimitives = [...((_f = (_e = this._scheme).initGroundPrimitives) == null ? void 0 : _f.call(_e)) ?? []];
-    this._skeletons = [];
-  }
-  get id() {
-    return this._id;
-  }
-  get scheme() {
-    return this._scheme;
-  }
-  get definitionChanged() {
-    return this._definitionChanged;
-  }
-  get defining() {
-    return this._defining;
-  }
-  /**
-   * @internal
-   */
-  static setDefining(plot, value) {
-    if (plot._defining !== value) {
-      plot._definitionChanged.raiseEvent(plot, "defining", value, plot._defining);
-      plot._defining = value;
-    }
-  }
-  /**
-   * 获取禁用状态
-   *
-   * 当为 `true` 时，标绘实例将停止响应交互和更新；
-   * 为 `false` 时恢复正常功能。
-   */
-  get disabled() {
-    return this._disabled;
-  }
-  set disabled(value) {
-    this.disabled = value;
-  }
-  get sampled() {
-    return this._sampled;
-  }
-  get entities() {
-    return this._entities;
-  }
-  set entities(value) {
-    this._definitionChanged.raiseEvent(this, "entities", value, this._entities);
-    this._entities = value;
-  }
-  get primitives() {
-    return this._primitives;
-  }
-  /**
-   * @internal
-   */
-  set primitives(value) {
-    this._definitionChanged.raiseEvent(this, "primitives", value, this._primitives);
-    this._primitives = value;
-  }
-  get groundPrimitives() {
-    return this._groundPrimitives;
-  }
-  /**
-   * @internal
-   */
-  set groundPrimitives(value) {
-    this._definitionChanged.raiseEvent(this, "groundPrimitives", value, this._groundPrimitives);
-    this._groundPrimitives = value;
-  }
-  get skeletons() {
-    return this._skeletons;
-  }
-  /**
-   * @internal
-   */
-  set skeletons(value) {
-    this._definitionChanged.raiseEvent(this, "skeletons", value, this._skeletons);
-    this._skeletons = value;
-  }
-}
-var PlotAction = /* @__PURE__ */ ((PlotAction2) => {
-  PlotAction2[PlotAction2["IDLE"] = 0] = "IDLE";
-  PlotAction2[PlotAction2["HOVER"] = 1] = "HOVER";
-  PlotAction2[PlotAction2["ACTIVE"] = 2] = "ACTIVE";
-  return PlotAction2;
-})(PlotAction || {});
-class PlotSkeletonEntity extends Entity {
-  constructor(options) {
-    super(options);
-  }
-}
+
+//#endregion
+//#region usePlot/PlotFeature.ts
+/**
+* 标绘实例
+*/
+var PlotFeature = class {
+	constructor(options) {
+		const { id, disabled = false, sampled } = options;
+		this._id = id || createGuid();
+		this._scheme = PlotScheme.resolve(options.scheme);
+		this._definitionChanged = new Event();
+		this._defining = true;
+		this._disabled = disabled;
+		this._sampled = sampled instanceof SampledPlotProperty ? sampled : new SampledPlotProperty(sampled);
+		this._sampled.definitionChanged.addEventListener((property) => this._definitionChanged.raiseEvent(this, "sampled", property, property), this);
+		const init = this._scheme.initRender?.() ?? {};
+		this._entities = [...init.entities ?? []];
+		this._primitives = [...init.primitives ?? []];
+		this._groundPrimitives = [...init.groundPrimitives ?? []];
+		this._skeletons = [];
+	}
+	/**
+	* @internal
+	*/
+	_id;
+	get id() {
+		return this._id;
+	}
+	/**
+	* @internal
+	*/
+	_scheme;
+	get scheme() {
+		return this._scheme;
+	}
+	/**
+	* @internal
+	*/
+	_definitionChanged;
+	get definitionChanged() {
+		return this._definitionChanged;
+	}
+	/**
+	* @internal
+	*/
+	_defining;
+	get defining() {
+		return this._defining;
+	}
+	/**
+	* @internal
+	*/
+	static setDefining(plot, value) {
+		if (plot._defining !== value) {
+			plot._definitionChanged.raiseEvent(plot, "defining", value, plot._defining);
+			plot._defining = value;
+		}
+	}
+	/**
+	* @internal
+	*/
+	_disabled;
+	/**
+	* 获取禁用状态
+	*
+	* 当为 `true` 时，标绘实例将停止响应交互和更新；
+	* 为 `false` 时恢复正常功能。
+	*/
+	get disabled() {
+		return this._disabled;
+	}
+	set disabled(value) {
+		this.disabled = value;
+	}
+	/**
+	* @internal
+	*/
+	_sampled;
+	get sampled() {
+		return this._sampled;
+	}
+	/**
+	* @internal
+	*/
+	_entities;
+	get entities() {
+		return this._entities;
+	}
+	set entities(value) {
+		this._definitionChanged.raiseEvent(this, "entities", value, this._entities);
+		this._entities = value;
+	}
+	/**
+	* @internal
+	*/
+	_primitives;
+	get primitives() {
+		return this._primitives;
+	}
+	/**
+	* @internal
+	*/
+	set primitives(value) {
+		this._definitionChanged.raiseEvent(this, "primitives", value, this._primitives);
+		this._primitives = value;
+	}
+	/**
+	* @internal
+	*/
+	_groundPrimitives;
+	get groundPrimitives() {
+		return this._groundPrimitives;
+	}
+	/**
+	* @internal
+	*/
+	set groundPrimitives(value) {
+		this._definitionChanged.raiseEvent(this, "groundPrimitives", value, this._groundPrimitives);
+		this._groundPrimitives = value;
+	}
+	/**
+	* @internal
+	*/
+	_skeletons;
+	get skeletons() {
+		return this._skeletons;
+	}
+	/**
+	* @internal
+	*/
+	set skeletons(value) {
+		this._definitionChanged.raiseEvent(this, "skeletons", value, this._skeletons);
+		this._skeletons = value;
+	}
+};
+
+//#endregion
+//#region usePlot/PlotSkeleton.ts
+/**
+* 框架点执行状态枚举
+* - IDLE 空闲状态
+* - HOVER 悬停状态
+* - ACTIVE 激活状态
+*/
+let PlotAction = /* @__PURE__ */ function(PlotAction$1) {
+	PlotAction$1[PlotAction$1["IDLE"] = 0] = "IDLE";
+	PlotAction$1[PlotAction$1["HOVER"] = 1] = "HOVER";
+	PlotAction$1[PlotAction$1["ACTIVE"] = 2] = "ACTIVE";
+	return PlotAction$1;
+}({});
+/**
+* 标绘框架点 Entity
+*/
+var PlotSkeletonEntity = class extends Entity {
+	constructor(options) {
+		super(options);
+	}
+};
+
+//#endregion
+//#region usePlot/useRender.ts
 function useRender(plots, current, getCurrentTime) {
-  const viewer = useViewer();
-  const primitiveCollection = usePrimitive(new PrimitiveCollection());
-  const groundPrimitiveCollection = usePrimitive(new PrimitiveCollection(), { collection: "ground" });
-  const dataSource = useDataSource(new CustomDataSource());
-  const entityScope = useEntityScope({ collection: () => dataSource.value.entities });
-  const primitiveScope = usePrimitiveScope({ collection: () => primitiveCollection.value });
-  const groundPrimitiveScope = usePrimitiveScope({ collection: () => groundPrimitiveCollection.value });
-  const mouseCartesian = shallowRef();
-  useScreenSpaceEventHandler(
-    ScreenSpaceEventType.MOUSE_MOVE,
-    (event) => {
-      mouseCartesian.value = canvasCoordToCartesian(event == null ? void 0 : event.endPosition, viewer.value.scene);
-    }
-  );
-  watchArray(plots, (_value, _oldValue, added, removed = []) => {
-    removed.forEach((plot) => {
-      entityScope.removeWhere((item) => plot.entities.includes(item));
-      primitiveScope.removeWhere((item) => plot.primitives.includes(item));
-      groundPrimitiveScope.removeWhere((item) => plot.groundPrimitives.includes(item));
-    });
-    added.forEach((plot) => {
-      plot.entities.forEach((item) => entityScope.add(item));
-      plot.primitives.forEach((item) => primitiveScope.add(item));
-      plot.groundPrimitives.forEach((item) => groundPrimitiveScope.add(item));
-    });
-  }, {
-    immediate: true,
-    flush: "post"
-  });
-  useCesiumEventListener(
-    () => plots.value.map((item) => item.definitionChanged),
-    (_scope, key, newValue, oldValue) => {
-      if (key === "entities") {
-        const { added, removed } = arrayDiff(newValue, oldValue);
-        added.forEach((item) => entityScope.add(item));
-        removed.forEach((item) => entityScope.remove(item));
-      } else if (key === "primitives") {
-        const { added, removed } = arrayDiff(newValue, oldValue);
-        added.forEach((item) => primitiveScope.add(item));
-        removed.forEach((item) => primitiveScope.remove(item));
-      } else if (key === "groundPrimitives") {
-        const { added, removed } = arrayDiff(newValue, oldValue);
-        added.forEach((item) => groundPrimitiveScope.add(item));
-        removed.forEach((item) => groundPrimitiveScope.remove(item));
-      }
-    }
-  );
-  const update = async (plot) => {
-    var _a, _b;
-    const reslut = await ((_b = (_a = plot.scheme).render) == null ? void 0 : _b.call(_a, {
-      packable: plot.sampled.getValue(getCurrentTime()),
-      mouse: plot.defining ? mouseCartesian.value : void 0,
-      defining: plot.defining,
-      previous: {
-        entities: plot.entities,
-        primitives: plot.primitives,
-        groundPrimitives: plot.groundPrimitives
-      }
-    }));
-    plot.entities = (reslut == null ? void 0 : reslut.entities) ?? [];
-    plot.primitives = (reslut == null ? void 0 : reslut.primitives) ?? [];
-    plot.groundPrimitives = (reslut == null ? void 0 : reslut.groundPrimitives) ?? [];
-  };
-  watch(current, (plot, previous) => {
-    previous && update(previous);
-  });
-  useCesiumEventListener(
-    () => plots.value.map((item) => item.definitionChanged),
-    (plot, key) => {
-      if (["disabled", "defining", "scheme", "sampled", "time"].includes(key)) {
-        update(plot);
-      }
-    }
-  );
-  watch(mouseCartesian, () => {
-    plots.value.forEach((plot) => plot.defining && update(plot));
-  });
-  return {
-    primitives: computed(() => Array.from(primitiveScope.scope)),
-    groundPrimitives: computed(() => Array.from(primitiveScope.scope)),
-    entities: computed(() => Array.from(entityScope.scope))
-  };
+	const viewer = useViewer();
+	const primitiveCollection = usePrimitive(new PrimitiveCollection());
+	const groundPrimitiveCollection = usePrimitive(new PrimitiveCollection(), { collection: "ground" });
+	const dataSource = useDataSource(new CustomDataSource());
+	const entityScope = useEntityScope({ collection: () => dataSource.value.entities });
+	const primitiveScope = usePrimitiveScope({ collection: () => primitiveCollection.value });
+	const groundPrimitiveScope = usePrimitiveScope({ collection: () => groundPrimitiveCollection.value });
+	const mouseCartesian = shallowRef();
+	useScreenSpaceEventHandler(ScreenSpaceEventType.MOUSE_MOVE, (event) => {
+		mouseCartesian.value = canvasCoordToCartesian(event?.endPosition, viewer.value.scene);
+	});
+	watchArray(plots, (_value, _oldValue, added, removed = []) => {
+		removed.forEach((plot) => {
+			entityScope.removeWhere((item) => plot.entities.includes(item));
+			primitiveScope.removeWhere((item) => plot.primitives.includes(item));
+			groundPrimitiveScope.removeWhere((item) => plot.groundPrimitives.includes(item));
+		});
+		added.forEach((plot) => {
+			plot.entities.forEach((item) => entityScope.add(item));
+			plot.primitives.forEach((item) => primitiveScope.add(item));
+			plot.groundPrimitives.forEach((item) => groundPrimitiveScope.add(item));
+		});
+	}, {
+		immediate: true,
+		flush: "post"
+	});
+	useCesiumEventListener(() => plots.value.map((item) => item.definitionChanged), (_scope, key, newValue, oldValue) => {
+		if (key === "entities") {
+			const { added, removed } = arrayDiff(newValue, oldValue);
+			added.forEach((item) => entityScope.add(item));
+			removed.forEach((item) => entityScope.remove(item));
+		} else if (key === "primitives") {
+			const { added, removed } = arrayDiff(newValue, oldValue);
+			added.forEach((item) => primitiveScope.add(item));
+			removed.forEach((item) => primitiveScope.remove(item));
+		} else if (key === "groundPrimitives") {
+			const { added, removed } = arrayDiff(newValue, oldValue);
+			added.forEach((item) => groundPrimitiveScope.add(item));
+			removed.forEach((item) => groundPrimitiveScope.remove(item));
+		}
+	});
+	const update = async (plot) => {
+		const reslut = await plot.scheme.render?.({
+			packable: plot.sampled.getValue(getCurrentTime()),
+			mouse: plot.defining ? mouseCartesian.value : void 0,
+			defining: plot.defining,
+			previous: {
+				entities: plot.entities,
+				primitives: plot.primitives,
+				groundPrimitives: plot.groundPrimitives
+			}
+		});
+		plot.entities = reslut?.entities ?? [];
+		plot.primitives = reslut?.primitives ?? [];
+		plot.groundPrimitives = reslut?.groundPrimitives ?? [];
+	};
+	watch(current, (plot, previous) => {
+		previous && update(previous);
+	});
+	useCesiumEventListener(() => plots.value.map((item) => item.definitionChanged), (plot, key) => {
+		if ([
+			"disabled",
+			"defining",
+			"scheme",
+			"sampled",
+			"time"
+		].includes(key)) update(plot);
+	});
+	watch(mouseCartesian, () => {
+		plots.value.forEach((plot) => plot.defining && update(plot));
+	});
+	return {
+		primitives: computed(() => Array.from(primitiveScope.scope)),
+		groundPrimitives: computed(() => Array.from(primitiveScope.scope)),
+		entities: computed(() => Array.from(entityScope.scope))
+	};
 }
+
+//#endregion
+//#region usePlot/useSampled.ts
 function useSampled(current, getCurrentTime) {
-  const viewer = useViewer();
-  const doubleClicking = ref(false);
-  const packable = computed(() => {
-    var _a;
-    return (_a = current.value) == null ? void 0 : _a.sampled.getValue(getCurrentTime());
-  });
-  useScreenSpaceEventHandler(
-    ScreenSpaceEventType.LEFT_CLICK,
-    async (ctx) => {
-      var _a, _b;
-      await promiseTimeout(1);
-      if (!current.value || !packable.value) {
-        return;
-      }
-      if (doubleClicking.value) {
-        return;
-      }
-      const { scheme, defining, sampled } = current.value;
-      if (!defining) {
-        return;
-      }
-      const position = canvasCoordToCartesian(ctx.position, viewer.value.scene);
-      if (!position) {
-        return;
-      }
-      (_a = packable.value).positions ?? (_a.positions = []);
-      packable.value.positions.push(position);
-      sampled.setSample(packable.value);
-      const completed = (_b = scheme.complete) == null ? void 0 : _b.call(scheme, packable.value);
-      completed && PlotFeature.setDefining(current.value, false);
-    }
-  );
-  useScreenSpaceEventHandler(
-    ScreenSpaceEventType.LEFT_DOUBLE_CLICK,
-    async (ctx) => {
-      var _a;
-      if (!current.value || !packable.value) {
-        return;
-      }
-      doubleClicking.value = true;
-      await promiseTimeout(2);
-      doubleClicking.value = false;
-      const { scheme, defining } = current.value;
-      if (!defining) {
-        return;
-      }
-      const position = canvasCoordToCartesian(ctx.position, viewer.value.scene);
-      if (!position) {
-        return;
-      }
-      const completed = (_a = scheme.allowManualComplete) == null ? void 0 : _a.call(scheme, packable.value);
-      completed && PlotFeature.setDefining(current.value, false);
-    }
-  );
-  useScreenSpaceEventHandler(
-    ScreenSpaceEventType.RIGHT_CLICK,
-    async () => {
-      var _a;
-      if (!current.value || !packable.value) {
-        return;
-      }
-      const { defining, sampled } = current.value;
-      if (!defining) {
-        return;
-      }
-      (_a = packable.value).positions ?? (_a.positions = []);
-      if (packable.value.positions.length === 0) {
-        return;
-      }
-      packable.value.positions.splice(packable.value.positions.length - 1, 1);
-      sampled.setSample(packable.value);
-    }
-  );
-  const definingCursorCss = ref();
-  const setDefiningCursorCss = () => {
-    var _a, _b;
-    if (!((_a = current.value) == null ? void 0 : _a.defining)) {
-      if (definingCursorCss.value) {
-        definingCursorCss.value = void 0;
-        viewer.value.container.parentElement.style.removeProperty("cursor");
-      }
-    } else {
-      const definingCursor = current.value.scheme.definingCursor;
-      definingCursorCss.value = isFunction(definingCursor) ? definingCursor(packable.value) : definingCursor;
-      if (definingCursorCss.value) {
-        (_b = viewer.value) == null ? void 0 : _b.container.parentElement.style.setProperty("cursor", definingCursorCss.value);
-      }
-    }
-  };
-  useCesiumEventListener(() => {
-    var _a;
-    return (_a = current.value) == null ? void 0 : _a.definitionChanged;
-  }, (plot, key) => {
-    if (key === "defining" || key === "sampled") {
-      setDefiningCursorCss();
-    }
-  });
-  watch(current, () => setDefiningCursorCss());
+	const viewer = useViewer();
+	const doubleClicking = ref(false);
+	const packable = computed(() => {
+		return current.value?.sampled.getValue(getCurrentTime());
+	});
+	useScreenSpaceEventHandler(ScreenSpaceEventType.LEFT_CLICK, async (ctx) => {
+		await promiseTimeout(1);
+		if (!current.value || !packable.value) return;
+		if (doubleClicking.value) return;
+		const { scheme, defining, sampled } = current.value;
+		if (!defining) return;
+		const position = canvasCoordToCartesian(ctx.position, viewer.value.scene);
+		if (!position) return;
+		packable.value.positions ??= [];
+		packable.value.positions.push(position);
+		sampled.setSample(packable.value);
+		const completed = scheme.complete?.(packable.value);
+		completed && PlotFeature.setDefining(current.value, false);
+	});
+	useScreenSpaceEventHandler(ScreenSpaceEventType.LEFT_DOUBLE_CLICK, async (ctx) => {
+		if (!current.value || !packable.value) return;
+		doubleClicking.value = true;
+		await promiseTimeout(2);
+		doubleClicking.value = false;
+		const { scheme, defining } = current.value;
+		if (!defining) return;
+		const position = canvasCoordToCartesian(ctx.position, viewer.value.scene);
+		if (!position) return;
+		const completed = scheme.allowManualComplete?.(packable.value);
+		completed && PlotFeature.setDefining(current.value, false);
+	});
+	useScreenSpaceEventHandler(ScreenSpaceEventType.RIGHT_CLICK, async () => {
+		if (!current.value || !packable.value) return;
+		const { defining, sampled } = current.value;
+		if (!defining) return;
+		packable.value.positions ??= [];
+		if (packable.value.positions.length === 0) return;
+		packable.value.positions.splice(packable.value.positions.length - 1, 1);
+		sampled.setSample(packable.value);
+	});
+	const definingCursorCss = ref();
+	const setDefiningCursorCss = () => {
+		if (!current.value?.defining) {
+			if (definingCursorCss.value) {
+				definingCursorCss.value = void 0;
+				viewer.value.container.parentElement.style.removeProperty("cursor");
+			}
+		} else {
+			const definingCursor = current.value.scheme.definingCursor;
+			definingCursorCss.value = isFunction(definingCursor) ? definingCursor(packable.value) : definingCursor;
+			if (definingCursorCss.value) viewer.value?.container.parentElement.style.setProperty("cursor", definingCursorCss.value);
+		}
+	};
+	useCesiumEventListener(() => current.value?.definitionChanged, (plot, key) => {
+		if (key === "defining" || key === "sampled") setDefiningCursorCss();
+	});
+	watch(current, () => setDefiningCursorCss());
 }
+
+//#endregion
+//#region usePlot/useSkeleton.ts
 function useSkeleton(plots, current, getCurrentTime) {
-  const viewer = useViewer();
-  const dataSource = useDataSource(new CustomDataSource());
-  const entityScope = useEntityScope({ collection: () => dataSource.value.entities });
-  const hoverEntity = shallowRef();
-  const activeEntity = shallowRef();
-  const getPointAction = (entity) => {
-    var _a, _b;
-    if (!entity) {
-      return PlotAction.IDLE;
-    }
-    return ((_a = activeEntity.value) == null ? void 0 : _a.id) === entity.id ? PlotAction.ACTIVE : ((_b = hoverEntity.value) == null ? void 0 : _b.id) === entity.id ? PlotAction.HOVER : PlotAction.IDLE;
-  };
-  const update = (plot, destroyed) => {
-    const oldEntities = plot.skeletons;
-    const entities = [];
-    if (destroyed || plot.disabled) {
-      plot.skeletons = [];
-    } else {
-      const packable = plot.sampled.getValue(getCurrentTime());
-      const defining = plot.defining;
-      const active = current.value === plot;
-      const skeletons = plot.scheme.skeletons;
-      skeletons.forEach((skeleton) => {
-        var _a;
-        const disabled = isFunction(skeleton.disabled) ? skeleton.disabled({ active, defining }) : skeleton.disabled;
-        if (disabled) {
-          return;
-        }
-        const positions = ((_a = skeleton.format) == null ? void 0 : _a.call(skeleton, packable)) ?? (packable == null ? void 0 : packable.positions) ?? [];
-        positions.forEach((position, index) => {
-          var _a2;
-          let entity = oldEntities.find((item) => item.index === index && item.skeleton === skeleton);
-          const options = (_a2 = skeleton.render) == null ? void 0 : _a2.call(skeleton, {
-            defining,
-            active,
-            index,
-            packable,
-            positions,
-            position,
-            action: getPointAction(entity)
-          });
-          const merge = new PlotSkeletonEntity(options ?? {});
-          if (entity) {
-            merge.propertyNames.forEach((key) => {
-              if (key !== "id") {
-                entity[key] = merge[key];
-              }
-            });
-          } else {
-            entity = merge;
-          }
-          entity.plot = plot;
-          entity.skeleton = skeleton;
-          entity.index = index;
-          entities.push(entity);
-        });
-      });
-    }
-    plot.skeletons = entities;
-  };
-  const { addGraphicEvent } = useGraphicEvent();
-  watchEffect((onCleanup) => {
-    const remove = addGraphicEvent("global", "DRAG", ({ event, pick, dragging, lockCamera }) => {
-      var _a;
-      if (pick.id instanceof PlotSkeletonEntity && entityScope.scope.has(pick.id)) {
-        const entity = pick.id;
-        const plot = entity.plot;
-        if (plot.defining) {
-          return;
-        }
-        activeEntity.value = entity;
-        const skeleton = entity.skeleton;
-        const index = entity.index;
-        const packable = plot.sampled.getValue(getCurrentTime());
-        (_a = skeleton.onDrag) == null ? void 0 : _a.call(skeleton, {
-          viewer: viewer.value,
-          sampled: plot.sampled,
-          packable,
-          active: current.value === plot,
-          index,
-          event,
-          dragging,
-          lockCamera
-        });
-      } else {
-        activeEntity.value = void 0;
-      }
-    }, {
-      cursor: ({ pick }) => {
-        var _a;
-        if (!((_a = current.value) == null ? void 0 : _a.defining) && entityScope.scope.has(pick.id)) {
-          const skeleton = pick.id.skeleton;
-          return isFunction(skeleton == null ? void 0 : skeleton.cursor) ? skeleton.cursor(pick) : toValue(skeleton == null ? void 0 : skeleton.cursor);
-        }
-      },
-      dragCursor: ({ pick }) => {
-        var _a;
-        if (!((_a = current.value) == null ? void 0 : _a.defining) && entityScope.scope.has(pick.id)) {
-          const skeleton = pick.id.skeleton;
-          return isFunction(skeleton == null ? void 0 : skeleton.dragCursor) ? skeleton.dragCursor(pick) : toValue(skeleton == null ? void 0 : skeleton.dragCursor);
-        }
-      }
-    });
-    onCleanup(remove);
-  });
-  onKeyStroke((keyEvent) => {
-    var _a;
-    if (activeEntity.value) {
-      const entity = activeEntity.value;
-      const plot = entity.plot;
-      const skeleton = entity.skeleton;
-      const index = entity.index;
-      const packable = plot.sampled.getValue(getCurrentTime());
-      (_a = skeleton.onKeyPressed) == null ? void 0 : _a.call(skeleton, {
-        viewer: viewer.value,
-        sampled: plot.sampled,
-        packable,
-        index,
-        keyEvent
-      });
-    }
-  });
-  watchEffect((onCleanup) => {
-    const remove = addGraphicEvent("global", "HOVER", ({ hovering, pick }) => {
-      if (hovering && pick.id instanceof PlotSkeletonEntity && entityScope.scope.has(pick.id)) {
-        const entity = pick.id;
-        hoverEntity.value = entity;
-      } else {
-        hoverEntity.value = void 0;
-      }
-    });
-    onCleanup(remove);
-  });
-  watchEffect((onCleanup) => {
-    const remove = addGraphicEvent("global", "LEFT_CLICK", ({ event, pick }) => {
-      var _a;
-      if (pick.id instanceof PlotSkeletonEntity && entityScope.scope.has(pick.id)) {
-        const entity = pick.id;
-        activeEntity.value = entity;
-        const plot = entity.plot;
-        const skeleton = entity.skeleton;
-        const index = entity.index;
-        const packable = plot.sampled.getValue(getCurrentTime());
-        (_a = skeleton.onLeftClick) == null ? void 0 : _a.call(skeleton, {
-          viewer: viewer.value,
-          sampled: plot.sampled,
-          packable,
-          active: current.value === plot,
-          defining: plot.defining,
-          index,
-          event
-        });
-      } else {
-        activeEntity.value = void 0;
-      }
-    });
-    onCleanup(remove);
-  });
-  watchArray(plots, (value, oldValue, added, removed = []) => {
-    added.forEach((plot) => update(plot));
-    removed.forEach((plot) => update(plot, true));
-  });
-  useCesiumEventListener(
-    () => plots.value.map((plot) => plot.definitionChanged),
-    (plot, key, newValue, oldValue) => {
-      if (["disabled", "defining", "scheme", "sampled", "time"].includes(key)) {
-        nextTick(() => update(plot));
-      } else if (key === "skeletons") {
-        const { added, removed } = arrayDiff(newValue, oldValue);
-        added.forEach((item) => entityScope.add(item));
-        removed.forEach((item) => entityScope.remove(item));
-      }
-    }
-  );
-  watch(current, (plot, previous) => {
-    plot && update(plot);
-    previous && update(previous);
-  });
-  return {
-    dataSource
-  };
+	const viewer = useViewer();
+	const dataSource = useDataSource(new CustomDataSource());
+	const entityScope = useEntityScope({ collection: () => dataSource.value.entities });
+	const hoverEntity = shallowRef();
+	const activeEntity = shallowRef();
+	const getPointAction = (entity) => {
+		if (!entity) return PlotAction.IDLE;
+		return activeEntity.value?.id === entity.id ? PlotAction.ACTIVE : hoverEntity.value?.id === entity.id ? PlotAction.HOVER : PlotAction.IDLE;
+	};
+	const update = (plot, destroyed) => {
+		const oldEntities = plot.skeletons;
+		const entities = [];
+		if (destroyed || plot.disabled) plot.skeletons = [];
+		else {
+			const packable = plot.sampled.getValue(getCurrentTime());
+			const defining = plot.defining;
+			const active = current.value === plot;
+			const skeletons = plot.scheme.skeletons;
+			skeletons.forEach((skeleton) => {
+				const disabled = isFunction(skeleton.disabled) ? skeleton.disabled({
+					active,
+					defining
+				}) : skeleton.disabled;
+				if (disabled) return;
+				const positions = skeleton.format?.(packable) ?? packable?.positions ?? [];
+				positions.forEach((position, index) => {
+					let entity = oldEntities.find((item) => item.index === index && item.skeleton === skeleton);
+					const options = skeleton.render?.({
+						defining,
+						active,
+						index,
+						packable,
+						positions,
+						position,
+						action: getPointAction(entity)
+					});
+					const merge = new PlotSkeletonEntity(options ?? {});
+					if (entity) merge.propertyNames.forEach((key) => {
+						if (key !== "id") entity[key] = merge[key];
+					});
+					else entity = merge;
+					entity.plot = plot;
+					entity.skeleton = skeleton;
+					entity.index = index;
+					entities.push(entity);
+				});
+			});
+		}
+		plot.skeletons = entities;
+	};
+	const { addGraphicEvent } = useGraphicEvent();
+	watchEffect((onCleanup) => {
+		const remove = addGraphicEvent("global", "DRAG", ({ event, pick, dragging, lockCamera }) => {
+			if (pick.id instanceof PlotSkeletonEntity && entityScope.scope.has(pick.id)) {
+				const entity = pick.id;
+				const plot = entity.plot;
+				if (plot.defining) return;
+				activeEntity.value = entity;
+				const skeleton = entity.skeleton;
+				const index = entity.index;
+				const packable = plot.sampled.getValue(getCurrentTime());
+				skeleton.onDrag?.({
+					viewer: viewer.value,
+					sampled: plot.sampled,
+					packable,
+					active: current.value === plot,
+					index,
+					event,
+					dragging,
+					lockCamera
+				});
+			} else activeEntity.value = void 0;
+		}, {
+			cursor: ({ pick }) => {
+				if (!current.value?.defining && entityScope.scope.has(pick.id)) {
+					const skeleton = pick.id.skeleton;
+					return isFunction(skeleton?.cursor) ? skeleton.cursor(pick) : toValue(skeleton?.cursor);
+				}
+			},
+			dragCursor: ({ pick }) => {
+				if (!current.value?.defining && entityScope.scope.has(pick.id)) {
+					const skeleton = pick.id.skeleton;
+					return isFunction(skeleton?.dragCursor) ? skeleton.dragCursor(pick) : toValue(skeleton?.dragCursor);
+				}
+			}
+		});
+		onCleanup(remove);
+	});
+	onKeyStroke((keyEvent) => {
+		if (activeEntity.value) {
+			const entity = activeEntity.value;
+			const plot = entity.plot;
+			const skeleton = entity.skeleton;
+			const index = entity.index;
+			const packable = plot.sampled.getValue(getCurrentTime());
+			skeleton.onKeyPressed?.({
+				viewer: viewer.value,
+				sampled: plot.sampled,
+				packable,
+				index,
+				keyEvent
+			});
+		}
+	});
+	watchEffect((onCleanup) => {
+		const remove = addGraphicEvent("global", "HOVER", ({ hovering, pick }) => {
+			if (hovering && pick.id instanceof PlotSkeletonEntity && entityScope.scope.has(pick.id)) {
+				const entity = pick.id;
+				hoverEntity.value = entity;
+			} else hoverEntity.value = void 0;
+		});
+		onCleanup(remove);
+	});
+	watchEffect((onCleanup) => {
+		const remove = addGraphicEvent("global", "LEFT_CLICK", ({ event, pick }) => {
+			if (pick.id instanceof PlotSkeletonEntity && entityScope.scope.has(pick.id)) {
+				const entity = pick.id;
+				activeEntity.value = entity;
+				const plot = entity.plot;
+				const skeleton = entity.skeleton;
+				const index = entity.index;
+				const packable = plot.sampled.getValue(getCurrentTime());
+				skeleton.onLeftClick?.({
+					viewer: viewer.value,
+					sampled: plot.sampled,
+					packable,
+					active: current.value === plot,
+					defining: plot.defining,
+					index,
+					event
+				});
+			} else activeEntity.value = void 0;
+		});
+		onCleanup(remove);
+	});
+	watchArray(plots, (value, oldValue, added, removed = []) => {
+		added.forEach((plot) => update(plot));
+		removed.forEach((plot) => update(plot, true));
+	});
+	useCesiumEventListener(() => plots.value.map((plot) => plot.definitionChanged), (plot, key, newValue, oldValue) => {
+		if ([
+			"disabled",
+			"defining",
+			"scheme",
+			"sampled",
+			"time"
+		].includes(key)) nextTick(() => update(plot));
+		else if (key === "skeletons") {
+			const { added, removed } = arrayDiff(newValue, oldValue);
+			added.forEach((item) => entityScope.add(item));
+			removed.forEach((item) => entityScope.remove(item));
+		}
+	});
+	watch(current, (plot, previous) => {
+		plot && update(plot);
+		previous && update(previous);
+	});
+	return { dataSource };
 }
+
+//#endregion
+//#region usePlot/usePlot.ts
 function usePlot(options) {
-  const time = (options == null ? void 0 : options.time) || shallowRef();
-  const viewer = useViewer();
-  const getCurrentTime = () => {
-    var _a;
-    return ((_a = time.value) == null ? void 0 : _a.clone()) || new JulianDate(0, 0);
-  };
-  const collection = shallowReactive(/* @__PURE__ */ new Set());
-  const plots = computed(() => Array.from(collection));
-  const current = shallowRef();
-  const packable = shallowRef();
-  useCesiumEventListener([
-    () => {
-      var _a;
-      return (_a = current.value) == null ? void 0 : _a.sampled.definitionChanged;
-    }
-  ], () => {
-    var _a;
-    packable.value = (_a = current.value) == null ? void 0 : _a.sampled.getValue(getCurrentTime());
-  });
-  useSampled(current, getCurrentTime);
-  useRender(plots, current, getCurrentTime);
-  useSkeleton(plots, current, getCurrentTime);
-  useScreenSpaceEventHandler(ScreenSpaceEventType.LEFT_CLICK, (data) => {
-    var _a, _b, _c;
-    if ((_a = current.value) == null ? void 0 : _a.defining) {
-      return;
-    }
-    const pick = (_b = viewer.value) == null ? void 0 : _b.scene.pick(data.position.clone());
-    if (((_c = pick == null ? void 0 : pick.id) == null ? void 0 : _c.plot) instanceof PlotFeature) {
-      return;
-    }
-    if (!pick) {
-      current.value = void 0;
-      return;
-    }
-    current.value = plots.value.find((plot) => pickHitGraphic(pick, [...plot.entities, ...plot.primitives, ...plot.groundPrimitives]));
-  });
-  let operateResolve;
-  let operateReject;
-  watch(current, (plot, previous) => {
-    var _a, _b;
-    if (previous) {
-      if (previous.defining) {
-        const packable2 = previous.sampled.getValue(getCurrentTime());
-        const completed = (_b = (_a = previous.scheme).allowManualComplete) == null ? void 0 : _b.call(_a, packable2);
-        if (completed) {
-          PlotFeature.setDefining(previous, false);
-          operateResolve == null ? void 0 : operateResolve(previous);
-        } else {
-          collection.delete(previous);
-        }
-      }
-    }
-  });
-  const operate = async (plot) => {
-    return new Promise((resolve, reject) => {
-      operateResolve = resolve;
-      operateReject = reject;
-      const _plot = plot instanceof PlotFeature ? plot : new PlotFeature(plot);
-      if (!collection.has(_plot)) {
-        collection.add(_plot);
-      }
-      current.value = _plot;
-      return resolve(_plot);
-    });
-  };
-  const remove = (plot) => {
-    if (plot === current.value) {
-      current.value = void 0;
-    }
-    if (collection.has(plot)) {
-      collection.delete(plot);
-      return true;
-    }
-    return false;
-  };
-  return {
-    plots,
-    time,
-    operate,
-    remove,
-    cancel: operateReject
-  };
+	const time = options?.time || shallowRef();
+	const viewer = useViewer();
+	const getCurrentTime = () => {
+		return time.value?.clone() || new JulianDate(0, 0);
+	};
+	const collection = shallowReactive(/* @__PURE__ */ new Set());
+	const plots = computed(() => Array.from(collection));
+	const current = shallowRef();
+	const packable = shallowRef();
+	useCesiumEventListener([() => current.value?.sampled.definitionChanged], () => {
+		packable.value = current.value?.sampled.getValue(getCurrentTime());
+	});
+	useSampled(current, getCurrentTime);
+	useRender(plots, current, getCurrentTime);
+	useSkeleton(plots, current, getCurrentTime);
+	useScreenSpaceEventHandler(ScreenSpaceEventType.LEFT_CLICK, (data) => {
+		if (current.value?.defining) return;
+		const pick = viewer.value?.scene.pick(data.position.clone());
+		if (pick?.id?.plot instanceof PlotFeature) return;
+		if (!pick) {
+			current.value = void 0;
+			return;
+		}
+		current.value = plots.value.find((plot) => pickHitGraphic(pick, [
+			...plot.entities,
+			...plot.primitives,
+			...plot.groundPrimitives
+		]));
+	});
+	let operateResolve;
+	let operateReject;
+	watch(current, (plot, previous) => {
+		if (previous) {
+			if (previous.defining) {
+				const packable$1 = previous.sampled.getValue(getCurrentTime());
+				const completed = previous.scheme.allowManualComplete?.(packable$1);
+				if (completed) {
+					PlotFeature.setDefining(previous, false);
+					operateResolve?.(previous);
+				} else collection.delete(previous);
+			}
+		}
+	});
+	const operate = async (plot) => {
+		return new Promise((resolve, reject) => {
+			operateResolve = resolve;
+			operateReject = reject;
+			const _plot = plot instanceof PlotFeature ? plot : new PlotFeature(plot);
+			if (!collection.has(_plot)) collection.add(_plot);
+			current.value = _plot;
+			return resolve(_plot);
+		});
+	};
+	const remove = (plot) => {
+		if (plot === current.value) current.value = void 0;
+		if (collection.has(plot)) {
+			collection.delete(plot);
+			return true;
+		}
+		return false;
+	};
+	return {
+		plots,
+		time,
+		operate,
+		remove,
+		cancel: operateReject
+	};
 }
+
+//#endregion
+//#region skeleton/control.ts
+/**
+* 绘制控制的框架点，拖拽时，将更新该控制点的实时位置
+*/
 function control() {
-  return {
-    disabled: ({ active }) => !active,
-    cursor: "pointer",
-    dragCursor: "crosshair",
-    onDrag({ viewer, sampled, packable, event, index, lockCamera }) {
-      lockCamera();
-      const position = canvasCoordToCartesian(event.endPosition, viewer.scene);
-      if (position) {
-        const positions = [...packable.positions ?? []];
-        positions[index] = position;
-        sampled.setSample({
-          time: packable.time,
-          derivative: packable.derivative,
-          positions
-        });
-      }
-    },
-    onKeyPressed({ viewer, keyEvent, sampled, packable, index }) {
-      var _a;
-      const height = (_a = toCartographic(viewer.camera.position)) == null ? void 0 : _a.height;
-      if (!height || !["ArrowUp", "ArrowRight", "ArrowDown", "ArrowLeft"].includes(keyEvent.key))
-        return;
-      keyEvent.preventDefault();
-      let headingAdjust = 0;
-      switch (keyEvent.key) {
-        case "ArrowRight":
-          headingAdjust = Math.PI / 2;
-          break;
-        case "ArrowDown":
-          headingAdjust = Math.PI;
-          break;
-        case "ArrowLeft":
-          headingAdjust = -Math.PI / 2;
-          break;
-        case "ArrowUp":
-          headingAdjust = 0;
-          break;
-      }
-      const newHeading = (viewer.camera.heading + headingAdjust) % (2 * Math.PI);
-      const positions = [...packable.positions ?? []];
-      const cartographic = toCartographic(positions[index]);
-      const r = height / 1e5;
-      const distance = r * Math.PI / 180 / 1e3;
-      cartographic.latitude += distance * Math.cos(newHeading);
-      cartographic.longitude += distance * Math.sin(newHeading);
-      positions[index] = toCartesian3(cartographic);
-      sampled.setSample({
-        time: packable.time,
-        derivative: packable.derivative,
-        positions
-      });
-    },
-    render: ({ position, action }) => {
-      const colors = {
-        [PlotAction.IDLE]: Color.BLUE.withAlpha(0.4),
-        [PlotAction.HOVER]: Color.BLUE.withAlpha(0.6),
-        [PlotAction.ACTIVE]: Color.AQUA.withAlpha(1)
-      };
-      return {
-        position,
-        point: {
-          pixelSize: 8,
-          color: colors[action],
-          disableDepthTestDistance: Number.POSITIVE_INFINITY,
-          outlineWidth: 1,
-          outlineColor: Color.WHITE.withAlpha(0.4)
-        }
-      };
-    }
-  };
+	return {
+		disabled: ({ active }) => !active,
+		cursor: "pointer",
+		dragCursor: "crosshair",
+		onDrag({ viewer, sampled, packable, event, index, lockCamera }) {
+			lockCamera();
+			const position = canvasCoordToCartesian(event.endPosition, viewer.scene);
+			if (position) {
+				const positions = [...packable.positions ?? []];
+				positions[index] = position;
+				sampled.setSample({
+					time: packable.time,
+					derivative: packable.derivative,
+					positions
+				});
+			}
+		},
+		onKeyPressed({ viewer, keyEvent, sampled, packable, index }) {
+			const height = toCartographic(viewer.camera.position)?.height;
+			if (!height || ![
+				"ArrowUp",
+				"ArrowRight",
+				"ArrowDown",
+				"ArrowLeft"
+			].includes(keyEvent.key)) return;
+			keyEvent.preventDefault();
+			let headingAdjust = 0;
+			switch (keyEvent.key) {
+				case "ArrowRight":
+					headingAdjust = Math.PI / 2;
+					break;
+				case "ArrowDown":
+					headingAdjust = Math.PI;
+					break;
+				case "ArrowLeft":
+					headingAdjust = -Math.PI / 2;
+					break;
+				case "ArrowUp":
+					headingAdjust = 0;
+					break;
+			}
+			const newHeading = (viewer.camera.heading + headingAdjust) % (2 * Math.PI);
+			const positions = [...packable.positions ?? []];
+			const cartographic = toCartographic(positions[index]);
+			const r = height / 1e5;
+			const distance$1 = r * Math.PI / 180 / 1e3;
+			cartographic.latitude += distance$1 * Math.cos(newHeading);
+			cartographic.longitude += distance$1 * Math.sin(newHeading);
+			positions[index] = toCartesian3(cartographic);
+			sampled.setSample({
+				time: packable.time,
+				derivative: packable.derivative,
+				positions
+			});
+		},
+		render: ({ position, action }) => {
+			const colors = {
+				[PlotAction.IDLE]: Color.BLUE.withAlpha(.4),
+				[PlotAction.HOVER]: Color.BLUE.withAlpha(.6),
+				[PlotAction.ACTIVE]: Color.AQUA.withAlpha(1)
+			};
+			return {
+				position,
+				point: {
+					pixelSize: 8,
+					color: colors[action],
+					disableDepthTestDistance: Number.POSITIVE_INFINITY,
+					outlineWidth: 1,
+					outlineColor: Color.WHITE.withAlpha(.4)
+				}
+			};
+		}
+	};
 }
+
+//#endregion
+//#region skeleton/interval.ts
+/**
+* 绘制封闭的间隔框架点，如多边形。拖拽时，会在两点之间插入一个控制点，并持续拖拽该点。
+*/
 function interval() {
-  let dragIndex = -1;
-  return {
-    disabled: ({ active, defining }) => !active || defining,
-    cursor: "pointer",
-    dragCursor: "crosshair",
-    format(packable) {
-      const _positions = packable.positions ?? [];
-      if (_positions.length < 2) {
-        return [];
-      }
-      return _positions.map((position, i) => {
-        const next = i === _positions.length - 1 ? _positions[0] : _positions[i + 1];
-        return Cartesian3.midpoint(position, next, new Cartesian3());
-      });
-    },
-    onDrag({ viewer, sampled, packable, event, index, lockCamera, dragging }) {
-      lockCamera();
-      const position = canvasCoordToCartesian(event.endPosition, viewer.scene);
-      if (!position) {
-        return;
-      }
-      const positions = [...packable.positions ?? []];
-      if (dragIndex === -1) {
-        dragIndex = index;
-        positions.splice(index + 1, 0, position);
-      } else {
-        positions[dragIndex + 1] = position;
-      }
-      if (!dragging) {
-        dragIndex = -1;
-      }
-      sampled.setSample({
-        time: packable.time,
-        derivative: packable.derivative,
-        positions
-      });
-    },
-    render: ({ position, action, active }) => {
-      if (!active) {
-        return;
-      }
-      const colors = {
-        [PlotAction.IDLE]: Color.GREEN.withAlpha(0.4),
-        [PlotAction.HOVER]: Color.GREEN.withAlpha(0.6),
-        [PlotAction.ACTIVE]: Color.GREEN.withAlpha(1)
-      };
-      return {
-        position,
-        point: {
-          pixelSize: 6,
-          color: colors[action],
-          disableDepthTestDistance: Number.POSITIVE_INFINITY,
-          outlineWidth: 1,
-          outlineColor: Color.WHITE.withAlpha(0.4)
-        }
-      };
-    }
-  };
+	let dragIndex = -1;
+	return {
+		disabled: ({ active, defining }) => !active || defining,
+		cursor: "pointer",
+		dragCursor: "crosshair",
+		format(packable) {
+			const _positions = packable.positions ?? [];
+			if (_positions.length < 2) return [];
+			return _positions.map((position, i) => {
+				const next = i === _positions.length - 1 ? _positions[0] : _positions[i + 1];
+				return Cartesian3.midpoint(position, next, new Cartesian3());
+			});
+		},
+		onDrag({ viewer, sampled, packable, event, index, lockCamera, dragging }) {
+			lockCamera();
+			const position = canvasCoordToCartesian(event.endPosition, viewer.scene);
+			if (!position) return;
+			const positions = [...packable.positions ?? []];
+			if (dragIndex === -1) {
+				dragIndex = index;
+				positions.splice(index + 1, 0, position);
+			} else positions[dragIndex + 1] = position;
+			if (!dragging) dragIndex = -1;
+			sampled.setSample({
+				time: packable.time,
+				derivative: packable.derivative,
+				positions
+			});
+		},
+		render: ({ position, action, active }) => {
+			if (!active) return;
+			const colors = {
+				[PlotAction.IDLE]: Color.GREEN.withAlpha(.4),
+				[PlotAction.HOVER]: Color.GREEN.withAlpha(.6),
+				[PlotAction.ACTIVE]: Color.GREEN.withAlpha(1)
+			};
+			return {
+				position,
+				point: {
+					pixelSize: 6,
+					color: colors[action],
+					disableDepthTestDistance: Number.POSITIVE_INFINITY,
+					outlineWidth: 1,
+					outlineColor: Color.WHITE.withAlpha(.4)
+				}
+			};
+		}
+	};
 }
+
+//#endregion
+//#region skeleton/intervalNonclosed.ts
+/**
+* 绘制非封闭的间隔框架点，如线段。拖拽时，会在两点之间插入一个控制点，并持续拖拽该点。
+*/
 function intervalNonclosed() {
-  let dragIndex = -1;
-  return {
-    disabled: ({ active, defining }) => !active || defining,
-    cursor: "pointer",
-    dragCursor: "crosshair",
-    format(packable) {
-      const _positions = packable.positions ?? [];
-      if (_positions.length < 2) {
-        return [];
-      }
-      const midpoints = [];
-      for (let i = 0; i < _positions.length - 1; i++) {
-        midpoints.push(Cartesian3.midpoint(_positions[i], _positions[i + 1], new Cartesian3()));
-      }
-      return midpoints;
-    },
-    onDrag({ viewer, sampled, packable, event, index, lockCamera, dragging }) {
-      lockCamera();
-      const position = canvasCoordToCartesian(event.endPosition, viewer.scene);
-      if (!position) {
-        return;
-      }
-      const positions = [...packable.positions ?? []];
-      if (dragIndex === -1) {
-        dragIndex = index;
-        positions.splice(index + 1, 0, position);
-      } else {
-        positions[dragIndex + 1] = position;
-      }
-      if (!dragging) {
-        dragIndex = -1;
-      }
-      sampled.setSample({
-        time: packable.time,
-        derivative: packable.derivative,
-        positions
-      });
-    },
-    render: ({ position, action }) => {
-      const colors = {
-        [PlotAction.IDLE]: Color.GREEN.withAlpha(0.4),
-        [PlotAction.HOVER]: Color.GREEN.withAlpha(0.6),
-        [PlotAction.ACTIVE]: Color.GREEN.withAlpha(1)
-      };
-      return {
-        position,
-        point: {
-          pixelSize: 6,
-          color: colors[action],
-          disableDepthTestDistance: Number.POSITIVE_INFINITY,
-          outlineWidth: 1,
-          outlineColor: Color.WHITE.withAlpha(0.4)
-        }
-      };
-    }
-  };
+	let dragIndex = -1;
+	return {
+		disabled: ({ active, defining }) => !active || defining,
+		cursor: "pointer",
+		dragCursor: "crosshair",
+		format(packable) {
+			const _positions = packable.positions ?? [];
+			if (_positions.length < 2) return [];
+			const midpoints = [];
+			for (let i = 0; i < _positions.length - 1; i++) midpoints.push(Cartesian3.midpoint(_positions[i], _positions[i + 1], new Cartesian3()));
+			return midpoints;
+		},
+		onDrag({ viewer, sampled, packable, event, index, lockCamera, dragging }) {
+			lockCamera();
+			const position = canvasCoordToCartesian(event.endPosition, viewer.scene);
+			if (!position) return;
+			const positions = [...packable.positions ?? []];
+			if (dragIndex === -1) {
+				dragIndex = index;
+				positions.splice(index + 1, 0, position);
+			} else positions[dragIndex + 1] = position;
+			if (!dragging) dragIndex = -1;
+			sampled.setSample({
+				time: packable.time,
+				derivative: packable.derivative,
+				positions
+			});
+		},
+		render: ({ position, action }) => {
+			const colors = {
+				[PlotAction.IDLE]: Color.GREEN.withAlpha(.4),
+				[PlotAction.HOVER]: Color.GREEN.withAlpha(.6),
+				[PlotAction.ACTIVE]: Color.GREEN.withAlpha(1)
+			};
+			return {
+				position,
+				point: {
+					pixelSize: 6,
+					color: colors[action],
+					disableDepthTestDistance: Number.POSITIVE_INFINITY,
+					outlineWidth: 1,
+					outlineColor: Color.WHITE.withAlpha(.4)
+				}
+			};
+		}
+	};
 }
-const svg = `data:image/svg+xml;utf8,${encodeURIComponent(
-  '<svg xmlns="http://www.w3.org/2000/svg" width="32" height="32" viewBox="0 0 24 24"><path  stroke="#ffffff" stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="m18 9l3 3l-3 3m-3-3h6M6 9l-3 3l3 3m-3-3h6m0 6l3 3l3-3m-3-3v6m3-15l-3-3l-3 3m3-3v6"/></svg>'
-)}`;
+
+//#endregion
+//#region skeleton/moved.ts
+const svg = `data:image/svg+xml;utf8,${encodeURIComponent("<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"32\" height=\"32\" viewBox=\"0 0 24 24\"><path  stroke=\"#ffffff\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"m18 9l3 3l-3 3m-3-3h6M6 9l-3 3l3 3m-3-3h6m0 6l3 3l3-3m-3-3v6m3-15l-3-3l-3 3m3-3v6\"/></svg>")}`;
+/**
+* 绘制非封闭的间隔框架点，如线段。拖拽时，会在两点之间插入一个控制点，并持续拖拽该点。
+*/
 function moved() {
-  return {
-    disabled: ({ active, defining }) => !active || defining,
-    cursor: "pointer",
-    dragCursor: "crosshair",
-    format(packable) {
-      const positions = packable.positions ?? [];
-      if (positions.length === 0) {
-        return [];
-      } else if (positions.length === 1) {
-        return [positions[0]];
-      } else {
-        const center = Rectangle.center(Rectangle.fromCartesianArray(positions));
-        return [toCartesian3(center)];
-      }
-    },
-    onDrag({ viewer, sampled, packable, event, lockCamera, dragging }) {
-      dragging && lockCamera();
-      const startPosition = canvasCoordToCartesian(event.startPosition, viewer.scene);
-      const endPosition = canvasCoordToCartesian(event.endPosition, viewer.scene);
-      if (!startPosition || !endPosition) {
-        return;
-      }
-      const offset = Cartesian3.subtract(endPosition, startPosition, new Cartesian3());
-      const positions = [...packable.positions ?? []];
-      sampled.setSample({
-        time: packable.time,
-        derivative: packable.derivative,
-        positions: positions.map((position) => Cartesian3.add(position, offset, new Cartesian3()))
-      });
-    },
-    render: ({ position, action }) => {
-      const colors = {
-        [PlotAction.IDLE]: Color.WHITE,
-        [PlotAction.HOVER]: Color.WHITE,
-        [PlotAction.ACTIVE]: Color.AQUA.withAlpha(1)
-      };
-      return {
-        position,
-        billboard: {
-          image: svg,
-          width: 20,
-          height: 20,
-          color: colors[action],
-          pixelOffset: new Cartesian3(0, -20),
-          horizontalOrigin: HorizontalOrigin.CENTER,
-          verticalOrigin: VerticalOrigin.BOTTOM,
-          disableDepthTestDistance: Number.POSITIVE_INFINITY
-        }
-      };
-    }
-  };
+	return {
+		disabled: ({ active, defining }) => !active || defining,
+		cursor: "pointer",
+		dragCursor: "crosshair",
+		format(packable) {
+			const positions = packable.positions ?? [];
+			if (positions.length === 0) return [];
+			else if (positions.length === 1) return [positions[0]];
+			else {
+				const center = Rectangle.center(Rectangle.fromCartesianArray(positions));
+				return [toCartesian3(center)];
+			}
+		},
+		onDrag({ viewer, sampled, packable, event, lockCamera, dragging }) {
+			dragging && lockCamera();
+			const startPosition = canvasCoordToCartesian(event.startPosition, viewer.scene);
+			const endPosition = canvasCoordToCartesian(event.endPosition, viewer.scene);
+			if (!startPosition || !endPosition) return;
+			const offset = Cartesian3.subtract(endPosition, startPosition, new Cartesian3());
+			const positions = [...packable.positions ?? []];
+			sampled.setSample({
+				time: packable.time,
+				derivative: packable.derivative,
+				positions: positions.map((position) => Cartesian3.add(position, offset, new Cartesian3()))
+			});
+		},
+		render: ({ position, action }) => {
+			const colors = {
+				[PlotAction.IDLE]: Color.WHITE,
+				[PlotAction.HOVER]: Color.WHITE,
+				[PlotAction.ACTIVE]: Color.AQUA.withAlpha(1)
+			};
+			return {
+				position,
+				billboard: {
+					image: svg,
+					width: 20,
+					height: 20,
+					color: colors[action],
+					pixelOffset: new Cartesian3(0, -20),
+					horizontalOrigin: HorizontalOrigin.CENTER,
+					verticalOrigin: VerticalOrigin.BOTTOM,
+					disableDepthTestDistance: Number.POSITIVE_INFINITY
+				}
+			};
+		}
+	};
 }
+
+//#endregion
+//#region measure/utils/tesselate.ts
+/**
+* 将多个边界点组成的面切割成多个三角形
+* @param positions
+*/
 function tesselate(positions) {
-  if (positions.length < 3) {
-    throw new Error("positions must >= 3");
-  }
-  if (positions.length === 3) {
-    return [[positions[0].clone(), positions[1].clone(), positions[2].clone()]];
-  }
-  const geometry = CoplanarPolygonGeometry.createGeometry(
-    CoplanarPolygonGeometry.fromPositions({
-      positions,
-      vertexFormat: VertexFormat.POSITION_ONLY
-    })
-  );
-  if (!geometry) {
-    throw new Error("positions无法组成有效的geometry,检查点位是否错误");
-  }
-  const values = geometry.attributes.position.values;
-  const indices = geometry.indices;
-  const result = [];
-  for (let i = 0; i < indices.length; i += 3) {
-    const a = Cartesian3.unpack(values, indices[i] * 3, new Cartesian3());
-    const b = Cartesian3.unpack(values, indices[i + 1] * 3, new Cartesian3());
-    const c = Cartesian3.unpack(values, indices[i + 2] * 3, new Cartesian3());
-    result.push([a, b, c]);
-  }
-  return result;
+	if (positions.length < 3) throw new Error("positions must >= 3");
+	if (positions.length === 3) return [[
+		positions[0].clone(),
+		positions[1].clone(),
+		positions[2].clone()
+	]];
+	const geometry = CoplanarPolygonGeometry.createGeometry(CoplanarPolygonGeometry.fromPositions({
+		positions,
+		vertexFormat: VertexFormat.POSITION_ONLY
+	}));
+	if (!geometry) throw new Error("positions无法组成有效的geometry,检查点位是否错误");
+	const values = geometry.attributes.position.values;
+	const indices = geometry.indices;
+	const result = [];
+	for (let i = 0; i < indices.length; i += 3) {
+		const a = Cartesian3.unpack(values, indices[i] * 3, new Cartesian3());
+		const b = Cartesian3.unpack(values, indices[i + 1] * 3, new Cartesian3());
+		const c = Cartesian3.unpack(values, indices[i + 2] * 3, new Cartesian3());
+		result.push([
+			a,
+			b,
+			c
+		]);
+	}
+	return result;
+}
+
+//#endregion
+//#region measure/utils/clampToGround.ts
+/**
+* 将传入的点位列表进行贴地处理,若某个点位获取高程失败则将此进行克隆返回
+* @param options - 配置项
+*/
+async function clampToHeightMostDetailedByTilesetOrTerrain(options) {
+	const { positions, scene, classificationType = ClassificationType.BOTH, terrainProvider = scene.terrainProvider } = options;
+	const tileset = [ClassificationType.BOTH, ClassificationType.CESIUM_3D_TILE].includes(classificationType);
+	const terrain = [ClassificationType.BOTH, ClassificationType.TERRAIN].includes(classificationType);
+	const tilesetPromise = new Promise((resolve) => {
+		if (tileset) scene.clampToHeightMostDetailed(positions.map((e) => e.clone())).then(resolve).catch((error) => {
+			console.warn(error);
+			resolve([]);
+		});
+		else resolve([]);
+	});
+	const terrainPromise = new Promise((resolve) => {
+		if (terrain && terrainProvider) sampleTerrainMostDetailed(terrainProvider, positions.map((e) => Cartographic.fromCartesian(e))).then((e) => resolve(e)).catch((error) => {
+			console.warn(error);
+			resolve([]);
+		});
+		else resolve([]);
+	});
+	const [tilesetPositions, terrainPositions] = await Promise.all([tilesetPromise, terrainPromise]);
+	const resluts = [];
+	positions.forEach((item, index) => {
+		const position = tilesetPositions[index] || terrainPositions[index] ? Ellipsoid.WGS84.cartographicToCartesian(terrainPositions[index]) : item.clone();
+		resluts.push(position);
+	});
+	return resluts;
 }
+
+//#endregion
+//#region measure/utils/triangleGrid.ts
+function defaultOptions$2(original) {
+	const clampToGround = original?.clampToGround ?? false;
+	const classificationType = original?.classificationType ?? ClassificationType.BOTH;
+	const density = Math.floor(original?.density ?? 10);
+	return {
+		scene: original?.scene,
+		clampToGround,
+		classificationType,
+		terrainProvider: original?.terrainProvider,
+		density
+	};
+}
+/**
+* 生成三角网数组
+* @param positions - 边界点数组
+* @param options - 配置项
+*/
+async function triangleGrid(positions, options) {
+	if (positions.length < 3) throw new Error("positions must >= 3");
+	const { density, scene, clampToGround, classificationType, terrainProvider } = defaultOptions$2(options);
+	if (density <= 0) throw new Error("options.density must > 0");
+	const bbox = Rectangle.fromCartesianArray(positions);
+	const vertical = bbox.north - bbox.south;
+	const horizontal = bbox.east - bbox.west;
+	const max = Math.max(horizontal, vertical);
+	const granularity = max / density;
+	const polygonGeometry = PolygonGeometry.fromPositions({
+		positions,
+		vertexFormat: PerInstanceColorAppearance.FLAT_VERTEX_FORMAT,
+		granularity
+	});
+	const geometry = PolygonGeometry.createGeometry(polygonGeometry);
+	const values = geometry.attributes.position.values;
+	if (!geometry || !values) throw new Error("positions无法组成有效的geometry,检查点位是否错误");
+	const indices = geometry.indices;
+	let cartesian3List = [];
+	for (let i = 0; i < indices.length; i += 3) {
+		const a = Cartesian3.unpack(values, indices[i] * 3, new Cartesian3());
+		const b = Cartesian3.unpack(values, indices[i + 1] * 3, new Cartesian3());
+		const c = Cartesian3.unpack(values, indices[i + 2] * 3, new Cartesian3());
+		cartesian3List.push(a, b, c);
+	}
+	if (clampToGround) {
+		if (!scene) throw new Error("scene is required on `clampToGround == true`.");
+		const detaileds = await clampToHeightMostDetailedByTilesetOrTerrain({
+			scene,
+			terrainProvider,
+			positions: cartesian3List,
+			classificationType
+		});
+		cartesian3List = detaileds;
+	}
+	const grid = [];
+	while (cartesian3List?.length) {
+		const [a, b, c] = cartesian3List.splice(0, 3);
+		grid.push([
+			a,
+			b,
+			c
+		]);
+	}
+	return grid;
+}
+
+//#endregion
+//#region measure/utils/area.ts
+/**
+* 计算三维坐标系下三角形面积
+* @param p0 - 三角形第一个点
+* @param p1 - 三角形第二个点
+* @param p2 - 三角形第三个点
+*/
 function triangleArea(p0, p1, p2) {
-  const v0 = Cartesian3.subtract(p0, p1, new Cartesian3());
-  const v1 = Cartesian3.subtract(p2, p1, new Cartesian3());
-  const cross = Cartesian3.cross(v0, v1, v0);
-  return Cartesian3.magnitude(cross) * 0.5;
+	const v0 = Cartesian3.subtract(p0, p1, new Cartesian3());
+	const v1 = Cartesian3.subtract(p2, p1, new Cartesian3());
+	const cross = Cartesian3.cross(v0, v1, v0);
+	return Cartesian3.magnitude(cross) * .5;
 }
-function defaultOptions(original) {
-  const clampToGround = false;
-  const classificationType = ClassificationType.BOTH;
-  const density = Math.floor(10);
-  return {
-    scene: original == null ? void 0 : original.scene,
-    clampToGround,
-    classificationType,
-    terrainProvider: original == null ? void 0 : original.terrainProvider,
-    density
-  };
+function defaultOptions$1(original) {
+	const clampToGround = original?.clampToGround ?? false;
+	const classificationType = original?.classificationType ?? ClassificationType.BOTH;
+	const density = Math.floor(original?.density ?? 10);
+	return {
+		scene: original?.scene,
+		clampToGround,
+		classificationType,
+		terrainProvider: original?.terrainProvider,
+		density
+	};
 }
+/**
+* 计算三维坐标系下图形面积
+* @param positions - 图形各点的笛卡尔数组
+*/
 async function area(positions, options) {
-  if (positions.length < 2) {
-    throw new Error("positions.length must >= 2");
-  }
-  const { density } = defaultOptions(options);
-  if (density <= 0) {
-    throw new Error("options.density must > 0");
-  }
-  {
-    const triangles2 = tesselate(positions);
-    return triangles2.reduce((count, current) => count += triangleArea(...current), 0);
-  }
+	if (positions.length < 2) throw new Error("positions.length must >= 2");
+	const { density, scene, clampToGround, classificationType, terrainProvider } = defaultOptions$1(options);
+	if (density <= 0) throw new Error("options.density must > 0");
+	if (!clampToGround) {
+		const triangles$1 = tesselate(positions);
+		return triangles$1.reduce((count, current) => count += triangleArea(...current), 0);
+	}
+	const triangles = await triangleGrid(positions, {
+		density,
+		scene,
+		clampToGround,
+		classificationType,
+		terrainProvider
+	});
+	return triangles.reduce((count, current) => count += triangleArea(...current), 0);
+}
+
+//#endregion
+//#region measure/utils/lerpArray.ts
+/**
+* 在起点和终点间进行插值, 返回的数组包括起点和终点，数组长度为 count+1
+*/
+async function lerpArray(options) {
+	const { start, end, count, scene, clampToGround, classificationType, terrainProvider } = options;
+	const result = [];
+	for (let i = 0; i < count; i++) {
+		const position = Cartesian3.lerp(start, end, 1 / count, new Cartesian3());
+		result.push(position);
+	}
+	result.push(end.clone());
+	if (!clampToGround) return result;
+	if (!scene) throw new Error("scene is required on `clampToGround == true`.");
+	const detaileds = await clampToHeightMostDetailedByTilesetOrTerrain({
+		scene,
+		terrainProvider,
+		positions: result,
+		classificationType
+	});
+	return detaileds;
 }
+
+//#endregion
+//#region measure/utils/distance.ts
+function defaultOptions(original) {
+	const clampToGround = original?.clampToGround ?? false;
+	const classificationType = original?.classificationType ?? ClassificationType.BOTH;
+	const density = Math.floor(original?.density ?? 50);
+	return {
+		scene: original?.scene,
+		clampToGround,
+		classificationType,
+		terrainProvider: original?.terrainProvider,
+		density
+	};
+}
+/**
+* 计算多点位之间的距离
+* @param positions
+*/
+async function distance(positions, options) {
+	if (positions.length < 2) throw new Error("positions.length must >= 2");
+	const _options = defaultOptions(options);
+	const stages = [];
+	let count = 0;
+	positions.forEach((position, index) => {
+		if (index !== positions.length - 1) {
+			const next = positions[index + 1];
+			const distance$1 = Cartesian3.distance(position, next);
+			stages.push(distance$1);
+			count += distance$1;
+		}
+	});
+	if (!_options.clampToGround) return {
+		stages,
+		count
+	};
+	const density = _options.density;
+	if (density <= 0) throw new Error("options.density must > 0");
+	const densities = stages.map((stage) => {
+		return Math.floor(stage / count * density);
+	});
+	const diff = density - densities.reduce((count$1, current) => count$1 += current, 0);
+	if (diff) densities[densities.length - 1] += diff;
+	const positionListPromises = densities.map((density$1, i) => {
+		return lerpArray({
+			scene: _options.scene,
+			start: positions[i],
+			end: positions[i + 1],
+			count: density$1,
+			clampToGround: true,
+			classificationType: _options.classificationType,
+			terrainProvider: _options.terrainProvider
+		});
+	});
+	const detaileds = await Promise.all(positionListPromises);
+	const stagePromises = detaileds.map(async (positions$1) => {
+		const { count: count$1 } = await distance(positions$1);
+		return count$1;
+	});
+	const groundStages = await Promise.all(stagePromises);
+	return {
+		stages: groundStages,
+		count: groundStages.reduce((count$1, current) => count$1 += current, 0)
+	};
+}
+
+//#endregion
+//#region measure/measureArea.ts
 const schemeMeasureArea = new PlotScheme({
-  type: "measureArea",
-  allowManualComplete: (packable) => packable.positions.length >= 3,
-  skeletons: [
-    control,
-    interval
-  ],
-  initEntites: () => [
-    new Entity({
-      label: {
-        font: "14pt"
-      },
-      polyline: {
-        material: Color.YELLOW.withAlpha(0.5)
-      },
-      polygon: {
-        material: Color.YELLOW.withAlpha(0.5)
-      }
-    })
-  ],
-  render(options) {
-    var _a;
-    const { mouse, packable } = options;
-    const entity = ((_a = options.previous.entities) == null ? void 0 : _a[0]) ?? new Entity({
-      label: {
-        font: "14pt"
-      },
-      polyline: {
-        material: Color.YELLOW.withAlpha(0.5)
-      },
-      polygon: {
-        material: Color.YELLOW.withAlpha(0.5)
-      }
-    });
-    const positions = [...packable.positions ?? []];
-    mouse && positions.push(mouse);
-    if (positions.length === 2) {
-      entity.position = void 0;
-      entity.label.text = void 0;
-      entity.polygon.hierarchy = void 0;
-      entity.polyline.positions = new CallbackProperty(() => positions, false);
-    } else if (positions.length >= 3) {
-      positions.push(positions[0]);
-      entity.position = new ConstantPositionProperty(
-        toCartesian3(
-          Rectangle.center(Rectangle.fromCartesianArray(positions))
-        )
-      );
-      entity.label.text = new ConstantProperty("");
-      area(positions).then((e) => {
-        let text = "";
-        if (e / 1e3 / 1e3 > 10) {
-          text = `${(e / 1e3 / 1e3).toFixed(2)}km²`;
-        } else {
-          text = `${(+e).toFixed(2)}m²`;
-        }
-        entity.label.text = new ConstantProperty(text);
-      });
-      entity.polyline.positions = void 0;
-      entity.polygon.hierarchy = new CallbackProperty(() => {
-        return positions.length >= 3 ? new PolygonHierarchy([...positions]) : void 0;
-      }, false);
-    } else {
-      entity.position = void 0;
-      entity.polygon.hierarchy = void 0;
-      entity.polyline.positions = void 0;
-    }
-    return {
-      entities: [entity]
-    };
-  }
+	type: "MeasureArea",
+	allowManualComplete: (packable) => packable.positions.length >= 3,
+	skeletons: [control, interval],
+	initRender() {
+		return { entities: [new Entity({
+			label: { font: "14pt" },
+			polyline: { material: Color.YELLOW.withAlpha(.5) },
+			polygon: { material: Color.YELLOW.withAlpha(.5) }
+		})] };
+	},
+	render(context) {
+		const entity = context.previous.entities[0];
+		const { mouse, packable } = context;
+		const positions = [...packable.positions ?? []];
+		mouse && positions.push(mouse);
+		if (positions.length === 2) {
+			entity.position = void 0;
+			entity.label.text = void 0;
+			entity.polygon.hierarchy = void 0;
+			entity.polyline.positions = new CallbackProperty(() => positions, false);
+		} else if (positions.length >= 3) {
+			positions.push(positions[0]);
+			entity.position = new ConstantPositionProperty(toCartesian3(Rectangle.center(Rectangle.fromCartesianArray(positions))));
+			entity.label.text = new ConstantProperty("");
+			area(positions).then((e) => {
+				let text = "";
+				if (e / 1e3 / 1e3 > 10) text = `${(e / 1e3 / 1e3).toFixed(2)}km²`;
+				else text = `${(+e).toFixed(2)}m²`;
+				entity.label.text = new ConstantProperty(text);
+			});
+			entity.polyline.positions = void 0;
+			entity.polygon.hierarchy = new CallbackProperty(() => {
+				return positions.length >= 3 ? new PolygonHierarchy([...positions]) : void 0;
+			}, false);
+		} else {
+			entity.position = void 0;
+			entity.polygon.hierarchy = void 0;
+			entity.polyline.positions = void 0;
+		}
+		return { entities: [entity] };
+	}
 });
-const schemeBillboard = new PlotScheme({
-  type: "billboard",
-  complete: (packable) => packable.positions.length >= 1,
-  skeletons: [
-    moved
-  ],
-  initEntites: () => [
-    new Entity({ billboard: { image: "/favicon.svg", width: 32, height: 32 } })
-  ],
-  render(options) {
-    var _a, _b;
-    const { mouse, packable } = options;
-    const entity = ((_a = options.previous.entities) == null ? void 0 : _a[0]) ?? new Entity({ billboard: {} });
-    const position = ((_b = packable.positions) == null ? void 0 : _b[0]) ?? mouse;
-    entity.position = new CallbackPositionProperty(() => position, true);
-    return {
-      entities: [entity]
-    };
-  }
+
+//#endregion
+//#region measure/measureDistance.ts
+const schemeMeasureDistance = new PlotScheme({
+	type: "MeasureDistance",
+	allowManualComplete: (packable) => packable.positions.length >= 2,
+	skeletons: [control],
+	initRender() {
+		return { entities: [new Entity({ polyline: {
+			width: 2,
+			material: Color.YELLOW.withAlpha(.5)
+		} })] };
+	},
+	render(context) {
+		const entity = context.previous.entities[0];
+		const { mouse, packable, previous } = context;
+		const entities = previous.entities;
+		const positions = [...packable.positions ?? []];
+		mouse && positions.push(mouse);
+		if (positions.length < 2) return { entities };
+		const pl = entities[0];
+		pl.polyline ??= new PolylineGraphics();
+		pl.polyline.positions = new CallbackProperty(() => positions, false);
+		positions.forEach((item, index) => {
+			if (!entities[index + 1]) entities[index + 1] = new Entity({
+				position: item,
+				label: new LabelGraphics({
+					backgroundColor: Color.fromCssColorString("#fff"),
+					font: "12pt sans-serif"
+				})
+			});
+		});
+		entities.splice(positions.length, entities.length - positions.length - 1);
+		distance(positions).then(({ count, stages }) => {
+			stages.forEach((stage, index) => {
+				entities[index + 1].position = new CallbackPositionProperty(() => Cartesian3.midpoint(positions[index], positions[index + 1], new Cartesian3()), false);
+				entities[index + 1].label.text = new CallbackProperty(() => `${stage.toFixed(2)} m`, false);
+			});
+			if (stages.length > 1) {
+				entities[entities.length - 1].position = new CallbackPositionProperty(() => positions[positions.length - 1], false);
+				entities[entities.length - 1].label.text = new CallbackProperty(() => `${count.toFixed(2)} m`, false);
+			} else {
+				entities[entities.length - 1].position = void 0;
+				entities[entities.length - 1].label.text = void 0;
+			}
+		});
+		return { entities };
+	}
 });
-const schemeLabel = new PlotScheme({
-  type: "label",
-  complete: (packable) => packable.positions.length >= 1,
-  skeletons: [
-    moved
-  ],
-  initEntites: () => [
-    new Entity({ label: { text: "Label" } })
-  ],
-  render(options) {
-    var _a, _b;
-    const { mouse, packable } = options;
-    const entity = ((_a = options.previous.entities) == null ? void 0 : _a[0]) ?? new Entity({ label: {} });
-    const position = ((_b = packable.positions) == null ? void 0 : _b[0]) ?? mouse;
-    entity.position = new CallbackPositionProperty(() => position, true);
-    return {
-      entities: [entity]
-    };
-  }
+
+//#endregion
+//#region scheme/Billboard.ts
+const PlotSchemeBillboard = new PlotScheme({
+	type: "Billboard",
+	complete: (packable) => packable.positions.length >= 1,
+	skeletons: [moved],
+	initRender: () => {
+		return { entities: [new Entity({ billboard: {
+			image: "/favicon.svg",
+			width: 32,
+			height: 32
+		} })] };
+	},
+	render(options) {
+		const { mouse, packable } = options;
+		const entity = options.previous.entities?.[0] ?? new Entity({ billboard: {} });
+		const position = packable.positions?.[0] ?? mouse;
+		entity.position = new CallbackPositionProperty(() => position, true);
+		return { entities: [entity] };
+	}
 });
-const schemePolygon = new PlotScheme({
-  type: "polygon",
-  allowManualComplete: (packable) => packable.positions.length >= 3,
-  skeletons: [
-    control,
-    interval,
-    moved
-  ],
-  initEntites: () => [
-    new Entity({
-      polyline: {
-        material: Color.YELLOW.withAlpha(0.5)
-      },
-      polygon: {
-        material: Color.YELLOW.withAlpha(0.5)
-      }
-    })
-  ],
-  render(options) {
-    var _a;
-    const { mouse, packable } = options;
-    const entity = ((_a = options.previous.entities) == null ? void 0 : _a[0]) ?? new Entity({
-      polyline: {
-        material: Color.YELLOW.withAlpha(0.5)
-      },
-      polygon: {
-        material: Color.YELLOW.withAlpha(0.5)
-      }
-    });
-    const positions = [...packable.positions ?? []];
-    mouse && positions.push(mouse);
-    if (positions.length === 2) {
-      entity.polygon.hierarchy = void 0;
-      entity.polyline.positions = new CallbackProperty(() => positions, false);
-    } else if (positions.length >= 3) {
-      entity.polyline.positions = void 0;
-      entity.polygon.hierarchy = new CallbackProperty(() => {
-        positions.push(positions[0]);
-        return positions.length >= 3 ? new PolygonHierarchy([...positions]) : void 0;
-      }, false);
-    } else {
-      entity.polygon.hierarchy = void 0;
-      entity.polyline.positions = void 0;
-    }
-    return {
-      entities: [entity]
-    };
-  }
+
+//#endregion
+//#region scheme/BillboardPinBuilder.ts
+const PlotSchemeBillboardPinBuilder = new PlotScheme({
+	type: "BillboardPinBuilder",
+	complete: (packable) => packable.positions.length >= 1,
+	skeletons: [moved],
+	initRender() {
+		return { entities: [new Entity({ billboard: {} })] };
+	},
+	render(context) {
+		const entity = context.previous.entities[0];
+		const position = context.packable.positions[0] ?? context.mouse;
+		entity.position = new CallbackPositionProperty(() => position, true);
+		return { entities: [entity] };
+	}
 });
-const schemePolyline = new PlotScheme(
-  {
-    type: "polyline",
-    allowManualComplete: (packable) => packable.positions.length >= 2,
-    skeletons: [
-      control,
-      intervalNonclosed,
-      moved
-    ],
-    initEntites: () => [
-      new Entity({ polyline: { width: 1 } })
-    ],
-    render(options) {
-      var _a;
-      const { mouse, packable } = options;
-      const entity = ((_a = options.previous.entities) == null ? void 0 : _a[0]) ?? new Entity({ polyline: {} });
-      entity.polyline.positions = new CallbackProperty(() => {
-        const positions = [...packable.positions ?? []].concat(mouse ? [mouse] : []);
-        return positions.length >= 2 ? positions : [];
-      }, false);
-      return {
-        entities: [entity]
-      };
-    }
-  }
-);
-const schemeRectangle = new PlotScheme({
-  type: "rectangle",
-  complete: (packable) => packable.positions.length >= 2,
-  skeletons: [
-    control,
-    interval,
-    moved
-  ],
-  initEntites: () => [
-    new Entity({
-      rectangle: {
-        material: Color.YELLOW.withAlpha(0.5)
-      }
-    })
-  ],
-  render(options) {
-    var _a;
-    const { mouse, packable } = options;
-    const entity = ((_a = options.previous.entities) == null ? void 0 : _a[0]) ?? new Entity({
-      rectangle: {
-        material: Color.YELLOW.withAlpha(0.5)
-      }
-    });
-    const positions = [...packable.positions ?? []];
-    mouse && positions.push(mouse);
-    if (positions.length >= 2) {
-      entity.rectangle.coordinates = new CallbackProperty(() => Rectangle.fromCartesianArray(positions), false);
-    } else {
-      entity.rectangle.coordinates = void 0;
-    }
-    return {
-      entities: [entity]
-    };
-  }
+
+//#endregion
+//#region scheme/Cylinder.ts
+const PlotSchemeCylinder = new PlotScheme({
+	type: "Cylinder",
+	complete: (packable) => packable.positions.length >= 2,
+	skeletons: [moved, control],
+	initRender() {
+		return { entities: [new Entity({ cylinder: {} })] };
+	},
+	render(context) {
+		const entity = context.previous.entities[0];
+		const positions = [...context.packable.positions];
+		if (positions.length === 0) return context.previous;
+		if (positions.length === 1) {
+			const position = context.mouse;
+			position && positions.push(position);
+		}
+		if (positions.length < 2) return context.previous;
+		entity.position = new ConstantPositionProperty(positions[0]);
+		const radius = Cartesian3.distance(positions[0], positions[1]);
+		entity.cylinder.bottomRadius = new CallbackProperty(() => radius, false);
+		if (context.defining || !toPropertyValue(entity.cylinder.length)) entity.cylinder.length = toProperty(radius * 2);
+		return { entities: [entity] };
+	}
 });
-export {
-  PlotAction,
-  PlotFeature,
-  PlotScheme,
-  PlotSkeletonEntity,
-  SampledPlotProperty,
-  SampledPlotStrategy,
-  control,
-  interval,
-  intervalNonclosed,
-  moved,
-  schemeBillboard,
-  schemeLabel,
-  schemeMeasureArea,
-  schemePolygon,
-  schemePolyline,
-  schemeRectangle,
-  usePlot
-};
-//# sourceMappingURL=index.mjs.map
+
+//#endregion
+//#region scheme/Ellipse.ts
+const PlotSchemeEllipse = new PlotScheme({
+	type: "Ellipse",
+	complete: (packable) => packable.positions.length >= 2,
+	skeletons: [moved, control],
+	initRender() {
+		return { entities: [new Entity({ ellipse: {} })] };
+	},
+	render(context) {
+		const entity = context.previous.entities[0];
+		const positions = [...context.packable.positions];
+		if (positions.length === 0) return context.previous;
+		if (positions.length === 1) {
+			const position = context.mouse;
+			position && positions.push(position);
+		}
+		if (positions.length < 2) return context.previous;
+		entity.position = new ConstantPositionProperty(positions[0]);
+		const radius = Cartesian3.distance(positions[0], positions[1]);
+		entity.ellipse.semiMinorAxis = new CallbackProperty(() => radius || 1, false);
+		entity.ellipse.semiMajorAxis = entity.ellipse.semiMinorAxis;
+		return { entities: [entity] };
+	}
+});
+
+//#endregion
+//#region scheme/Label.ts
+const PlotSchemeLabel = new PlotScheme({
+	type: "Label",
+	complete: (packable) => packable.positions.length >= 1,
+	skeletons: [moved],
+	initRender() {
+		return { entities: [new Entity({ label: { text: "Label" } })] };
+	},
+	render(context) {
+		const entity = context.previous.entities[0];
+		const position = context.packable.positions[0] ?? context.mouse;
+		entity.position = new CallbackPositionProperty(() => position, true);
+		return { entities: [entity] };
+	}
+});
+
+//#endregion
+//#region scheme/Point.ts
+const PlotSchemePoint = new PlotScheme({
+	type: "Point",
+	complete: (packable) => packable.positions.length >= 1,
+	skeletons: [moved],
+	initRender() {
+		return { entities: [new Entity({ point: {
+			pixelSize: 10,
+			color: Color.RED
+		} })] };
+	},
+	render(context) {
+		const entity = context.previous.entities[0];
+		const position = context.packable.positions[0] ?? context.mouse;
+		entity.position = new CallbackPositionProperty(() => position, true);
+		return { entities: [entity] };
+	}
+});
+
+//#endregion
+//#region scheme/Polygon.ts
+const PlotSchemePolygon = new PlotScheme({
+	type: "Polygon",
+	allowManualComplete: (packable) => packable.positions.length >= 2,
+	skeletons: [
+		moved,
+		control,
+		interval
+	],
+	initRender: () => {
+		return { entities: [new Entity({
+			polyline: {},
+			polygon: {}
+		})] };
+	},
+	render(options) {
+		const { mouse, packable } = options;
+		const entity = options.previous.entities[0];
+		const positions = [...packable.positions ?? []];
+		mouse && positions.push(mouse);
+		if (positions.length === 2) {
+			entity.polygon.hierarchy = void 0;
+			entity.polyline.positions = new CallbackProperty(() => positions, false);
+		} else if (positions.length >= 3) {
+			entity.polyline.positions = void 0;
+			entity.polygon.hierarchy = new CallbackProperty(() => {
+				positions.push(positions[0]);
+				return positions.length >= 3 ? new PolygonHierarchy([...positions]) : void 0;
+			}, false);
+		} else {
+			entity.polygon.hierarchy = void 0;
+			entity.polyline.positions = void 0;
+		}
+		return { entities: [entity] };
+	}
+});
+
+//#endregion
+//#region geom/helper.ts
+const FITTING_COUNT = 100;
+const HALF_PI = Math.PI / 2;
+const ZERO_TOLERANCE = 1e-4;
+const TWO_PI = Math.PI * 2;
+/**
+* 计算两个坐标之间的距离
+* @param coord1
+* @param coord2
+*/
+function mathDistance(coord1, coord2) {
+	return Math.hypot(coord1[0] - coord2[0], coord1[1] - coord2[1]);
+}
+/**
+* 计算点集合的总距离
+* @param points
+*/
+function wholeDistance(points) {
+	let distance$1 = 0;
+	if (points && Array.isArray(points) && points.length > 0) points.forEach((item, index) => {
+		if (index < points.length - 1) distance$1 += mathDistance(item, points[index + 1]);
+	});
+	return distance$1;
+}
+/**
+* 获取基础长度
+* @param points
+*/
+const getBaseLength = (points) => wholeDistance(points) ** .99;
+/**
+* 求取两个坐标的中间坐标
+* @param coord1
+* @param coord2
+*/
+function mid(coord1, coord2) {
+	return [(coord1[0] + coord2[0]) / 2, (coord1[1] + coord2[1]) / 2];
+}
+/**
+* 通过三个点确定一个圆的中心点
+* @param coord1
+* @param coord2
+* @param coord3
+*/
+function getCircleCenterOfThreeCoords(coord1, coord2, coord3) {
+	const coordA = [(coord1[0] + coord2[0]) / 2, (coord1[1] + coord2[1]) / 2];
+	const coordB = [coordA[0] - coord1[1] + coord2[1], coordA[1] + coord1[0] - coord2[0]];
+	const coordC = [(coord1[0] + coord3[0]) / 2, (coord1[1] + coord3[1]) / 2];
+	const coordD = [coordC[0] - coord1[1] + coord3[1], coordC[1] + coord1[0] - coord3[0]];
+	return getIntersectCoord(coordA, coordB, coordC, coordD);
+}
+/**
+* 获取交集的点
+* @param coordA
+* @param coordB
+* @param coordC
+* @param coordD
+*/
+function getIntersectCoord(coordA, coordB, coordC, coordD) {
+	if (coordA[1] === coordB[1]) {
+		const f$1 = (coordD[0] - coordC[0]) / (coordD[1] - coordC[1]);
+		const x$1 = f$1 * (coordA[1] - coordC[1]) + coordC[0];
+		const y$1 = coordA[1];
+		return [x$1, y$1];
+	}
+	if (coordC[1] === coordD[1]) {
+		const e$1 = (coordB[0] - coordA[0]) / (coordB[1] - coordA[1]);
+		const x$1 = e$1 * (coordC[1] - coordA[1]) + coordA[0];
+		const y$1 = coordC[1];
+		return [x$1, y$1];
+	}
+	const e = (coordB[0] - coordA[0]) / (coordB[1] - coordA[1]);
+	const f = (coordD[0] - coordC[0]) / (coordD[1] - coordC[1]);
+	const y = (e * coordA[1] - coordA[0] - f * coordC[1] + coordC[0]) / (e - f);
+	const x = e * y - e * coordA[1] + coordA[0];
+	return [x, y];
+}
+/**
+* 获取方位角（地平经度）
+* @param startCoord
+* @param endCoord
+*/
+function getAzimuth(startCoord, endCoord) {
+	let azimuth = 0;
+	const angle = Math.asin(Math.abs(endCoord[1] - startCoord[1]) / mathDistance(startCoord, endCoord));
+	if (endCoord[1] >= startCoord[1] && endCoord[0] >= startCoord[0]) azimuth = angle + Math.PI;
+	else if (endCoord[1] >= startCoord[1] && endCoord[0] < startCoord[0]) azimuth = Math.PI * 2 - angle;
+	else if (endCoord[1] < startCoord[1] && endCoord[0] < startCoord[0]) azimuth = angle;
+	else if (endCoord[1] < startCoord[1] && endCoord[0] >= startCoord[0]) azimuth = Math.PI - angle;
+	return azimuth;
+}
+/**
+* 通过三个点获取方位角
+* @param coordA
+* @param coordB
+* @param coordC
+*/
+function getAngleOfThreeCoords(coordA, coordB, coordC) {
+	const angle = getAzimuth(coordB, coordA) - getAzimuth(coordB, coordC);
+	return angle < 0 ? angle + Math.PI * 2 : angle;
+}
+/**
+* 判断是否是顺时针
+* @param coord1
+* @param coord2
+* @param coord3
+*/
+function isClockWise(coord1, coord2, coord3) {
+	return (coord3[1] - coord1[1]) * (coord2[0] - coord1[0]) > (coord2[1] - coord1[1]) * (coord3[0] - coord1[0]);
+}
+/**
+* 获取立方值
+*/
+function getCubicValue(t, startCoord, coord1, coord2, endCoord) {
+	t = Math.max(Math.min(t, 1), 0);
+	const [tp, t2] = [1 - t, t * t];
+	const t3 = t2 * t;
+	const tp2 = tp * tp;
+	const tp3 = tp2 * tp;
+	const x = tp3 * startCoord[0] + 3 * tp2 * t * coord1[0] + 3 * tp * t2 * coord2[0] + t3 * endCoord[0];
+	const y = tp3 * startCoord[1] + 3 * tp2 * t * coord1[1] + 3 * tp * t2 * coord2[1] + t3 * endCoord[1];
+	return [x, y];
+}
+/**
+* 根据起止点和旋转方向求取第三个点
+* @param startCoord
+* @param endCoord
+* @param angle
+* @param distance
+* @param clockWise
+*/
+function getThirdCoord(startCoord, endCoord, angle, distance$1, clockWise) {
+	const azimuth = getAzimuth(startCoord, endCoord);
+	const alpha = clockWise ? azimuth + angle : azimuth - angle;
+	const dx = distance$1 * Math.cos(alpha);
+	const dy = distance$1 * Math.sin(alpha);
+	return [endCoord[0] + dx, endCoord[1] + dy];
+}
+/**
+* 插值弓形线段点
+* @param center
+* @param radius
+* @param startAngle
+* @param endAngle
+*/
+function getArcCoords(center, radius, startAngle, endAngle) {
+	let [x, y, coords, angleDiff] = [
+		0,
+		0,
+		[],
+		endAngle - startAngle
+	];
+	angleDiff = angleDiff < 0 ? angleDiff + Math.PI * 2 : angleDiff;
+	for (let i = 0; i <= 100; i++) {
+		const angle = startAngle + angleDiff * i / 100;
+		x = center[0] + radius * Math.cos(angle);
+		y = center[1] + radius * Math.sin(angle);
+		coords.push([x, y]);
+	}
+	return coords;
+}
+/**
+* getBisectorNormals
+* @param t
+* @param coord1
+* @param coord2
+* @param coord3
+*/
+function getBisectorNormals(t, coord1, coord2, coord3) {
+	const normal = getNormal(coord1, coord2, coord3);
+	let [bisectorNormalRight, bisectorNormalLeft, dt, x, y] = [
+		[0, 0],
+		[0, 0],
+		0,
+		0,
+		0
+	];
+	const dist = Math.hypot(normal[0], normal[1]);
+	const uX = normal[0] / dist;
+	const uY = normal[1] / dist;
+	const d1 = mathDistance(coord1, coord2);
+	const d2 = mathDistance(coord2, coord3);
+	if (dist > ZERO_TOLERANCE) if (isClockWise(coord1, coord2, coord3)) {
+		dt = t * d1;
+		x = coord2[0] - dt * uY;
+		y = coord2[1] + dt * uX;
+		bisectorNormalRight = [x, y];
+		dt = t * d2;
+		x = coord2[0] + dt * uY;
+		y = coord2[1] - dt * uX;
+		bisectorNormalLeft = [x, y];
+	} else {
+		dt = t * d1;
+		x = coord2[0] + dt * uY;
+		y = coord2[1] - dt * uX;
+		bisectorNormalRight = [x, y];
+		dt = t * d2;
+		x = coord2[0] - dt * uY;
+		y = coord2[1] + dt * uX;
+		bisectorNormalLeft = [x, y];
+	}
+	else {
+		x = coord2[0] + t * (coord1[0] - coord2[0]);
+		y = coord2[1] + t * (coord1[1] - coord2[1]);
+		bisectorNormalRight = [x, y];
+		x = coord2[0] + t * (coord3[0] - coord2[0]);
+		y = coord2[1] + t * (coord3[1] - coord2[1]);
+		bisectorNormalLeft = [x, y];
+	}
+	return [bisectorNormalRight, bisectorNormalLeft];
+}
+/**
+* 获取默认三点的内切圆
+* @param coord1
+* @param coord2
+* @param coord3
+*/
+function getNormal(coord1, coord2, coord3) {
+	let dX1 = coord1[0] - coord2[0];
+	let dY1 = coord1[1] - coord2[1];
+	const d1 = Math.hypot(dX1, dY1);
+	dX1 /= d1;
+	dY1 /= d1;
+	let dX2 = coord3[0] - coord2[0];
+	let dY2 = coord3[1] - coord2[1];
+	const d2 = Math.hypot(dX2, dY2);
+	dX2 /= d2;
+	dY2 /= d2;
+	const uX = dX1 + dX2;
+	const uY = dY1 + dY2;
+	return [uX, uY];
+}
+/**
+* 贝塞尔曲线
+* @param points
+*/
+function getBezierCoords(points) {
+	if (points.length <= 2) return points;
+	const bezierCoords = [];
+	const n = points.length - 1;
+	for (let t = 0; t <= 1; t += .01) {
+		let [x, y] = [0, 0];
+		for (let index = 0; index <= n; index++) {
+			const factor = getBinomialFactor(n, index);
+			const a = t ** index;
+			const b = (1 - t) ** (n - index);
+			x += factor * a * b * points[index][0];
+			y += factor * a * b * points[index][1];
+		}
+		bezierCoords.push([x, y]);
+	}
+	bezierCoords.push(points[n]);
+	return bezierCoords;
+}
+/**
+* 获取阶乘数据
+* @param n
+*/
+function getFactorial(n) {
+	let result = 1;
+	switch (true) {
+		case n <= 1:
+			result = 1;
+			break;
+		case n === 2:
+			result = 2;
+			break;
+		case n === 3:
+			result = 6;
+			break;
+		case n === 24:
+			result = 24;
+			break;
+		case n === 5:
+			result = 120;
+			break;
+		default:
+			for (let i = 1; i <= n; i++) result *= i;
+			break;
+	}
+	return result;
+}
+/**
+* 获取二项分布
+* @param n
+* @param index
+*/
+function getBinomialFactor(n, index) {
+	return getFactorial(n) / (getFactorial(index) * getFactorial(n - index));
+}
+/**
+* 插值线性点
+* @param points
+*/
+function getQBSplineCoords(points) {
+	if (points.length <= 2) return points;
+	const [n, bSplineCoords] = [2, []];
+	const m = points.length - n - 1;
+	bSplineCoords.push(points[0]);
+	for (let i = 0; i <= m; i++) for (let t = 0; t <= 1; t += .05) {
+		let [x, y] = [0, 0];
+		for (let k = 0; k <= n; k++) {
+			const factor = getQuadricBSplineFactor(k, t);
+			x += factor * points[i + k][0];
+			y += factor * points[i + k][1];
+		}
+		bSplineCoords.push([x, y]);
+	}
+	bSplineCoords.push(points.at(-1));
+	return bSplineCoords;
+}
+/**
+* 得到二次线性因子
+* @param k
+* @param t
+*/
+function getQuadricBSplineFactor(k, t) {
+	let res = 0;
+	if (k === 0) res = (t - 1) ** 2 / 2;
+	else if (k === 1) res = (-2 * t ** 2 + 2 * t + 1) / 2;
+	else if (k === 2) res = t ** 2 / 2;
+	return res;
+}
+
+//#endregion
+//#region geom/arc.ts
+/**
+* 标绘画弓形算法，继承线要素相关方法和属性
+*/
+function arc(coords) {
+	const coordlength = coords.length;
+	if (coordlength <= 2) throw new Error("coords.length must >= 3");
+	else {
+		let [coord1, coord2, coord3, startAngle, endAngle] = [
+			coords[0],
+			coords[1],
+			coords[2],
+			0,
+			0
+		];
+		const center = getCircleCenterOfThreeCoords(coord1, coord2, coord3);
+		const radius = mathDistance(coord1, center);
+		const angle1 = getAzimuth(coord1, center);
+		const angle2 = getAzimuth(coord2, center);
+		if (isClockWise(coord1, coord2, coord3)) {
+			startAngle = angle2;
+			endAngle = angle1;
+		} else {
+			startAngle = angle1;
+			endAngle = angle2;
+		}
+		return getArcCoords(center, radius, startAngle, endAngle);
+	}
+}
+
+//#endregion
+//#region geom/arrowAttackDirection.ts
+/**
+* 尖曲箭头
+*/
+function arrowAttackDirection(coords, options = {}) {
+	const coordLength = coords.length;
+	if (coordLength < 3) throw new Error("coords.length must >= 3");
+	else {
+		let [tailLeft, tailRight] = [coords[0], coords[1]];
+		if (isClockWise(coords[0], coords[1], coords[2])) {
+			tailLeft = coords[1];
+			tailRight = coords[0];
+		}
+		const midTail = mid(tailLeft, tailRight);
+		const boneCoords = [midTail].concat(coords.slice(2));
+		const headCoords = getArrowHeadCoords(boneCoords, {
+			tailLeft,
+			tailRight,
+			...options
+		});
+		if (headCoords && headCoords.length > 4) {
+			const [neckLeft, neckRight] = [headCoords[0], headCoords[4]];
+			const tailWidthFactor = mathDistance(tailLeft, tailRight) / getBaseLength(boneCoords);
+			const bodyCoords = getArrowBodyCoords(boneCoords, neckLeft, neckRight, tailWidthFactor);
+			const coordlength = bodyCoords.length;
+			let leftCoords = [tailLeft].concat(bodyCoords.slice(0, coordlength / 2));
+			leftCoords.push(neckLeft);
+			let rightCoords = [tailRight].concat(bodyCoords.slice(coordlength / 2, coordlength));
+			rightCoords.push(neckRight);
+			leftCoords = getQBSplineCoords(leftCoords);
+			rightCoords = getQBSplineCoords(rightCoords);
+			return leftCoords.concat(headCoords, rightCoords.reverse());
+		} else return [];
+	}
+}
+/**
+* 插值头部点
+*/
+function getArrowHeadCoords(points, options) {
+	const { tailLeft, tailRight, headHeightFactor = .18, headWidthFactor = .3, neckHeightFactor = .85, neckWidthFactor = .15, headTailFactor = .8 } = options;
+	let len = getBaseLength(points);
+	let headHeight = len * headHeightFactor;
+	const headCoord = points.at(-1);
+	len = mathDistance(headCoord, points.at(-2));
+	let tailWidth = 0;
+	if (tailLeft && tailRight) tailWidth = mathDistance(tailLeft, tailRight);
+	if (headHeight > tailWidth * headTailFactor) headHeight = tailWidth * headTailFactor;
+	const headWidth = headHeight * headWidthFactor;
+	const neckWidth = headHeight * neckWidthFactor;
+	headHeight = Math.min(headHeight, len);
+	const neckHeight = headHeight * neckHeightFactor;
+	const headEndCoord = getThirdCoord(points.at(-2), headCoord, 0, headHeight, true);
+	const neckEndCoord = getThirdCoord(points.at(-2), headCoord, 0, neckHeight, true);
+	const headLeft = getThirdCoord(headCoord, headEndCoord, HALF_PI, headWidth, false);
+	const headRight = getThirdCoord(headCoord, headEndCoord, HALF_PI, headWidth, true);
+	const neckLeft = getThirdCoord(headCoord, neckEndCoord, HALF_PI, neckWidth, false);
+	const neckRight = getThirdCoord(headCoord, neckEndCoord, HALF_PI, neckWidth, true);
+	return [
+		neckLeft,
+		headLeft,
+		headCoord,
+		headRight,
+		neckRight
+	];
+}
+/**
+* 插值面部分数据
+* @param points
+* @param neckLeft
+* @param neckRight
+* @param tailWidthFactor
+*/
+function getArrowBodyCoords(points, neckLeft, neckRight, tailWidthFactor) {
+	const allLen = wholeDistance(points);
+	const len = getBaseLength(points);
+	const tailWidth = len * tailWidthFactor;
+	const neckWidth = mathDistance(neckLeft, neckRight);
+	const widthDif = (tailWidth - neckWidth) / 2;
+	let tempLen = 0;
+	const leftBodyCoords = [];
+	const rightBodyCoords = [];
+	for (let i = 1; i < points.length - 1; i++) {
+		const angle = getAngleOfThreeCoords(points[i - 1], points[i], points[i + 1]) / 2;
+		tempLen += mathDistance(points[i - 1], points[i]);
+		const w = (tailWidth / 2 - tempLen / allLen * widthDif) / Math.sin(angle);
+		const left = getThirdCoord(points[i - 1], points[i], Math.PI - angle, w, true);
+		const right = getThirdCoord(points[i - 1], points[i], angle, w, false);
+		leftBodyCoords.push(left);
+		rightBodyCoords.push(right);
+	}
+	return leftBodyCoords.concat(rightBodyCoords);
+}
+
+//#endregion
+//#region geom/arrowAttackDirectionTailed.ts
+/**
+* 燕尾尖曲箭头
+*/
+function arrowAttackDirectionTailed(coords, options = {}) {
+	const { headHeightFactor = .18, headWidthFactor = .3, neckHeightFactor = .85, neckWidthFactor = .15, tailWidthFactor = .1, swallowTailFactor = 1 } = options;
+	const coordLength = coords.length;
+	if (coordLength < 3) throw new Error("coords.length must >= 3");
+	let [tailLeft, tailRight] = [coords[0], coords[1]];
+	if (isClockWise(coords[0], coords[1], coords[2])) {
+		tailLeft = coords[1];
+		tailRight = coords[0];
+	}
+	const midTail = mid(tailLeft, tailRight);
+	const boneCoords = [midTail].concat(coords.slice(2));
+	const headCoords = getArrowHeadCoords(boneCoords, {
+		tailLeft,
+		tailRight,
+		headHeightFactor,
+		headWidthFactor,
+		neckWidthFactor,
+		neckHeightFactor
+	});
+	if (headCoords && headCoords.length > 4) {
+		const [neckLeft, neckRight] = [headCoords[0], headCoords[4]];
+		const tailWidth = mathDistance(tailLeft, tailRight);
+		const allLen = getBaseLength(boneCoords);
+		const len = allLen * tailWidthFactor * swallowTailFactor;
+		const swallowTailCoord = getThirdCoord(boneCoords[1], boneCoords[0], 0, len, true);
+		const factor = tailWidth / allLen;
+		const bodyCoords = getArrowBodyCoords(boneCoords, neckLeft, neckRight, factor);
+		const coordlength = bodyCoords.length;
+		let leftCoords = [tailLeft].concat(bodyCoords.slice(0, coordlength / 2));
+		leftCoords.push(neckLeft);
+		let rightCoords = [tailRight].concat(bodyCoords.slice(coordlength / 2, coordlength));
+		rightCoords.push(neckRight);
+		leftCoords = getQBSplineCoords(leftCoords);
+		rightCoords = getQBSplineCoords(rightCoords);
+		return leftCoords.concat(headCoords, rightCoords.reverse(), [swallowTailCoord, leftCoords[0]]);
+	} else return [];
+}
+
+//#endregion
+//#region geom/arrowClamped.ts
+/**
+* 钳击箭头 有效点位长度3,4,5
+*/
+function arrowClamped(coords) {
+	const options = {
+		headHeightFactor: .25,
+		headWidthFactor: .3,
+		neckHeightFactor: .85,
+		neckWidthFactor: .15
+	};
+	if (coords.length < 3) throw new Error(`coords.length must >= 3`);
+	const [coord1, coord2, coord3] = coords;
+	let tempCoord4, connCoord;
+	if (coords.length === 3) {
+		tempCoord4 = getTempCoord4(coord1, coord2, coord3);
+		connCoord = mid(coord1, coord2);
+	} else if (coords.length === 4) {
+		tempCoord4 = coords[3];
+		connCoord = mid(coord1, coord2);
+	} else {
+		tempCoord4 = coords[3];
+		connCoord = coords[4];
+	}
+	let leftArrowCoords;
+	let rightArrowCoords;
+	if (isClockWise(coord1, coord2, coord3)) {
+		leftArrowCoords = getArrowCoords(coord1, connCoord, tempCoord4, false, options);
+		rightArrowCoords = getArrowCoords(connCoord, coord2, coord3, true, options);
+	} else {
+		leftArrowCoords = getArrowCoords(coord2, connCoord, coord3, false, options);
+		rightArrowCoords = getArrowCoords(connCoord, coord1, tempCoord4, true, options);
+	}
+	const m = leftArrowCoords.length;
+	const t = (m - 5) / 2;
+	const llBodyCoords = leftArrowCoords.slice(0, t);
+	const lArrowCoords = leftArrowCoords.slice(t, t + 5);
+	let lrBodyCoords = leftArrowCoords.slice(t + 5, m);
+	let rlBodyCoords = rightArrowCoords.slice(0, t);
+	const rArrowCoords = rightArrowCoords.slice(t, t + 5);
+	const rrBodyCoords = rightArrowCoords.slice(t + 5, m);
+	rlBodyCoords = getBezierCoords(rlBodyCoords);
+	const bodyCoords = getBezierCoords(rrBodyCoords.concat(llBodyCoords.slice(1)));
+	lrBodyCoords = getBezierCoords(lrBodyCoords);
+	return rlBodyCoords.concat(rArrowCoords, bodyCoords, lArrowCoords, lrBodyCoords);
+}
+/**
+* 插值箭形上的点
+* @param coord1  - Wgs84坐标
+* @param coord2 - Wgs84坐标
+* @param coord3 - Wgs84坐标
+* @param clockWise - 是否顺时针
+*/
+function getArrowCoords(coord1, coord2, coord3, clockWise, options) {
+	const midCoord = mid(coord1, coord2);
+	const len = mathDistance(midCoord, coord3);
+	let midCoord1 = getThirdCoord(coord3, midCoord, 0, len * .3, true);
+	let midCoord2 = getThirdCoord(coord3, midCoord, 0, len * .5, true);
+	midCoord1 = getThirdCoord(midCoord, midCoord1, HALF_PI, len / 5, clockWise);
+	midCoord2 = getThirdCoord(midCoord, midCoord2, HALF_PI, len / 4, clockWise);
+	const coords = [
+		midCoord,
+		midCoord1,
+		midCoord2,
+		coord3
+	];
+	const arrowCoords = getArrowHeadCoords$1(coords, options);
+	if (arrowCoords && Array.isArray(arrowCoords) && arrowCoords.length > 0) {
+		const [neckLeftCoord, neckRightCoord] = [arrowCoords[0], arrowCoords[4]];
+		const tailWidthFactor = mathDistance(coord1, coord2) / getBaseLength(coords) / 2;
+		const bodyCoords = getArrowBodyCoords$1(coords, neckLeftCoord, neckRightCoord, tailWidthFactor);
+		const n = bodyCoords.length;
+		let lCoords = bodyCoords.slice(0, n / 2);
+		let rCoords = bodyCoords.slice(n / 2, n);
+		lCoords.push(neckLeftCoord);
+		rCoords.push(neckRightCoord);
+		lCoords = lCoords.reverse();
+		lCoords.push(coord2);
+		rCoords = rCoords.reverse();
+		rCoords.push(coord1);
+		return lCoords.reverse().concat(arrowCoords, rCoords);
+	} else throw new Error("插值出错");
+}
+/**
+* 插值头部点
+* @param coords
+*/
+function getArrowHeadCoords$1(coords, options) {
+	const { headHeightFactor, headWidthFactor, neckWidthFactor, neckHeightFactor } = options;
+	const len = getBaseLength(coords);
+	const headHeight = len * headHeightFactor;
+	const headCoord = coords.at(-1);
+	const headWidth = headHeight * headWidthFactor;
+	const neckWidth = headHeight * neckWidthFactor;
+	const neckHeight = headHeight * neckHeightFactor;
+	const headEndCoord = getThirdCoord(coords.at(-2), headCoord, 0, headHeight, true);
+	const neckEndCoord = getThirdCoord(coords.at(-2), headCoord, 0, neckHeight, true);
+	const headLeft = getThirdCoord(headCoord, headEndCoord, HALF_PI, headWidth, false);
+	const headRight = getThirdCoord(headCoord, headEndCoord, HALF_PI, headWidth, true);
+	const neckLeft = getThirdCoord(headCoord, neckEndCoord, HALF_PI, neckWidth, false);
+	const neckRight = getThirdCoord(headCoord, neckEndCoord, HALF_PI, neckWidth, true);
+	return [
+		neckLeft,
+		headLeft,
+		headCoord,
+		headRight,
+		neckRight
+	];
+}
+/**
+* 插值面部分数据
+* @param coords
+* @param neckLeft
+* @param neckRight
+* @param tailWidthFactor
+*/
+function getArrowBodyCoords$1(coords, neckLeft, neckRight, tailWidthFactor) {
+	const allLen = wholeDistance(coords);
+	const len = getBaseLength(coords);
+	const tailWidth = len * tailWidthFactor;
+	const neckWidth = mathDistance(neckLeft, neckRight);
+	const widthDif = (tailWidth - neckWidth) / 2;
+	let tempLen = 0;
+	const leftBodyCoords = [];
+	const rightBodyCoords = [];
+	for (let i = 1; i < coords.length - 1; i++) {
+		const angle = getAngleOfThreeCoords(coords[i - 1], coords[i], coords[i + 1]) / 2;
+		tempLen += mathDistance(coords[i - 1], coords[i]);
+		const w = (tailWidth / 2 - tempLen / allLen * widthDif) / Math.sin(angle);
+		const left = getThirdCoord(coords[i - 1], coords[i], Math.PI - angle, w, true);
+		const right = getThirdCoord(coords[i - 1], coords[i], angle, w, false);
+		leftBodyCoords.push(left);
+		rightBodyCoords.push(right);
+	}
+	return leftBodyCoords.concat(rightBodyCoords);
+}
+/**
+* 获取对称点
+* @param lineCoord1
+* @param lineCoord2
+* @param coord
+*/
+function getTempCoord4(lineCoord1, lineCoord2, coord) {
+	const midCoord = mid(lineCoord1, lineCoord2);
+	const len = mathDistance(midCoord, coord);
+	const angle = getAngleOfThreeCoords(lineCoord1, midCoord, coord);
+	if (angle < HALF_PI) {
+		const distance1 = len * Math.sin(angle);
+		const distance2 = len * Math.cos(angle);
+		const mid$1 = getThirdCoord(lineCoord1, midCoord, HALF_PI, distance1, false);
+		return getThirdCoord(midCoord, mid$1, HALF_PI, distance2, true);
+	} else if (angle >= HALF_PI && angle < Math.PI) {
+		const distance1 = len * Math.sin(Math.PI - angle);
+		const distance2 = len * Math.cos(Math.PI - angle);
+		const mid$1 = getThirdCoord(lineCoord1, midCoord, HALF_PI, distance1, false);
+		return getThirdCoord(midCoord, mid$1, HALF_PI, distance2, false);
+	} else if (angle >= Math.PI && angle < Math.PI * 1.5) {
+		const distance1 = len * Math.sin(angle - Math.PI);
+		const distance2 = len * Math.cos(angle - Math.PI);
+		const mid$1 = getThirdCoord(lineCoord1, midCoord, HALF_PI, distance1, true);
+		return getThirdCoord(midCoord, mid$1, HALF_PI, distance2, true);
+	} else {
+		const distance1 = len * Math.sin(Math.PI * 2 - angle);
+		const distance2 = len * Math.cos(Math.PI * 2 - angle);
+		const mid$1 = getThirdCoord(lineCoord1, midCoord, HALF_PI, distance1, true);
+		return getThirdCoord(midCoord, mid$1, HALF_PI, distance2, false);
+	}
+}
+
+//#endregion
+//#region geom/arrowStraightSharp.ts
+/**
+* 尖箭头
+*
+*/
+function arrowStraightSharp(coords, options = {}) {
+	const { tailWidthFactor = .1, neckWidthFactor = .2, headWidthFactor = .25, headAngle = Math.PI / 8.5, neckAngle = Math.PI / 13 } = options;
+	const coordlength = coords.length;
+	if (coordlength < 2) throw new Error("coords.length must >= 2");
+	const [coord1, coord2] = [coords[0], coords[1]];
+	const len = getBaseLength(coords);
+	const tailWidth = len * tailWidthFactor;
+	const neckWidth = len * neckWidthFactor;
+	const headWidth = len * headWidthFactor;
+	const tailLeft = getThirdCoord(coord2, coord1, HALF_PI, tailWidth, true);
+	const tailRight = getThirdCoord(coord2, coord1, HALF_PI, tailWidth, false);
+	const headLeft = getThirdCoord(coord1, coord2, headAngle, headWidth, false);
+	const headRight = getThirdCoord(coord1, coord2, headAngle, headWidth, true);
+	const neckLeft = getThirdCoord(coord1, coord2, neckAngle, neckWidth, false);
+	const neckRight = getThirdCoord(coord1, coord2, neckAngle, neckWidth, true);
+	const pList = [
+		tailLeft,
+		neckLeft,
+		headLeft,
+		coord2,
+		headRight,
+		neckRight,
+		tailRight
+	];
+	return pList;
+}
+
+//#endregion
+//#region geom/arrowStraight.ts
+/**
+* 直箭头
+*/
+function arrowStraight(coords) {
+	const tailWidthFactor = .05;
+	const neckWidthFactor = .1;
+	const headWidthFactor = .15;
+	const headAngle = Math.PI / 4;
+	const neckAngle = Math.PI * .17741;
+	return arrowStraightSharp(coords, {
+		tailWidthFactor,
+		neckWidthFactor,
+		headWidthFactor,
+		headAngle,
+		neckAngle
+	});
+}
+
+//#endregion
+//#region geom/arrowUnitCombatOperation.ts
+/**
+* 分队战斗行动（尖曲箭头）
+*/
+function arrowUnitCombatOperation(coords, options = {}) {
+	const { headHeightFactor = .18, headWidthFactor = .3, neckHeightFactor = .85, neckWidthFactor = .15, tailWidthFactor = .1 } = options;
+	const coordlength = coords.length;
+	if (coordlength < 2) throw new Error("coords.length must >= 2");
+	else {
+		const allLen = getBaseLength(coords);
+		const tailWidth = allLen * tailWidthFactor;
+		const tailLeft = getThirdCoord(coords[1], coords[0], HALF_PI, tailWidth, false);
+		const tailRight = getThirdCoord(coords[1], coords[0], HALF_PI, tailWidth, true);
+		const headCoords = getArrowHeadCoords(coords, {
+			tailLeft,
+			tailRight,
+			headHeightFactor,
+			headWidthFactor,
+			neckWidthFactor,
+			neckHeightFactor
+		});
+		if (headCoords && headCoords.length > 4) {
+			const neckLeft = headCoords[0];
+			const neckRight = headCoords[4];
+			const bodyCoords = getArrowBodyCoords(coords, neckLeft, neckRight, tailWidthFactor);
+			const coordlength$1 = bodyCoords.length;
+			let leftCoords = [tailLeft].concat(bodyCoords.slice(0, coordlength$1 / 2));
+			leftCoords.push(neckLeft);
+			let rightCoords = [tailRight].concat(bodyCoords.slice(coordlength$1 / 2, coordlength$1));
+			rightCoords.push(neckRight);
+			leftCoords = getQBSplineCoords(leftCoords);
+			rightCoords = getQBSplineCoords(rightCoords);
+			return leftCoords.concat(headCoords, rightCoords.reverse());
+		} else return [];
+	}
+}
+
+//#endregion
+//#region geom/arrowUnitCombatOperationTailed.ts
+/**
+* 燕尾尖箭头
+*/
+function arrowUnitCombatOperationTailed(coords, options = {}) {
+	const { headHeightFactor = .18, headWidthFactor = .3, neckHeightFactor = .85, neckWidthFactor = .15, tailWidthFactor = .1, swallowTailFactor = 1 } = options;
+	const coordlength = coords.length;
+	if (coordlength < 2) throw new Error("coords.length must >= 2");
+	const allLen = getBaseLength(coords);
+	const tailWidth = allLen * tailWidthFactor;
+	const tailLeft = getThirdCoord(coords[1], coords[0], HALF_PI, tailWidth, false);
+	const tailRight = getThirdCoord(coords[1], coords[0], HALF_PI, tailWidth, true);
+	const len = tailWidth * swallowTailFactor;
+	const swallowTailCoord = getThirdCoord(coords[1], coords[0], 0, len, true);
+	const tailCoords = [
+		tailLeft,
+		swallowTailCoord,
+		tailRight
+	];
+	const headCoords = getArrowHeadCoords(coords, {
+		tailLeft: tailCoords[0],
+		tailRight: tailCoords[2],
+		headHeightFactor,
+		headWidthFactor,
+		neckWidthFactor,
+		neckHeightFactor
+	});
+	if (headCoords && headCoords.length > 4) {
+		const neckLeft = headCoords[0];
+		const neckRight = headCoords[4];
+		const bodyCoords = getArrowBodyCoords(coords, neckLeft, neckRight, tailWidthFactor);
+		const coordlength$1 = bodyCoords.length;
+		let leftCoords = [tailCoords[0]].concat(bodyCoords.slice(0, coordlength$1 / 2));
+		leftCoords.push(neckLeft);
+		let rightCoords = [tailCoords[2]].concat(bodyCoords.slice(coordlength$1 / 2, coordlength$1));
+		rightCoords.push(neckRight);
+		leftCoords = getQBSplineCoords(leftCoords);
+		rightCoords = getQBSplineCoords(rightCoords);
+		return leftCoords.concat(headCoords, rightCoords.reverse(), [tailCoords[1], leftCoords[0]]);
+	}
+	return [];
+}
+
+//#endregion
+//#region geom/assemblingPlace.ts
+/**
+* 集结地
+*
+*/
+function assemblingPlace(coords) {
+	if (coords.length < 3) throw new Error(`coords.length must >= 3`);
+	const t = .4;
+	const midCoord = mid(coords[0], coords[2]);
+	coords.push(midCoord, coords[0], coords[1]);
+	let normals = [];
+	const pList = [];
+	for (let i = 0; i < coords.length - 2; i++) {
+		const coord1 = coords[i];
+		const coord2 = coords[i + 1];
+		const coord3 = coords[i + 2];
+		const normalCoords = getBisectorNormals(t, coord1, coord2, coord3);
+		normals = normals.concat(normalCoords);
+	}
+	const count = normals.length;
+	normals = [normals[count - 1]].concat(normals.slice(0, count - 1));
+	for (let i = 0; i < coords.length - 2; i++) {
+		const coord1 = coords[i];
+		const coord2 = coords[i + 1];
+		pList.push(coord1);
+		for (let t$1 = 0; t$1 <= FITTING_COUNT; t$1++) {
+			const coord = getCubicValue(t$1 / FITTING_COUNT, coord1, normals[i * 2], normals[i * 2 + 1], coord2);
+			pList.push(coord);
+		}
+		pList.push(coord2);
+	}
+	return pList;
+}
+
+//#endregion
+//#region geom/flagCurve.ts
+/**
+* 曲线旗标
+*/
+function flagCurve(coords) {
+	const coordlength = coords.length;
+	if (coordlength < 2) throw new Error("coords.length must >= 2");
+	return calculatePonits(coords);
+}
+/**
+* 插值点数据
+* @param coords
+*/
+function calculatePonits(coords) {
+	let components = [];
+	if (coords.length > 1) {
+		const startCoord = coords[0];
+		const endCoord = coords.at(-1);
+		const coord1 = startCoord;
+		const coord2 = [(endCoord[0] - startCoord[0]) / 4 + startCoord[0], (endCoord[1] - startCoord[1]) / 8 + startCoord[1]];
+		const coord3 = [(startCoord[0] + endCoord[0]) / 2, startCoord[1]];
+		const coord4 = [(endCoord[0] - startCoord[0]) * 3 / 4 + startCoord[0], -(endCoord[1] - startCoord[1]) / 8 + startCoord[1]];
+		const coord5 = [endCoord[0], startCoord[1]];
+		const coord6 = [endCoord[0], (startCoord[1] + endCoord[1]) / 2];
+		const coord7 = [(endCoord[0] - startCoord[0]) * 3 / 4 + startCoord[0], (endCoord[1] - startCoord[1]) * 3 / 8 + startCoord[1]];
+		const coord8 = [(startCoord[0] + endCoord[0]) / 2, (startCoord[1] + endCoord[1]) / 2];
+		const coord9 = [(endCoord[0] - startCoord[0]) / 4 + startCoord[0], (endCoord[1] - startCoord[1]) * 5 / 8 + startCoord[1]];
+		const coord10 = [startCoord[0], (startCoord[1] + endCoord[1]) / 2];
+		const coord11 = [startCoord[0], endCoord[1]];
+		const curve1 = getBezierCoords([
+			coord1,
+			coord2,
+			coord3,
+			coord4,
+			coord5
+		]);
+		const curve2 = getBezierCoords([
+			coord6,
+			coord7,
+			coord8,
+			coord9,
+			coord10
+		]);
+		components = curve1.concat(curve2);
+		components.push(coord11);
+	}
+	return components;
+}
+
+//#endregion
+//#region geom/flagRect.ts
+/**
+* 直角旗标（使用两个控制点直接创建直角旗标）
+*/
+function flagRect(coords) {
+	if (coords.length < 2) throw new Error("coords.length must >= 2");
+	const [startCoord, endCoord] = coords;
+	const coord1 = [endCoord[0], startCoord[1]];
+	const coord2 = [endCoord[0], (startCoord[1] + endCoord[1]) / 2];
+	const coord3 = [startCoord[0], (startCoord[1] + endCoord[1]) / 2];
+	const coord4 = [startCoord[0], endCoord[1]];
+	return [
+		startCoord,
+		coord1,
+		coord2,
+		coord3,
+		coord4
+	];
+}
+
+//#endregion
+//#region geom/flagTriangle.ts
+/**
+* 三角旗标（使用两个控制点直接创建三角旗标）
+*/
+function flagTriangle(coords) {
+	const coordlength = coords.length;
+	if (coordlength < 2) throw new Error("coords.length must >= 2");
+	const [startCoord, endCoord] = coords;
+	const coord1 = [endCoord[0], (startCoord[1] + endCoord[1]) / 2];
+	const coord2 = [startCoord[0], (startCoord[1] + endCoord[1]) / 2];
+	const coord3 = [startCoord[0], endCoord[1]];
+	return [
+		startCoord,
+		coord1,
+		coord2,
+		coord3
+	];
+}
+
+//#endregion
+//#region scheme/PolygonArc.ts
+const PlotSchemePolygonArc = new PlotScheme({
+	type: "PolygonArc",
+	complete: (packable) => packable.positions.length >= 3,
+	skeletons: [moved, control],
+	initRender() {
+		return { entities: [new Entity({ polygon: {} })] };
+	},
+	render(context) {
+		const entity = context.previous.entities[0];
+		const points = context.packable.positions;
+		if (points.length < 3) context.mouse && points.push(context.mouse.clone());
+		const coords = points.map((e) => toCoord(e));
+		if (coords.length < 3) {
+			entity.polygon.hierarchy = void 0;
+			return context.previous;
+		}
+		const positions = arc(coords).map((item) => toCartesian3(item));
+		const hierarchy = new PolygonHierarchy(positions);
+		entity.polygon.hierarchy = new CallbackProperty(() => hierarchy, false);
+		return { entities: [entity] };
+	}
+});
+
+//#endregion
+//#region scheme/PolygonArrowAttackDirection.ts
+const PlotSchemePolygonArrowAttackDirection = new PlotScheme({
+	type: "PolygonArrowAttackDirection",
+	allowManualComplete: (packable) => packable.positions.length >= 3,
+	skeletons: [
+		moved,
+		control,
+		intervalNonclosed
+	],
+	initRender() {
+		return { entities: [new Entity({ polygon: {} })] };
+	},
+	render(context) {
+		const entity = context.previous.entities[0];
+		const points = context.packable.positions;
+		context.mouse && points.push(context.mouse.clone());
+		const coords = points.map((e) => toCoord(e));
+		if (coords.length < 3) {
+			entity.polygon.hierarchy = void 0;
+			return context.previous;
+		}
+		const positions = arrowAttackDirection(coords).map((item) => toCartesian3(item));
+		const hierarchy = new PolygonHierarchy(positions);
+		entity.polygon.hierarchy = new CallbackProperty(() => hierarchy, false);
+		return { entities: [entity] };
+	}
+});
+
+//#endregion
+//#region scheme/PolygonArrowAttackDirectionTailed.ts
+const PlotSchemePolygonArrowAttackDirectionTailed = new PlotScheme({
+	type: "PolygonArrowAttackDirectionTailed",
+	allowManualComplete: (packable) => packable.positions.length >= 3,
+	skeletons: [
+		moved,
+		control,
+		intervalNonclosed
+	],
+	initRender() {
+		return { entities: [new Entity({ polygon: {} })] };
+	},
+	render(context) {
+		const entity = context.previous.entities[0];
+		const points = context.packable.positions;
+		context.mouse && points.push(context.mouse.clone());
+		const coords = points.map((e) => toCoord(e));
+		if (coords.length < 3) {
+			entity.polygon.hierarchy = void 0;
+			return context.previous;
+		}
+		const positions = arrowAttackDirectionTailed(coords).map((item) => toCartesian3(item));
+		const hierarchy = new PolygonHierarchy(positions);
+		entity.polygon.hierarchy = new CallbackProperty(() => hierarchy, false);
+		return { entities: [entity] };
+	}
+});
+
+//#endregion
+//#region scheme/PolygonArrowClamped.ts
+const PlotSchemePolygonArrowClamped = new PlotScheme({
+	type: "PolygonArrowClamped",
+	complete: (packable) => packable.positions.length >= 5,
+	skeletons: [moved, control],
+	initRender() {
+		return { entities: [new Entity({ polygon: {} })] };
+	},
+	render(context) {
+		const entity = context.previous.entities[0];
+		const points = context.packable.positions;
+		if (points.length < 5) {
+			const mouse = context.mouse;
+			mouse && points.push(mouse.clone());
+		}
+		const coords = points.map((e) => toCoord(e));
+		if (coords.length >= 3) {
+			const positions = arrowClamped(coords);
+			const hierarchy = new PolygonHierarchy(positions.map((item) => toCartesian3(item)));
+			entity.polygon.hierarchy = new CallbackProperty(() => hierarchy, false);
+		} else entity.polygon.hierarchy = void 0;
+		return { entities: [entity] };
+	}
+});
+
+//#endregion
+//#region scheme/PolygonArrowStraight.ts
+const PlotSchemePolygonArrowStraight = new PlotScheme({
+	type: "PolygonArrowStraight",
+	complete: (packable) => packable.positions.length >= 2,
+	skeletons: [moved, control],
+	initRender() {
+		return { entities: [new Entity({ polygon: {} })] };
+	},
+	render(context) {
+		const entity = context.previous.entities[0];
+		const points = context.packable.positions;
+		if (points.length < 2) {
+			const mouse = context.mouse;
+			mouse && points.push(mouse.clone());
+		}
+		const coords = points.map((e) => toCoord(e));
+		if (coords.length >= 2) {
+			const positions = arrowStraight(coords);
+			const hierarchy = new PolygonHierarchy(positions.map((item) => toCartesian3(item)));
+			entity.polygon.hierarchy = new CallbackProperty(() => hierarchy, false);
+		} else entity.polygon.hierarchy = void 0;
+		return { entities: [entity] };
+	}
+});
+
+//#endregion
+//#region scheme/PolygonArrowStraightSharp.ts
+const PlotSchemePolygonArrowStraightSharp = new PlotScheme({
+	type: "PolygonArrowStraightSharp",
+	complete: (packable) => packable.positions.length >= 2,
+	skeletons: [moved, control],
+	initRender() {
+		return { entities: [new Entity({ polygon: {} })] };
+	},
+	render(context) {
+		const entity = context.previous.entities[0];
+		const points = context.packable.positions;
+		if (points.length < 2) {
+			const mouse = context.mouse;
+			mouse && points.push(mouse.clone());
+		}
+		const coords = points.map((e) => toCoord(e));
+		if (coords.length >= 2) {
+			const positions = arrowStraightSharp(coords);
+			const hierarchy = new PolygonHierarchy(positions.map((item) => toCartesian3(item)));
+			entity.polygon.hierarchy = new CallbackProperty(() => hierarchy, false);
+		} else entity.polygon.hierarchy = void 0;
+		return { entities: [entity] };
+	}
+});
+
+//#endregion
+//#region scheme/PolygonArrowUnitCombatOperation.ts
+const PlotSchemePolygonArrowUnitCombatOperation = new PlotScheme({
+	type: "PolygonArrowUnitCombatOperation",
+	allowManualComplete: (packable) => packable.positions.length >= 2,
+	skeletons: [
+		moved,
+		control,
+		intervalNonclosed
+	],
+	initRender() {
+		return { entities: [new Entity({ polygon: {} })] };
+	},
+	render(context) {
+		const entity = context.previous.entities[0];
+		const points = context.packable.positions;
+		context.mouse && points.push(context.mouse.clone());
+		const coords = points.map((e) => toCoord(e));
+		if (coords.length < 2) {
+			entity.polygon.hierarchy = void 0;
+			return context.previous;
+		}
+		const positions = arrowUnitCombatOperation(coords).map((item) => toCartesian3(item));
+		const hierarchy = new PolygonHierarchy(positions);
+		entity.polygon.hierarchy = new CallbackProperty(() => hierarchy, false);
+		return { entities: [entity] };
+	}
+});
+
+//#endregion
+//#region scheme/PolygonArrowUnitCombatOperationTailed.ts
+const PlotSchemePolygonArrowUnitCombatOperationTailed = new PlotScheme({
+	type: "PolygonArrowUnitCombatOperationTailed",
+	allowManualComplete: (packable) => packable.positions.length >= 2,
+	skeletons: [
+		moved,
+		control,
+		interval
+	],
+	initRender() {
+		return { entities: [new Entity({ polygon: {} })] };
+	},
+	render(context) {
+		const entity = context.previous.entities[0];
+		const points = context.packable.positions;
+		context.mouse && points.push(context.mouse.clone());
+		const coords = points.map((e) => toCoord(e));
+		if (coords.length < 2) {
+			entity.polygon.hierarchy = void 0;
+			return context.previous;
+		}
+		const positions = arrowUnitCombatOperationTailed(coords).map((item) => toCartesian3(item));
+		const hierarchy = new PolygonHierarchy(positions);
+		entity.polygon.hierarchy = new CallbackProperty(() => hierarchy, false);
+		return { entities: [entity] };
+	}
+});
+
+//#endregion
+//#region scheme/PolygonAssemblingPlace.ts
+const PlotSchemePolygonAssemblingPlace = new PlotScheme({
+	type: "PolygonAssemblingPlace",
+	complete: (packable) => packable.positions.length >= 3,
+	skeletons: [
+		moved,
+		control,
+		interval
+	],
+	initRender() {
+		return { entities: [new Entity({ polygon: {} })] };
+	},
+	render(context) {
+		const entity = context.previous.entities[0];
+		const points = context.packable.positions;
+		context.mouse && points.push(context.mouse.clone());
+		const coords = points.map((e) => toCoord(e));
+		if (coords.length < 2) {
+			entity.polygon.hierarchy = void 0;
+			return context.previous;
+		}
+		const positions = assemblingPlace(coords).map((item) => toCartesian3(item));
+		const hierarchy = new PolygonHierarchy(positions);
+		entity.polygon.hierarchy = new CallbackProperty(() => hierarchy, false);
+		return { entities: [entity] };
+	}
+});
+
+//#endregion
+//#region scheme/PolygonFlagCurve.ts
+const PlotSchemePolygonFlagCurve = new PlotScheme({
+	type: "PolygonFlagCurve",
+	complete: (packable) => packable.positions.length >= 2,
+	skeletons: [moved, control],
+	initRender() {
+		return { entities: [new Entity({ polygon: {} })] };
+	},
+	render(context) {
+		const entity = context.previous.entities[0];
+		const points = context.packable.positions;
+		context.mouse && points.push(context.mouse.clone());
+		const coords = points.map((e) => toCoord(e));
+		if (coords.length < 2) {
+			entity.polygon.hierarchy = void 0;
+			return context.previous;
+		}
+		const positions = flagCurve(coords).map((item) => toCartesian3(item));
+		const hierarchy = new PolygonHierarchy(positions);
+		entity.polygon.hierarchy = new CallbackProperty(() => hierarchy, false);
+		return { entities: [entity] };
+	}
+});
+
+//#endregion
+//#region scheme/PolygonFlagRect.ts
+const PlotSchemePolygonFlagRect = new PlotScheme({
+	type: "PolygonFlagRect",
+	complete: (packable) => packable.positions.length >= 2,
+	skeletons: [moved, control],
+	initRender() {
+		return { entities: [new Entity({ polygon: {} })] };
+	},
+	render(context) {
+		const entity = context.previous.entities[0];
+		const points = context.packable.positions;
+		context.mouse && points.push(context.mouse.clone());
+		const coords = points.map((e) => toCoord(e));
+		if (coords.length < 2) {
+			entity.polygon.hierarchy = void 0;
+			return context.previous;
+		}
+		const positions = flagRect(coords).map((item) => toCartesian3(item));
+		const hierarchy = new PolygonHierarchy(positions);
+		entity.polygon.hierarchy = new CallbackProperty(() => hierarchy, false);
+		return { entities: [entity] };
+	}
+});
+
+//#endregion
+//#region scheme/PolygonFlagTriangle.ts
+const PlotSchemePolygonFlagTriangle = new PlotScheme({
+	type: "PolygonFlagTriangle",
+	complete: (packable) => packable.positions.length >= 2,
+	skeletons: [moved, control],
+	initRender() {
+		return { entities: [new Entity({ polygon: {} })] };
+	},
+	render(context) {
+		const entity = context.previous.entities[0];
+		const points = context.packable.positions;
+		context.mouse && points.push(context.mouse.clone());
+		const coords = points.map((e) => toCoord(e));
+		if (coords.length < 2) {
+			entity.polygon.hierarchy = void 0;
+			return context.previous;
+		}
+		const positions = flagTriangle(coords).map((item) => toCartesian3(item));
+		const hierarchy = new PolygonHierarchy(positions);
+		entity.polygon.hierarchy = new CallbackProperty(() => hierarchy, false);
+		return { entities: [entity] };
+	}
+});
+
+//#endregion
+//#region scheme/PolygonSmooth.ts
+const PlotSchemePolygonSmooth = new PlotScheme({
+	type: "PolygonSmooth",
+	allowManualComplete: (packable) => packable.positions.length >= 3,
+	skeletons: [
+		moved,
+		control,
+		intervalNonclosed
+	],
+	initRender() {
+		return { entities: [new Entity({ polygon: {} })] };
+	},
+	render(context) {
+		const entity = context.previous.entities[0];
+		const positions = context.packable.positions;
+		const mousePosition = context.mouse;
+		mousePosition && positions.push(mousePosition.clone());
+		if (positions.length <= 2) {
+			entity.polygon.hierarchy = void 0;
+			return context.previous;
+		}
+		const wgs84s = positions.map((e) => toCoord(e));
+		wgs84s.push(wgs84s[0]);
+		const { features } = turf$1.polygonSmooth(turf$1.polygon([wgs84s]), { iterations: 3 });
+		const cartesians = features[0].geometry.coordinates[0].map((item) => toCartesian3(item)).filter((e) => !!e);
+		const hierarchy = new PolygonHierarchy(cartesians);
+		entity.polygon.hierarchy = new CallbackProperty(() => hierarchy, false);
+		return { entities: [entity] };
+	}
+});
+
+//#endregion
+//#region scheme/Polyline.ts
+const PlotSchemePolyline = new PlotScheme({
+	type: "Polyline",
+	allowManualComplete: (packable) => packable.positions.length > 1,
+	skeletons: [
+		moved,
+		control,
+		intervalNonclosed
+	],
+	initRender() {
+		return { entities: [new Entity({ polyline: {
+			material: Color.RED,
+			width: 2
+		} })] };
+	},
+	render(context) {
+		const entity = context.previous.entities[0];
+		const positions = [...context.packable.positions];
+		const mouse = context.mouse;
+		mouse && positions.push(mouse.clone());
+		const cache = positions.length >= 2 ? positions : [];
+		entity.polyline.positions = new CallbackProperty(() => cache, false);
+		return { entities: [entity] };
+	}
+});
+
+//#endregion
+//#region scheme/PolylineCurve.ts
+const PlotSchemePolylineCurve = new PlotScheme({
+	type: "PolylineCurve",
+	allowManualComplete: (packable) => packable.positions.length > 1,
+	skeletons: [
+		moved,
+		control,
+		intervalNonclosed
+	],
+	initRender() {
+		return { entities: [new Entity({ polyline: {
+			material: Color.RED,
+			width: 2
+		} })] };
+	},
+	render(context) {
+		const entity = context.previous.entities[0];
+		const positions = [...context.packable.positions];
+		const mouse = context.mouse;
+		mouse && positions.push(mouse.clone());
+		if (positions.length < 2) {
+			entity.polyline.positions = void 0;
+			return context.previous;
+		}
+		const coords = positions.map((position) => toCoord(position));
+		const { geometry: { coordinates } } = turf.bezierSpline(turf.lineString(coords));
+		entity.polyline.positions = new CallbackProperty(() => coordinates.map(toCartesian3), false);
+		return { entities: [entity] };
+	}
+});
+
+//#endregion
+//#region scheme/Rectangle.ts
+const PlotSchemeRectangle = new PlotScheme({
+	type: "Rectangle",
+	complete: (packable) => packable.positions.length >= 2,
+	skeletons: [moved, control],
+	initRender() {
+		return { entities: [new Entity({ rectangle: {} })] };
+	},
+	render(context) {
+		const entity = context.previous.entities[0];
+		const positions = [...context.packable.positions];
+		const mouse = context.mouse;
+		mouse && positions.push(mouse.clone());
+		if (positions.length < 2) {
+			entity.rectangle.coordinates = void 0;
+			return context.previous;
+		}
+		const coordinates = Rectangle.fromCartesianArray(positions ?? []);
+		entity.rectangle.coordinates = new CallbackProperty(() => coordinates, false);
+		return { entities: [entity] };
+	}
+});
+
+//#endregion
+export { PlotAction, PlotFeature, PlotScheme, PlotSchemeBillboard, PlotSchemeBillboardPinBuilder, PlotSchemeCylinder, PlotSchemeEllipse, PlotSchemeLabel, PlotSchemePoint, PlotSchemePolygon, PlotSchemePolygonArc, PlotSchemePolygonArrowAttackDirection, PlotSchemePolygonArrowAttackDirectionTailed, PlotSchemePolygonArrowClamped, PlotSchemePolygonArrowStraight, PlotSchemePolygonArrowStraightSharp, PlotSchemePolygonArrowUnitCombatOperation, PlotSchemePolygonArrowUnitCombatOperationTailed, PlotSchemePolygonAssemblingPlace, PlotSchemePolygonFlagCurve, PlotSchemePolygonFlagRect, PlotSchemePolygonFlagTriangle, PlotSchemePolygonSmooth, PlotSchemePolyline, PlotSchemePolylineCurve, PlotSchemeRectangle, PlotSkeletonEntity, SampledPlotProperty, SampledPlotStrategy, control, interval, intervalNonclosed, moved, schemeMeasureArea, schemeMeasureDistance, usePlot };
+//# sourceMappingURL=index.mjs.map