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

package/dist/index.iife.js

@@ -1,3029 +1,2006 @@
-(function(exports, cesium, vesium, __vueuse_core, vue, __turf_turf) {
+(function(exports, cesium, vesium, __vueuse_core, vue, __vesium_geometry, __turf_turf) {
 
 //#region rolldown:runtime
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
+	var __create = Object.create;
+	var __defProp = Object.defineProperty;
+	var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+	var __getOwnPropNames = Object.getOwnPropertyNames;
+	var __getProtoOf = Object.getPrototypeOf;
+	var __hasOwnProp = Object.prototype.hasOwnProperty;
+	var __copyProps = (to, from, except, desc) => {
+		if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+				get: ((k) => from[k]).bind(null, key),
+				enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+			});
+		}
+		return to;
+	};
+	var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+		value: mod,
+		enumerable: true
+	}) : target, mod));
 
 //#endregion
 cesium = __toESM(cesium);
 vesium = __toESM(vesium);
 __vueuse_core = __toESM(__vueuse_core);
 vue = __toESM(vue);
+__vesium_geometry = __toESM(__vesium_geometry);
 __turf_turf = __toESM(__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) {
-		(0, vesium.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);
-			(0, __vueuse_core.assert)(!!_scheme, `scheme ${maybeScheme} not found`);
-			return _scheme;
-		} else if (!(maybeScheme instanceof PlotScheme)) return new PlotScheme(maybeScheme);
-		else return maybeScheme;
-	}
-};
+	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) {
+			(0, vesium.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);
+				(0, __vueuse_core.assert)(!!_scheme, `scheme ${maybeScheme} not found`);
+				return _scheme;
+			} else if (!(maybeScheme instanceof PlotScheme)) return new PlotScheme(maybeScheme);
+			else return maybeScheme;
+		}
+	};
 
 //#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) => {
-	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 : cesium.Cartesian3.lerp(left, right, proportion, new cesium.Cartesian3());
-		}),
-		derivative: previous.derivative
-	};
-};
-/**
-* 标绘采样点数据。
-* 标绘采样点数据是一个时间序列数据，包含时间、位置和附带的额外数据。
-* 具体用法可参考 [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 cesium.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;
-	}
+	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;
+	}({});
 	/**
-	* @internal
-	*/
-	_definitionChanged = new cesium.Event();
-	get definitionChanged() {
-		return this._definitionChanged;
-	}
-	/**
-	* 获取时间数组
+	* 默认插值算法
 	*
-	* @returns 返回包含所有时间的 JulianDate 数组
+	* @param time 时间
+	* @param previous 前一个数据点
+	* @param next 后一个数据点
+	* @param proportion 比例
+	* @returns 插值结果
 	*/
-	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 (cesium.JulianDate.lessThan(time, start) || cesium.JulianDate.greaterThan(time, end)) switch (this.strategy) {
-			case SampledPlotStrategy.STRICT: return;
-			case SampledPlotStrategy.NEAR: {
-				time = cesium.JulianDate.lessThan(time, this._times[0]) ? this._times[0].clone() : this._times[this._times.length - 1].clone();
-				break;
-			}
-			case SampledPlotStrategy.CYCLE: {
-				const startMS = cesium.JulianDate.toDate(this._times[0]).getTime();
-				const endMS = cesium.JulianDate.toDate(this._times[this._times.length - 1]).getTime();
-				const duration = endMS - startMS;
-				const timeMS = cesium.JulianDate.toDate(time).getTime();
-				const diff = (timeMS - startMS) % duration;
-				const dete = new Date(startMS + diff);
-				time = cesium.JulianDate.fromDate(dete);
-				break;
-			}
-		}
-		const prevIndex = this._times.findIndex((t) => cesium.JulianDate.lessThanOrEquals(time, t));
-		const nextIndex = Math.min(prevIndex, this._times.length - 1);
-		const prevMs = cesium.JulianDate.toDate(this._times[prevIndex]).getTime();
-		const nextMs = cesium.JulianDate.toDate(this._times[nextIndex]).getTime();
-		const ms = cesium.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 ??= {
+	const defaultInterpolationAlgorithm = (time, previous, next, proportion) => {
+		if (proportion === 0) return {
 			time,
-			positions: []
+			positions: previous.positions?.map((item) => item.clone()),
+			derivative: previous.derivative
 		};
-		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]
+		else if (proportion === 1) return {
+			time,
+			positions: next.positions?.map((item) => item.clone()),
+			derivative: previous.derivative
 		};
-		const next = {
-			time: this._times[nextIndex],
-			positions: this._sampleds[nextIndex],
-			derivative: this._derivatives[nextIndex]
+		return {
+			time,
+			positions: next.positions?.map((right, index) => {
+				const left = previous.positions?.[index];
+				return !left ? right : cesium.Cartesian3.lerp(left, right, proportion, new cesium.Cartesian3());
+			}),
+			derivative: previous.derivative
 		};
-		const packable = (this.interpolationAlgorithm || SampledPlotProperty.defaultInterpolationAlgorithm)(time, previous, next, proportion);
-		Object.assign(result, packable);
-		return result;
-	}
+	};
 	/**
-	* 设置样本数据，如果传入的数据不含时间，则会存入时间最早的集合中
-	* @param value 样本数据对象，包含时间、位置和导数信息
+	* 标绘采样点数据。
+	* 标绘采样点数据是一个时间序列数据，包含时间、位置和附带的额外数据。
+	* 具体用法可参考 [Cesium.SampledProperty](https://cesium.com/learn/cesiumjs/ref-doc/SampledProperty.html)
 	*/
-	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) => cesium.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 (cesium.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 (cesium.JulianDate.greaterThan(time, this._times[this._times.length - 1])) {
-			this._times.push(time);
-			this._sampleds.push(positions);
-			this._derivatives.push(derivative);
+	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 cesium.JulianDate(0, 0),
+				positions: [],
+				derivative: void 0
+			});
 		}
-		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;
+		static defaultInterpolationAlgorithm = defaultInterpolationAlgorithm;
+		strategy;
+		interpolationAlgorithm;
+		/**
+		* @internal
+		*/
+		_times = [];
+		/**
+		* @internal
+		*/
+		_sampleds = [];
+		/**
+		* @internal
+		*/
+		_derivatives = [];
+		get isConstant() {
+			return this._times.length === 0;
+		}
+		/**
+		* @internal
+		*/
+		_definitionChanged = new cesium.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 (cesium.JulianDate.lessThan(time, start) || cesium.JulianDate.greaterThan(time, end)) switch (this.strategy) {
+				case SampledPlotStrategy.STRICT: return;
+				case SampledPlotStrategy.NEAR:
+					time = cesium.JulianDate.lessThan(time, this._times[0]) ? this._times[0].clone() : this._times[this._times.length - 1].clone();
+					break;
+				case SampledPlotStrategy.CYCLE: {
+					const startMS = cesium.JulianDate.toDate(this._times[0]).getTime();
+					const duration = cesium.JulianDate.toDate(this._times[this._times.length - 1]).getTime() - startMS;
+					const diff = (cesium.JulianDate.toDate(time).getTime() - startMS) % duration;
+					const dete = new Date(startMS + diff);
+					time = cesium.JulianDate.fromDate(dete);
+					break;
+				}
 			}
+			const prevIndex = this._times.findIndex((t) => cesium.JulianDate.lessThanOrEquals(time, t));
+			const nextIndex = Math.min(prevIndex, this._times.length - 1);
+			const prevMs = cesium.JulianDate.toDate(this._times[prevIndex]).getTime();
+			const nextMs = cesium.JulianDate.toDate(this._times[nextIndex]).getTime();
+			return {
+				prevIndex,
+				nextIndex,
+				proportion: (cesium.JulianDate.toDate(time).getTime() - prevMs) / (nextMs - prevMs) || 0
+			};
 		}
