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

package/dist/index.cjs

@@ -6,12 +6,16 @@ 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
-		});
+	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;
 };
@@ -21,11 +25,13 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 
 //#endregion
-const cesium = __toESM(require("cesium"));
-const vesium = __toESM(require("vesium"));
-const __vueuse_core = __toESM(require("@vueuse/core"));
-const vue = __toESM(require("vue"));
-const __turf_turf = __toESM(require("@turf/turf"));
+let cesium = require("cesium");
+let vesium = require("vesium");
+let __vueuse_core = require("@vueuse/core");
+let vue = require("vue");
+let __vesium_geometry = require("@vesium/geometry");
+let __turf_turf = require("@turf/turf");
+__turf_turf = __toESM(__turf_turf);
 
 //#region usePlot/PlotScheme.ts
 var PlotScheme = class PlotScheme {
@@ -204,16 +210,13 @@ var SampledPlotProperty = class SampledPlotProperty {
 		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: {
+			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 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;
@@ -223,11 +226,10 @@ var SampledPlotProperty = class SampledPlotProperty {
 		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
+			proportion: (cesium.JulianDate.toDate(time).getTime() - prevMs) / (nextMs - prevMs) || 0
 		};
 	}
 	/**
@@ -319,8 +321,7 @@ var SampledPlotProperty = class SampledPlotProperty {
 		if (index !== -1) {
 			this._sampleds.splice(index, 1);
 			this._derivatives.splice(index, 1);
-			const removed = this._times.splice(index, 1);
-			if (removed.length) {
+			if (this._times.splice(index, 1).length) {
 				this._definitionChanged.raiseEvent(this);
 				return true;
 			}
@@ -550,19 +551,27 @@ function useRender(plots, current, getCurrentTime) {
 		}
 	});
 	const update = async (plot) => {
-		const reslut = await plot.scheme.render?.({
-			packable: plot.sampled.getValue(getCurrentTime()),
-			mouse: plot.defining ? mouseCartesian.value : void 0,
+		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 = reslut?.entities ?? [];
-		plot.primitives = reslut?.primitives ?? [];
-		plot.groundPrimitives = reslut?.groundPrimitives ?? [];
+		plot.entities = result?.entities ?? [];
+		plot.primitives = result?.primitives ?? [];
+		plot.groundPrimitives = result?.groundPrimitives ?? [];
 	};
 	(0, vue.watch)(current, (plot, previous) => {
 		previous && update(previous);
@@ -605,8 +614,7 @@ function useSampled(current, getCurrentTime) {
 		packable.value.positions ??= [];
 		packable.value.positions.push(position);
 		sampled.setSample(packable.value);
-		const completed = scheme.complete?.(packable.value);
-		completed && PlotFeature.setDefining(current.value, false);
+		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;
@@ -615,10 +623,8 @@ function useSampled(current, getCurrentTime) {
 		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);
+		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;
@@ -668,13 +674,11 @@ function useSkeleton(plots, current, getCurrentTime) {
 			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({
+			plot.scheme.skeletons.forEach((skeleton) => {
+				if ((0, vesium.isFunction)(skeleton.disabled) ? skeleton.disabled({
 					active,
 					defining
-				}) : skeleton.disabled;
-				if (disabled) return;
+				}) : 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);
@@ -701,9 +705,9 @@ function useSkeleton(plots, current, getCurrentTime) {
 		}
 		plot.skeletons = entities;
 	};
-	const { addGraphicEvent } = (0, vesium.useGraphicEvent)();
+	const graphicEvent = (0, vesium.useGraphicEvent)();
 	(0, vue.watchEffect)((onCleanup) => {
-		const remove = addGraphicEvent("global", "DRAG", ({ event, pick, dragging, lockCamera }) => {
+		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;
@@ -736,8 +740,7 @@ function useSkeleton(plots, current, getCurrentTime) {
 					return (0, vesium.isFunction)(skeleton?.dragCursor) ? skeleton.dragCursor(pick) : (0, vue.toValue)(skeleton?.dragCursor);
 				}
 			}
-		});
-		onCleanup(remove);
+		}));
 	});
 	(0, __vueuse_core.onKeyStroke)((keyEvent) => {
 		if (activeEntity.value) {
@@ -756,16 +759,13 @@ function useSkeleton(plots, current, getCurrentTime) {
 		}
 	});
 	(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;
-		});
-		onCleanup(remove);
+		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;
+		}));
 	});
 	(0, vue.watchEffect)((onCleanup) => {
-		const remove = addGraphicEvent("global", "LEFT_CLICK", ({ event, pick }) => {
+		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;
@@ -783,8 +783,7 @@ function useSkeleton(plots, current, getCurrentTime) {
 					event
 				});
 			} else activeEntity.value = void 0;
-		});
-		onCleanup(remove);
+		}));
 	});
 	(0, __vueuse_core.watchArray)(plots, (value, oldValue, added, removed = []) => {
 		added.forEach((plot) => update(plot));
@@ -849,8 +848,7 @@ function usePlot(options) {
 		if (previous) {
 			if (previous.defining) {
 				const packable$1 = previous.sampled.getValue(getCurrentTime());
-				const completed = previous.scheme.allowManualComplete?.(packable$1);
-				if (completed) {
+				if (previous.scheme.allowManualComplete?.(packable$1)) {
 					PlotFeature.setDefining(previous, false);
 					operateResolve?.(previous);
 				} else collection.delete(previous);
@@ -934,8 +932,7 @@ function control() {
 			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;
+			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);
@@ -946,16 +943,15 @@ function control() {
 			});
 		},
 		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],
+					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)
@@ -1002,16 +998,15 @@ function interval() {
 		},
 		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],
+					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)
@@ -1056,16 +1051,15 @@ function intervalNonclosed() {
 			});
 		},
 		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],
+					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)
@@ -1090,10 +1084,7 @@ function moved() {
 			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)];
-			}
+			else return [(0, vesium.toCartesian3)(cesium.Rectangle.center(cesium.Rectangle.fromCartesianArray(positions)))];
 		},
 		onDrag({ viewer, sampled, packable, event, lockCamera, dragging }) {
 			dragging && lockCamera();
@@ -1109,18 +1100,17 @@ function moved() {
 			});
 		},
 		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],
+					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,
@@ -1190,12 +1180,12 @@ async function clampToHeightMostDetailedByTilesetOrTerrain(options) {
 		else resolve([]);
 	});
 	const [tilesetPositions, terrainPositions] = await Promise.all([tilesetPromise, terrainPromise]);
-	const resluts = [];
+	const results = [];
 	positions.forEach((item, index) => {
 		const position = tilesetPositions[index] || terrainPositions[index] ? cesium.Ellipsoid.WGS84.cartographicToCartesian(terrainPositions[index]) : item.clone();
-		resluts.push(position);
+		results.push(position);
 	});
-	return resluts;
+	return results;
 }
 
 //#endregion
@@ -1224,8 +1214,7 @@ async function triangleGrid(positions, options) {
 	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 granularity = Math.max(horizontal, vertical) / density;
 	const polygonGeometry = cesium.PolygonGeometry.fromPositions({
 		positions,
 		vertexFormat: cesium.PerInstanceColorAppearance.FLAT_VERTEX_FORMAT,
@@ -1244,13 +1233,12 @@ async function triangleGrid(positions, options) {
 	}
 	if (clampToGround) {
 		if (!scene) throw new Error("scene is required on `clampToGround == true`.");
-		const detaileds = await clampToHeightMostDetailedByTilesetOrTerrain({
+		cartesian3List = await clampToHeightMostDetailedByTilesetOrTerrain({
 			scene,
 			terrainProvider,
 			positions: cartesian3List,
 			classificationType
 		});
-		cartesian3List = detaileds;
 	}
 	const grid = [];
 	while (cartesian3List?.length) {
@@ -1298,18 +1286,14 @@ 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, {
+	if (!clampToGround) return tesselate(positions).reduce((count, current) => count += triangleArea(...current), 0);
+	return (await triangleGrid(positions, {
 		density,
 		scene,
 		clampToGround,
 		classificationType,
 		terrainProvider
-	});
-	return triangles.reduce((count, current) => count += triangleArea(...current), 0);
+	})).reduce((count, current) => count += triangleArea(...current), 0);
 }
 
 //#endregion
@@ -1327,13 +1311,12 @@ async function lerpArray(options) {
 	result.push(end.clone());
 	if (!clampToGround) return result;
 	if (!scene) throw new Error("scene is required on `clampToGround == true`.");
-	const detaileds = await clampToHeightMostDetailedByTilesetOrTerrain({
+	return await clampToHeightMostDetailedByTilesetOrTerrain({
 		scene,
 		terrainProvider,
 		positions: result,
 		classificationType
 	});
-	return detaileds;
 }
 
 //#endregion
@@ -1389,8 +1372,7 @@ async function distance(positions, options) {
 			terrainProvider: _options.terrainProvider
 		});
 	});
-	const detaileds = await Promise.all(positionListPromises);
-	const stagePromises = detaileds.map(async (positions$1) => {
+	const stagePromises = (await Promise.all(positionListPromises)).map(async (positions$1) => {
 		const { count: count$1 } = await distance(positions$1);
 		return count$1;
 	});
@@ -1460,7 +1442,7 @@ const schemeMeasureDistance = new PlotScheme({
 		} })] };
 	},
 	render(context) {
-		const entity = context.previous.entities[0];
+		context.previous.entities[0];
 		const { mouse, packable, previous } = context;
 		const entities = previous.entities;
 		const positions = [...packable.positions ?? []];
@@ -1498,6 +1480,9 @@ const schemeMeasureDistance = new PlotScheme({
 
 //#endregion
 //#region scheme/Billboard.ts
+/**
+* billboard标绘配置
+*/
 const PlotSchemeBillboard = new PlotScheme({
 	type: "Billboard",
 	complete: (packable) => packable.positions.length >= 1,
@@ -1520,6 +1505,9 @@ const PlotSchemeBillboard = new PlotScheme({
 
 //#endregion
 //#region scheme/BillboardPinBuilder.ts
+/**
+* billboard-pin-builder标绘配置
+*/
 const PlotSchemeBillboardPinBuilder = new PlotScheme({
 	type: "BillboardPinBuilder",
 	complete: (packable) => packable.positions.length >= 1,
@@ -1537,6 +1525,9 @@ const PlotSchemeBillboardPinBuilder = new PlotScheme({
 
 //#endregion
 //#region scheme/Cylinder.ts
+/**
+* cylinder标绘配置
+*/
 const PlotSchemeCylinder = new PlotScheme({
 	type: "Cylinder",
 	complete: (packable) => packable.positions.length >= 2,
@@ -1563,6 +1554,9 @@ const PlotSchemeCylinder = new PlotScheme({
 
 //#endregion
 //#region scheme/Ellipse.ts
+/**
+* ellipse标绘配置 圆形扩散波
+*/
 const PlotSchemeEllipse = new PlotScheme({
 	type: "Ellipse",
 	complete: (packable) => packable.positions.length >= 2,
@@ -1589,6 +1583,9 @@ const PlotSchemeEllipse = new PlotScheme({
 
 //#endregion
 //#region scheme/Label.ts
+/**
+* 基础label标绘配置
+*/
 const PlotSchemeLabel = new PlotScheme({
 	type: "Label",
 	complete: (packable) => packable.positions.length >= 1,
@@ -1606,6 +1603,9 @@ const PlotSchemeLabel = new PlotScheme({
 
 //#endregion
 //#region scheme/Point.ts
+/**
+* 基础point标绘配置
+*/
 const PlotSchemePoint = new PlotScheme({
 	type: "Point",
 	complete: (packable) => packable.positions.length >= 1,
@@ -1626,6 +1626,9 @@ const PlotSchemePoint = new PlotScheme({
 
 //#endregion
 //#region scheme/Polygon.ts
+/**
+* 基础Polygon标绘配置
+*/
 const PlotSchemePolygon = new PlotScheme({
 	type: "Polygon",
 	allowManualComplete: (packable) => packable.positions.length >= 2,
@@ -1663,930 +1666,10 @@ const PlotSchemePolygon = new PlotScheme({
 });
 
 //#endregion
-//#region geom/helper.ts
-const FITTING_COUNT = 100;
-const HALF_PI = Math.PI / 2;
-const ZERO_TOLERANCE = 1e-4;
-const TWO_PI = Math.PI * 2;
-/**
-* 计算两个坐标之间的距离
-* @param coord1
-* @param coord2
-*/
-function mathDistance(coord1, coord2) {
-	return Math.hypot(coord1[0] - coord2[0], coord1[1] - coord2[1]);
-}
-/**
-* 计算点集合的总距离
-* @param points
-*/
-function wholeDistance(points) {
-	let distance$1 = 0;
-	if (points && Array.isArray(points) && points.length > 0) points.forEach((item, index) => {
-		if (index < points.length - 1) distance$1 += mathDistance(item, points[index + 1]);
-	});
-	return distance$1;
-}
-/**
-* 获取基础长度
-* @param points
-*/
-const getBaseLength = (points) => wholeDistance(points) ** .99;
-/**
-* 求取两个坐标的中间坐标
-* @param coord1
-* @param coord2
-*/
-function mid(coord1, coord2) {
-	return [(coord1[0] + coord2[0]) / 2, (coord1[1] + coord2[1]) / 2];
-}
-/**
-* 通过三个点确定一个圆的中心点
-* @param coord1
-* @param coord2
-* @param coord3
-*/
-function getCircleCenterOfThreeCoords(coord1, coord2, coord3) {
-	const coordA = [(coord1[0] + coord2[0]) / 2, (coord1[1] + coord2[1]) / 2];
-	const coordB = [coordA[0] - coord1[1] + coord2[1], coordA[1] + coord1[0] - coord2[0]];
-	const coordC = [(coord1[0] + coord3[0]) / 2, (coord1[1] + coord3[1]) / 2];
-	const coordD = [coordC[0] - coord1[1] + coord3[1], coordC[1] + coord1[0] - coord3[0]];
-	return getIntersectCoord(coordA, coordB, coordC, coordD);
-}
-/**
-* 获取交集的点
-* @param coordA
-* @param coordB
-* @param coordC
-* @param coordD
-*/
-function getIntersectCoord(coordA, coordB, coordC, coordD) {
-	if (coordA[1] === coordB[1]) {
-		const f$1 = (coordD[0] - coordC[0]) / (coordD[1] - coordC[1]);
-		const x$1 = f$1 * (coordA[1] - coordC[1]) + coordC[0];
-		const y$1 = coordA[1];
-		return [x$1, y$1];
-	}
-	if (coordC[1] === coordD[1]) {
-		const e$1 = (coordB[0] - coordA[0]) / (coordB[1] - coordA[1]);
-		const x$1 = e$1 * (coordC[1] - coordA[1]) + coordA[0];
-		const y$1 = coordC[1];
-		return [x$1, y$1];
-	}
-	const e = (coordB[0] - coordA[0]) / (coordB[1] - coordA[1]);
-	const f = (coordD[0] - coordC[0]) / (coordD[1] - coordC[1]);
-	const y = (e * coordA[1] - coordA[0] - f * coordC[1] + coordC[0]) / (e - f);
-	const x = e * y - e * coordA[1] + coordA[0];
-	return [x, y];
-}
-/**
-* 获取方位角（地平经度）
-* @param startCoord
-* @param endCoord
-*/
-function getAzimuth(startCoord, endCoord) {
-	let azimuth = 0;
-	const angle = Math.asin(Math.abs(endCoord[1] - startCoord[1]) / mathDistance(startCoord, endCoord));
-	if (endCoord[1] >= startCoord[1] && endCoord[0] >= startCoord[0]) azimuth = angle + Math.PI;
-	else if (endCoord[1] >= startCoord[1] && endCoord[0] < startCoord[0]) azimuth = Math.PI * 2 - angle;
-	else if (endCoord[1] < startCoord[1] && endCoord[0] < startCoord[0]) azimuth = angle;
-	else if (endCoord[1] < startCoord[1] && endCoord[0] >= startCoord[0]) azimuth = Math.PI - angle;
-	return azimuth;
-}
-/**
-* 通过三个点获取方位角
-* @param coordA
-* @param coordB
-* @param coordC
-*/
-function getAngleOfThreeCoords(coordA, coordB, coordC) {
-	const angle = getAzimuth(coordB, coordA) - getAzimuth(coordB, coordC);
-	return angle < 0 ? angle + Math.PI * 2 : angle;
-}
-/**
-* 判断是否是顺时针
-* @param coord1
-* @param coord2
-* @param coord3
-*/
-function isClockWise(coord1, coord2, coord3) {
-	return (coord3[1] - coord1[1]) * (coord2[0] - coord1[0]) > (coord2[1] - coord1[1]) * (coord3[0] - coord1[0]);
-}
-/**
-* 获取立方值
-*/
-function getCubicValue(t, startCoord, coord1, coord2, endCoord) {
-	t = Math.max(Math.min(t, 1), 0);
-	const [tp, t2] = [1 - t, t * t];
-	const t3 = t2 * t;
-	const tp2 = tp * tp;
-	const tp3 = tp2 * tp;
-	const x = tp3 * startCoord[0] + 3 * tp2 * t * coord1[0] + 3 * tp * t2 * coord2[0] + t3 * endCoord[0];
-	const y = tp3 * startCoord[1] + 3 * tp2 * t * coord1[1] + 3 * tp * t2 * coord2[1] + t3 * endCoord[1];
-	return [x, y];
-}
-/**
-* 根据起止点和旋转方向求取第三个点
-* @param startCoord
-* @param endCoord
-* @param angle
-* @param distance
-* @param clockWise
-*/
-function getThirdCoord(startCoord, endCoord, angle, distance$1, clockWise) {
-	const azimuth = getAzimuth(startCoord, endCoord);
-	const alpha = clockWise ? azimuth + angle : azimuth - angle;
-	const dx = distance$1 * Math.cos(alpha);
-	const dy = distance$1 * Math.sin(alpha);
-	return [endCoord[0] + dx, endCoord[1] + dy];
-}
-/**
-* 插值弓形线段点
-* @param center
-* @param radius
-* @param startAngle
-* @param endAngle
-*/
-function getArcCoords(center, radius, startAngle, endAngle) {
-	let [x, y, coords, angleDiff] = [
-		0,
-		0,
-		[],
-		endAngle - startAngle
-	];
-	angleDiff = angleDiff < 0 ? angleDiff + Math.PI * 2 : angleDiff;
-	for (let i = 0; i <= 100; i++) {
-		const angle = startAngle + angleDiff * i / 100;
-		x = center[0] + radius * Math.cos(angle);
-		y = center[1] + radius * Math.sin(angle);
-		coords.push([x, y]);
-	}
-	return coords;
-}
-/**
-* getBisectorNormals
-* @param t
-* @param coord1
-* @param coord2
-* @param coord3
-*/
-function getBisectorNormals(t, coord1, coord2, coord3) {
-	const normal = getNormal(coord1, coord2, coord3);
-	let [bisectorNormalRight, bisectorNormalLeft, dt, x, y] = [
-		[0, 0],
-		[0, 0],
-		0,
-		0,
-		0
-	];
-	const dist = Math.hypot(normal[0], normal[1]);
-	const uX = normal[0] / dist;
-	const uY = normal[1] / dist;
-	const d1 = mathDistance(coord1, coord2);
-	const d2 = mathDistance(coord2, coord3);
-	if (dist > ZERO_TOLERANCE) if (isClockWise(coord1, coord2, coord3)) {
-		dt = t * d1;
-		x = coord2[0] - dt * uY;
-		y = coord2[1] + dt * uX;
-		bisectorNormalRight = [x, y];
-		dt = t * d2;
-		x = coord2[0] + dt * uY;
-		y = coord2[1] - dt * uX;
-		bisectorNormalLeft = [x, y];
-	} else {
-		dt = t * d1;
-		x = coord2[0] + dt * uY;
-		y = coord2[1] - dt * uX;
-		bisectorNormalRight = [x, y];
-		dt = t * d2;
-		x = coord2[0] - dt * uY;
-		y = coord2[1] + dt * uX;
-		bisectorNormalLeft = [x, y];
-	}
-	else {
-		x = coord2[0] + t * (coord1[0] - coord2[0]);
-		y = coord2[1] + t * (coord1[1] - coord2[1]);
-		bisectorNormalRight = [x, y];
-		x = coord2[0] + t * (coord3[0] - coord2[0]);
-		y = coord2[1] + t * (coord3[1] - coord2[1]);
-		bisectorNormalLeft = [x, y];
-	}
-	return [bisectorNormalRight, bisectorNormalLeft];
-}
-/**
-* 获取默认三点的内切圆
-* @param coord1
-* @param coord2
-* @param coord3
-*/
-function getNormal(coord1, coord2, coord3) {
-	let dX1 = coord1[0] - coord2[0];
-	let dY1 = coord1[1] - coord2[1];
-	const d1 = Math.hypot(dX1, dY1);
-	dX1 /= d1;
-	dY1 /= d1;
-	let dX2 = coord3[0] - coord2[0];
-	let dY2 = coord3[1] - coord2[1];
-	const d2 = Math.hypot(dX2, dY2);
-	dX2 /= d2;
-	dY2 /= d2;
-	const uX = dX1 + dX2;
-	const uY = dY1 + dY2;
-	return [uX, uY];
-}
-/**
-* 贝塞尔曲线
-* @param points
-*/
-function getBezierCoords(points) {
-	if (points.length <= 2) return points;
-	const bezierCoords = [];
-	const n = points.length - 1;
-	for (let t = 0; t <= 1; t += .01) {
-		let [x, y] = [0, 0];
-		for (let index = 0; index <= n; index++) {
-			const factor = getBinomialFactor(n, index);
-			const a = t ** index;
-			const b = (1 - t) ** (n - index);
-			x += factor * a * b * points[index][0];
-			y += factor * a * b * points[index][1];
-		}
-		bezierCoords.push([x, y]);
-	}
-	bezierCoords.push(points[n]);
-	return bezierCoords;
-}
-/**
-* 获取阶乘数据
-* @param n
-*/
-function getFactorial(n) {
-	let result = 1;
-	switch (true) {
-		case n <= 1:
-			result = 1;
-			break;
-		case n === 2:
-			result = 2;
-			break;
-		case n === 3:
-			result = 6;
-			break;
-		case n === 24:
-			result = 24;
-			break;
-		case n === 5:
-			result = 120;
-			break;
-		default:
-			for (let i = 1; i <= n; i++) result *= i;
-			break;
-	}
-	return result;
-}
-/**
-* 获取二项分布
-* @param n
-* @param index
-*/
-function getBinomialFactor(n, index) {
-	return getFactorial(n) / (getFactorial(index) * getFactorial(n - index));
-}
-/**
-* 插值线性点
-* @param points
-*/
-function getQBSplineCoords(points) {
-	if (points.length <= 2) return points;
-	const [n, bSplineCoords] = [2, []];
-	const m = points.length - n - 1;
-	bSplineCoords.push(points[0]);
-	for (let i = 0; i <= m; i++) for (let t = 0; t <= 1; t += .05) {
-		let [x, y] = [0, 0];
-		for (let k = 0; k <= n; k++) {
-			const factor = getQuadricBSplineFactor(k, t);
-			x += factor * points[i + k][0];
-			y += factor * points[i + k][1];
-		}
-		bSplineCoords.push([x, y]);
-	}
-	bSplineCoords.push(points.at(-1));
-	return bSplineCoords;
-}
-/**
-* 得到二次线性因子
-* @param k
-* @param t
-*/
-function getQuadricBSplineFactor(k, t) {
-	let res = 0;
-	if (k === 0) res = (t - 1) ** 2 / 2;
-	else if (k === 1) res = (-2 * t ** 2 + 2 * t + 1) / 2;
-	else if (k === 2) res = t ** 2 / 2;
-	return res;
-}
-
-//#endregion
-//#region geom/arc.ts
-/**
-* 标绘画弓形算法，继承线要素相关方法和属性
-*/
-function arc(coords) {
-	const coordlength = coords.length;
-	if (coordlength <= 2) throw new Error("coords.length must >= 3");
-	else {
-		let [coord1, coord2, coord3, startAngle, endAngle] = [
-			coords[0],
-			coords[1],
-			coords[2],
-			0,
-			0
-		];
-		const center = getCircleCenterOfThreeCoords(coord1, coord2, coord3);
-		const radius = mathDistance(coord1, center);
-		const angle1 = getAzimuth(coord1, center);
-		const angle2 = getAzimuth(coord2, center);
-		if (isClockWise(coord1, coord2, coord3)) {
-			startAngle = angle2;
-			endAngle = angle1;
-		} else {
-			startAngle = angle1;
-			endAngle = angle2;
-		}
-		return getArcCoords(center, radius, startAngle, endAngle);
-	}
-}
-
-//#endregion
-//#region geom/arrowAttackDirection.ts
-/**
-* 尖曲箭头
-*/
-function arrowAttackDirection(coords, options = {}) {
-	const coordLength = coords.length;
-	if (coordLength < 3) throw new Error("coords.length must >= 3");
-	else {
-		let [tailLeft, tailRight] = [coords[0], coords[1]];
-		if (isClockWise(coords[0], coords[1], coords[2])) {
-			tailLeft = coords[1];
-			tailRight = coords[0];
-		}
-		const midTail = mid(tailLeft, tailRight);
-		const boneCoords = [midTail].concat(coords.slice(2));
-		const headCoords = getArrowHeadCoords(boneCoords, {
-			tailLeft,
-			tailRight,
-			...options
-		});
-		if (headCoords && headCoords.length > 4) {
-			const [neckLeft, neckRight] = [headCoords[0], headCoords[4]];
-			const tailWidthFactor = mathDistance(tailLeft, tailRight) / getBaseLength(boneCoords);
-			const bodyCoords = getArrowBodyCoords(boneCoords, neckLeft, neckRight, tailWidthFactor);
-			const coordlength = bodyCoords.length;
-			let leftCoords = [tailLeft].concat(bodyCoords.slice(0, coordlength / 2));
-			leftCoords.push(neckLeft);
-			let rightCoords = [tailRight].concat(bodyCoords.slice(coordlength / 2, coordlength));
-			rightCoords.push(neckRight);
-			leftCoords = getQBSplineCoords(leftCoords);
-			rightCoords = getQBSplineCoords(rightCoords);
-			return leftCoords.concat(headCoords, rightCoords.reverse());
-		} else return [];
-	}
-}
-/**
-* 插值头部点
-*/
-function getArrowHeadCoords(points, options) {
-	const { tailLeft, tailRight, headHeightFactor = .18, headWidthFactor = .3, neckHeightFactor = .85, neckWidthFactor = .15, headTailFactor = .8 } = options;
-	let len = getBaseLength(points);
-	let headHeight = len * headHeightFactor;
-	const headCoord = points.at(-1);
-	len = mathDistance(headCoord, points.at(-2));
-	let tailWidth = 0;
-	if (tailLeft && tailRight) tailWidth = mathDistance(tailLeft, tailRight);
-	if (headHeight > tailWidth * headTailFactor) headHeight = tailWidth * headTailFactor;
-	const headWidth = headHeight * headWidthFactor;
-	const neckWidth = headHeight * neckWidthFactor;
-	headHeight = Math.min(headHeight, len);
-	const neckHeight = headHeight * neckHeightFactor;
-	const headEndCoord = getThirdCoord(points.at(-2), headCoord, 0, headHeight, true);
-	const neckEndCoord = getThirdCoord(points.at(-2), headCoord, 0, neckHeight, true);
-	const headLeft = getThirdCoord(headCoord, headEndCoord, HALF_PI, headWidth, false);
-	const headRight = getThirdCoord(headCoord, headEndCoord, HALF_PI, headWidth, true);
-	const neckLeft = getThirdCoord(headCoord, neckEndCoord, HALF_PI, neckWidth, false);
-	const neckRight = getThirdCoord(headCoord, neckEndCoord, HALF_PI, neckWidth, true);
-	return [
-		neckLeft,
-		headLeft,
-		headCoord,
-		headRight,
-		neckRight
-	];
-}
-/**
-* 插值面部分数据
-* @param points
-* @param neckLeft
-* @param neckRight
-* @param tailWidthFactor
-*/
-function getArrowBodyCoords(points, neckLeft, neckRight, tailWidthFactor) {
-	const allLen = wholeDistance(points);
-	const len = getBaseLength(points);
-	const tailWidth = len * tailWidthFactor;
-	const neckWidth = mathDistance(neckLeft, neckRight);
-	const widthDif = (tailWidth - neckWidth) / 2;
-	let tempLen = 0;
-	const leftBodyCoords = [];
-	const rightBodyCoords = [];
-	for (let i = 1; i < points.length - 1; i++) {
-		const angle = getAngleOfThreeCoords(points[i - 1], points[i], points[i + 1]) / 2;
-		tempLen += mathDistance(points[i - 1], points[i]);
-		const w = (tailWidth / 2 - tempLen / allLen * widthDif) / Math.sin(angle);
-		const left = getThirdCoord(points[i - 1], points[i], Math.PI - angle, w, true);
-		const right = getThirdCoord(points[i - 1], points[i], angle, w, false);
-		leftBodyCoords.push(left);
-		rightBodyCoords.push(right);
-	}
-	return leftBodyCoords.concat(rightBodyCoords);
-}
-
-//#endregion
-//#region geom/arrowAttackDirectionTailed.ts
-/**
-* 燕尾尖曲箭头
-*/
-function arrowAttackDirectionTailed(coords, options = {}) {
-	const { headHeightFactor = .18, headWidthFactor = .3, neckHeightFactor = .85, neckWidthFactor = .15, tailWidthFactor = .1, swallowTailFactor = 1 } = options;
-	const coordLength = coords.length;
-	if (coordLength < 3) throw new Error("coords.length must >= 3");
-	let [tailLeft, tailRight] = [coords[0], coords[1]];
-	if (isClockWise(coords[0], coords[1], coords[2])) {
-		tailLeft = coords[1];
-		tailRight = coords[0];
-	}
-	const midTail = mid(tailLeft, tailRight);
-	const boneCoords = [midTail].concat(coords.slice(2));
-	const headCoords = getArrowHeadCoords(boneCoords, {
-		tailLeft,
-		tailRight,
-		headHeightFactor,
-		headWidthFactor,
-		neckWidthFactor,
-		neckHeightFactor
-	});
-	if (headCoords && headCoords.length > 4) {
-		const [neckLeft, neckRight] = [headCoords[0], headCoords[4]];
-		const tailWidth = mathDistance(tailLeft, tailRight);
-		const allLen = getBaseLength(boneCoords);
-		const len = allLen * tailWidthFactor * swallowTailFactor;
-		const swallowTailCoord = getThirdCoord(boneCoords[1], boneCoords[0], 0, len, true);
-		const factor = tailWidth / allLen;
-		const bodyCoords = getArrowBodyCoords(boneCoords, neckLeft, neckRight, factor);
-		const coordlength = bodyCoords.length;
-		let leftCoords = [tailLeft].concat(bodyCoords.slice(0, coordlength / 2));
-		leftCoords.push(neckLeft);
-		let rightCoords = [tailRight].concat(bodyCoords.slice(coordlength / 2, coordlength));
-		rightCoords.push(neckRight);
-		leftCoords = getQBSplineCoords(leftCoords);
-		rightCoords = getQBSplineCoords(rightCoords);
-		return leftCoords.concat(headCoords, rightCoords.reverse(), [swallowTailCoord, leftCoords[0]]);
-	} else return [];
-}
-
-//#endregion
-//#region geom/arrowClamped.ts
-/**
-* 钳击箭头 有效点位长度3,4,5
-*/
-function arrowClamped(coords) {
-	const options = {
-		headHeightFactor: .25,
-		headWidthFactor: .3,
-		neckHeightFactor: .85,
-		neckWidthFactor: .15
-	};
-	if (coords.length < 3) throw new Error(`coords.length must >= 3`);
-	const [coord1, coord2, coord3] = coords;
-	let tempCoord4, connCoord;
-	if (coords.length === 3) {
-		tempCoord4 = getTempCoord4(coord1, coord2, coord3);
-		connCoord = mid(coord1, coord2);
-	} else if (coords.length === 4) {
-		tempCoord4 = coords[3];
-		connCoord = mid(coord1, coord2);
-	} else {
-		tempCoord4 = coords[3];
-		connCoord = coords[4];
-	}
-	let leftArrowCoords;
-	let rightArrowCoords;
-	if (isClockWise(coord1, coord2, coord3)) {
-		leftArrowCoords = getArrowCoords(coord1, connCoord, tempCoord4, false, options);
-		rightArrowCoords = getArrowCoords(connCoord, coord2, coord3, true, options);
-	} else {
-		leftArrowCoords = getArrowCoords(coord2, connCoord, coord3, false, options);
-		rightArrowCoords = getArrowCoords(connCoord, coord1, tempCoord4, true, options);
-	}
-	const m = leftArrowCoords.length;
-	const t = (m - 5) / 2;
-	const llBodyCoords = leftArrowCoords.slice(0, t);
-	const lArrowCoords = leftArrowCoords.slice(t, t + 5);
-	let lrBodyCoords = leftArrowCoords.slice(t + 5, m);
-	let rlBodyCoords = rightArrowCoords.slice(0, t);
-	const rArrowCoords = rightArrowCoords.slice(t, t + 5);
-	const rrBodyCoords = rightArrowCoords.slice(t + 5, m);
-	rlBodyCoords = getBezierCoords(rlBodyCoords);
-	const bodyCoords = getBezierCoords(rrBodyCoords.concat(llBodyCoords.slice(1)));
-	lrBodyCoords = getBezierCoords(lrBodyCoords);
-	return rlBodyCoords.concat(rArrowCoords, bodyCoords, lArrowCoords, lrBodyCoords);
-}
-/**
-* 插值箭形上的点
-* @param coord1  - Wgs84坐标
-* @param coord2 - Wgs84坐标
-* @param coord3 - Wgs84坐标
-* @param clockWise - 是否顺时针
-*/
-function getArrowCoords(coord1, coord2, coord3, clockWise, options) {
-	const midCoord = mid(coord1, coord2);
-	const len = mathDistance(midCoord, coord3);
-	let midCoord1 = getThirdCoord(coord3, midCoord, 0, len * .3, true);
-	let midCoord2 = getThirdCoord(coord3, midCoord, 0, len * .5, true);
-	midCoord1 = getThirdCoord(midCoord, midCoord1, HALF_PI, len / 5, clockWise);
-	midCoord2 = getThirdCoord(midCoord, midCoord2, HALF_PI, len / 4, clockWise);
-	const coords = [
-		midCoord,
-		midCoord1,
-		midCoord2,
-		coord3
-	];
-	const arrowCoords = getArrowHeadCoords$1(coords, options);
-	if (arrowCoords && Array.isArray(arrowCoords) && arrowCoords.length > 0) {
-		const [neckLeftCoord, neckRightCoord] = [arrowCoords[0], arrowCoords[4]];
-		const tailWidthFactor = mathDistance(coord1, coord2) / getBaseLength(coords) / 2;
-		const bodyCoords = getArrowBodyCoords$1(coords, neckLeftCoord, neckRightCoord, tailWidthFactor);
-		const n = bodyCoords.length;
-		let lCoords = bodyCoords.slice(0, n / 2);
-		let rCoords = bodyCoords.slice(n / 2, n);
-		lCoords.push(neckLeftCoord);
-		rCoords.push(neckRightCoord);
-		lCoords = lCoords.reverse();
-		lCoords.push(coord2);
-		rCoords = rCoords.reverse();
-		rCoords.push(coord1);
-		return lCoords.reverse().concat(arrowCoords, rCoords);
-	} else throw new Error("插值出错");
-}
-/**
-* 插值头部点
-* @param coords
-*/
-function getArrowHeadCoords$1(coords, options) {
-	const { headHeightFactor, headWidthFactor, neckWidthFactor, neckHeightFactor } = options;
-	const len = getBaseLength(coords);
-	const headHeight = len * headHeightFactor;
-	const headCoord = coords.at(-1);
-	const headWidth = headHeight * headWidthFactor;
-	const neckWidth = headHeight * neckWidthFactor;
-	const neckHeight = headHeight * neckHeightFactor;
-	const headEndCoord = getThirdCoord(coords.at(-2), headCoord, 0, headHeight, true);
-	const neckEndCoord = getThirdCoord(coords.at(-2), headCoord, 0, neckHeight, true);
-	const headLeft = getThirdCoord(headCoord, headEndCoord, HALF_PI, headWidth, false);
-	const headRight = getThirdCoord(headCoord, headEndCoord, HALF_PI, headWidth, true);
-	const neckLeft = getThirdCoord(headCoord, neckEndCoord, HALF_PI, neckWidth, false);
-	const neckRight = getThirdCoord(headCoord, neckEndCoord, HALF_PI, neckWidth, true);
-	return [
-		neckLeft,
-		headLeft,
-		headCoord,
-		headRight,
-		neckRight
-	];
-}
-/**
-* 插值面部分数据
-* @param coords
-* @param neckLeft
-* @param neckRight
-* @param tailWidthFactor
-*/
-function getArrowBodyCoords$1(coords, neckLeft, neckRight, tailWidthFactor) {
-	const allLen = wholeDistance(coords);
-	const len = getBaseLength(coords);
-	const tailWidth = len * tailWidthFactor;
-	const neckWidth = mathDistance(neckLeft, neckRight);
-	const widthDif = (tailWidth - neckWidth) / 2;
-	let tempLen = 0;
-	const leftBodyCoords = [];
-	const rightBodyCoords = [];
-	for (let i = 1; i < coords.length - 1; i++) {
-		const angle = getAngleOfThreeCoords(coords[i - 1], coords[i], coords[i + 1]) / 2;
-		tempLen += mathDistance(coords[i - 1], coords[i]);
-		const w = (tailWidth / 2 - tempLen / allLen * widthDif) / Math.sin(angle);
-		const left = getThirdCoord(coords[i - 1], coords[i], Math.PI - angle, w, true);
-		const right = getThirdCoord(coords[i - 1], coords[i], angle, w, false);
-		leftBodyCoords.push(left);
-		rightBodyCoords.push(right);
-	}
-	return leftBodyCoords.concat(rightBodyCoords);
-}
-/**
-* 获取对称点
-* @param lineCoord1
-* @param lineCoord2
-* @param coord
-*/
-function getTempCoord4(lineCoord1, lineCoord2, coord) {
-	const midCoord = mid(lineCoord1, lineCoord2);
-	const len = mathDistance(midCoord, coord);
-	const angle = getAngleOfThreeCoords(lineCoord1, midCoord, coord);
-	if (angle < HALF_PI) {
-		const distance1 = len * Math.sin(angle);
-		const distance2 = len * Math.cos(angle);
-		const mid$1 = getThirdCoord(lineCoord1, midCoord, HALF_PI, distance1, false);
-		return getThirdCoord(midCoord, mid$1, HALF_PI, distance2, true);
-	} else if (angle >= HALF_PI && angle < Math.PI) {
-		const distance1 = len * Math.sin(Math.PI - angle);
-		const distance2 = len * Math.cos(Math.PI - angle);
-		const mid$1 = getThirdCoord(lineCoord1, midCoord, HALF_PI, distance1, false);
-		return getThirdCoord(midCoord, mid$1, HALF_PI, distance2, false);
-	} else if (angle >= Math.PI && angle < Math.PI * 1.5) {
-		const distance1 = len * Math.sin(angle - Math.PI);
-		const distance2 = len * Math.cos(angle - Math.PI);
-		const mid$1 = getThirdCoord(lineCoord1, midCoord, HALF_PI, distance1, true);
-		return getThirdCoord(midCoord, mid$1, HALF_PI, distance2, true);
-	} else {
-		const distance1 = len * Math.sin(Math.PI * 2 - angle);
-		const distance2 = len * Math.cos(Math.PI * 2 - angle);
-		const mid$1 = getThirdCoord(lineCoord1, midCoord, HALF_PI, distance1, true);
-		return getThirdCoord(midCoord, mid$1, HALF_PI, distance2, false);
-	}
-}
-
-//#endregion
-//#region geom/arrowStraightSharp.ts
-/**
-* 尖箭头
-*
-*/
-function arrowStraightSharp(coords, options = {}) {
-	const { tailWidthFactor = .1, neckWidthFactor = .2, headWidthFactor = .25, headAngle = Math.PI / 8.5, neckAngle = Math.PI / 13 } = options;
-	const coordlength = coords.length;
-	if (coordlength < 2) throw new Error("coords.length must >= 2");
-	const [coord1, coord2] = [coords[0], coords[1]];
-	const len = getBaseLength(coords);
-	const tailWidth = len * tailWidthFactor;
-	const neckWidth = len * neckWidthFactor;
-	const headWidth = len * headWidthFactor;
-	const tailLeft = getThirdCoord(coord2, coord1, HALF_PI, tailWidth, true);
-	const tailRight = getThirdCoord(coord2, coord1, HALF_PI, tailWidth, false);
-	const headLeft = getThirdCoord(coord1, coord2, headAngle, headWidth, false);
-	const headRight = getThirdCoord(coord1, coord2, headAngle, headWidth, true);
-	const neckLeft = getThirdCoord(coord1, coord2, neckAngle, neckWidth, false);
-	const neckRight = getThirdCoord(coord1, coord2, neckAngle, neckWidth, true);
-	const pList = [
-		tailLeft,
-		neckLeft,
-		headLeft,
-		coord2,
-		headRight,
-		neckRight,
-		tailRight
-	];
-	return pList;
-}
-
-//#endregion
-//#region geom/arrowStraight.ts
-/**
-* 直箭头
-*/
-function arrowStraight(coords) {
-	const tailWidthFactor = .05;
-	const neckWidthFactor = .1;
-	const headWidthFactor = .15;
-	const headAngle = Math.PI / 4;
-	const neckAngle = Math.PI * .17741;
-	return arrowStraightSharp(coords, {
-		tailWidthFactor,
-		neckWidthFactor,
-		headWidthFactor,
-		headAngle,
-		neckAngle
-	});
-}
-
-//#endregion
-//#region geom/arrowUnitCombatOperation.ts
-/**
-* 分队战斗行动（尖曲箭头）
-*/
-function arrowUnitCombatOperation(coords, options = {}) {
-	const { headHeightFactor = .18, headWidthFactor = .3, neckHeightFactor = .85, neckWidthFactor = .15, tailWidthFactor = .1 } = options;
-	const coordlength = coords.length;
-	if (coordlength < 2) throw new Error("coords.length must >= 2");
-	else {
-		const allLen = getBaseLength(coords);
-		const tailWidth = allLen * tailWidthFactor;
-		const tailLeft = getThirdCoord(coords[1], coords[0], HALF_PI, tailWidth, false);
-		const tailRight = getThirdCoord(coords[1], coords[0], HALF_PI, tailWidth, true);
-		const headCoords = getArrowHeadCoords(coords, {
-			tailLeft,
-			tailRight,
-			headHeightFactor,
-			headWidthFactor,
-			neckWidthFactor,
-			neckHeightFactor
-		});
-		if (headCoords && headCoords.length > 4) {
-			const neckLeft = headCoords[0];
-			const neckRight = headCoords[4];
-			const bodyCoords = getArrowBodyCoords(coords, neckLeft, neckRight, tailWidthFactor);
-			const coordlength$1 = bodyCoords.length;
-			let leftCoords = [tailLeft].concat(bodyCoords.slice(0, coordlength$1 / 2));
-			leftCoords.push(neckLeft);
-			let rightCoords = [tailRight].concat(bodyCoords.slice(coordlength$1 / 2, coordlength$1));
-			rightCoords.push(neckRight);
-			leftCoords = getQBSplineCoords(leftCoords);
-			rightCoords = getQBSplineCoords(rightCoords);
-			return leftCoords.concat(headCoords, rightCoords.reverse());
-		} else return [];
-	}
-}
-
-//#endregion
-//#region geom/arrowUnitCombatOperationTailed.ts
-/**
-* 燕尾尖箭头
-*/
-function arrowUnitCombatOperationTailed(coords, options = {}) {
-	const { headHeightFactor = .18, headWidthFactor = .3, neckHeightFactor = .85, neckWidthFactor = .15, tailWidthFactor = .1, swallowTailFactor = 1 } = options;
-	const coordlength = coords.length;
-	if (coordlength < 2) throw new Error("coords.length must >= 2");
-	const allLen = getBaseLength(coords);
-	const tailWidth = allLen * tailWidthFactor;
-	const tailLeft = getThirdCoord(coords[1], coords[0], HALF_PI, tailWidth, false);
-	const tailRight = getThirdCoord(coords[1], coords[0], HALF_PI, tailWidth, true);
-	const len = tailWidth * swallowTailFactor;
-	const swallowTailCoord = getThirdCoord(coords[1], coords[0], 0, len, true);
-	const tailCoords = [
-		tailLeft,
-		swallowTailCoord,
-		tailRight
-	];
-	const headCoords = getArrowHeadCoords(coords, {
-		tailLeft: tailCoords[0],
-		tailRight: tailCoords[2],
-		headHeightFactor,
-		headWidthFactor,
-		neckWidthFactor,
-		neckHeightFactor
-	});
-	if (headCoords && headCoords.length > 4) {
-		const neckLeft = headCoords[0];
-		const neckRight = headCoords[4];
-		const bodyCoords = getArrowBodyCoords(coords, neckLeft, neckRight, tailWidthFactor);
-		const coordlength$1 = bodyCoords.length;
-		let leftCoords = [tailCoords[0]].concat(bodyCoords.slice(0, coordlength$1 / 2));
-		leftCoords.push(neckLeft);
-		let rightCoords = [tailCoords[2]].concat(bodyCoords.slice(coordlength$1 / 2, coordlength$1));
-		rightCoords.push(neckRight);
-		leftCoords = getQBSplineCoords(leftCoords);
-		rightCoords = getQBSplineCoords(rightCoords);
-		return leftCoords.concat(headCoords, rightCoords.reverse(), [tailCoords[1], leftCoords[0]]);
-	}
-	return [];
-}
-
-//#endregion
-//#region geom/assemblingPlace.ts
-/**
-* 集结地
-*
-*/
-function assemblingPlace(coords) {
-	if (coords.length < 3) throw new Error(`coords.length must >= 3`);
-	const t = .4;
-	const midCoord = mid(coords[0], coords[2]);
-	coords.push(midCoord, coords[0], coords[1]);
-	let normals = [];
-	const pList = [];
-	for (let i = 0; i < coords.length - 2; i++) {
-		const coord1 = coords[i];
-		const coord2 = coords[i + 1];
-		const coord3 = coords[i + 2];
-		const normalCoords = getBisectorNormals(t, coord1, coord2, coord3);
-		normals = normals.concat(normalCoords);
-	}
-	const count = normals.length;
-	normals = [normals[count - 1]].concat(normals.slice(0, count - 1));
-	for (let i = 0; i < coords.length - 2; i++) {
-		const coord1 = coords[i];
-		const coord2 = coords[i + 1];
-		pList.push(coord1);
-		for (let t$1 = 0; t$1 <= FITTING_COUNT; t$1++) {
-			const coord = getCubicValue(t$1 / FITTING_COUNT, coord1, normals[i * 2], normals[i * 2 + 1], coord2);
-			pList.push(coord);
-		}
-		pList.push(coord2);
-	}
-	return pList;
-}
-
-//#endregion
-//#region geom/flagCurve.ts
-/**
-* 曲线旗标
-*/
-function flagCurve(coords) {
-	const coordlength = coords.length;
-	if (coordlength < 2) throw new Error("coords.length must >= 2");
-	return calculatePonits(coords);
-}
-/**
-* 插值点数据
-* @param coords
-*/
-function calculatePonits(coords) {
-	let components = [];
-	if (coords.length > 1) {
-		const startCoord = coords[0];
-		const endCoord = coords.at(-1);
-		const coord1 = startCoord;
-		const coord2 = [(endCoord[0] - startCoord[0]) / 4 + startCoord[0], (endCoord[1] - startCoord[1]) / 8 + startCoord[1]];
-		const coord3 = [(startCoord[0] + endCoord[0]) / 2, startCoord[1]];
-		const coord4 = [(endCoord[0] - startCoord[0]) * 3 / 4 + startCoord[0], -(endCoord[1] - startCoord[1]) / 8 + startCoord[1]];
-		const coord5 = [endCoord[0], startCoord[1]];
-		const coord6 = [endCoord[0], (startCoord[1] + endCoord[1]) / 2];
-		const coord7 = [(endCoord[0] - startCoord[0]) * 3 / 4 + startCoord[0], (endCoord[1] - startCoord[1]) * 3 / 8 + startCoord[1]];
-		const coord8 = [(startCoord[0] + endCoord[0]) / 2, (startCoord[1] + endCoord[1]) / 2];
-		const coord9 = [(endCoord[0] - startCoord[0]) / 4 + startCoord[0], (endCoord[1] - startCoord[1]) * 5 / 8 + startCoord[1]];
-		const coord10 = [startCoord[0], (startCoord[1] + endCoord[1]) / 2];
-		const coord11 = [startCoord[0], endCoord[1]];
-		const curve1 = getBezierCoords([
-			coord1,
-			coord2,
-			coord3,
-			coord4,
-			coord5
-		]);
-		const curve2 = getBezierCoords([
-			coord6,
-			coord7,
-			coord8,
-			coord9,
-			coord10
-		]);
-		components = curve1.concat(curve2);
-		components.push(coord11);
-	}
-	return components;
-}
-
-//#endregion
-//#region geom/flagRect.ts
-/**
-* 直角旗标（使用两个控制点直接创建直角旗标）
-*/
-function flagRect(coords) {
-	if (coords.length < 2) throw new Error("coords.length must >= 2");
-	const [startCoord, endCoord] = coords;
-	const coord1 = [endCoord[0], startCoord[1]];
-	const coord2 = [endCoord[0], (startCoord[1] + endCoord[1]) / 2];
-	const coord3 = [startCoord[0], (startCoord[1] + endCoord[1]) / 2];
-	const coord4 = [startCoord[0], endCoord[1]];
-	return [
-		startCoord,
-		coord1,
-		coord2,
-		coord3,
-		coord4
-	];
-}
-
-//#endregion
-//#region geom/flagTriangle.ts
+//#region scheme/PolygonArc.ts
 /**
-* 三角旗标（使用两个控制点直接创建三角旗标）
+* 弓形
 */
-function flagTriangle(coords) {
-	const coordlength = coords.length;
-	if (coordlength < 2) throw new Error("coords.length must >= 2");
-	const [startCoord, endCoord] = coords;
-	const coord1 = [endCoord[0], (startCoord[1] + endCoord[1]) / 2];
-	const coord2 = [startCoord[0], (startCoord[1] + endCoord[1]) / 2];
-	const coord3 = [startCoord[0], endCoord[1]];
-	return [
-		startCoord,
-		coord1,
-		coord2,
-		coord3
-	];
-}
-
-//#endregion
-//#region scheme/PolygonArc.ts
 const PlotSchemePolygonArc = new PlotScheme({
 	type: "PolygonArc",
 	complete: (packable) => packable.positions.length >= 3,
@@ -2603,8 +1686,7 @@ const PlotSchemePolygonArc = new PlotScheme({
 			entity.polygon.hierarchy = void 0;
 			return context.previous;
 		}
-		const positions = arc(coords).map((item) => (0, vesium.toCartesian3)(item));
-		const hierarchy = new cesium.PolygonHierarchy(positions);
+		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] };
 	}
@@ -2632,8 +1714,7 @@ const PlotSchemePolygonArrowAttackDirection = new PlotScheme({
 			entity.polygon.hierarchy = void 0;
 			return context.previous;
 		}
-		const positions = arrowAttackDirection(coords).map((item) => (0, vesium.toCartesian3)(item));
-		const hierarchy = new cesium.PolygonHierarchy(positions);
+		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] };
 	}
@@ -2661,8 +1742,7 @@ const PlotSchemePolygonArrowAttackDirectionTailed = new PlotScheme({
 			entity.polygon.hierarchy = void 0;
 			return context.previous;
 		}
-		const positions = arrowAttackDirectionTailed(coords).map((item) => (0, vesium.toCartesian3)(item));
-		const hierarchy = new cesium.PolygonHierarchy(positions);
+		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] };
 	}
@@ -2686,8 +1766,7 @@ const PlotSchemePolygonArrowClamped = new PlotScheme({
 		}
 		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)));
+			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] };
@@ -2712,8 +1791,7 @@ const PlotSchemePolygonArrowStraight = new PlotScheme({
 		}
 		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)));
+			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] };
@@ -2738,8 +1816,7 @@ const PlotSchemePolygonArrowStraightSharp = new PlotScheme({
 		}
 		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)));
+			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] };
@@ -2768,8 +1845,7 @@ const PlotSchemePolygonArrowUnitCombatOperation = new PlotScheme({
 			entity.polygon.hierarchy = void 0;
 			return context.previous;
 		}
-		const positions = arrowUnitCombatOperation(coords).map((item) => (0, vesium.toCartesian3)(item));
-		const hierarchy = new cesium.PolygonHierarchy(positions);
+		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] };
 	}
@@ -2797,8 +1873,7 @@ const PlotSchemePolygonArrowUnitCombatOperationTailed = new PlotScheme({
 			entity.polygon.hierarchy = void 0;
 			return context.previous;
 		}
-		const positions = arrowUnitCombatOperationTailed(coords).map((item) => (0, vesium.toCartesian3)(item));
-		const hierarchy = new cesium.PolygonHierarchy(positions);
+		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] };
 	}
@@ -2826,83 +1901,15 @@ const PlotSchemePolygonAssemblingPlace = new PlotScheme({
 			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;
+		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 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 positions = flagTriangle(coords).map((item) => (0, vesium.toCartesian3)(item));
-		const hierarchy = new cesium.PolygonHierarchy(positions);
+		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] };
 	}
@@ -2910,6 +1917,9 @@ const PlotSchemePolygonFlagTriangle = new PlotScheme({
 
 //#endregion
 //#region scheme/PolygonSmooth.ts
+/**
+* polygon-smooth 标绘配置 平滑闭合面
+*/
 const PlotSchemePolygonSmooth = new PlotScheme({
 	type: "PolygonSmooth",
 	allowManualComplete: (packable) => packable.positions.length >= 3,
@@ -2933,8 +1943,7 @@ const PlotSchemePolygonSmooth = new PlotScheme({
 		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);
+		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] };
 	}
@@ -2942,6 +1951,9 @@ const PlotSchemePolygonSmooth = new PlotScheme({
 
 //#endregion
 //#region scheme/Polyline.ts
+/**
+* polyline
+*/
 const PlotSchemePolyline = new PlotScheme({
 	type: "Polyline",
 	allowManualComplete: (packable) => packable.positions.length > 1,
@@ -2969,6 +1981,9 @@ const PlotSchemePolyline = new PlotScheme({
 
 //#endregion
 //#region scheme/PolylineCurve.ts
+/**
+* polyline-Curve
+*/
 const PlotSchemePolylineCurve = new PlotScheme({
 	type: "PolylineCurve",
 	allowManualComplete: (packable) => packable.positions.length > 1,
@@ -3001,6 +2016,9 @@ const PlotSchemePolylineCurve = new PlotScheme({
 
 //#endregion
 //#region scheme/Rectangle.ts
+/**
+* rectangle
+*/
 const PlotSchemeRectangle = new PlotScheme({
 	type: "Rectangle",
 	complete: (packable) => packable.positions.length >= 2,
@@ -3043,9 +2061,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;