-		return false;
-	}
-	/**
-	* 从样本中移除指定时间间隔内的样本。
-	*
-	* @param interval 要移除样本的时间间隔
-	*/
-	removeSamples(interval$1) {
-		for (let i = 0; i < this._times.length; i++) {
-			const time = this._times[i];
-			cesium.TimeInterval.contains(interval$1, time) && this.removeSample(time);
+		/**
+		* 根据给定的儒略日期（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;
 		}
-	}
-	/**
-	* 判断两个property是否相等
-	*/
-	equals(other) {
-		return other === this;
-	}
-};
+		/**
+		* 设置样本数据，如果传入的数据不含时间，则会存入时间最早的集合中
+		* @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) => cesium.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 (cesium.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 (cesium.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);
+				if (this._times.splice(index, 1).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];
+				cesium.TimeInterval.contains(interval$1, time) && this.removeSample(time);
+			}
+		}
+		/**
+		* 判断两个property是否相等
+		*/
+		equals(other) {
+			return other === this;
+		}
+	};
 
 //#endregion
 //#region usePlot/PlotFeature.ts
 /**
-* 标绘实例
-*/
-var PlotFeature = class {
-	constructor(options) {
-		const { id, disabled = false, sampled } = options;
-		this._id = id || (0, cesium.createGuid)();
-		this._scheme = PlotScheme.resolve(options.scheme);
-		this._definitionChanged = new cesium.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;
+	var PlotFeature = class {
+		constructor(options) {
+			const { id, disabled = false, sampled } = options;
+			this._id = id || (0, cesium.createGuid)();
+			this._scheme = PlotScheme.resolve(options.scheme);
+			this._definitionChanged = new cesium.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
-	*/
-	_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;
-	}
-};
+		/**
+		* @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 cesium.Entity {
-	constructor(options) {
-		super(options);
-	}
-};
+	* 框架点执行状态枚举
+	* - 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 cesium.Entity {
+		constructor(options) {
+			super(options);
+		}
+	};
 
 //#endregion
 //#region usePlot/useRender.ts
-function useRender(plots, current, getCurrentTime) {
-	const viewer = (0, vesium.useViewer)();
-	const primitiveCollection = (0, vesium.usePrimitive)(new cesium.PrimitiveCollection());
-	const groundPrimitiveCollection = (0, vesium.usePrimitive)(new cesium.PrimitiveCollection(), { collection: "ground" });
-	const dataSource = (0, vesium.useDataSource)(new cesium.CustomDataSource());
-	const entityScope = (0, vesium.useEntityScope)({ collection: () => dataSource.value.entities });
-	const primitiveScope = (0, vesium.usePrimitiveScope)({ collection: () => primitiveCollection.value });
-	const groundPrimitiveScope = (0, vesium.usePrimitiveScope)({ collection: () => groundPrimitiveCollection.value });
-	const mouseCartesian = (0, vue.shallowRef)();
-	(0, vesium.useScreenSpaceEventHandler)(cesium.ScreenSpaceEventType.MOUSE_MOVE, (event) => {
-		mouseCartesian.value = (0, vesium.canvasCoordToCartesian)(event?.endPosition, viewer.value.scene);
-	});
-	(0, __vueuse_core.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));
+	function useRender(plots, current, getCurrentTime) {
+		const viewer = (0, vesium.useViewer)();
+		const primitiveCollection = (0, vesium.usePrimitive)(new cesium.PrimitiveCollection());
+		const groundPrimitiveCollection = (0, vesium.usePrimitive)(new cesium.PrimitiveCollection(), { collection: "ground" });
+		const dataSource = (0, vesium.useDataSource)(new cesium.CustomDataSource());
+		const entityScope = (0, vesium.useEntityScope)({ collection: () => dataSource.value.entities });
+		const primitiveScope = (0, vesium.usePrimitiveScope)({ collection: () => primitiveCollection.value });
+		const groundPrimitiveScope = (0, vesium.usePrimitiveScope)({ collection: () => groundPrimitiveCollection.value });
+		const mouseCartesian = (0, vue.shallowRef)();
+		(0, vesium.useScreenSpaceEventHandler)(cesium.ScreenSpaceEventType.MOUSE_MOVE, (event) => {
+			mouseCartesian.value = (0, vesium.canvasCoordToCartesian)(event?.endPosition, viewer.value.scene);
 		});
-		added.forEach((plot) => {
-			plot.entities.forEach((item) => entityScope.add(item));
-			plot.primitives.forEach((item) => primitiveScope.add(item));
-			plot.groundPrimitives.forEach((item) => groundPrimitiveScope.add(item));
+		(0, __vueuse_core.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"
 		});
-	}, {
-		immediate: true,
-		flush: "post"
-	});
-	(0, vesium.useCesiumEventListener)(() => plots.value.map((item) => item.definitionChanged), (_scope, key, newValue, oldValue) => {
-		if (key === "entities") {
-			const { added, removed } = (0, vesium.arrayDiff)(newValue, oldValue);
-			added.forEach((item) => entityScope.add(item));
-			removed.forEach((item) => entityScope.remove(item));
-		} else if (key === "primitives") {
-			const { added, removed } = (0, vesium.arrayDiff)(newValue, oldValue);
-			added.forEach((item) => primitiveScope.add(item));
-			removed.forEach((item) => primitiveScope.remove(item));
-		} else if (key === "groundPrimitives") {
-			const { added, removed } = (0, vesium.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
+		(0, vesium.useCesiumEventListener)(() => plots.value.map((item) => item.definitionChanged), (_scope, key, newValue, oldValue) => {
+			if (key === "entities") {
+				const { added, removed } = (0, vesium.arrayDiff)(newValue, oldValue);
+				added.forEach((item) => entityScope.add(item));
+				removed.forEach((item) => entityScope.remove(item));
+			} else if (key === "primitives") {
+				const { added, removed } = (0, vesium.arrayDiff)(newValue, oldValue);
+				added.forEach((item) => primitiveScope.add(item));
+				removed.forEach((item) => primitiveScope.remove(item));
+			} else if (key === "groundPrimitives") {
+				const { added, removed } = (0, vesium.arrayDiff)(newValue, oldValue);
+				added.forEach((item) => groundPrimitiveScope.add(item));
+				removed.forEach((item) => groundPrimitiveScope.remove(item));
 			}
 		});
-		plot.entities = reslut?.entities ?? [];
-		plot.primitives = reslut?.primitives ?? [];
-		plot.groundPrimitives = reslut?.groundPrimitives ?? [];
-	};
-	(0, vue.watch)(current, (plot, previous) => {
-		previous && update(previous);
-	});
-	(0, vesium.useCesiumEventListener)(() => plots.value.map((item) => item.definitionChanged), (plot, key) => {
-		if ([
-			"disabled",
-			"defining",
-			"scheme",
-			"sampled",
-			"time"
-		].includes(key)) update(plot);
-	});
-	(0, vue.watch)(mouseCartesian, () => {
-		plots.value.forEach((plot) => plot.defining && update(plot));
-	});
-	return {
-		primitives: (0, vue.computed)(() => Array.from(primitiveScope.scope)),
-		groundPrimitives: (0, vue.computed)(() => Array.from(primitiveScope.scope)),
-		entities: (0, vue.computed)(() => Array.from(entityScope.scope))
-	};
-}
+		const update = async (plot) => {
+			await (0, vue.nextTick)();
+			const packable = plot.sampled.getValue(getCurrentTime());
+			const mouse = plot.defining ? mouseCartesian.value : void 0;
+			const result = await plot.scheme.render?.({
+				packable,
+				mouse,
+				defining: plot.defining,
+				previous: {
+					entities: plot.entities,
+					primitives: plot.primitives,
+					groundPrimitives: plot.groundPrimitives
+				},
+				getPositions() {
+					const points = packable.positions;
+					mouse && points.push(mouse);
+					return points;
+				}
+			});
+			plot.entities = result?.entities ?? [];
+			plot.primitives = result?.primitives ?? [];
+			plot.groundPrimitives = result?.groundPrimitives ?? [];
+		};
+		(0, vue.watch)(current, (plot, previous) => {
+			previous && update(previous);
+		});
+		(0, vesium.useCesiumEventListener)(() => plots.value.map((item) => item.definitionChanged), (plot, key) => {
+			if ([
+				"disabled",
+				"defining",
+				"scheme",
+				"sampled",
+				"time"
+			].includes(key)) update(plot);
+		});
+		(0, vue.watch)(mouseCartesian, () => {
+			plots.value.forEach((plot) => plot.defining && update(plot));
+		});
+		return {
+			primitives: (0, vue.computed)(() => Array.from(primitiveScope.scope)),
+			groundPrimitives: (0, vue.computed)(() => Array.from(primitiveScope.scope)),
+			entities: (0, vue.computed)(() => Array.from(entityScope.scope))
+		};
+	}
 
 //#endregion
 //#region usePlot/useSampled.ts
-function useSampled(current, getCurrentTime) {
-	const viewer = (0, vesium.useViewer)();
-	const doubleClicking = (0, vue.ref)(false);
-	const packable = (0, vue.computed)(() => {
-		return current.value?.sampled.getValue(getCurrentTime());
-	});
-	(0, vesium.useScreenSpaceEventHandler)(cesium.ScreenSpaceEventType.LEFT_CLICK, async (ctx) => {
-		await (0, __vueuse_core.promiseTimeout)(1);
-		if (!current.value || !packable.value) return;
-		if (doubleClicking.value) return;
-		const { scheme, defining, sampled } = current.value;
-		if (!defining) return;
-		const position = (0, vesium.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);
-	});
-	(0, vesium.useScreenSpaceEventHandler)(cesium.ScreenSpaceEventType.LEFT_DOUBLE_CLICK, async (ctx) => {
-		if (!current.value || !packable.value) return;
-		doubleClicking.value = true;
-		await (0, __vueuse_core.promiseTimeout)(2);
-		doubleClicking.value = false;
-		const { scheme, defining } = current.value;
-		if (!defining) return;
-		const position = (0, vesium.canvasCoordToCartesian)(ctx.position, viewer.value.scene);
-		if (!position) return;
-		const completed = scheme.allowManualComplete?.(packable.value);
-		completed && PlotFeature.setDefining(current.value, false);
-	});
-	(0, vesium.useScreenSpaceEventHandler)(cesium.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 = (0, vue.ref)();
-	const setDefiningCursorCss = () => {
-		if (!current.value?.defining) {
-			if (definingCursorCss.value) {
-				definingCursorCss.value = void 0;
-				viewer.value.container.parentElement.style.removeProperty("cursor");
+	function useSampled(current, getCurrentTime) {
+		const viewer = (0, vesium.useViewer)();
+		const doubleClicking = (0, vue.ref)(false);
+		const packable = (0, vue.computed)(() => {
+			return current.value?.sampled.getValue(getCurrentTime());
+		});
+		(0, vesium.useScreenSpaceEventHandler)(cesium.ScreenSpaceEventType.LEFT_CLICK, async (ctx) => {
+			await (0, __vueuse_core.promiseTimeout)(1);
+			if (!current.value || !packable.value) return;
+			if (doubleClicking.value) return;
+			const { scheme, defining, sampled } = current.value;
+			if (!defining) return;
+			const position = (0, vesium.canvasCoordToCartesian)(ctx.position, viewer.value.scene);
+			if (!position) return;
+			packable.value.positions ??= [];
+			packable.value.positions.push(position);
+			sampled.setSample(packable.value);
+			scheme.complete?.(packable.value) && PlotFeature.setDefining(current.value, false);
+		});
+		(0, vesium.useScreenSpaceEventHandler)(cesium.ScreenSpaceEventType.LEFT_DOUBLE_CLICK, async (ctx) => {
+			if (!current.value || !packable.value) return;
+			doubleClicking.value = true;
+			await (0, __vueuse_core.promiseTimeout)(2);
+			doubleClicking.value = false;
+			const { scheme, defining } = current.value;
+			if (!defining) return;
+			if (!(0, vesium.canvasCoordToCartesian)(ctx.position, viewer.value.scene)) return;
+			scheme.allowManualComplete?.(packable.value) && PlotFeature.setDefining(current.value, false);
+		});
+		(0, vesium.useScreenSpaceEventHandler)(cesium.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 = (0, vue.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 = (0, vesium.isFunction)(definingCursor) ? definingCursor(packable.value) : definingCursor;
+				if (definingCursorCss.value) viewer.value?.container.parentElement.style.setProperty("cursor", definingCursorCss.value);
 			}
-		} else {
-			const definingCursor = current.value.scheme.definingCursor;
-			definingCursorCss.value = (0, vesium.isFunction)(definingCursor) ? definingCursor(packable.value) : definingCursor;
-			if (definingCursorCss.value) viewer.value?.container.parentElement.style.setProperty("cursor", definingCursorCss.value);
-		}
-	};
-	(0, vesium.useCesiumEventListener)(() => current.value?.definitionChanged, (plot, key) => {
-		if (key === "defining" || key === "sampled") setDefiningCursorCss();
-	});
-	(0, vue.watch)(current, () => setDefiningCursorCss());
-}
+		};
+		(0, vesium.useCesiumEventListener)(() => current.value?.definitionChanged, (plot, key) => {
+			if (key === "defining" || key === "sampled") setDefiningCursorCss();
+		});
+		(0, vue.watch)(current, () => setDefiningCursorCss());
+	}
 
 //#endregion
 //#region usePlot/useSkeleton.ts
-function useSkeleton(plots, current, getCurrentTime) {
-	const viewer = (0, vesium.useViewer)();
-	const dataSource = (0, vesium.useDataSource)(new cesium.CustomDataSource());
-	const entityScope = (0, vesium.useEntityScope)({ collection: () => dataSource.value.entities });
-	const hoverEntity = (0, vue.shallowRef)();
-	const activeEntity = (0, vue.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 = (0, vesium.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,
+	function useSkeleton(plots, current, getCurrentTime) {
+		const viewer = (0, vesium.useViewer)();
+		const dataSource = (0, vesium.useDataSource)(new cesium.CustomDataSource());
+		const entityScope = (0, vesium.useEntityScope)({ collection: () => dataSource.value.entities });
+		const hoverEntity = (0, vue.shallowRef)();
+		const activeEntity = (0, vue.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;
+				plot.scheme.skeletons.forEach((skeleton) => {
+					if ((0, vesium.isFunction)(skeleton.disabled) ? skeleton.disabled({
 						active,
-						index,
-						packable,
-						positions,
-						position,
-						action: getPointAction(entity)
+						defining
+					}) : skeleton.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);
 					});
-					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 } = (0, vesium.useGraphicEvent)();
-	(0, vue.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;
+			}
+			plot.skeletons = entities;
+		};
+		const graphicEvent = (0, vesium.useGraphicEvent)();
+		(0, vue.watchEffect)((onCleanup) => {
+			onCleanup(graphicEvent.add("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 (0, vesium.isFunction)(skeleton?.cursor) ? skeleton.cursor(pick) : (0, vue.toValue)(skeleton?.cursor);
+					}
+				},
+				dragCursor: ({ pick }) => {
+					if (!current.value?.defining && entityScope.scope.has(pick.id)) {
+						const skeleton = pick.id.skeleton;
+						return (0, vesium.isFunction)(skeleton?.dragCursor) ? skeleton.dragCursor(pick) : (0, vue.toValue)(skeleton?.dragCursor);
+					}
+				}
+			}));
+		});
+		(0, __vueuse_core.onKeyStroke)((keyEvent) => {
+			if (activeEntity.value) {
+				const entity = activeEntity.value;
 				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?.({
+				skeleton.onKeyPressed?.({
 					viewer: viewer.value,
 					sampled: plot.sampled,
 					packable,
-					active: current.value === plot,
 					index,
-					event,
-					dragging,
-					lockCamera
+					keyEvent
 				});
-			} else activeEntity.value = void 0;
-		}, {
-			cursor: ({ pick }) => {
-				if (!current.value?.defining && entityScope.scope.has(pick.id)) {
-					const skeleton = pick.id.skeleton;
-					return (0, vesium.isFunction)(skeleton?.cursor) ? skeleton.cursor(pick) : (0, vue.toValue)(skeleton?.cursor);
-				}
-			},
-			dragCursor: ({ pick }) => {
-				if (!current.value?.defining && entityScope.scope.has(pick.id)) {
-					const skeleton = pick.id.skeleton;
-					return (0, vesium.isFunction)(skeleton?.dragCursor) ? skeleton.dragCursor(pick) : (0, vue.toValue)(skeleton?.dragCursor);
-				}
 			}
 		});
-		onCleanup(remove);
-	});
-	(0, __vueuse_core.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
-			});
-		}
-	});
-	(0, vue.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;
+		(0, vue.watchEffect)((onCleanup) => {
+			onCleanup(graphicEvent.add("global", "HOVER", ({ hovering, pick }) => {
+				if (hovering && pick.id instanceof PlotSkeletonEntity && entityScope.scope.has(pick.id)) hoverEntity.value = pick.id;
+				else hoverEntity.value = void 0;
+			}));
 		});
-		onCleanup(remove);
-	});
-	(0, vue.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;
+		(0, vue.watchEffect)((onCleanup) => {
+			onCleanup(graphicEvent.add("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);
-	});
-	(0, __vueuse_core.watchArray)(plots, (value, oldValue, added, removed = []) => {
-		added.forEach((plot) => update(plot));
-		removed.forEach((plot) => update(plot, true));
-	});
-	(0, vesium.useCesiumEventListener)(() => plots.value.map((plot) => plot.definitionChanged), (plot, key, newValue, oldValue) => {
-		if ([
-			"disabled",
-			"defining",
-			"scheme",
-			"sampled",
-			"time"
-		].includes(key)) (0, vue.nextTick)(() => update(plot));
-		else if (key === "skeletons") {
-			const { added, removed } = (0, vesium.arrayDiff)(newValue, oldValue);
-			added.forEach((item) => entityScope.add(item));
-			removed.forEach((item) => entityScope.remove(item));
-		}
-	});
-	(0, vue.watch)(current, (plot, previous) => {
-		plot && update(plot);
-		previous && update(previous);
-	});
-	return { dataSource };
-}
+		(0, __vueuse_core.watchArray)(plots, (value, oldValue, added, removed = []) => {
+			added.forEach((plot) => update(plot));
+			removed.forEach((plot) => update(plot, true));
+		});
+		(0, vesium.useCesiumEventListener)(() => plots.value.map((plot) => plot.definitionChanged), (plot, key, newValue, oldValue) => {
+			if ([
+				"disabled",
+				"defining",
+				"scheme",
+				"sampled",
+				"time"
+			].includes(key)) (0, vue.nextTick)(() => update(plot));
+			else if (key === "skeletons") {
+				const { added, removed } = (0, vesium.arrayDiff)(newValue, oldValue);
+				added.forEach((item) => entityScope.add(item));
+				removed.forEach((item) => entityScope.remove(item));
+			}
+		});
+		(0, vue.watch)(current, (plot, previous) => {
+			plot && update(plot);
+			previous && update(previous);
+		});
+		return { dataSource };
+	}
 
 //#endregion
 //#region usePlot/usePlot.ts
-function usePlot(options) {
-	const time = options?.time || (0, vue.shallowRef)();
-	const viewer = (0, vesium.useViewer)();
-	const getCurrentTime = () => {
-		return time.value?.clone() || new cesium.JulianDate(0, 0);
-	};
-	const collection = (0, vue.shallowReactive)(/* @__PURE__ */ new Set());
-	const plots = (0, vue.computed)(() => Array.from(collection));
-	const current = (0, vue.shallowRef)();
-	const packable = (0, vue.shallowRef)();
-	(0, vesium.useCesiumEventListener)([() => current.value?.sampled.definitionChanged], () => {
-		packable.value = current.value?.sampled.getValue(getCurrentTime());
-	});
-	useSampled(current, getCurrentTime);
-	useRender(plots, current, getCurrentTime);
-	useSkeleton(plots, current, getCurrentTime);
-	(0, vesium.useScreenSpaceEventHandler)(cesium.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) => (0, vesium.pickHitGraphic)(pick, [
-			...plot.entities,
-			...plot.primitives,
-			...plot.groundPrimitives
-		]));
-	});
-	let operateResolve;
-	let operateReject;
-	(0, vue.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);
+	function usePlot(options) {
+		const time = options?.time || (0, vue.shallowRef)();
+		const viewer = (0, vesium.useViewer)();
+		const getCurrentTime = () => {
+			return time.value?.clone() || new cesium.JulianDate(0, 0);
+		};
+		const collection = (0, vue.shallowReactive)(/* @__PURE__ */ new Set());
+		const plots = (0, vue.computed)(() => Array.from(collection));
+		const current = (0, vue.shallowRef)();
+		const packable = (0, vue.shallowRef)();
+		(0, vesium.useCesiumEventListener)([() => current.value?.sampled.definitionChanged], () => {
+			packable.value = current.value?.sampled.getValue(getCurrentTime());
+		});
+		useSampled(current, getCurrentTime);
+		useRender(plots, current, getCurrentTime);
+		useSkeleton(plots, current, getCurrentTime);
+		(0, vesium.useScreenSpaceEventHandler)(cesium.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;
 			}
-		}
-	});
-	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);
+			current.value = plots.value.find((plot) => (0, vesium.pickHitGraphic)(pick, [
+				...plot.entities,
+				...plot.primitives,
+				...plot.groundPrimitives
+			]));
 		});
-	};
-	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
-	};
-}
+		let operateResolve;
+		let operateReject;
+		(0, vue.watch)(current, (plot, previous) => {
+			if (previous) {
+				if (previous.defining) {
+					const packable$1 = previous.sampled.getValue(getCurrentTime());
+					if (previous.scheme.allowManualComplete?.(packable$1)) {
+						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 = (0, vesium.canvasCoordToCartesian)(event.endPosition, viewer.scene);
-			if (position) {
+	* 绘制控制的框架点，拖拽时，将更新该控制点的实时位置
+	*/
+	function control() {
+		return {
+			disabled: ({ active }) => !active,
+			cursor: "pointer",
+			dragCursor: "crosshair",
+			onDrag({ viewer, sampled, packable, event, index, lockCamera }) {
+				lockCamera();
+				const position = (0, vesium.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 = (0, vesium.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 ?? []];
-				positions[index] = position;
+				const cartographic = (0, vesium.toCartographic)(positions[index]);
+				const distance$1 = height / 1e5 * Math.PI / 180 / 1e3;
+				cartographic.latitude += distance$1 * Math.cos(newHeading);
+				cartographic.longitude += distance$1 * Math.sin(newHeading);
+				positions[index] = (0, vesium.toCartesian3)(cartographic);
 				sampled.setSample({
 					time: packable.time,
 					derivative: packable.derivative,
 					positions
 				});
+			},
+			render: ({ position, action }) => {
+				return {
+					position,
+					point: {
+						pixelSize: 8,
+						color: {
+							[PlotAction.IDLE]: cesium.Color.BLUE.withAlpha(.4),
+							[PlotAction.HOVER]: cesium.Color.BLUE.withAlpha(.6),
+							[PlotAction.ACTIVE]: cesium.Color.AQUA.withAlpha(1)
+						}[action],
+						disableDepthTestDistance: Number.POSITIVE_INFINITY,
+						outlineWidth: 1,
+						outlineColor: cesium.Color.WHITE.withAlpha(.4)
+					}
+				};
 			}
-		},
-		onKeyPressed({ viewer, keyEvent, sampled, packable, index }) {
-			const height = (0, vesium.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 = (0, vesium.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] = (0, vesium.toCartesian3)(cartographic);
-			sampled.setSample({
-				time: packable.time,
-				derivative: packable.derivative,
-				positions
-			});
-		},
-		render: ({ position, action }) => {
-			const colors = {
-				[PlotAction.IDLE]: cesium.Color.BLUE.withAlpha(.4),
-				[PlotAction.HOVER]: cesium.Color.BLUE.withAlpha(.6),
-				[PlotAction.ACTIVE]: cesium.Color.AQUA.withAlpha(1)
-			};
-			return {
-				position,
-				point: {
-					pixelSize: 8,
-					color: colors[action],
-					disableDepthTestDistance: Number.POSITIVE_INFINITY,
-					outlineWidth: 1,
-					outlineColor: cesium.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 cesium.Cartesian3.midpoint(position, next, new cesium.Cartesian3());
-			});
-		},
-		onDrag({ viewer, sampled, packable, event, index, lockCamera, dragging }) {
-			lockCamera();
-			const position = (0, vesium.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]: cesium.Color.GREEN.withAlpha(.4),
-				[PlotAction.HOVER]: cesium.Color.GREEN.withAlpha(.6),
-				[PlotAction.ACTIVE]: cesium.Color.GREEN.withAlpha(1)
-			};
-			return {
-				position,
-				point: {
-					pixelSize: 6,
-					color: colors[action],
-					disableDepthTestDistance: Number.POSITIVE_INFINITY,
-					outlineWidth: 1,
-					outlineColor: cesium.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(cesium.Cartesian3.midpoint(_positions[i], _positions[i + 1], new cesium.Cartesian3()));
-			return midpoints;
-		},
-		onDrag({ viewer, sampled, packable, event, index, lockCamera, dragging }) {
-			lockCamera();
-			const position = (0, vesium.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]: cesium.Color.GREEN.withAlpha(.4),
-				[PlotAction.HOVER]: cesium.Color.GREEN.withAlpha(.6),
-				[PlotAction.ACTIVE]: cesium.Color.GREEN.withAlpha(1)
-			};
-			return {
-				position,
-				point: {
-					pixelSize: 6,
-					color: colors[action],
-					disableDepthTestDistance: Number.POSITIVE_INFINITY,
-					outlineWidth: 1,
-					outlineColor: cesium.Color.WHITE.withAlpha(.4)
-				}
-			};
-		}
-	};
-}
-
-//#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 = cesium.Rectangle.center(cesium.Rectangle.fromCartesianArray(positions));
-				return [(0, vesium.toCartesian3)(center)];
+	* 绘制封闭的间隔框架点，如多边形。拖拽时，会在两点之间插入一个控制点，并持续拖拽该点。
+	*/
+	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 cesium.Cartesian3.midpoint(position, next, new cesium.Cartesian3());
+				});
+			},
+			onDrag({ viewer, sampled, packable, event, index, lockCamera, dragging }) {
+				lockCamera();
+				const position = (0, vesium.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;
+				return {
+					position,
+					point: {
+						pixelSize: 6,
+						color: {
+							[PlotAction.IDLE]: cesium.Color.GREEN.withAlpha(.4),
+							[PlotAction.HOVER]: cesium.Color.GREEN.withAlpha(.6),
+							[PlotAction.ACTIVE]: cesium.Color.GREEN.withAlpha(1)
+						}[action],
+						disableDepthTestDistance: Number.POSITIVE_INFINITY,
+						outlineWidth: 1,
+						outlineColor: cesium.Color.WHITE.withAlpha(.4)
+					}
+				};
 			}
-		},
-		onDrag({ viewer, sampled, packable, event, lockCamera, dragging }) {
-			dragging && lockCamera();
-			const startPosition = (0, vesium.canvasCoordToCartesian)(event.startPosition, viewer.scene);
-			const endPosition = (0, vesium.canvasCoordToCartesian)(event.endPosition, viewer.scene);
-			if (!startPosition || !endPosition) return;
-			const offset = cesium.Cartesian3.subtract(endPosition, startPosition, new cesium.Cartesian3());
-			const positions = [...packable.positions ?? []];
-			sampled.setSample({
-				time: packable.time,
-				derivative: packable.derivative,
-				positions: positions.map((position) => cesium.Cartesian3.add(position, offset, new cesium.Cartesian3()))
-			});
-		},
-		render: ({ position, action }) => {
-			const colors = {
-				[PlotAction.IDLE]: cesium.Color.WHITE,
-				[PlotAction.HOVER]: cesium.Color.WHITE,
-				[PlotAction.ACTIVE]: cesium.Color.AQUA.withAlpha(1)
-			};
-			return {
-				position,
-				billboard: {
-					image: svg,
-					width: 20,
-					height: 20,
-					color: colors[action],
-					pixelOffset: new cesium.Cartesian3(0, -20),
-					horizontalOrigin: cesium.HorizontalOrigin.CENTER,
-					verticalOrigin: cesium.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 = cesium.CoplanarPolygonGeometry.createGeometry(cesium.CoplanarPolygonGeometry.fromPositions({
-		positions,
-		vertexFormat: cesium.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 = cesium.Cartesian3.unpack(values, indices[i] * 3, new cesium.Cartesian3());
-		const b = cesium.Cartesian3.unpack(values, indices[i + 1] * 3, new cesium.Cartesian3());
-		const c = cesium.Cartesian3.unpack(values, indices[i + 2] * 3, new cesium.Cartesian3());
-		result.push([
-			a,
-			b,
-			c
-		]);
-	}
-	return result;
-}
-
-//#endregion
-//#region measure/utils/clampToGround.ts
-/**
-* 将传入的点位列表进行贴地处理,若某个点位获取高程失败则将此进行克隆返回
-* @param options - 配置项
-*/
-async function clampToHeightMostDetailedByTilesetOrTerrain(options) {
-	const { positions, scene, classificationType = cesium.ClassificationType.BOTH, terrainProvider = scene.terrainProvider } = options;
-	const tileset = [cesium.ClassificationType.BOTH, cesium.ClassificationType.CESIUM_3D_TILE].includes(classificationType);
-	const terrain = [cesium.ClassificationType.BOTH, cesium.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) (0, cesium.sampleTerrainMostDetailed)(terrainProvider, positions.map((e) => cesium.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] ? cesium.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 ?? cesium.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 = cesium.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 = cesium.PolygonGeometry.fromPositions({
-		positions,
-		vertexFormat: cesium.PerInstanceColorAppearance.FLAT_VERTEX_FORMAT,
-		granularity
-	});
-	const geometry = cesium.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 = cesium.Cartesian3.unpack(values, indices[i] * 3, new cesium.Cartesian3());
-		const b = cesium.Cartesian3.unpack(values, indices[i + 1] * 3, new cesium.Cartesian3());
-		const c = cesium.Cartesian3.unpack(values, indices[i + 2] * 3, new cesium.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 = cesium.Cartesian3.subtract(p0, p1, new cesium.Cartesian3());
-	const v1 = cesium.Cartesian3.subtract(p2, p1, new cesium.Cartesian3());
-	const cross = cesium.Cartesian3.cross(v0, v1, v0);
-	return cesium.Cartesian3.magnitude(cross) * .5;
-}
-function defaultOptions$1(original) {
-	const clampToGround = original?.clampToGround ?? false;
-	const classificationType = original?.classificationType ?? cesium.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, 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 = cesium.Cartesian3.lerp(start, end, 1 / count, new cesium.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 ?? cesium.ClassificationType.BOTH;
-	const density = Math.floor(original?.density ?? 50);
-	return {
-		scene: original?.scene,
-		clampToGround,
-		classificationType,
-		terrainProvider: original?.terrainProvider,
-		density
-	};
-}
+//#region skeleton/intervalNonclosed.ts
 /**
-* 计算多点位之间的距离
-* @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 = cesium.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],
-	initRender() {
-		return { entities: [new cesium.Entity({
-			label: { font: "14pt" },
-			polyline: { material: cesium.Color.YELLOW.withAlpha(.5) },
-			polygon: { material: cesium.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 cesium.CallbackProperty(() => positions, false);
-		} else if (positions.length >= 3) {
-			positions.push(positions[0]);
-			entity.position = new cesium.ConstantPositionProperty((0, vesium.toCartesian3)(cesium.Rectangle.center(cesium.Rectangle.fromCartesianArray(positions))));
-			entity.label.text = new cesium.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 cesium.ConstantProperty(text);
-			});
-			entity.polyline.positions = void 0;
-			entity.polygon.hierarchy = new cesium.CallbackProperty(() => {
-				return positions.length >= 3 ? new cesium.PolygonHierarchy([...positions]) : void 0;
-			}, false);
-		} else {
-			entity.position = void 0;
-			entity.polygon.hierarchy = void 0;
-			entity.polyline.positions = void 0;
-		}
-		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 cesium.Entity({ polyline: {
-			width: 2,
-			material: cesium.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 cesium.PolylineGraphics();
-		pl.polyline.positions = new cesium.CallbackProperty(() => positions, false);
-		positions.forEach((item, index) => {
-			if (!entities[index + 1]) entities[index + 1] = new cesium.Entity({
-				position: item,
-				label: new cesium.LabelGraphics({
-					backgroundColor: cesium.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 cesium.CallbackPositionProperty(() => cesium.Cartesian3.midpoint(positions[index], positions[index + 1], new cesium.Cartesian3()), false);
-				entities[index + 1].label.text = new cesium.CallbackProperty(() => `${stage.toFixed(2)} m`, false);
-			});
-			if (stages.length > 1) {
-				entities[entities.length - 1].position = new cesium.CallbackPositionProperty(() => positions[positions.length - 1], false);
-				entities[entities.length - 1].label.text = new cesium.CallbackProperty(() => `${count.toFixed(2)} m`, false);
-			} else {
-				entities[entities.length - 1].position = void 0;
-				entities[entities.length - 1].label.text = void 0;
-			}
-		});
-		return { entities };
-	}
-});
-
-//#endregion
-//#region scheme/Billboard.ts
-const PlotSchemeBillboard = new PlotScheme({
-	type: "Billboard",
-	complete: (packable) => packable.positions.length >= 1,
-	skeletons: [moved],
-	initRender: () => {
-		return { entities: [new cesium.Entity({ billboard: {
-			image: "/favicon.svg",
-			width: 32,
-			height: 32
-		} })] };
-	},
-	render(options) {
-		const { mouse, packable } = options;
-		const entity = options.previous.entities?.[0] ?? new cesium.Entity({ billboard: {} });
-		const position = packable.positions?.[0] ?? mouse;
-		entity.position = new cesium.CallbackPositionProperty(() => position, true);
-		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 cesium.Entity({ billboard: {} })] };
-	},
-	render(context) {
-		const entity = context.previous.entities[0];
-		const position = context.packable.positions[0] ?? context.mouse;
-		entity.position = new cesium.CallbackPositionProperty(() => position, true);
-		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 cesium.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 cesium.ConstantPositionProperty(positions[0]);
-		const radius = cesium.Cartesian3.distance(positions[0], positions[1]);
-		entity.cylinder.bottomRadius = new cesium.CallbackProperty(() => radius, false);
-		if (context.defining || !(0, vesium.toPropertyValue)(entity.cylinder.length)) entity.cylinder.length = (0, vesium.toProperty)(radius * 2);
-		return { entities: [entity] };
-	}
-});
-
-//#endregion
-//#region scheme/Ellipse.ts
-const PlotSchemeEllipse = new PlotScheme({
-	type: "Ellipse",
-	complete: (packable) => packable.positions.length >= 2,
-	skeletons: [moved, control],
-	initRender() {
-		return { entities: [new cesium.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 cesium.ConstantPositionProperty(positions[0]);
-		const radius = cesium.Cartesian3.distance(positions[0], positions[1]);
-		entity.ellipse.semiMinorAxis = new cesium.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 cesium.Entity({ label: { text: "Label" } })] };
-	},
-	render(context) {
-		const entity = context.previous.entities[0];
-		const position = context.packable.positions[0] ?? context.mouse;
-		entity.position = new cesium.CallbackPositionProperty(() => position, true);
-		return { entities: [entity] };
+	* 绘制非封闭的间隔框架点，如线段。拖拽时，会在两点之间插入一个控制点，并持续拖拽该点。
+	*/
+	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(cesium.Cartesian3.midpoint(_positions[i], _positions[i + 1], new cesium.Cartesian3()));
+				return midpoints;
+			},
+			onDrag({ viewer, sampled, packable, event, index, lockCamera, dragging }) {
+				lockCamera();
+				const position = (0, vesium.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 }) => {
+				return {
+					position,
+					point: {
+						pixelSize: 6,
+						color: {
+							[PlotAction.IDLE]: cesium.Color.GREEN.withAlpha(.4),
+							[PlotAction.HOVER]: cesium.Color.GREEN.withAlpha(.6),
+							[PlotAction.ACTIVE]: cesium.Color.GREEN.withAlpha(1)
+						}[action],
+						disableDepthTestDistance: Number.POSITIVE_INFINITY,
+						outlineWidth: 1,
+						outlineColor: cesium.Color.WHITE.withAlpha(.4)
+					}
+				};
+			}
+		};
 	}
-});
 
 //#endregion
-//#region scheme/Point.ts
-const PlotSchemePoint = new PlotScheme({
-	type: "Point",
-	complete: (packable) => packable.positions.length >= 1,
-	skeletons: [moved],
-	initRender() {
-		return { entities: [new cesium.Entity({ point: {
-			pixelSize: 10,
-			color: cesium.Color.RED
-		} })] };
-	},
-	render(context) {
-		const entity = context.previous.entities[0];
-		const position = context.packable.positions[0] ?? context.mouse;
-		entity.position = new cesium.CallbackPositionProperty(() => position, true);
-		return { entities: [entity] };
+//#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 return [(0, vesium.toCartesian3)(cesium.Rectangle.center(cesium.Rectangle.fromCartesianArray(positions)))];
+			},
+			onDrag({ viewer, sampled, packable, event, lockCamera, dragging }) {
+				dragging && lockCamera();
+				const startPosition = (0, vesium.canvasCoordToCartesian)(event.startPosition, viewer.scene);
+				const endPosition = (0, vesium.canvasCoordToCartesian)(event.endPosition, viewer.scene);
+				if (!startPosition || !endPosition) return;
+				const offset = cesium.Cartesian3.subtract(endPosition, startPosition, new cesium.Cartesian3());
+				const positions = [...packable.positions ?? []];
+				sampled.setSample({
+					time: packable.time,
+					derivative: packable.derivative,
+					positions: positions.map((position) => cesium.Cartesian3.add(position, offset, new cesium.Cartesian3()))
+				});
+			},
+			render: ({ position, action }) => {
+				return {
+					position,
+					billboard: {
+						image: svg,
+						width: 20,
+						height: 20,
+						color: {
+							[PlotAction.IDLE]: cesium.Color.WHITE,
+							[PlotAction.HOVER]: cesium.Color.WHITE,
+							[PlotAction.ACTIVE]: cesium.Color.AQUA.withAlpha(1)
+						}[action],
+						pixelOffset: new cesium.Cartesian3(0, -20),
+						horizontalOrigin: cesium.HorizontalOrigin.CENTER,
+						verticalOrigin: cesium.VerticalOrigin.BOTTOM,
+						disableDepthTestDistance: Number.POSITIVE_INFINITY
+					}
+				};
+			}
+		};
 	}
-});
 
 //#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 cesium.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 cesium.CallbackProperty(() => positions, false);
-		} else if (positions.length >= 3) {
-			entity.polyline.positions = void 0;
-			entity.polygon.hierarchy = new cesium.CallbackProperty(() => {
-				positions.push(positions[0]);
-				return positions.length >= 3 ? new cesium.PolygonHierarchy([...positions]) : void 0;
-			}, false);
-		} else {
-			entity.polygon.hierarchy = void 0;
-			entity.polyline.positions = void 0;
+//#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 = cesium.CoplanarPolygonGeometry.createGeometry(cesium.CoplanarPolygonGeometry.fromPositions({
+			positions,
+			vertexFormat: cesium.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 = cesium.Cartesian3.unpack(values, indices[i] * 3, new cesium.Cartesian3());
+			const b = cesium.Cartesian3.unpack(values, indices[i + 1] * 3, new cesium.Cartesian3());
+			const c = cesium.Cartesian3.unpack(values, indices[i + 2] * 3, new cesium.Cartesian3());
+			result.push([
+				a,
+				b,
+				c
+			]);
 		}
-		return { entities: [entity] };
+		return result;
 	}
-});
 
 //#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;
-}
+//#region measure/utils/clampToGround.ts
 /**
-* 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];
+	* 将传入的点位列表进行贴地处理,若某个点位获取高程失败则将此进行克隆返回
+	* @param options - 配置项
+	*/
+	async function clampToHeightMostDetailedByTilesetOrTerrain(options) {
+		const { positions, scene, classificationType = cesium.ClassificationType.BOTH, terrainProvider = scene.terrainProvider } = options;
+		const tileset = [cesium.ClassificationType.BOTH, cesium.ClassificationType.CESIUM_3D_TILE].includes(classificationType);
+		const terrain = [cesium.ClassificationType.BOTH, cesium.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) (0, cesium.sampleTerrainMostDetailed)(terrainProvider, positions.map((e) => cesium.Cartographic.fromCartesian(e))).then((e) => resolve(e)).catch((error) => {
+				console.warn(error);
+				resolve([]);
+			});
+			else resolve([]);
+		});
+		const [tilesetPositions, terrainPositions] = await Promise.all([tilesetPromise, terrainPromise]);
+		const results = [];
+		positions.forEach((item, index) => {
+			const position = tilesetPositions[index] || terrainPositions[index] ? cesium.Ellipsoid.WGS84.cartographicToCartesian(terrainPositions[index]) : item.clone();
+			results.push(position);
+		});
+		return results;
 	}
-	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];
+
+//#endregion
+//#region measure/utils/triangleGrid.ts
+	function defaultOptions$2(original) {
+		const clampToGround = original?.clampToGround ?? false;
+		const classificationType = original?.classificationType ?? cesium.ClassificationType.BOTH;
+		const density = Math.floor(original?.density ?? 10);
+		return {
+			scene: original?.scene,
+			clampToGround,
+			classificationType,
+			terrainProvider: original?.terrainProvider,
+			density
+		};
 	}
-	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];
+	/**
+	* 生成三角网数组
+	* @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 = cesium.Rectangle.fromCartesianArray(positions);
+		const vertical = bbox.north - bbox.south;
+		const horizontal = bbox.east - bbox.west;
+		const granularity = Math.max(horizontal, vertical) / density;
+		const polygonGeometry = cesium.PolygonGeometry.fromPositions({
+			positions,
+			vertexFormat: cesium.PerInstanceColorAppearance.FLAT_VERTEX_FORMAT,
+			granularity
+		});
+		const geometry = cesium.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 = cesium.Cartesian3.unpack(values, indices[i] * 3, new cesium.Cartesian3());
+			const b = cesium.Cartesian3.unpack(values, indices[i + 1] * 3, new cesium.Cartesian3());
+			const c = cesium.Cartesian3.unpack(values, indices[i + 2] * 3, new cesium.Cartesian3());
+			cartesian3List.push(a, b, c);
 		}
-		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];
+		if (clampToGround) {
+			if (!scene) throw new Error("scene is required on `clampToGround == true`.");
+			cartesian3List = await clampToHeightMostDetailedByTilesetOrTerrain({
+				scene,
+				terrainProvider,
+				positions: cartesian3List,
+				classificationType
+			});
 		}
-		bSplineCoords.push([x, y]);
+		const grid = [];
+		while (cartesian3List?.length) {
+			const [a, b, c] = cartesian3List.splice(0, 3);
+			grid.push([
+				a,
+				b,
+				c
+			]);
+		}
+		return grid;
 	}
-	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
+//#region measure/utils/area.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);
+	* 计算三维坐标系下三角形面积
+	* @param p0 - 三角形第一个点
+	* @param p1 - 三角形第二个点
+	* @param p2 - 三角形第三个点
+	*/
+	function triangleArea(p0, p1, p2) {
+		const v0 = cesium.Cartesian3.subtract(p0, p1, new cesium.Cartesian3());
+		const v1 = cesium.Cartesian3.subtract(p2, p1, new cesium.Cartesian3());
+		const cross = cesium.Cartesian3.cross(v0, v1, v0);
+		return cesium.Cartesian3.magnitude(cross) * .5;
+	}
+	function defaultOptions$1(original) {
+		const clampToGround = original?.clampToGround ?? false;
+		const classificationType = original?.classificationType ?? cesium.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, scene, clampToGround, classificationType, terrainProvider } = defaultOptions$1(options);
+		if (density <= 0) throw new Error("options.density must > 0");
+		if (!clampToGround) return tesselate(positions).reduce((count, current) => count += triangleArea(...current), 0);
+		return (await triangleGrid(positions, {
+			density,
+			scene,
+			clampToGround,
+			classificationType,
+			terrainProvider
+		})).reduce((count, current) => count += triangleArea(...current), 0);
 	}
-}
 
 //#endregion
-//#region geom/arrowAttackDirection.ts
+//#region measure/utils/lerpArray.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];
+	* 在起点和终点间进行插值, 返回的数组包括起点和终点，数组长度为 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 = cesium.Cartesian3.lerp(start, end, 1 / count, new cesium.Cartesian3());
+			result.push(position);
 		}
-		const midTail = mid(tailLeft, tailRight);
-		const boneCoords = [midTail].concat(coords.slice(2));
-		const headCoords = getArrowHeadCoords(boneCoords, {
-			tailLeft,
-			tailRight,
-			...options
+		result.push(end.clone());
+		if (!clampToGround) return result;
+		if (!scene) throw new Error("scene is required on `clampToGround == true`.");
+		return await clampToHeightMostDetailedByTilesetOrTerrain({
+			scene,
+			terrainProvider,
+			positions: result,
+			classificationType
 		});
-		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];
+//#region measure/utils/distance.ts
+	function defaultOptions(original) {
+		const clampToGround = original?.clampToGround ?? false;
+		const classificationType = original?.classificationType ?? cesium.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 = cesium.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 stagePromises = (await Promise.all(positionListPromises)).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)
+		};
 	}
-	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);
-	}
-}
+//#region measure/measureArea.ts
+	const schemeMeasureArea = new PlotScheme({
+		type: "MeasureArea",
+		allowManualComplete: (packable) => packable.positions.length >= 3,
+		skeletons: [control, interval],
+		initRender() {
+			return { entities: [new cesium.Entity({
+				label: { font: "14pt" },
+				polyline: { material: cesium.Color.YELLOW.withAlpha(.5) },
+				polygon: { material: cesium.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 cesium.CallbackProperty(() => positions, false);
+			} else if (positions.length >= 3) {
+				positions.push(positions[0]);
+				entity.position = new cesium.ConstantPositionProperty((0, vesium.toCartesian3)(cesium.Rectangle.center(cesium.Rectangle.fromCartesianArray(positions))));
+				entity.label.text = new cesium.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 cesium.ConstantProperty(text);
+				});
+				entity.polyline.positions = void 0;
+				entity.polygon.hierarchy = new cesium.CallbackProperty(() => {
+					return positions.length >= 3 ? new cesium.PolygonHierarchy([...positions]) : void 0;
+				}, false);
+			} else {
+				entity.position = void 0;
+				entity.polygon.hierarchy = void 0;
+				entity.polyline.positions = void 0;
+			}
+			return { entities: [entity] };
+		}
+	});
 
 //#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;
-}
+//#region measure/measureDistance.ts
+	const schemeMeasureDistance = new PlotScheme({
+		type: "MeasureDistance",
+		allowManualComplete: (packable) => packable.positions.length >= 2,
+		skeletons: [control],
+		initRender() {
+			return { entities: [new cesium.Entity({ polyline: {
+				width: 2,
+				material: cesium.Color.YELLOW.withAlpha(.5)
+			} })] };
+		},
+		render(context) {
+			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 cesium.PolylineGraphics();
+			pl.polyline.positions = new cesium.CallbackProperty(() => positions, false);
+			positions.forEach((item, index) => {
+				if (!entities[index + 1]) entities[index + 1] = new cesium.Entity({
+					position: item,
+					label: new cesium.LabelGraphics({
+						backgroundColor: cesium.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 cesium.CallbackPositionProperty(() => cesium.Cartesian3.midpoint(positions[index], positions[index + 1], new cesium.Cartesian3()), false);
+					entities[index + 1].label.text = new cesium.CallbackProperty(() => `${stage.toFixed(2)} m`, false);
+				});
+				if (stages.length > 1) {
+					entities[entities.length - 1].position = new cesium.CallbackPositionProperty(() => positions[positions.length - 1], false);
+					entities[entities.length - 1].label.text = new cesium.CallbackProperty(() => `${count.toFixed(2)} m`, false);
+				} else {
+					entities[entities.length - 1].position = void 0;
+					entities[entities.length - 1].label.text = void 0;
+				}
+			});
+			return { entities };
+		}
+	});
 
 //#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
+//#region scheme/Billboard.ts
+	const PlotSchemeBillboard = new PlotScheme({
+		type: "Billboard",
+		complete: (packable) => packable.positions.length >= 1,
+		skeletons: [moved],
+		initRender: () => {
+			return { entities: [new cesium.Entity({ billboard: {
+				image: "/favicon.svg",
+				width: 32,
+				height: 32
+			} })] };
+		},
+		render(options) {
+			const { mouse, packable } = options;
+			const entity = options.previous.entities?.[0] ?? new cesium.Entity({ billboard: {} });
+			const position = packable.positions?.[0] ?? mouse;
+			entity.position = new cesium.CallbackPositionProperty(() => position, true);
+			return { entities: [entity] };
+		}
 	});
-}
 
 //#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 [];
-	}
-}
+//#region scheme/BillboardPinBuilder.ts
+	const PlotSchemeBillboardPinBuilder = new PlotScheme({
+		type: "BillboardPinBuilder",
+		complete: (packable) => packable.positions.length >= 1,
+		skeletons: [moved],
+		initRender() {
+			return { entities: [new cesium.Entity({ billboard: {} })] };
+		},
+		render(context) {
+			const entity = context.previous.entities[0];
+			const position = context.packable.positions[0] ?? context.mouse;
+			entity.position = new cesium.CallbackPositionProperty(() => position, true);
+			return { entities: [entity] };
+		}
+	});
 
 //#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
+//#region scheme/Cylinder.ts
+	const PlotSchemeCylinder = new PlotScheme({
+		type: "Cylinder",
+		complete: (packable) => packable.positions.length >= 2,
+		skeletons: [moved, control],
+		initRender() {
+			return { entities: [new cesium.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 cesium.ConstantPositionProperty(positions[0]);
+			const radius = cesium.Cartesian3.distance(positions[0], positions[1]);
+			entity.cylinder.bottomRadius = new cesium.CallbackProperty(() => radius, false);
+			if (context.defining || !(0, vesium.toPropertyValue)(entity.cylinder.length)) entity.cylinder.length = (0, vesium.toProperty)(radius * 2);
+			return { entities: [entity] };
+		}
 	});
-	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);
+//#region scheme/Ellipse.ts
+	const PlotSchemeEllipse = new PlotScheme({
+		type: "Ellipse",
+		complete: (packable) => packable.positions.length >= 2,
+		skeletons: [moved, control],
+		initRender() {
+			return { entities: [new cesium.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 cesium.ConstantPositionProperty(positions[0]);
+			const radius = cesium.Cartesian3.distance(positions[0], positions[1]);
+			entity.ellipse.semiMinorAxis = new cesium.CallbackProperty(() => radius || 1, false);
+			entity.ellipse.semiMajorAxis = entity.ellipse.semiMinorAxis;
+			return { entities: [entity] };
 		}
-		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;
-}
+//#region scheme/Label.ts
+	const PlotSchemeLabel = new PlotScheme({
+		type: "Label",
+		complete: (packable) => packable.positions.length >= 1,
+		skeletons: [moved],
+		initRender() {
+			return { entities: [new cesium.Entity({ label: { text: "Label" } })] };
+		},
+		render(context) {
+			const entity = context.previous.entities[0];
+			const position = context.packable.positions[0] ?? context.mouse;
+			entity.position = new cesium.CallbackPositionProperty(() => position, true);
+			return { entities: [entity] };
+		}
+	});
 
 //#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
-	];
-}
+//#region scheme/Point.ts
+	const PlotSchemePoint = new PlotScheme({
+		type: "Point",
+		complete: (packable) => packable.positions.length >= 1,
+		skeletons: [moved],
+		initRender() {
+			return { entities: [new cesium.Entity({ point: {
+				pixelSize: 10,
+				color: cesium.Color.RED
+			} })] };
+		},
+		render(context) {
+			const entity = context.previous.entities[0];
+			const position = context.packable.positions[0] ?? context.mouse;
+			entity.position = new cesium.CallbackPositionProperty(() => position, true);
+			return { entities: [entity] };
+		}
+	});
 
 //#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
-	];
-}
+//#region scheme/Polygon.ts
+	const PlotSchemePolygon = new PlotScheme({
+		type: "Polygon",
+		allowManualComplete: (packable) => packable.positions.length >= 2,
+		skeletons: [
+			moved,
+			control,
+			interval
+		],
+		initRender: () => {
+			return { entities: [new cesium.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 cesium.CallbackProperty(() => positions, false);
+			} else if (positions.length >= 3) {
+				entity.polyline.positions = void 0;
+				entity.polygon.hierarchy = new cesium.CallbackProperty(() => {
+					positions.push(positions[0]);
+					return positions.length >= 3 ? new cesium.PolygonHierarchy([...positions]) : void 0;
+				}, false);
+			} else {
+				entity.polygon.hierarchy = void 0;
+				entity.polyline.positions = void 0;
+			}
+			return { entities: [entity] };
+		}
+	});
 
 //#endregion
 //#region scheme/PolygonArc.ts
-const PlotSchemePolygonArc = new PlotScheme({
-	type: "PolygonArc",
-	complete: (packable) => packable.positions.length >= 3,
-	skeletons: [moved, control],
-	initRender() {
-		return { entities: [new cesium.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) => (0, vesium.toCoord)(e));
-		if (coords.length < 3) {
-			entity.polygon.hierarchy = void 0;
-			return context.previous;
+	const PlotSchemePolygonArc = new PlotScheme({
+		type: "PolygonArc",
+		complete: (packable) => packable.positions.length >= 3,
+		skeletons: [moved, control],
+		initRender() {
+			return { entities: [new cesium.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) => (0, vesium.toCoord)(e));
+			if (coords.length < 3) {
+				entity.polygon.hierarchy = void 0;
+				return context.previous;
+			}
+			const hierarchy = new cesium.PolygonHierarchy((0, __vesium_geometry.arc)(coords).map((item) => (0, vesium.toCartesian3)(item)));
+			entity.polygon.hierarchy = new cesium.CallbackProperty(() => hierarchy, false);
+			return { entities: [entity] };
 		}
-		const positions = arc(coords).map((item) => (0, vesium.toCartesian3)(item));
-		const hierarchy = new cesium.PolygonHierarchy(positions);
-		entity.polygon.hierarchy = new cesium.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 cesium.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) => (0, vesium.toCoord)(e));
-		if (coords.length < 3) {
-			entity.polygon.hierarchy = void 0;
-			return context.previous;
+	const PlotSchemePolygonArrowAttackDirection = new PlotScheme({
+		type: "PolygonArrowAttackDirection",
+		allowManualComplete: (packable) => packable.positions.length >= 3,
+		skeletons: [
+			moved,
+			control,
+			intervalNonclosed
+		],
+		initRender() {
+			return { entities: [new cesium.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) => (0, vesium.toCoord)(e));
+			if (coords.length < 3) {
+				entity.polygon.hierarchy = void 0;
+				return context.previous;
+			}
+			const hierarchy = new cesium.PolygonHierarchy((0, __vesium_geometry.arrowAttackDirection)(coords).map((item) => (0, vesium.toCartesian3)(item)));
+			entity.polygon.hierarchy = new cesium.CallbackProperty(() => hierarchy, false);
+			return { entities: [entity] };
 		}
-		const positions = arrowAttackDirection(coords).map((item) => (0, vesium.toCartesian3)(item));
-		const hierarchy = new cesium.PolygonHierarchy(positions);
-		entity.polygon.hierarchy = new cesium.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 cesium.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) => (0, vesium.toCoord)(e));
-		if (coords.length < 3) {
-			entity.polygon.hierarchy = void 0;
-			return context.previous;
+	const PlotSchemePolygonArrowAttackDirectionTailed = new PlotScheme({
+		type: "PolygonArrowAttackDirectionTailed",
+		allowManualComplete: (packable) => packable.positions.length >= 3,
+		skeletons: [
+			moved,
+			control,
+			intervalNonclosed
+		],
+		initRender() {
+			return { entities: [new cesium.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) => (0, vesium.toCoord)(e));
+			if (coords.length < 3) {
+				entity.polygon.hierarchy = void 0;
+				return context.previous;
+			}
+			const hierarchy = new cesium.PolygonHierarchy((0, __vesium_geometry.arrowAttackDirectionTailed)(coords).map((item) => (0, vesium.toCartesian3)(item)));
+			entity.polygon.hierarchy = new cesium.CallbackProperty(() => hierarchy, false);
+			return { entities: [entity] };
 		}
-		const positions = arrowAttackDirectionTailed(coords).map((item) => (0, vesium.toCartesian3)(item));
-		const hierarchy = new cesium.PolygonHierarchy(positions);
-		entity.polygon.hierarchy = new cesium.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 cesium.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 PlotSchemePolygonArrowClamped = new PlotScheme({
+		type: "PolygonArrowClamped",
+		complete: (packable) => packable.positions.length >= 5,
+		skeletons: [moved, control],
+		initRender() {
+			return { entities: [new cesium.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) => (0, vesium.toCoord)(e));
+			if (coords.length >= 3) {
+				const hierarchy = new cesium.PolygonHierarchy((0, __vesium_geometry.arrowClamped)(coords).map((item) => (0, vesium.toCartesian3)(item)));
+				entity.polygon.hierarchy = new cesium.CallbackProperty(() => hierarchy, false);
+			} else entity.polygon.hierarchy = void 0;
+			return { entities: [entity] };
 		}
-		const coords = points.map((e) => (0, vesium.toCoord)(e));
-		if (coords.length >= 3) {
-			const positions = arrowClamped(coords);
-			const hierarchy = new cesium.PolygonHierarchy(positions.map((item) => (0, vesium.toCartesian3)(item)));
-			entity.polygon.hierarchy = new cesium.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 cesium.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 PlotSchemePolygonArrowStraight = new PlotScheme({
+		type: "PolygonArrowStraight",
+		complete: (packable) => packable.positions.length >= 2,
+		skeletons: [moved, control],
+		initRender() {
+			return { entities: [new cesium.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) => (0, vesium.toCoord)(e));
+			if (coords.length >= 2) {
+				const hierarchy = new cesium.PolygonHierarchy((0, __vesium_geometry.arrowStraight)(coords).map((item) => (0, vesium.toCartesian3)(item)));
+				entity.polygon.hierarchy = new cesium.CallbackProperty(() => hierarchy, false);
+			} else entity.polygon.hierarchy = void 0;
+			return { entities: [entity] };
 		}
-		const coords = points.map((e) => (0, vesium.toCoord)(e));
-		if (coords.length >= 2) {
-			const positions = arrowStraight(coords);
-			const hierarchy = new cesium.PolygonHierarchy(positions.map((item) => (0, vesium.toCartesian3)(item)));
-			entity.polygon.hierarchy = new cesium.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 cesium.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 PlotSchemePolygonArrowStraightSharp = new PlotScheme({
+		type: "PolygonArrowStraightSharp",
+		complete: (packable) => packable.positions.length >= 2,
+		skeletons: [moved, control],
+		initRender() {
+			return { entities: [new cesium.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) => (0, vesium.toCoord)(e));
+			if (coords.length >= 2) {
+				const hierarchy = new cesium.PolygonHierarchy((0, __vesium_geometry.arrowStraightSharp)(coords).map((item) => (0, vesium.toCartesian3)(item)));
+				entity.polygon.hierarchy = new cesium.CallbackProperty(() => hierarchy, false);
+			} else entity.polygon.hierarchy = void 0;
+			return { entities: [entity] };
 		}
-		const coords = points.map((e) => (0, vesium.toCoord)(e));
-		if (coords.length >= 2) {
-			const positions = arrowStraightSharp(coords);
-			const hierarchy = new cesium.PolygonHierarchy(positions.map((item) => (0, vesium.toCartesian3)(item)));
-			entity.polygon.hierarchy = new cesium.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 cesium.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) => (0, vesium.toCoord)(e));
-		if (coords.length < 2) {
-			entity.polygon.hierarchy = void 0;
-			return context.previous;
+	const PlotSchemePolygonArrowUnitCombatOperation = new PlotScheme({
+		type: "PolygonArrowUnitCombatOperation",
+		allowManualComplete: (packable) => packable.positions.length >= 2,
+		skeletons: [
+			moved,
+			control,
+			intervalNonclosed
+		],
+		initRender() {
+			return { entities: [new cesium.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) => (0, vesium.toCoord)(e));
+			if (coords.length < 2) {
+				entity.polygon.hierarchy = void 0;
+				return context.previous;
+			}
+			const hierarchy = new cesium.PolygonHierarchy((0, __vesium_geometry.arrowUnitCombatOperation)(coords).map((item) => (0, vesium.toCartesian3)(item)));
+			entity.polygon.hierarchy = new cesium.CallbackProperty(() => hierarchy, false);
+			return { entities: [entity] };
 		}
-		const positions = arrowUnitCombatOperation(coords).map((item) => (0, vesium.toCartesian3)(item));
-		const hierarchy = new cesium.PolygonHierarchy(positions);
-		entity.polygon.hierarchy = new cesium.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 cesium.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) => (0, vesium.toCoord)(e));
-		if (coords.length < 2) {
-			entity.polygon.hierarchy = void 0;
-			return context.previous;
+	const PlotSchemePolygonArrowUnitCombatOperationTailed = new PlotScheme({
+		type: "PolygonArrowUnitCombatOperationTailed",
+		allowManualComplete: (packable) => packable.positions.length >= 2,
+		skeletons: [
+			moved,
+			control,
+			interval
+		],
+		initRender() {
+			return { entities: [new cesium.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) => (0, vesium.toCoord)(e));
+			if (coords.length < 2) {
+				entity.polygon.hierarchy = void 0;
+				return context.previous;
+			}
+			const hierarchy = new cesium.PolygonHierarchy((0, __vesium_geometry.arrowUnitCombatOperationTailed)(coords).map((item) => (0, vesium.toCartesian3)(item)));
+			entity.polygon.hierarchy = new cesium.CallbackProperty(() => hierarchy, false);
+			return { entities: [entity] };
 		}
-		const positions = arrowUnitCombatOperationTailed(coords).map((item) => (0, vesium.toCartesian3)(item));
-		const hierarchy = new cesium.PolygonHierarchy(positions);
-		entity.polygon.hierarchy = new cesium.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 cesium.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) => (0, vesium.toCoord)(e));
-		if (coords.length < 2) {
-			entity.polygon.hierarchy = void 0;
-			return context.previous;
-		}
-		const positions = assemblingPlace(coords).map((item) => (0, vesium.toCartesian3)(item));
-		const hierarchy = new cesium.PolygonHierarchy(positions);
-		entity.polygon.hierarchy = new cesium.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 cesium.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) => (0, vesium.toCoord)(e));
-		if (coords.length < 2) {
-			entity.polygon.hierarchy = void 0;
-			return context.previous;
-		}
-		const positions = flagCurve(coords).map((item) => (0, vesium.toCartesian3)(item));
-		const hierarchy = new cesium.PolygonHierarchy(positions);
-		entity.polygon.hierarchy = new cesium.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 cesium.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) => (0, vesium.toCoord)(e));
-		if (coords.length < 2) {
-			entity.polygon.hierarchy = void 0;
-			return context.previous;
-		}
-		const positions = flagRect(coords).map((item) => (0, vesium.toCartesian3)(item));
-		const hierarchy = new cesium.PolygonHierarchy(positions);
-		entity.polygon.hierarchy = new cesium.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 cesium.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) => (0, vesium.toCoord)(e));
-		if (coords.length < 2) {
-			entity.polygon.hierarchy = void 0;
-			return context.previous;
+	const PlotSchemePolygonAssemblingPlace = new PlotScheme({
+		type: "PolygonAssemblingPlace",
+		complete: (packable) => packable.positions.length >= 3,
+		skeletons: [
+			moved,
+			control,
+			interval
+		],
+		initRender() {
+			return { entities: [new cesium.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) => (0, vesium.toCoord)(e));
+			if (coords.length < 2) {
+				entity.polygon.hierarchy = void 0;
+				return context.previous;
+			}
+			if (coords.length === 2) {
+				const c0 = (0, vesium.toCartographic)(coords[0]);
+				const c1 = (0, vesium.toCartographic)(coords[1]);
+				const latitude = c0.latitude;
+				const height = c0.height;
+				const longitude = c1.longitude - (c0.longitude - c1.longitude);
+				coords.push((0, vesium.toCoord)(new cesium.Cartographic(longitude, latitude, height)));
+			}
+			const hierarchy = new cesium.PolygonHierarchy((0, __vesium_geometry.assemblingPlace)(coords).map((item) => (0, vesium.toCartesian3)(item)));
+			entity.polygon.hierarchy = new cesium.CallbackProperty(() => hierarchy, false);
+			return { entities: [entity] };
 		}
-		const positions = flagTriangle(coords).map((item) => (0, vesium.toCartesian3)(item));
-		const hierarchy = new cesium.PolygonHierarchy(positions);
-		entity.polygon.hierarchy = new cesium.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 cesium.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 PlotSchemePolygonSmooth = new PlotScheme({
+		type: "PolygonSmooth",
+		allowManualComplete: (packable) => packable.positions.length >= 3,
+		skeletons: [
+			moved,
+			control,
+			intervalNonclosed
+		],
+		initRender() {
+			return { entities: [new cesium.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) => (0, vesium.toCoord)(e));
+			wgs84s.push(wgs84s[0]);
+			const { features } = __turf_turf.polygonSmooth(__turf_turf.polygon([wgs84s]), { iterations: 3 });
+			const hierarchy = new cesium.PolygonHierarchy(features[0].geometry.coordinates[0].map((item) => (0, vesium.toCartesian3)(item)).filter((e) => !!e));
+			entity.polygon.hierarchy = new cesium.CallbackProperty(() => hierarchy, false);
+			return { entities: [entity] };
 		}
-		const wgs84s = positions.map((e) => (0, vesium.toCoord)(e));
-		wgs84s.push(wgs84s[0]);
-		const { features } = __turf_turf.polygonSmooth(__turf_turf.polygon([wgs84s]), { iterations: 3 });
-		const cartesians = features[0].geometry.coordinates[0].map((item) => (0, vesium.toCartesian3)(item)).filter((e) => !!e);
-		const hierarchy = new cesium.PolygonHierarchy(cartesians);
-		entity.polygon.hierarchy = new cesium.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 cesium.Entity({ polyline: {
-			material: cesium.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 cesium.CallbackProperty(() => cache, false);
-		return { entities: [entity] };
-	}
-});
+	const PlotSchemePolyline = new PlotScheme({
+		type: "Polyline",
+		allowManualComplete: (packable) => packable.positions.length > 1,
+		skeletons: [
+			moved,
+			control,
+			intervalNonclosed
+		],
+		initRender() {
+			return { entities: [new cesium.Entity({ polyline: {
+				material: cesium.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 cesium.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 cesium.Entity({ polyline: {
-			material: cesium.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 PlotSchemePolylineCurve = new PlotScheme({
+		type: "PolylineCurve",
+		allowManualComplete: (packable) => packable.positions.length > 1,
+		skeletons: [
+			moved,
+			control,
+			intervalNonclosed
+		],
+		initRender() {
+			return { entities: [new cesium.Entity({ polyline: {
+				material: cesium.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) => (0, vesium.toCoord)(position));
+			const { geometry: { coordinates } } = __turf_turf.bezierSpline(__turf_turf.lineString(coords));
+			entity.polyline.positions = new cesium.CallbackProperty(() => coordinates.map(vesium.toCartesian3), false);
+			return { entities: [entity] };
 		}
-		const coords = positions.map((position) => (0, vesium.toCoord)(position));
-		const { geometry: { coordinates } } = __turf_turf.bezierSpline(__turf_turf.lineString(coords));
-		entity.polyline.positions = new cesium.CallbackProperty(() => coordinates.map(vesium.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 cesium.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 PlotSchemeRectangle = new PlotScheme({
+		type: "Rectangle",
+		complete: (packable) => packable.positions.length >= 2,
+		skeletons: [moved, control],
+		initRender() {
+			return { entities: [new cesium.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 = cesium.Rectangle.fromCartesianArray(positions ?? []);
+			entity.rectangle.coordinates = new cesium.CallbackProperty(() => coordinates, false);
+			return { entities: [entity] };
 		}
-		const coordinates = cesium.Rectangle.fromCartesianArray(positions ?? []);
-		entity.rectangle.coordinates = new cesium.CallbackProperty(() => coordinates, false);
-		return { entities: [entity] };
-	}
-});
+	});
 
 //#endregion
 exports.PlotAction = PlotAction;
@@ -3045,9 +2022,6 @@ exports.PlotSchemePolygonArrowStraightSharp = PlotSchemePolygonArrowStraightShar
 exports.PlotSchemePolygonArrowUnitCombatOperation = PlotSchemePolygonArrowUnitCombatOperation;
 exports.PlotSchemePolygonArrowUnitCombatOperationTailed = PlotSchemePolygonArrowUnitCombatOperationTailed;
 exports.PlotSchemePolygonAssemblingPlace = PlotSchemePolygonAssemblingPlace;
-exports.PlotSchemePolygonFlagCurve = PlotSchemePolygonFlagCurve;
-exports.PlotSchemePolygonFlagRect = PlotSchemePolygonFlagRect;
-exports.PlotSchemePolygonFlagTriangle = PlotSchemePolygonFlagTriangle;
 exports.PlotSchemePolygonSmooth = PlotSchemePolygonSmooth;
 exports.PlotSchemePolyline = PlotSchemePolyline;
 exports.PlotSchemePolylineCurve = PlotSchemePolylineCurve;
@@ -3062,5 +2036,5 @@ exports.moved = moved;
 exports.schemeMeasureArea = schemeMeasureArea;
 exports.schemeMeasureDistance = schemeMeasureDistance;
 exports.usePlot = usePlot;
-})(this.Vesium = this.Vesium || {}, Cesium, Vesium, VueUse, Vue, turf);
+})(this.Vesium = this.Vesium || {}, Cesium, Vesium, VueUse, Vue, Vesium, turf);
 //# sourceMappingURL=index.iife.js.map