@cn-map/gaode-vue 0.0.0 → 0.0.1

package/dist/index.js

@@ -0,0 +1,4717 @@
+import { a as toDefinedRaw, i as shallowReactiveOmit, n as useMap, o as use_event_listeners_default, r as useMapInstance, t as setMapContext } from "./context-BEyZOuBr.js";
+import { Fragment, Teleport, computed, createBlock, createCommentVNode, createElementBlock, createPropsRestProxy, defineComponent, inject, nextTick, normalizeClass, normalizeStyle, onBeforeUnmount, onMounted, onUnmounted, openBlock, provide, ref, renderSlot, shallowReactive, shallowRef, toRaw, toValue, unref, useId, useSlots, useTemplateRef, watch, watchEffect, withCtx } from "vue";
+import { LoadStatus, getAPIStatus, load, reset, subscribeAPIStatus } from "@cn-map/gaode-jsapi-loader";
+import { clone, logger, lostContextError, lowercase } from "@cn-map/gaode-shared/utils";
+import { add, addNode, adjust, click, close, complete, dblClick, dragEnd, dragStart, dragging, draw, end, error, hide, hotspotClick, hotspotOut, hotspotOver, mapMove, mouseDown, mouseMove, mouseOut, mouseOver, mouseUp, mouseWheel, move, moveAlong, moveEnd, moveStart, moving, open, pitchChange, pitchEnd, pitchStart, removeNode, resize, rightClick, rotateChange, rotateEnd, rotateStart, show, touchEnd, touchMove, touchStart, viewChange, zoomChange, zoomEnd, zoomStart } from "@cn-map/gaode-shared/const";
+import { patchContextMenu, patchMap, patchPolygonEditor } from "@cn-map/gaode-shared/patch";
+// src/api-loader/context.ts
+const status = shallowRef({ ...getAPIStatus() });
+subscribeAPIStatus(() => {
+	status.value = { ...getAPIStatus() };
+});
+function useAPIStatus(type) {
+	return computed(() => type ? status.value[type] : status.value);
+}
+// src/api-loader/use-api-loader.ts
+/**
+* 加载高德地图依赖的 Hook
+* @param {ShallowReactive<APILoaderOptions>} config - 加载高德地图API的配置项
+* @param {boolean} [resetOnUnmounted=false] - 组件卸载时是否重置全局 JSAPI 状态
+*/
+const useAPILoader = (config, resetOnUnmounted = false) => {
+	const error = shallowRef(null);
+	onMounted(() => {
+		watch(() => ({
+			...config,
+			key: config.apiKey
+		}), (val) => {
+			load(val).catch((err) => {
+				if (err instanceof Error || err instanceof Event) error.value = err;
+				else throw new Error(`Unexpected error when loading API`, { cause: err });
+			});
+		}, { immediate: true });
+	});
+	onUnmounted(() => {
+		if (resetOnUnmounted) reset();
+	});
+	return {
+		status: useAPIStatus(),
+		error: computed(() => error.value)
+	};
+};
+// src/api-loader/api-loader.vue
+var api_loader_default = /* @__PURE__ */ defineComponent({
+	name: "APILoader",
+	inheritAttrs: false,
+	__name: "api-loader",
+	props: {
+		resetOnUnmounted: {
+			type: Boolean,
+			default: false
+		},
+		apiKey: {},
+		version: {},
+		plugins: {},
+		AMapUI: {},
+		Loca: {}
+	},
+	setup(__props) {
+		const props = createPropsRestProxy(__props, ["resetOnUnmounted"]);
+		const { status, error } = useAPILoader(props, __props.resetOnUnmounted);
+		return (_ctx, _cache) => {
+			return renderSlot(_ctx.$slots, "default", {
+				status: unref(status),
+				error: unref(error)
+			});
+		};
+	}
+});
+// src/composables/use-instance.ts
+var use_instance_default = (key) => {
+	const componentRef = useTemplateRef(key);
+	return computed(() => componentRef.value?.instance);
+};
+// src/map/map.vue?vue&type=script&setup=true&lang.ts
+const _hoisted_1 = ["id"];
+// src/map/map.vue
+var map_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.Map",
+	inheritAttrs: false,
+	__name: "map",
+	props: {
+		immediately: {
+			type: [Boolean, Object],
+			default: void 0
+		},
+		duration: {},
+		container: {},
+		asyncOverlay: {
+			type: Boolean,
+			default: void 0
+		},
+		backgroundColor: {},
+		buildingColor: {},
+		cacheSize: {},
+		center: {},
+		defaultCursor: {},
+		labelRejectMask: {
+			type: Boolean,
+			default: void 0
+		},
+		langForeign: {},
+		languageCode: {},
+		layers: {},
+		limitBounds: {},
+		mask: {},
+		overseaDataType: {},
+		pitch: {},
+		poiIcon: {},
+		roofColor: {},
+		rotation: {},
+		showLabel: {
+			type: Boolean,
+			default: void 0
+		},
+		showOversea: {
+			type: Boolean,
+			default: void 0
+		},
+		showIndoorMap: {
+			type: Boolean,
+			default: void 0
+		},
+		skyColor: {},
+		terrain: {
+			type: Boolean,
+			default: void 0
+		},
+		vdataProxy: {},
+		vectorMapForeign: {
+			type: [Boolean, String],
+			default: void 0
+		},
+		viewMode: {},
+		wallColor: {},
+		WebGLParams: {},
+		zoom: {},
+		zooms: {},
+		allBubble: {
+			type: Boolean,
+			default: void 0
+		},
+		animateEnable: {
+			type: Boolean,
+			default: void 0
+		},
+		doubleClickZoom: {
+			type: Boolean,
+			default: void 0
+		},
+		dragEnable: {
+			type: Boolean,
+			default: void 0
+		},
+		features: {},
+		isHotspot: {
+			type: Boolean,
+			default: void 0
+		},
+		jogEnable: {
+			type: Boolean,
+			default: void 0
+		},
+		keyboardEnable: {
+			type: Boolean,
+			default: void 0
+		},
+		mapStyle: {},
+		pickWhenMoving: {
+			type: Boolean,
+			default: void 0
+		},
+		pitchEnable: {
+			type: Boolean,
+			default: void 0
+		},
+		rotateEnable: {
+			type: Boolean,
+			default: void 0
+		},
+		scrollWheel: {
+			type: Boolean,
+			default: void 0
+		},
+		showBuildingBlock: {
+			type: Boolean,
+			default: void 0
+		},
+		touchZoom: {
+			type: Boolean,
+			default: void 0
+		},
+		touchZoomCenter: {},
+		zoomEnable: {
+			type: Boolean,
+			default: void 0
+		},
+		zoomSpeed: {}
+	},
+	emits: [
+		"click",
+		"complete",
+		"dblClick",
+		"dragEnd",
+		"dragging",
+		"dragStart",
+		"hotspotClick",
+		"hotspotOut",
+		"hotspotOver",
+		"mapMove",
+		"mouseDown",
+		"mouseMove",
+		"mouseOut",
+		"mouseOver",
+		"mouseUp",
+		"mouseWheel",
+		"moveEnd",
+		"moveStart",
+		"pitchChange",
+		"pitchEnd",
+		"pitchStart",
+		"resize",
+		"rightClick",
+		"rotateChange",
+		"rotateEnd",
+		"rotateStart",
+		"touchEnd",
+		"touchMove",
+		"touchStart",
+		"viewChange",
+		"zoomChange",
+		"zoomEnd",
+		"zoomStart"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const mapEvents = [
+			click,
+			complete,
+			dblClick,
+			dragEnd,
+			dragging,
+			dragStart,
+			hotspotClick,
+			hotspotOut,
+			hotspotOver,
+			mapMove,
+			viewChange,
+			mouseDown,
+			mouseMove,
+			mouseOut,
+			mouseOver,
+			mouseUp,
+			mouseWheel,
+			moveEnd,
+			moveStart,
+			pitchChange,
+			pitchEnd,
+			pitchStart,
+			resize,
+			rightClick,
+			rotateChange,
+			rotateEnd,
+			rotateStart,
+			touchEnd,
+			touchMove,
+			touchStart,
+			zoomChange,
+			zoomEnd,
+			zoomStart
+		];
+		const mapSetOptions = [
+			["center", "setCenter"],
+			["pitch", "setPitch"],
+			["rotation", "setRotation"],
+			["zoom", "setZoom"]
+		];
+		const mapStatusKeys = [
+			"allBubble",
+			"animateEnable",
+			"doubleClickZoom",
+			"dragEnable",
+			"features",
+			"isHotspot",
+			"jogEnable",
+			"keyboardEnable",
+			"pickWhenMoving",
+			"pitchEnable",
+			"rotateEnable",
+			"scrollWheel",
+			"showBuildingBlock",
+			"touchZoom",
+			"touchZoomCenter",
+			"zoomEnable",
+			"zoomSpeed"
+		];
+		function getContainer(container) {
+			if (container === void 0) return container;
+			if (typeof container === "string") return document.getElementById(container);
+			else return toValue(container);
+		}
+		patchMap();
+		const id = `map-gaode-${useId()}`;
+		const container = ref();
+		const containerStyles = shallowReactive({});
+		const map = shallowRef(null);
+		setMapContext(map);
+		async function setContainer(el) {
+			if (!el || el === container.value) return;
+			if (el.offsetWidth === 0 || el.offsetHeight === 0) await nextTick();
+			container.value = el;
+			containerStyles.cursor = container.value.style.getPropertyValue("cursor");
+			containerStyles.backgroundColor = container.value.style.getPropertyValue("background-color");
+			try {
+				map.value = new AMap.Map(container.value, toDefinedRaw(shallowReactiveOmit(props, "container", "immediately", "duration")));
+			} catch (e) {
+				logger.error("init map error", e);
+			}
+		}
+		const setEl = (el) => {
+			setContainer(el);
+		};
+		function resetStyle(target, property, value) {
+			if (value) target.value?.style.setProperty(property, value);
+			else target.value?.style.removeProperty(property);
+		}
+		function destroyMap() {
+			container.value?.classList.remove("amap-container");
+			resetStyle(container, "cursor", containerStyles.cursor);
+			resetStyle(container, "background-color", containerStyles.backgroundColor);
+			map.value?.clearInfoWindow();
+			map.value?.clearMap();
+			map.value?.destroy();
+			map.value = null;
+		}
+		watch(() => props.container, async (newVal) => {
+			destroyMap();
+			await setContainer(getContainer(newVal));
+		}, {
+			immediate: true,
+			flush: "post"
+		});
+		mapSetOptions.forEach(([key, method]) => {
+			watch(() => props[key], (val) => {
+				if (val !== void 0) map.value?.[method](key === "center" ? clone(toRaw(val)) : val, typeof props.immediately === "boolean" ? props.immediately : props.immediately?.[key], typeof props.duration === "number" ? props.duration : props.duration?.[key]);
+			});
+		});
+		watch(() => props.zooms, (val) => {
+			if (val !== void 0) map.value?.setZooms(clone(toRaw(val)));
+		});
+		watch(() => props.labelRejectMask, (val) => {
+			if (val !== void 0) map.value?.setLabelRejectMask(val);
+		});
+		watch(() => props.mapStyle, (val) => {
+			if (val !== void 0) map.value?.setMapStyle(val);
+		});
+		watch(() => props.mask, (val) => {
+			if (val !== void 0) map.value?.setMask(clone(toRaw(val)));
+		});
+		watch(() => props.layers, (val) => {
+			if (val !== void 0) map.value?.setLayers(val);
+		});
+		watch(() => props.showLabel, (val) => {
+			if (val !== void 0) {
+				map.value?.set("showLabel", val);
+				map.value?.setNeedUpdate(true);
+			}
+		});
+		mapStatusKeys.forEach((key) => {
+			watch(() => props[key], (val) => {
+				map.value?.setStatus({ [key]: val });
+			});
+		});
+		use_event_listeners_default(map, emits, mapEvents);
+		__expose({ instance: map });
+		onUnmounted(destroyMap);
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock(Fragment, null, [_ctx.$props.container === void 0 ? (openBlock(), createElementBlock("div", {
+				key: 0,
+				id: typeof _ctx.$attrs.id === "string" ? _ctx.$attrs.id : id,
+				ref: setEl,
+				class: normalizeClass(_ctx.$attrs.class),
+				style: normalizeStyle({
+					width: "100%",
+					height: "100%",
+					..._ctx.$attrs.style || {}
+				})
+			}, null, 14, _hoisted_1)) : createCommentVNode("v-if", true), renderSlot(_ctx.$slots, "default")], 64);
+		};
+	}
+});
+// src/control/control/control.ts
+const controlEvents = [hide, show];
+function useControlAttributes(control, props) {
+	watch(() => props.visible, (val) => {
+		if (val !== void 0) {
+			if (val) control.value.show();
+			else control.value.hide();
+		}
+	});
+}
+// src/control/control-bar/control-bar.vue
+var control_bar_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.ControlBar",
+	inheritAttrs: false,
+	__name: "control-bar",
+	props: {
+		map: {},
+		showControlButton: {
+			type: Boolean,
+			default: void 0
+		},
+		position: {},
+		offset: {},
+		visible: {
+			type: Boolean,
+			default: void 0
+		}
+	},
+	emits: ["hide", "show"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const controlBarEvents = controlEvents;
+		const map = useMapInstance(props);
+		const restProps = shallowReactiveOmit(props, "map");
+		const controlBar = shallowRef(new AMap.ControlBar(toDefinedRaw(restProps)));
+		watchEffect((onCleanup) => {
+			map.value?.addControl(controlBar.value);
+			onCleanup(() => {
+				map.value?.removeControl(controlBar.value);
+			});
+		});
+		useControlAttributes(controlBar, restProps);
+		use_event_listeners_default(controlBar, emits, controlBarEvents);
+		__expose({ instance: controlBar });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/control/geolocation/geolocation.vue
+var geolocation_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.Geolocation",
+	inheritAttrs: false,
+	__name: "geolocation",
+	props: {
+		map: {},
+		GeoLocationFirst: {
+			type: Boolean,
+			default: void 0
+		},
+		borderColor: {},
+		borderRadius: {},
+		buttonSize: {},
+		circleOptions: {},
+		convert: {
+			type: Boolean,
+			default: void 0
+		},
+		enableHighAccuracy: {
+			type: Boolean,
+			default: void 0
+		},
+		extensions: {},
+		getCityWhenFail: {
+			type: Boolean,
+			default: void 0
+		},
+		markerOptions: {},
+		maximumAge: {},
+		needAddress: {
+			type: Boolean,
+			default: void 0
+		},
+		noGeoLocation: {
+			type: Boolean,
+			default: void 0
+		},
+		noIpLocate: {
+			type: Boolean,
+			default: void 0
+		},
+		panToLocation: {
+			type: Boolean,
+			default: void 0
+		},
+		showButton: {
+			type: Boolean,
+			default: void 0
+		},
+		showCircle: {
+			type: Boolean,
+			default: void 0
+		},
+		showMarker: {
+			type: Boolean,
+			default: void 0
+		},
+		timeout: {},
+		useNative: {
+			type: Boolean,
+			default: void 0
+		},
+		zoomToAccuracy: {
+			type: Boolean,
+			default: void 0
+		},
+		position: {},
+		offset: {},
+		visible: {
+			type: Boolean,
+			default: void 0
+		}
+	},
+	emits: [
+		"hide",
+		"show",
+		"complete",
+		"error"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const geolocationEvents = [
+			...controlEvents,
+			complete,
+			error
+		];
+		const map = useMapInstance(props);
+		const restProps = shallowReactiveOmit(props, "map");
+		const geolocation = shallowRef(new AMap.Geolocation(toDefinedRaw(restProps)));
+		watchEffect((onCleanup) => {
+			map.value?.addControl(geolocation.value);
+			onCleanup(() => {
+				map.value?.removeControl(geolocation.value);
+			});
+		});
+		useControlAttributes(geolocation, restProps);
+		use_event_listeners_default(geolocation, emits, geolocationEvents);
+		__expose({ instance: geolocation });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/control/hawk-eye/hawk-eye.vue
+var hawk_eye_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.HawkEye",
+	inheritAttrs: false,
+	__name: "hawk-eye",
+	props: {
+		map: {},
+		autoMove: {
+			type: Boolean,
+			default: void 0
+		},
+		showRectangle: {
+			type: Boolean,
+			default: void 0
+		},
+		showButton: {
+			type: Boolean,
+			default: void 0
+		},
+		opened: {
+			type: Boolean,
+			default: void 0
+		},
+		mapStyle: {},
+		layers: {},
+		width: {},
+		height: {},
+		offset: {},
+		borderStyle: {},
+		borderColor: {},
+		borderRadius: {},
+		borderWidth: {},
+		buttonSize: {},
+		position: {},
+		visible: {
+			type: Boolean,
+			default: void 0
+		}
+	},
+	emits: ["hide", "show"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const hawkEyeEvents = controlEvents;
+		const map = useMapInstance(props);
+		const restProps = shallowReactiveOmit(props, "map");
+		const hawkEye = shallowRef(new AMap.HawkEye(toDefinedRaw(restProps)));
+		watchEffect((onCleanup) => {
+			map.value?.addControl(hawkEye.value);
+			onCleanup(() => {
+				map.value?.removeControl(hawkEye.value);
+			});
+		});
+		useControlAttributes(hawkEye, restProps);
+		use_event_listeners_default(hawkEye, emits, hawkEyeEvents);
+		__expose({ instance: hawkEye });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/control/map-type/map-type.vue
+var map_type_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.MapType",
+	inheritAttrs: false,
+	__name: "map-type",
+	props: {
+		map: {},
+		defaultType: {},
+		showTraffic: {
+			type: Boolean,
+			default: void 0
+		},
+		showRoad: {
+			type: Boolean,
+			default: void 0
+		},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		position: {}
+	},
+	emits: ["hide", "show"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const mapTypeEvents = controlEvents;
+		const map = useMapInstance(props);
+		const restProps = shallowReactiveOmit(props, "map");
+		const mapType = shallowRef(new AMap.MapType(toDefinedRaw(restProps)));
+		watchEffect((onCleanup) => {
+			map.value?.addControl(mapType.value);
+			onCleanup(() => {
+				mapType.value._config.layerInfos.forEach((layerInfo) => {
+					layerInfo.layer.setMap(null);
+					layerInfo.layer.destroy();
+				});
+				map.value?.removeControl(mapType.value);
+			});
+		});
+		useControlAttributes(mapType, restProps);
+		use_event_listeners_default(mapType, emits, mapTypeEvents);
+		__expose({ instance: mapType });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/control/scale/scale.vue
+var scale_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.Scale",
+	inheritAttrs: false,
+	__name: "scale",
+	props: {
+		map: {},
+		position: {},
+		offset: {},
+		visible: {
+			type: Boolean,
+			default: void 0
+		}
+	},
+	emits: ["hide", "show"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const scaleEvents = controlEvents;
+		const map = useMapInstance(props);
+		const restProps = shallowReactiveOmit(props, "map");
+		const scale = shallowRef(new AMap.Scale(toDefinedRaw(restProps)));
+		watchEffect((onCleanup) => {
+			map.value?.addControl(scale.value);
+			onCleanup(() => {
+				map.value?.removeControl(scale.value);
+			});
+		});
+		useControlAttributes(scale, restProps);
+		use_event_listeners_default(scale, emits, scaleEvents);
+		__expose({ instance: scale });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/control/tool-bar/tool-bar.vue
+var tool_bar_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.ToolBar",
+	inheritAttrs: false,
+	__name: "tool-bar",
+	props: {
+		map: {},
+		position: {},
+		offset: {},
+		visible: {
+			type: Boolean,
+			default: void 0
+		}
+	},
+	emits: ["hide", "show"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const toolBarEvents = controlEvents;
+		const map = useMapInstance(props);
+		const restProps = shallowReactiveOmit(props, "map");
+		const toolBar = shallowRef(new AMap.ToolBar(toDefinedRaw(restProps)));
+		watchEffect((onCleanup) => {
+			map.value?.addControl(toolBar.value);
+			onCleanup(() => {
+				map.value?.removeControl(toolBar.value);
+			});
+		});
+		useControlAttributes(toolBar, restProps);
+		use_event_listeners_default(toolBar, emits, toolBarEvents);
+		__expose({ instance: toolBar });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/layer/layer/layer.ts
+const layerEvents = [complete];
+function useLayerAttributes(layer, props) {
+	watch(() => props.opacity, (val) => {
+		if (val !== void 0) layer.value.setOpacity(val);
+	});
+	watch(() => props.zooms, (val) => {
+		if (val !== void 0) layer.value.setZooms(val);
+	});
+	watch(() => props.zIndex, (val) => {
+		if (val !== void 0) layer.value.setzIndex(val);
+	});
+	watch(() => props.visible, (val) => {
+		if (val !== void 0) {
+			if (val) layer.value.show();
+			else layer.value.hide();
+		}
+	});
+}
+// src/layer/buildings/buildings.vue
+var buildings_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.Buildings",
+	inheritAttrs: false,
+	__name: "buildings",
+	props: {
+		style: {},
+		heightFactor: {},
+		roofColor: {},
+		wallColor: {},
+		cacheSize: {},
+		ce: {
+			type: Boolean,
+			default: void 0
+		},
+		depthTest: {
+			type: Boolean,
+			default: void 0
+		},
+		map: {},
+		opacity: {},
+		rejectMapMask: {
+			type: Boolean,
+			default: void 0
+		},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		zIndex: {},
+		zooms: {}
+	},
+	emits: ["complete"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const buildingsEvents = layerEvents;
+		const map = useMapInstance(props);
+		const restProps = shallowReactiveOmit(props, "map");
+		const buildings = shallowRef(new AMap.Buildings(toDefinedRaw(restProps)));
+		watchEffect((onCleanup) => {
+			if (!map.value) return;
+			buildings.value.setMap(map.value);
+			onCleanup(() => {
+				buildings.value.setMap(null);
+			});
+		});
+		onUnmounted(() => buildings.value.destroy());
+		useLayerAttributes(buildings, props);
+		watch(() => props.style, (val) => {
+			if (val !== void 0) buildings.value.setStyle(val);
+		});
+		use_event_listeners_default(buildings, emits, buildingsEvents);
+		__expose({ instance: buildings });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/layer/canvas-layer/canvas-layer.vue
+var canvas_layer_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.CanvasLayer",
+	inheritAttrs: false,
+	__name: "canvas-layer",
+	props: {
+		bounds: {},
+		canvas: {},
+		tileUrl: {},
+		url: {},
+		cacheSize: {},
+		ce: {
+			type: Boolean,
+			default: void 0
+		},
+		depthTest: {
+			type: Boolean,
+			default: void 0
+		},
+		map: {},
+		opacity: {},
+		rejectMapMask: {
+			type: Boolean,
+			default: void 0
+		},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		zIndex: {},
+		zooms: {}
+	},
+	emits: ["complete"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const canvasLayerEvents = layerEvents;
+		const map = useMapInstance(props);
+		const restProps = shallowReactiveOmit(props, "map");
+		const canvasLayer = shallowRef(new AMap.CanvasLayer(toDefinedRaw(restProps)));
+		watchEffect((onCleanup) => {
+			if (!map.value) return;
+			canvasLayer.value.setMap(map.value);
+			onCleanup(() => {
+				canvasLayer.value.setMap(null);
+			});
+		});
+		onUnmounted(() => canvasLayer.value.destroy());
+		useLayerAttributes(canvasLayer, props);
+		watchEffect(() => {
+			if (!map.value) return;
+			canvasLayer.value.setBounds(props.bounds);
+		});
+		watch(() => props.canvas, (val) => {
+			if (val !== void 0) canvasLayer.value.setCanvas(val);
+		});
+		use_event_listeners_default(canvasLayer, emits, canvasLayerEvents);
+		__expose({ instance: canvasLayer });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/layer/custom-layer/custom-layer.vue
+var custom_layer_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.CustomLayer",
+	inheritAttrs: false,
+	__name: "custom-layer",
+	props: {
+		element: {},
+		render: {},
+		alwaysRender: {
+			type: Boolean,
+			default: void 0
+		},
+		cacheSize: {},
+		ce: {
+			type: Boolean,
+			default: void 0
+		},
+		depthTest: {
+			type: Boolean,
+			default: void 0
+		},
+		map: {},
+		opacity: {},
+		rejectMapMask: {
+			type: Boolean,
+			default: void 0
+		},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		zIndex: {},
+		zooms: {}
+	},
+	emits: ["complete"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const customLayerEvents = layerEvents;
+		const map = useMapInstance(props);
+		const restProps = shallowReactiveOmit(props, "map", "element");
+		const customLayer = shallowRef(new AMap.CustomLayer(props.element, toDefinedRaw(restProps)));
+		watchEffect((onCleanup) => {
+			if (!map.value) return;
+			customLayer.value.setMap(map.value);
+			onCleanup(() => {
+				customLayer.value.setMap(null);
+			});
+		});
+		onUnmounted(() => customLayer.value.destroy());
+		useLayerAttributes(customLayer, props);
+		watch(() => props.render, (val) => {
+			customLayer.value.render = val || customLayer.value.render;
+		});
+		watch(() => props.visible, (val) => {
+			if (val !== void 0) {
+				if (val) {
+					customLayer.value.canvas.style.visibility = "visible";
+					customLayer.value.canvas.style.display = "block";
+				} else {
+					customLayer.value.canvas.style.visibility = "hidden";
+					customLayer.value.canvas.style.display = "none";
+				}
+			}
+		});
+		use_event_listeners_default(customLayer, emits, customLayerEvents);
+		__expose({ instance: customLayer });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/layer/district-layer/district-layer/use-attributes.ts
+function useDistrictLayerAttributes(districtLayer, props) {
+	useLayerAttributes(districtLayer, props);
+	watch(() => props.adcode, (val) => {
+		if (val !== void 0) districtLayer.value.setAdcode(val);
+	});
+	watch(() => props.SOC, (val) => {
+		if (val !== void 0) districtLayer.value.setSOC(val);
+	});
+	watch(() => props.styles, (val) => {
+		if (val !== void 0) districtLayer.value.setStyles(toRaw(val));
+	});
+}
+// src/layer/district-layer/district-layer/district-layer.vue
+var district_layer_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.DistrictLayer",
+	inheritAttrs: false,
+	__name: "district-layer",
+	props: {
+		adcode: {},
+		depth: {},
+		SOC: {},
+		styles: {},
+		zIndex: {},
+		getTileUrl: {},
+		name: {},
+		id: {},
+		dataZooms: {},
+		detectRetina: {
+			type: Boolean,
+			default: void 0
+		},
+		projection: {},
+		tileUrl: {},
+		tileSize: {},
+		cacheSize: {},
+		ce: {
+			type: Boolean,
+			default: void 0
+		},
+		depthTest: {
+			type: Boolean,
+			default: void 0
+		},
+		map: {},
+		opacity: {},
+		rejectMapMask: {
+			type: Boolean,
+			default: void 0
+		},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		zooms: {}
+	},
+	emits: ["complete"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const districtLayerEvents = layerEvents;
+		const map = useMapInstance(props);
+		const restProps = shallowReactiveOmit(props, "map");
+		const districtLayer = shallowRef(new AMap.DistrictLayer(toDefinedRaw(restProps)));
+		watchEffect((onCleanup) => {
+			if (!map.value) return;
+			districtLayer.value.setMap(map.value);
+			onCleanup(() => {
+				districtLayer.value.setMap(null);
+			});
+		});
+		onUnmounted(() => districtLayer.value.destroy());
+		useDistrictLayerAttributes(districtLayer, props);
+		use_event_listeners_default(districtLayer, emits, districtLayerEvents);
+		__expose({ instance: districtLayer });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/layer/district-layer/country/country.vue
+var country_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.DistrictLayer.Country",
+	inheritAttrs: false,
+	__name: "country",
+	props: {
+		depth: {},
+		SOC: {},
+		zIndex: {},
+		adcode: {},
+		styles: {},
+		getTileUrl: {},
+		name: {},
+		id: {},
+		dataZooms: {},
+		detectRetina: {
+			type: Boolean,
+			default: void 0
+		},
+		projection: {},
+		tileUrl: {},
+		tileSize: {},
+		cacheSize: {},
+		ce: {
+			type: Boolean,
+			default: void 0
+		},
+		depthTest: {
+			type: Boolean,
+			default: void 0
+		},
+		map: {},
+		opacity: {},
+		rejectMapMask: {
+			type: Boolean,
+			default: void 0
+		},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		zooms: {}
+	},
+	emits: ["complete"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const countryEvents = layerEvents;
+		const map = useMapInstance(props);
+		const restProps = shallowReactiveOmit(props, "map");
+		const country = shallowRef(new AMap.DistrictLayer.Country(toDefinedRaw(restProps)));
+		watchEffect((onCleanup) => {
+			if (!map.value) return;
+			country.value.setMap(map.value);
+			onCleanup(() => {
+				country.value.setMap(null);
+			});
+		});
+		onUnmounted(() => country.value.destroy());
+		useDistrictLayerAttributes(country, props);
+		use_event_listeners_default(country, emits, countryEvents);
+		__expose({ instance: country });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/layer/district-layer/province/province.vue
+var province_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.DistrictLayer.Province",
+	inheritAttrs: false,
+	__name: "province",
+	props: {
+		depth: {},
+		SOC: {},
+		zIndex: {},
+		adcode: {},
+		styles: {},
+		getTileUrl: {},
+		name: {},
+		id: {},
+		dataZooms: {},
+		detectRetina: {
+			type: Boolean,
+			default: void 0
+		},
+		projection: {},
+		tileUrl: {},
+		tileSize: {},
+		cacheSize: {},
+		ce: {
+			type: Boolean,
+			default: void 0
+		},
+		depthTest: {
+			type: Boolean,
+			default: void 0
+		},
+		map: {},
+		opacity: {},
+		rejectMapMask: {
+			type: Boolean,
+			default: void 0
+		},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		zooms: {}
+	},
+	emits: ["complete"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const provinceEvents = layerEvents;
+		const map = useMapInstance(props);
+		const restProps = shallowReactiveOmit(props, "map");
+		const province = shallowRef(new AMap.DistrictLayer.Province(toDefinedRaw(restProps)));
+		watchEffect((onCleanup) => {
+			if (!map.value) return;
+			province.value.setMap(map.value);
+			onCleanup(() => {
+				province.value.setMap(null);
+			});
+		});
+		onUnmounted(() => province.value.destroy());
+		useDistrictLayerAttributes(province, props);
+		use_event_listeners_default(province, emits, provinceEvents);
+		__expose({ instance: province });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/layer/district-layer/world/world.vue
+var world_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.DistrictLayer.World",
+	inheritAttrs: false,
+	__name: "world",
+	props: {
+		SOC: {},
+		zIndex: {},
+		adcode: {},
+		depth: {},
+		styles: {},
+		getTileUrl: {},
+		name: {},
+		id: {},
+		dataZooms: {},
+		detectRetina: {
+			type: Boolean,
+			default: void 0
+		},
+		projection: {},
+		tileUrl: {},
+		tileSize: {},
+		cacheSize: {},
+		ce: {
+			type: Boolean,
+			default: void 0
+		},
+		depthTest: {
+			type: Boolean,
+			default: void 0
+		},
+		map: {},
+		opacity: {},
+		rejectMapMask: {
+			type: Boolean,
+			default: void 0
+		},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		zooms: {}
+	},
+	emits: ["complete"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const worldEvents = layerEvents;
+		const map = useMapInstance(props);
+		const restProps = shallowReactiveOmit(props, "map");
+		const world = shallowRef(new AMap.DistrictLayer.World(toDefinedRaw(restProps)));
+		watchEffect((onCleanup) => {
+			if (!map.value) return;
+			world.value.setMap(map.value);
+			onCleanup(() => {
+				world.value.setMap(null);
+			});
+		});
+		onUnmounted(() => world.value.destroy());
+		useDistrictLayerAttributes(world, props);
+		use_event_listeners_default(world, emits, worldEvents);
+		__expose({ instance: world });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/layer/gl-custom-layer/gl-custom-layer.vue
+var gl_custom_layer_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.GLCustomLayer",
+	inheritAttrs: false,
+	__name: "gl-custom-layer",
+	props: {
+		init: {},
+		render: {},
+		cacheSize: {},
+		ce: {
+			type: Boolean,
+			default: void 0
+		},
+		depthTest: {
+			type: Boolean,
+			default: void 0
+		},
+		map: {},
+		opacity: {},
+		rejectMapMask: {
+			type: Boolean,
+			default: void 0
+		},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		zIndex: {},
+		zooms: {}
+	},
+	emits: ["complete"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const glCustomLayerEvents = layerEvents;
+		const map = useMapInstance(props);
+		const restProps = shallowReactiveOmit(props, "map");
+		const glCustomLayer = shallowRef(new AMap.GLCustomLayer(toDefinedRaw(restProps)));
+		watchEffect((onCleanup) => {
+			if (!map.value) return;
+			glCustomLayer.value.setMap(map.value);
+			onCleanup(() => {
+				glCustomLayer.value.setMap(null);
+			});
+		});
+		onUnmounted(() => glCustomLayer.value.destroy());
+		useLayerAttributes(glCustomLayer, props);
+		watch(() => props.init, (val) => {
+			glCustomLayer.value.init = val || glCustomLayer.value.init;
+		});
+		watch(() => props.render, (val) => {
+			glCustomLayer.value.render = val || glCustomLayer.value.render;
+		});
+		use_event_listeners_default(glCustomLayer, emits, glCustomLayerEvents);
+		__expose({ instance: glCustomLayer });
+		return (_ctx, _cache) => {
+			return renderSlot(_ctx.$slots, "default");
+		};
+	}
+});
+// src/layer/heat-map/heat-map.vue
+var heat_map_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.HeatMap",
+	inheritAttrs: false,
+	__name: "heat-map",
+	props: {
+		map: {},
+		dataset: {},
+		blur: {},
+		gradient: {},
+		opacity: {},
+		radius: {},
+		radiusUnit: {},
+		rejectMapMask: {
+			type: Boolean,
+			default: void 0
+		},
+		renderOnZooming: {
+			type: Boolean,
+			default: void 0
+		},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		zIndex: {},
+		zooms: {},
+		threeD: {}
+	},
+	setup(__props, { expose: __expose }) {
+		const props = __props;
+		const map = useMapInstance(props);
+		const restProps = shallowReactiveOmit(props, "map");
+		const { threeD, ...options } = toDefinedRaw(restProps);
+		const heatMap = shallowRef(new AMap.HeatMap(null, {
+			...options,
+			"3d": threeD
+		}));
+		watchEffect((onCleanup) => {
+			if (!map.value) return;
+			heatMap.value.setMap(map.value);
+			onCleanup(() => {
+				heatMap.value._renderLayer._render.setMap(null);
+				heatMap.value._renderLayer._render.render.destroy();
+				heatMap.value.setMap(null);
+			});
+		});
+		watch(() => props.visible, (val) => {
+			if (val !== void 0) {
+				if (val) heatMap.value.show();
+				else heatMap.value.hide();
+			}
+		}, { immediate: true });
+		watch(() => props.zIndex, (val) => {
+			if (val !== void 0) heatMap.value.setzIndex(val);
+		});
+		watch(() => props.dataset, (val) => {
+			if (val !== void 0) heatMap.value.setDataSet(clone(toRaw(val), true));
+		}, { immediate: true });
+		watch(shallowReactiveOmit(restProps, [
+			"visible",
+			"zIndex",
+			"dataset"
+		]), (val) => {
+			const { threeD, ...options } = toDefinedRaw(val);
+			heatMap.value.setOptions({
+				...options,
+				"3d": threeD
+			});
+		});
+		__expose({ instance: heatMap });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/layer/image-layer/image-layer.vue
+var image_layer_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.ImageLayer",
+	inheritAttrs: false,
+	__name: "image-layer",
+	props: {
+		bounds: {},
+		canvas: {},
+		tileUrl: {},
+		url: {},
+		cacheSize: {},
+		ce: {
+			type: Boolean,
+			default: void 0
+		},
+		depthTest: {
+			type: Boolean,
+			default: void 0
+		},
+		map: {},
+		opacity: {},
+		rejectMapMask: {
+			type: Boolean,
+			default: void 0
+		},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		zIndex: {},
+		zooms: {}
+	},
+	emits: ["complete"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const imageLayerEvents = layerEvents;
+		const map = useMapInstance(props);
+		const restProps = shallowReactiveOmit(props, "map");
+		const imageLayer = shallowRef(new AMap.ImageLayer(toDefinedRaw(restProps)));
+		watchEffect((onCleanup) => {
+			if (!map.value) return;
+			imageLayer.value.setMap(map.value);
+			onCleanup(() => {
+				imageLayer.value.setMap(null);
+			});
+		});
+		onUnmounted(() => imageLayer.value.destroy());
+		useLayerAttributes(imageLayer, props);
+		watchEffect(() => {
+			if (!map.value) return;
+			imageLayer.value.setBounds(props.bounds);
+		});
+		watchEffect(() => {
+			if (!map.value) return;
+			imageLayer.value.setImageUrl(props.url ?? props.tileUrl);
+		});
+		use_event_listeners_default(imageLayer, emits, imageLayerEvents);
+		__expose({ instance: imageLayer });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/layer/indoor-map/indoor-map.vue
+var indoor_map_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.IndoorMap",
+	inheritAttrs: false,
+	__name: "indoor-map",
+	props: {
+		POIId: {},
+		floor: {},
+		cursor: {},
+		hideFloorBar: {
+			type: Boolean,
+			default: void 0
+		},
+		cacheSize: {},
+		ce: {
+			type: Boolean,
+			default: void 0
+		},
+		depthTest: {
+			type: Boolean,
+			default: void 0
+		},
+		map: {},
+		opacity: {},
+		rejectMapMask: {
+			type: Boolean,
+			default: void 0
+		},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		zIndex: {},
+		zooms: {}
+	},
+	emits: ["complete", "click"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const indoorMapEvents = [...layerEvents, click];
+		const map = useMapInstance(props);
+		const restProps = shallowReactiveOmit(props, "map", "POIId", "floor");
+		const indoorMap = shallowRef(map.value?.indoorMap ?? new AMap.IndoorMap(toDefinedRaw(restProps)));
+		watchEffect((onCleanup) => {
+			if (!map.value) return;
+			if (map.value.indoorMap) return;
+			const { animateEnable } = map.value.getStatus();
+			const before = [...map.value.getEvents()?.moveend ?? []];
+			indoorMap.value.setMap(map.value);
+			const moveEndFns = [...map.value.getEvents()?.moveend ?? []].filter((a) => !before?.some((b) => b.fn === a.fn && b.context === a.context));
+			onCleanup(() => {
+				moveEndFns?.forEach(({ fn, context }) => {
+					map.value?.off("moveend", fn, context);
+				});
+				if (indoorMap.value.e$) map.value?.removeControl(indoorMap.value.e$);
+				indoorMap.value.VR.labelsLayer?.setMap(null);
+				map.value?.removeLayer(indoorMap.value);
+				map.value?.setStatus({ animateEnable });
+				delete map.value?.im().Yh.indoor;
+			});
+		});
+		watchEffect(() => {
+			if (map.value && props.POIId) {
+				indoorMap.value.showIndoorMap(props.POIId, props.floor);
+				indoorMap.value.getSource()?.JR?.(props.POIId, props.floor);
+			}
+		});
+		onUnmounted(() => {
+			if (!map.value || map.value.indoorMap) return;
+			indoorMap.value.VR.labelsLayer?.destroy();
+			indoorMap.value?.destroy();
+		});
+		useLayerAttributes(indoorMap, props);
+		watch(() => props.hideFloorBar, (val) => {
+			if (val !== void 0) {
+				if (val) indoorMap.value.hideFloorBar();
+				else indoorMap.value.showFloorBar();
+			}
+		});
+		use_event_listeners_default(indoorMap, emits, indoorMapEvents);
+		__expose({ instance: indoorMap });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/layer/labels-layer/context.ts
+const AMap_Symbol_LabelsLayer = Symbol("LabelsLayer");
+/**
+* 设置LabelsLayer实例Context
+* @param {ShallowRef<AMap.LabelsLayer>} labelsLayer - LabelsLayer实例ref
+*/
+function setLabelsLayerContext(labelsLayer) {
+	provide(AMap_Symbol_LabelsLayer, labelsLayer);
+}
+/**
+* 获取LabelsLayer实例
+* @returns {ShallowRef<AMap.LabelsLayer>} - LabelsLayer实例ref
+*/
+function useLabelsLayer() {
+	const context = inject(AMap_Symbol_LabelsLayer);
+	if (!context) throw lostContextError("`AMap.LabelsLayer`");
+	return context;
+}
+/**
+* 获取LabelsLayer实例
+* @returns {ShallowRef<AMap.LabelsLayer> | undefined} - LabelsLayer实例ref或 `undefined`
+*/
+function useLabelsLayerInstance() {
+	return inject(AMap_Symbol_LabelsLayer, void 0);
+}
+// src/layer/labels-layer/labels-layer.vue
+var labels_layer_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.LabelsLayer",
+	inheritAttrs: false,
+	__name: "labels-layer",
+	props: {
+		labelMarkers: {},
+		allowCollision: {
+			type: Boolean,
+			default: void 0
+		},
+		animation: {
+			type: Boolean,
+			default: void 0
+		},
+		collision: {
+			type: Boolean,
+			default: void 0
+		},
+		createTile: {},
+		cacheSize: {},
+		ce: {
+			type: Boolean,
+			default: void 0
+		},
+		depthTest: {
+			type: Boolean,
+			default: void 0
+		},
+		map: {},
+		opacity: {},
+		rejectMapMask: {
+			type: Boolean,
+			default: void 0
+		},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		zIndex: {},
+		zooms: {}
+	},
+	emits: ["complete"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const labelsLayerEvents = layerEvents;
+		const map = useMapInstance(props);
+		const restProps = shallowReactiveOmit(props, "map", "labelMarkers");
+		const labelsLayer = shallowRef(new AMap.LabelsLayer(toDefinedRaw(restProps)));
+		watchEffect((onCleanup) => {
+			if (!map.value) return;
+			labelsLayer.value.setMap(map.value);
+			onCleanup(() => {
+				labelsLayer.value.setMap(null);
+			});
+		});
+		watchEffect((onCleanup) => {
+			if (props.labelMarkers !== void 0) labelsLayer.value.add(props.labelMarkers);
+			onCleanup(() => {
+				labelsLayer.value.remove(labelsLayer.value.getAllOverlays());
+			});
+		});
+		onUnmounted(() => labelsLayer.value.destroy());
+		useLayerAttributes(labelsLayer, props);
+		watch(() => props.allowCollision, (val) => {
+			if (val !== void 0) labelsLayer.value.setAllowCollision(val);
+		});
+		watch(() => props.collision, (val) => {
+			if (val !== void 0) labelsLayer.value.setCollision(val);
+		});
+		use_event_listeners_default(labelsLayer, emits, labelsLayerEvents);
+		setLabelsLayerContext(labelsLayer);
+		__expose({ instance: labelsLayer });
+		return (_ctx, _cache) => {
+			return __props.labelMarkers === void 0 ? renderSlot(_ctx.$slots, "default", {}, void 0, void 0, 0) : createCommentVNode("v-if", true);
+		};
+	}
+});
+// src/layer/layer-group/layer-group.vue
+var layer_group_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.LayerGroup",
+	inheritAttrs: false,
+	__name: "layer-group",
+	props: {
+		map: {},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		layers: { default: () => [] }
+	},
+	emits: ["complete"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const layerGroupEvents = layerEvents;
+		const map = useMapInstance(props);
+		const layerGroup = shallowRef(new AMap.LayerGroup());
+		watch(() => [...props.layers], (newLayers) => {
+			const current = new Set(layerGroup.value.getLayers());
+			const next = new Set(newLayers);
+			const toRemove = [...current].filter((l) => !next.has(l));
+			const toAdd = [...next].filter((l) => !current.has(l));
+			if (toRemove.length) layerGroup.value.removeLayers(toRemove);
+			if (toAdd.length) layerGroup.value.addLayers(toAdd);
+		}, {
+			deep: true,
+			immediate: true
+		});
+		watchEffect((onCleanup) => {
+			if (!map.value) return;
+			layerGroup.value.setMap(map.value);
+			onCleanup(() => {
+				layerGroup.value.setMap(null);
+			});
+		});
+		watch(() => props.visible, (val) => {
+			if (val !== void 0) {
+				if (val) layerGroup.value.show();
+				else layerGroup.value.hide();
+			}
+		});
+		const boundMap = /* @__PURE__ */ new Map();
+		watch(() => [...props.layers], (newLayers) => {
+			const nextLayers = newLayers ? [...new Set(newLayers)] : [];
+			const nextSet = new Set(nextLayers);
+			for (const [layer, handlerMap] of boundMap) if (!nextSet.has(layer)) {
+				for (const [eventType, handler] of handlerMap) layer.off(lowercase(eventType), handler);
+				boundMap.delete(layer);
+				if ("destroy" in layer && typeof layer.destroy === "function") layer.destroy();
+			}
+			for (const layer of nextLayers) {
+				if (boundMap.has(layer)) continue;
+				const handlerMap = /* @__PURE__ */ new Map();
+				for (const eventType of layerGroupEvents) {
+					const handler = (event) => {
+						emits(eventType, event);
+					};
+					layer.on(lowercase(eventType), handler);
+					handlerMap.set(eventType, handler);
+				}
+				boundMap.set(layer, handlerMap);
+			}
+		}, {
+			deep: true,
+			immediate: true
+		});
+		__expose({ instance: layerGroup });
+		function dispose() {
+			for (const [layer, handlerMap] of boundMap) {
+				for (const [eventType, handler] of handlerMap) layer.off(lowercase(eventType), handler);
+				if ("destroy" in layer && typeof layer.destroy === "function") layer.destroy();
+			}
+			boundMap.clear();
+		}
+		onUnmounted(() => {
+			dispose();
+			layerGroup.value.clearLayers();
+		});
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/layer/mapbox/mapbox.vue
+var mapbox_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.Mapbox",
+	inheritAttrs: false,
+	__name: "mapbox",
+	props: {
+		tileSize: {},
+		cacheSize: {},
+		ce: {
+			type: Boolean,
+			default: void 0
+		},
+		depthTest: {
+			type: Boolean,
+			default: void 0
+		},
+		map: {},
+		opacity: {},
+		rejectMapMask: {
+			type: Boolean,
+			default: void 0
+		},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		zIndex: {},
+		zooms: {}
+	},
+	emits: ["complete"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const mapboxEvents = layerEvents;
+		const map = useMapInstance(props);
+		const restProps = shallowReactiveOmit(props, "map");
+		const mapbox = shallowRef(new AMap.Mapbox(toDefinedRaw(restProps)));
+		watchEffect((onCleanup) => {
+			if (!map.value) return;
+			mapbox.value.setMap(map.value);
+			onCleanup(() => {
+				mapbox.value.setMap(null);
+			});
+		});
+		onUnmounted(() => mapbox.value.destroy());
+		useLayerAttributes(mapbox, props);
+		use_event_listeners_default(mapbox, emits, mapboxEvents);
+		__expose({ instance: mapbox });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/layer/tile-layer/tile-layer/use-attributes.ts
+function useTileLayerAttributes(tileLayer, props) {
+	useLayerAttributes(tileLayer, props);
+	watch(() => props.getTileUrl, (val) => {
+		if (typeof val === "string") tileLayer.value.setTileUrl(val);
+	});
+}
+// src/layer/tile-layer/tile-layer/tile-layer.vue
+var tile_layer_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.TileLayer",
+	inheritAttrs: false,
+	__name: "tile-layer",
+	props: {
+		getTileUrl: {},
+		name: {},
+		id: {},
+		dataZooms: {},
+		detectRetina: {
+			type: Boolean,
+			default: void 0
+		},
+		projection: {},
+		tileUrl: {},
+		tileSize: {},
+		zIndex: {},
+		cacheSize: {},
+		ce: {
+			type: Boolean,
+			default: void 0
+		},
+		depthTest: {
+			type: Boolean,
+			default: void 0
+		},
+		map: {},
+		opacity: {},
+		rejectMapMask: {
+			type: Boolean,
+			default: void 0
+		},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		zooms: {}
+	},
+	emits: ["complete"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const tileLayerEvents = layerEvents;
+		const map = useMapInstance(props);
+		const restProps = shallowReactiveOmit(props, "map");
+		const tileLayer = shallowRef(new AMap.TileLayer(toDefinedRaw(restProps)));
+		watchEffect((onCleanup) => {
+			if (!map.value) return;
+			tileLayer.value.setMap(map.value);
+			onCleanup(() => {
+				tileLayer.value.setMap(null);
+			});
+		});
+		onUnmounted(() => tileLayer.value.destroy());
+		useTileLayerAttributes(tileLayer, props);
+		use_event_listeners_default(tileLayer, emits, tileLayerEvents);
+		__expose({ instance: tileLayer });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/layer/tile-layer/flexible/flexible.vue
+var flexible_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.TileLayer.Flexible",
+	inheritAttrs: false,
+	__name: "flexible",
+	props: {
+		createTile: {},
+		getTileUrl: {},
+		name: {},
+		id: {},
+		dataZooms: {},
+		detectRetina: {
+			type: Boolean,
+			default: void 0
+		},
+		projection: {},
+		tileUrl: {},
+		tileSize: {},
+		zIndex: {},
+		cacheSize: {},
+		ce: {
+			type: Boolean,
+			default: void 0
+		},
+		depthTest: {
+			type: Boolean,
+			default: void 0
+		},
+		map: {},
+		opacity: {},
+		rejectMapMask: {
+			type: Boolean,
+			default: void 0
+		},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		zooms: {}
+	},
+	emits: ["complete"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const flexibleEvents = layerEvents;
+		const map = useMapInstance(props);
+		const restProps = shallowReactiveOmit(props, "map");
+		const flexible = shallowRef(new AMap.TileLayer.Flexible(toDefinedRaw(restProps)));
+		watchEffect((onCleanup) => {
+			if (!map.value) return;
+			flexible.value.setMap(map.value);
+			onCleanup(() => {
+				flexible.value.setMap(null);
+			});
+		});
+		onUnmounted(() => flexible.value.destroy());
+		useTileLayerAttributes(flexible, props);
+		use_event_listeners_default(flexible, emits, flexibleEvents);
+		__expose({ instance: flexible });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/layer/tile-layer/mark/mark.vue
+var mark_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.TileLayer.Mark",
+	inheritAttrs: false,
+	__name: "mark",
+	props: {
+		opacity: {},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		zIndex: {},
+		zooms: {},
+		getTileUrl: {},
+		name: {},
+		id: {},
+		dataZooms: {},
+		detectRetina: {
+			type: Boolean,
+			default: void 0
+		},
+		projection: {},
+		tileUrl: {},
+		tileSize: {},
+		cacheSize: {},
+		ce: {
+			type: Boolean,
+			default: void 0
+		},
+		depthTest: {
+			type: Boolean,
+			default: void 0
+		},
+		map: {},
+		rejectMapMask: {
+			type: Boolean,
+			default: void 0
+		}
+	},
+	emits: ["complete"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const markEvents = layerEvents;
+		const map = useMapInstance(props);
+		const restProps = shallowReactiveOmit(props, "map");
+		const mark = shallowRef(new AMap.TileLayer.Mark(toDefinedRaw(restProps)));
+		watchEffect((onCleanup) => {
+			if (!map.value) return;
+			mark.value.setMap(map.value);
+			onCleanup(() => {
+				mark.value.setMap(null);
+			});
+		});
+		onUnmounted(() => mark.value.destroy());
+		useTileLayerAttributes(mark, props);
+		use_event_listeners_default(mark, emits, markEvents);
+		__expose({ instance: mark });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/layer/tile-layer/road-net/road-net.vue
+var road_net_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.TileLayer.RoadNet",
+	inheritAttrs: false,
+	__name: "road-net",
+	props: {
+		getTileUrl: {},
+		name: {},
+		id: {},
+		dataZooms: {},
+		detectRetina: {
+			type: Boolean,
+			default: void 0
+		},
+		projection: {},
+		tileUrl: {},
+		tileSize: {},
+		zIndex: {},
+		cacheSize: {},
+		ce: {
+			type: Boolean,
+			default: void 0
+		},
+		depthTest: {
+			type: Boolean,
+			default: void 0
+		},
+		map: {},
+		opacity: {},
+		rejectMapMask: {
+			type: Boolean,
+			default: void 0
+		},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		zooms: {}
+	},
+	emits: ["complete"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const roadNetEvents = layerEvents;
+		const map = useMapInstance(props);
+		const restProps = shallowReactiveOmit(props, "map");
+		const roadNet = shallowRef(new AMap.TileLayer.RoadNet(toDefinedRaw(restProps)));
+		watchEffect((onCleanup) => {
+			if (!map.value) return;
+			roadNet.value.setMap(map.value);
+			onCleanup(() => {
+				roadNet.value.setMap(null);
+			});
+		});
+		onUnmounted(() => roadNet.value.destroy());
+		useTileLayerAttributes(roadNet, props);
+		use_event_listeners_default(roadNet, emits, roadNetEvents);
+		__expose({ instance: roadNet });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/layer/tile-layer/satellite/satellite.vue
+var satellite_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.TileLayer.Satellite",
+	inheritAttrs: false,
+	__name: "satellite",
+	props: {
+		cacheSize: {},
+		ce: {
+			type: Boolean,
+			default: void 0
+		},
+		depthTest: {
+			type: Boolean,
+			default: void 0
+		},
+		map: {},
+		opacity: {},
+		rejectMapMask: {
+			type: Boolean,
+			default: void 0
+		},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		zIndex: {},
+		zooms: {}
+	},
+	emits: ["complete"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const satelliteEvents = layerEvents;
+		const map = useMapInstance(props);
+		const restProps = shallowReactiveOmit(props, "map");
+		const satellite = shallowRef(new AMap.TileLayer.Satellite(toDefinedRaw(restProps)));
+		watchEffect((onCleanup) => {
+			if (!map.value) return;
+			satellite.value.setMap(map.value);
+			onCleanup(() => {
+				satellite.value.setMap(null);
+			});
+		});
+		onUnmounted(() => satellite.value.destroy());
+		useTileLayerAttributes(satellite, props);
+		use_event_listeners_default(satellite, emits, satelliteEvents);
+		__expose({ instance: satellite });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/layer/tile-layer/traffic/traffic.vue
+var traffic_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.TileLayer.Traffic",
+	inheritAttrs: false,
+	__name: "traffic",
+	props: {
+		autoRefresh: {
+			type: Boolean,
+			default: void 0
+		},
+		interval: {},
+		cacheSize: {},
+		ce: {
+			type: Boolean,
+			default: void 0
+		},
+		depthTest: {
+			type: Boolean,
+			default: void 0
+		},
+		map: {},
+		opacity: {},
+		rejectMapMask: {
+			type: Boolean,
+			default: void 0
+		},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		zIndex: {},
+		zooms: {}
+	},
+	emits: ["complete"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const trafficEvents = layerEvents;
+		const map = useMapInstance(props);
+		const restProps = shallowReactiveOmit(props, "map");
+		const traffic = shallowRef(new AMap.TileLayer.Traffic(toDefinedRaw(restProps)));
+		watchEffect((onCleanup) => {
+			if (!map.value) return;
+			traffic.value.setMap(map.value);
+			onCleanup(() => {
+				traffic.value.setMap(null);
+			});
+		});
+		onUnmounted(() => traffic.value.destroy());
+		useTileLayerAttributes(traffic, props);
+		use_event_listeners_default(traffic, emits, trafficEvents);
+		__expose({ instance: traffic });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/layer/tile-layer/wms/wms.vue
+var wms_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.TileLayer.WMS",
+	inheritAttrs: false,
+	__name: "wms",
+	props: {
+		blend: {
+			type: Boolean,
+			default: void 0
+		},
+		params: {},
+		url: {},
+		getTileUrl: {},
+		name: {},
+		id: {},
+		dataZooms: {},
+		detectRetina: {
+			type: Boolean,
+			default: void 0
+		},
+		projection: {},
+		tileUrl: {},
+		tileSize: {},
+		zIndex: {},
+		cacheSize: {},
+		ce: {
+			type: Boolean,
+			default: void 0
+		},
+		depthTest: {
+			type: Boolean,
+			default: void 0
+		},
+		map: {},
+		opacity: {},
+		rejectMapMask: {
+			type: Boolean,
+			default: void 0
+		},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		zooms: {}
+	},
+	emits: ["complete"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const wmsEvents = layerEvents;
+		const map = useMapInstance(props);
+		const restProps = shallowReactiveOmit(props, "map");
+		const wms = shallowRef(new AMap.TileLayer.WMS(toDefinedRaw(restProps)));
+		watchEffect((onCleanup) => {
+			if (!map.value) return;
+			wms.value.setMap(map.value);
+			onCleanup(() => {
+				wms.value.setMap(null);
+			});
+		});
+		onUnmounted(() => wms.value.destroy());
+		useTileLayerAttributes(wms, props);
+		use_event_listeners_default(wms, emits, wmsEvents);
+		__expose({ instance: wms });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/layer/tile-layer/wmts/wmts.vue
+var wmts_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.TileLayer.WMTS",
+	inheritAttrs: false,
+	__name: "wmts",
+	props: {
+		blend: {
+			type: Boolean,
+			default: void 0
+		},
+		params: {},
+		url: {},
+		getTileUrl: {},
+		name: {},
+		id: {},
+		dataZooms: {},
+		detectRetina: {
+			type: Boolean,
+			default: void 0
+		},
+		projection: {},
+		tileUrl: {},
+		tileSize: {},
+		zIndex: {},
+		cacheSize: {},
+		ce: {
+			type: Boolean,
+			default: void 0
+		},
+		depthTest: {
+			type: Boolean,
+			default: void 0
+		},
+		map: {},
+		opacity: {},
+		rejectMapMask: {
+			type: Boolean,
+			default: void 0
+		},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		zooms: {}
+	},
+	emits: ["complete"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const wmtsEvents = layerEvents;
+		const map = useMapInstance(props);
+		const restProps = shallowReactiveOmit(props, "map");
+		const wmts = shallowRef(new AMap.TileLayer.WMTS(toDefinedRaw(restProps)));
+		watchEffect((onCleanup) => {
+			if (!map.value) return;
+			wmts.value.setMap(map.value);
+			onCleanup(() => {
+				wmts.value.setMap(null);
+			});
+		});
+		onUnmounted(() => wmts.value.destroy());
+		useTileLayerAttributes(wmts, props);
+		use_event_listeners_default(wmts, emits, wmtsEvents);
+		__expose({ instance: wmts });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/layer/mapbox-vector-tile-layer/mapbox-vector-tile-layer.vue
+var mapbox_vector_tile_layer_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.MapboxVectorTileLayer",
+	inheritAttrs: false,
+	__name: "mapbox-vector-tile-layer",
+	props: {
+		styles: {},
+		url: {},
+		getTileUrl: {},
+		name: {},
+		id: {},
+		dataZooms: {},
+		detectRetina: {
+			type: Boolean,
+			default: void 0
+		},
+		projection: {},
+		tileUrl: {},
+		tileSize: {},
+		zIndex: {},
+		cacheSize: {},
+		ce: {
+			type: Boolean,
+			default: void 0
+		},
+		depthTest: {
+			type: Boolean,
+			default: void 0
+		},
+		map: {},
+		opacity: {},
+		rejectMapMask: {
+			type: Boolean,
+			default: void 0
+		},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		zooms: {}
+	},
+	emits: ["complete"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const mvtLayerEvents = layerEvents;
+		const map = useMapInstance(props);
+		const restProps = shallowReactiveOmit(props, "map");
+		const mvtLayer = shallowRef(new AMap.MapboxVectorTileLayer(toDefinedRaw(restProps)));
+		watchEffect((onCleanup) => {
+			if (!map.value) return;
+			mvtLayer.value.setMap(map.value);
+			onCleanup(() => {
+				mvtLayer.value.getLabelsLayer().setMap(null);
+				mvtLayer.value.setMap(null);
+			});
+		});
+		onUnmounted(() => {
+			mvtLayer.value.getLabelsLayer().destroy();
+			mvtLayer.value.destroy();
+		});
+		useTileLayerAttributes(mvtLayer, props);
+		watch(() => props.styles, (val) => {
+			if (val !== void 0) mvtLayer.value.setStyle(toRaw(val));
+		});
+		use_event_listeners_default(mvtLayer, emits, mvtLayerEvents);
+		__expose({ instance: mvtLayer });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/layer/vector-layer/context.ts
+const AMap_Symbol_VectorLayer = Symbol("VectorLayer");
+/**
+* 设置VectorLayer实例Context
+* @param {ShallowRef<AMap.VectorLayer>} vectorLayer - VectorLayer实例ref
+*/
+function setVectorLayerContext(vectorLayer) {
+	provide(AMap_Symbol_VectorLayer, vectorLayer);
+}
+/**
+* 获取VectorLayer实例ref
+* @returns {ShallowRef<AMap.VectorLayer>} - VectorLayer实例ref
+*/
+function useVectorLayer() {
+	const context = inject(AMap_Symbol_VectorLayer);
+	if (!context) throw lostContextError("`AMap.VectorLayer`");
+	return context;
+}
+/**
+* 获取VectorLayer实例ref
+* @returns {ShallowRef<AMap.VectorLayer> | undefined} - VectorLayer实例ref或 `undefined`
+*/
+function useVectorLayerInstance() {
+	return inject(AMap_Symbol_VectorLayer, void 0);
+}
+// src/layer/vector-layer/vector-layer.vue
+var vector_layer_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.VectorLayer",
+	inheritAttrs: false,
+	__name: "vector-layer",
+	props: {
+		zIndex: {},
+		cacheSize: {},
+		ce: {
+			type: Boolean,
+			default: void 0
+		},
+		depthTest: {
+			type: Boolean,
+			default: void 0
+		},
+		map: {},
+		opacity: {},
+		rejectMapMask: {
+			type: Boolean,
+			default: void 0
+		},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		zooms: {}
+	},
+	setup(__props, { expose: __expose }) {
+		const props = __props;
+		const map = useMapInstance(props);
+		const restProps = shallowReactiveOmit(props, "map");
+		const vectorLayer = shallowRef(new AMap.VectorLayer(toDefinedRaw(restProps)));
+		watchEffect((onCleanup) => {
+			if (!map.value) return;
+			vectorLayer.value.setMap(map.value);
+			onCleanup(() => {
+				vectorLayer.value.setMap(null);
+			});
+		});
+		onUnmounted(() => vectorLayer.value.destroy());
+		useLayerAttributes(vectorLayer, props);
+		setVectorLayerContext(vectorLayer);
+		__expose({ instance: vectorLayer });
+		return (_ctx, _cache) => {
+			return renderSlot(_ctx.$slots, "default");
+		};
+	}
+});
+// src/overlay/vector-overlay/vector-overlay.ts
+const vectorOverlayEvents = [
+	hide,
+	show,
+	click,
+	dblClick,
+	rightClick,
+	mouseDown,
+	mouseUp,
+	mouseOver,
+	mouseOut,
+	dragStart,
+	dragging,
+	dragEnd,
+	touchStart,
+	touchMove,
+	touchEnd
+];
+function useVectorOverlayAttributes(overlay, props) {
+	watch(() => props.draggable, (val) => {
+		if (val !== void 0) overlay.value.setDraggable(val);
+	});
+	watch(() => props.extData, (val) => {
+		overlay.value.setExtData(toRaw(val));
+	});
+	watch(() => props.visible, (val) => {
+		if (val !== void 0) {
+			if (val) overlay.value.show();
+			else overlay.value.hide();
+		}
+	});
+}
+// src/overlay/bezier-curve/bezier-curve.vue
+var bezier_curve_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.BezierCurve",
+	inheritAttrs: false,
+	__name: "bezier-curve",
+	props: {
+		map: {},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		path: {},
+		borderWeight: {},
+		dirColor: {},
+		dirImg: {},
+		geodesic: {
+			type: Boolean,
+			default: void 0
+		},
+		height: {},
+		isOutLine: {
+			type: Boolean,
+			default: void 0
+		},
+		lineCap: {},
+		lineGradient: {},
+		lineJoin: {},
+		outlineColor: {},
+		showDir: {
+			type: Boolean,
+			default: void 0
+		},
+		cursor: {},
+		draggable: {
+			type: Boolean,
+			default: void 0
+		},
+		extData: {},
+		strokeColor: {},
+		strokeDasharray: {},
+		strokeOpacity: {},
+		strokeStyle: {},
+		strokeWeight: {},
+		zIndex: {},
+		zooms: {}
+	},
+	emits: [
+		"hide",
+		"show",
+		"click",
+		"dblClick",
+		"rightClick",
+		"mouseDown",
+		"mouseUp",
+		"mouseOver",
+		"mouseOut",
+		"dragStart",
+		"dragging",
+		"dragEnd",
+		"touchStart",
+		"touchMove",
+		"touchEnd"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const bezierCurveEvents = vectorOverlayEvents;
+		const map = useMapInstance(props);
+		const restProps = shallowReactiveOmit(props, "map");
+		const vectorLayer = useVectorLayerInstance();
+		const bezierCurve = shallowRef(new AMap.BezierCurve(toDefinedRaw(restProps)));
+		watchEffect((onCleanup) => {
+			if (vectorLayer) vectorLayer.value.add(bezierCurve.value);
+			else map.value?.add(bezierCurve.value);
+			onCleanup(() => {
+				if (vectorLayer) vectorLayer.value.remove(bezierCurve.value);
+				else map.value?.remove(bezierCurve.value);
+			});
+		});
+		useVectorOverlayAttributes(bezierCurve, props);
+		watch(() => props.path, (val) => {
+			bezierCurve.value.setPath(toRaw(val));
+			bezierCurve.value.setOptions({ path: toRaw(val) });
+		});
+		watch(shallowReactiveOmit(props, [
+			"map",
+			"draggable",
+			"extData",
+			"visible",
+			"path"
+		]), (val) => {
+			bezierCurve.value.setOptions(toDefinedRaw(val));
+		});
+		use_event_listeners_default(bezierCurve, emits, bezierCurveEvents);
+		onUnmounted(() => bezierCurve.value.destroy());
+		__expose({ instance: bezierCurve });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/overlay/circle/circle.vue
+var circle_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.Circle",
+	inheritAttrs: false,
+	__name: "circle",
+	props: {
+		map: {},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		center: {},
+		height: {},
+		radius: {},
+		async: {
+			type: Boolean,
+			default: void 0
+		},
+		bubble: {
+			type: Boolean,
+			default: void 0
+		},
+		extrusionHeight: {},
+		fillColor: {},
+		fillOpacity: {},
+		innerOverlay: {
+			type: Boolean,
+			default: void 0
+		},
+		noSelect: {
+			type: Boolean,
+			default: void 0
+		},
+		cursor: {},
+		draggable: {
+			type: Boolean,
+			default: void 0
+		},
+		extData: {},
+		strokeColor: {},
+		strokeDasharray: {},
+		strokeOpacity: {},
+		strokeStyle: {},
+		strokeWeight: {},
+		zIndex: {},
+		zooms: {}
+	},
+	emits: [
+		"hide",
+		"show",
+		"click",
+		"dblClick",
+		"rightClick",
+		"mouseDown",
+		"mouseUp",
+		"mouseOver",
+		"mouseOut",
+		"dragStart",
+		"dragging",
+		"dragEnd",
+		"touchStart",
+		"touchMove",
+		"touchEnd"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const circleEvents = vectorOverlayEvents;
+		const map = useMapInstance(props);
+		const restProps = shallowReactiveOmit(props, "map");
+		const vectorLayer = useVectorLayerInstance();
+		const circle = shallowRef(new AMap.Circle(toDefinedRaw(restProps)));
+		watchEffect((onCleanup) => {
+			if (vectorLayer) vectorLayer.value.add(circle.value);
+			else map.value?.add(circle.value);
+			onCleanup(() => {
+				if (vectorLayer) vectorLayer.value.remove(circle.value);
+				else map.value?.remove(circle.value);
+			});
+		});
+		useVectorOverlayAttributes(circle, props);
+		watch(() => props.center, (val) => {
+			if (val !== void 0) circle.value.setCenter(toRaw(val));
+		});
+		watch(() => props.radius, (val) => {
+			if (val !== void 0) circle.value.setRadius(val);
+		});
+		watch(shallowReactiveOmit(props, [
+			"map",
+			"draggable",
+			"extData",
+			"visible",
+			"center",
+			"radius"
+		]), (val) => {
+			circle.value.setOptions(toDefinedRaw(val));
+		});
+		use_event_listeners_default(circle, emits, circleEvents);
+		onUnmounted(() => circle.value.destroy());
+		__expose({ instance: circle });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/overlay/circle-marker/circle-marker.vue
+var circle_marker_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.CircleMarker",
+	inheritAttrs: false,
+	__name: "circle-marker",
+	props: {
+		map: {},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		fillColor: {},
+		fillOpacity: {},
+		radius: {},
+		async: {
+			type: Boolean,
+			default: void 0
+		},
+		bubble: {
+			type: Boolean,
+			default: void 0
+		},
+		center: {},
+		innerOverlay: {
+			type: Boolean,
+			default: void 0
+		},
+		noSelect: {
+			type: Boolean,
+			default: void 0
+		},
+		cursor: {},
+		draggable: {
+			type: Boolean,
+			default: void 0
+		},
+		extData: {},
+		strokeColor: {},
+		strokeDasharray: {},
+		strokeOpacity: {},
+		strokeStyle: {},
+		strokeWeight: {},
+		zIndex: {},
+		zooms: {}
+	},
+	emits: [
+		"hide",
+		"show",
+		"click",
+		"dblClick",
+		"rightClick",
+		"mouseDown",
+		"mouseUp",
+		"mouseOver",
+		"mouseOut",
+		"dragStart",
+		"dragging",
+		"dragEnd",
+		"touchStart",
+		"touchMove",
+		"touchEnd"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const circleMarkerEvents = vectorOverlayEvents;
+		const map = useMapInstance(props);
+		const restProps = shallowReactiveOmit(props, "map");
+		const vectorLayer = useVectorLayerInstance();
+		const circleMarker = shallowRef(new AMap.CircleMarker(toDefinedRaw(restProps)));
+		watchEffect((onCleanup) => {
+			if (vectorLayer) vectorLayer.value.add(circleMarker.value);
+			else map.value?.add(circleMarker.value);
+			onCleanup(() => {
+				if (vectorLayer) vectorLayer.value.remove(circleMarker.value);
+				else map.value?.remove(circleMarker.value);
+			});
+		});
+		useVectorOverlayAttributes(circleMarker, props);
+		watch(() => props.center, (val) => {
+			if (val !== void 0) circleMarker.value.setCenter(toRaw(val));
+		});
+		watch(() => props.radius, (val) => {
+			if (val !== void 0) circleMarker.value.setRadius(val);
+		});
+		watch(shallowReactiveOmit(props, [
+			"map",
+			"draggable",
+			"extData",
+			"visible",
+			"center",
+			"radius"
+		]), (val) => {
+			circleMarker.value.setOptions(toDefinedRaw(val));
+		});
+		use_event_listeners_default(circleMarker, emits, circleMarkerEvents);
+		onUnmounted(() => circleMarker.value.destroy());
+		__expose({ instance: circleMarker });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/overlay/dom-overlay/custom-content.vue
+var custom_content_default = /* @__PURE__ */ defineComponent({
+	__name: "custom-content",
+	props: { instance: {} },
+	setup(__props) {
+		const props = __props;
+		const dom = document.createElement("div");
+		props.instance.setContent(dom);
+		onMounted(() => {
+			const ro = new ResizeObserver(() => {
+				props.instance.setContent(dom);
+			});
+			ro.observe(dom);
+			onBeforeUnmount(() => {
+				ro.disconnect();
+				dom.remove();
+			});
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(Teleport, { to: unref(dom) }, [renderSlot(_ctx.$slots, "default")], 8, ["to"]);
+		};
+	}
+});
+// src/overlay/dom-overlay/dom-overlay.ts
+const domOverlayEvents = [
+	click,
+	dblClick,
+	rightClick,
+	dragStart,
+	dragging,
+	dragEnd,
+	mouseDown,
+	mouseUp,
+	mouseOver,
+	mouseOut,
+	mouseMove,
+	moveStart,
+	moveAlong,
+	moveEnd,
+	moving,
+	touchStart,
+	touchMove,
+	touchEnd
+];
+function useDOMOverlayAttributes(overlay, props, hasChildren) {
+	watch(() => props.anchor, (val) => {
+		overlay.value.setAnchor(val);
+	});
+	watch([() => hasChildren?.value, () => props.content], ([c1, c2]) => {
+		if (!c1) return;
+		overlay.value.setContent(c2);
+	}, { immediate: true });
+	watch(() => props.offset, (val) => {
+		overlay.value.setOffset(clone(toRaw(val)));
+	});
+	watch(() => props.orientation, (val) => {
+		overlay.value.setOrientation(val);
+	});
+	watch(() => props.position, (val) => {
+		if (val !== void 0) overlay.value.setPosition(clone(toRaw(val)));
+	});
+	watch(() => props.rotate, (val) => {
+		if (val !== void 0) overlay.value.setAngle(val);
+	});
+	watch(() => props.size, (val) => {
+		if (val !== void 0) overlay.value.setSize(clone(toRaw(val)));
+	});
+	watch(() => props.visible, (val) => {
+		if (val !== void 0) {
+			if (val) overlay.value.show();
+			else overlay.value.hide();
+		}
+	});
+	watch(() => props.zIndex, (val) => {
+		if (val !== void 0) overlay.value.setzIndex(val);
+	});
+}
+// src/overlay/context-menu/context-menu.vue
+var context_menu_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.ContextMenu",
+	inheritAttrs: false,
+	__name: "context-menu",
+	props: {
+		aliveWhenMapClick: {
+			type: Boolean,
+			default: void 0
+		},
+		content: {},
+		anchor: {},
+		innerOverlay: {
+			type: Boolean,
+			default: void 0
+		},
+		isCustom: {
+			type: Boolean,
+			default: void 0
+		},
+		map: {},
+		noSelect: {
+			type: Boolean,
+			default: void 0
+		},
+		offset: {},
+		orientation: {},
+		position: {},
+		rotate: {},
+		scale: {},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		size: {},
+		zIndex: {},
+		zooms: {}
+	},
+	emits: ["close", "open"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const contextMenuEvents = [close, open];
+		patchContextMenu();
+		const restProps = shallowReactiveOmit(props, "map");
+		const contextMenu = shallowRef(new AMap.ContextMenu(toDefinedRaw(restProps)));
+		const slots = useSlots();
+		useDOMOverlayAttributes(contextMenu, props, computed(() => slots.default !== void 0));
+		use_event_listeners_default(contextMenu, emits, contextMenuEvents);
+		onUnmounted(() => {
+			if (contextMenu.value._parent?._container?.contains(contextMenu.value.getContentDom())) contextMenu.value.remove();
+			contextMenu.value.destroy();
+		});
+		__expose({ instance: contextMenu });
+		return (_ctx, _cache) => {
+			return _ctx.$slots.default ? (openBlock(), createBlock(unref(custom_content_default), {
+				key: 0,
+				instance: contextMenu.value
+			}, {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+				_: 3
+			}, 8, ["instance"])) : createCommentVNode("v-if", true);
+		};
+	}
+});
+// src/overlay/marker/use-attributes.ts
+function useMarkerAttributes(marker, props, hasChildren) {
+	watch(() => props.clickable, (val) => {
+		marker.value.setClickable(val);
+	});
+	watch(() => props.cursor, (val) => {
+		marker.value.setCursor(val);
+	});
+	watch(() => props.draggable, (val) => {
+		if (val !== void 0) marker.value.setDraggable(val);
+	});
+	watch(() => props.extData, (val) => {
+		marker.value.setExtData(toRaw(val));
+	});
+	watch(() => props.icon, (val) => {
+		marker.value.setIcon(clone(toRaw(val)));
+	});
+	watch(() => props.isTop, (val) => {
+		marker.value.setTop(val);
+	});
+	watch(() => props.label, (val) => {
+		if (val !== void 0) marker.value.setLabel(clone(toRaw(val)));
+	});
+	watch(() => props.title, (val) => {
+		if (val !== void 0) marker.value.setTitle(clone(toRaw(val)));
+	});
+	watch(shallowReactiveOmit(props, "anchor", "content", "offset", "orientation", "position", "rotate", "size", "visible", "zIndex", "clickable", "cursor", "draggable", "extData", "icon", "isTop", "label", "title"), (val) => {
+		marker.value.setOptions(toDefinedRaw(val));
+	});
+	useDOMOverlayAttributes(marker, props, hasChildren);
+}
+// src/overlay/marker/marker.vue
+var marker_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.Marker",
+	inheritAttrs: false,
+	__name: "marker",
+	props: {
+		isTop: {
+			type: Boolean,
+			default: void 0
+		},
+		bubble: {
+			type: Boolean,
+			default: void 0
+		},
+		clickable: {
+			type: Boolean,
+			default: void 0
+		},
+		cursor: {},
+		draggable: {
+			type: Boolean,
+			default: void 0
+		},
+		extData: {},
+		icon: {},
+		title: {},
+		topWhenClick: {
+			type: Boolean,
+			default: void 0
+		},
+		label: {},
+		anchor: {},
+		innerOverlay: {
+			type: Boolean,
+			default: void 0
+		},
+		isCustom: {
+			type: Boolean,
+			default: void 0
+		},
+		map: {},
+		noSelect: {
+			type: Boolean,
+			default: void 0
+		},
+		offset: {},
+		orientation: {},
+		position: {},
+		rotate: {},
+		scale: {},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		content: {},
+		size: {},
+		zIndex: {},
+		zooms: {}
+	},
+	emits: [
+		"click",
+		"dblClick",
+		"rightClick",
+		"dragStart",
+		"dragging",
+		"dragEnd",
+		"mouseDown",
+		"mouseUp",
+		"mouseOver",
+		"mouseOut",
+		"mouseMove",
+		"moveStart",
+		"moveAlong",
+		"moveEnd",
+		"moving",
+		"touchStart",
+		"touchMove",
+		"touchEnd"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const markerEvents = domOverlayEvents;
+		const map = useMapInstance(props);
+		const restProps = shallowReactiveOmit(props, "map");
+		const marker = shallowRef(new AMap.Marker(toDefinedRaw(restProps)));
+		watchEffect((onCleanup) => {
+			map.value?.add(marker.value);
+			onCleanup(() => {
+				map.value?.remove(marker.value);
+			});
+		});
+		const slots = useSlots();
+		useMarkerAttributes(marker, restProps, computed(() => slots.default !== void 0));
+		use_event_listeners_default(marker, emits, markerEvents);
+		onUnmounted(() => marker.value.destroy());
+		__expose({ instance: marker });
+		return (_ctx, _cache) => {
+			return _ctx.$slots.default ? (openBlock(), createBlock(unref(custom_content_default), {
+				key: 0,
+				instance: marker.value
+			}, {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+				_: 3
+			}, 8, ["instance"])) : createCommentVNode("v-if", true);
+		};
+	}
+});
+// src/overlay/elastic-marker/elastic-marker.vue
+var elastic_marker_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.ElasticMarker",
+	inheritAttrs: false,
+	__name: "elastic-marker",
+	props: {
+		isTop: {
+			type: Boolean,
+			default: void 0
+		},
+		styles: {},
+		zoomStyleMapping: {},
+		bubble: {
+			type: Boolean,
+			default: void 0
+		},
+		clickable: {
+			type: Boolean,
+			default: void 0
+		},
+		cursor: {},
+		draggable: {
+			type: Boolean,
+			default: void 0
+		},
+		extData: {},
+		icon: {},
+		title: {},
+		topWhenClick: {
+			type: Boolean,
+			default: void 0
+		},
+		label: {},
+		anchor: {},
+		innerOverlay: {
+			type: Boolean,
+			default: void 0
+		},
+		isCustom: {
+			type: Boolean,
+			default: void 0
+		},
+		map: {},
+		noSelect: {
+			type: Boolean,
+			default: void 0
+		},
+		offset: {},
+		orientation: {},
+		position: {},
+		rotate: {},
+		scale: {},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		content: {},
+		size: {},
+		zIndex: {},
+		zooms: {}
+	},
+	emits: [
+		"click",
+		"dblClick",
+		"rightClick",
+		"dragStart",
+		"dragging",
+		"dragEnd",
+		"mouseDown",
+		"mouseUp",
+		"mouseOver",
+		"mouseOut",
+		"mouseMove",
+		"moveStart",
+		"moveAlong",
+		"moveEnd",
+		"moving",
+		"touchStart",
+		"touchMove",
+		"touchEnd"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const elasticMarkerEvents = domOverlayEvents;
+		const map = useMapInstance(props);
+		const restProps = shallowReactiveOmit(props, "map");
+		const elasticMarker = shallowRef(new AMap.ElasticMarker(toDefinedRaw(restProps)));
+		watchEffect((onCleanup) => {
+			map.value?.add(elasticMarker.value);
+			onCleanup(() => {
+				map.value?.remove(elasticMarker.value);
+			});
+		});
+		useMarkerAttributes(elasticMarker, shallowReactiveOmit(props, [
+			"map",
+			"styles",
+			"zoomStyleMapping"
+		]));
+		watch(() => props.zoomStyleMapping, (val) => {
+			if (val !== void 0) elasticMarker.value.setMapping(clone(toRaw(val)));
+		});
+		watch(() => props.styles, (val) => {
+			if (val !== void 0) elasticMarker.value.setStyle(clone(toRaw(val)));
+		});
+		use_event_listeners_default(elasticMarker, emits, elasticMarkerEvents);
+		onUnmounted(() => elasticMarker.value.destroy());
+		__expose({ instance: elasticMarker });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/overlay/ellipse/ellipse.vue
+var ellipse_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.Ellipse",
+	inheritAttrs: false,
+	__name: "ellipse",
+	props: {
+		map: {},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		center: {},
+		height: {},
+		radius: {},
+		async: {
+			type: Boolean,
+			default: void 0
+		},
+		bubble: {
+			type: Boolean,
+			default: void 0
+		},
+		extrusionHeight: {},
+		fillColor: {},
+		fillOpacity: {},
+		innerOverlay: {
+			type: Boolean,
+			default: void 0
+		},
+		noSelect: {
+			type: Boolean,
+			default: void 0
+		},
+		cursor: {},
+		draggable: {
+			type: Boolean,
+			default: void 0
+		},
+		extData: {},
+		strokeColor: {},
+		strokeDasharray: {},
+		strokeOpacity: {},
+		strokeStyle: {},
+		strokeWeight: {},
+		zIndex: {},
+		zooms: {}
+	},
+	emits: [
+		"hide",
+		"show",
+		"click",
+		"dblClick",
+		"rightClick",
+		"mouseDown",
+		"mouseUp",
+		"mouseOver",
+		"mouseOut",
+		"dragStart",
+		"dragging",
+		"dragEnd",
+		"touchStart",
+		"touchMove",
+		"touchEnd"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const ellipseEvents = vectorOverlayEvents;
+		const map = useMapInstance(props);
+		const restProps = shallowReactiveOmit(props, "map");
+		const vectorLayer = useVectorLayerInstance();
+		const ellipse = shallowRef(new AMap.Ellipse(toDefinedRaw(restProps)));
+		watchEffect((onCleanup) => {
+			if (vectorLayer) vectorLayer.value.add(ellipse.value);
+			else map.value?.add(ellipse.value);
+			onCleanup(() => {
+				if (vectorLayer) vectorLayer.value.remove(ellipse.value);
+				else map.value?.remove(ellipse.value);
+			});
+		});
+		useVectorOverlayAttributes(ellipse, props);
+		watch(() => props.center, (val) => {
+			if (val !== void 0) ellipse.value.setCenter(toRaw(val));
+		});
+		watch(() => props.radius, (val) => {
+			if (val !== void 0) ellipse.value.setRadius(val);
+		});
+		watch(shallowReactiveOmit(props, [
+			"map",
+			"draggable",
+			"extData",
+			"visible",
+			"center",
+			"radius"
+		]), (val) => {
+			ellipse.value.setOptions(toDefinedRaw(val));
+		});
+		use_event_listeners_default(ellipse, emits, ellipseEvents);
+		onUnmounted(() => ellipse.value.destroy());
+		__expose({ instance: ellipse });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/overlay/index-cluster/index-cluster.vue
+var index_cluster_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.IndexCluster",
+	inheritAttrs: false,
+	__name: "index-cluster",
+	props: {
+		data: {},
+		map: {},
+		gridSize: {},
+		minClusterSize: {},
+		maxZoom: {},
+		averageCenter: {
+			type: Boolean,
+			default: void 0
+		},
+		clusterByZoomChange: {
+			type: Boolean,
+			default: void 0
+		},
+		styles: {},
+		renderMarker: {},
+		renderClusterMarker: {},
+		customRender: {},
+		clusterIndexSet: {}
+	},
+	emits: ["click"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const indexClusterEvents = [click];
+		const map = useMapInstance(props);
+		const restProps = shallowReactiveOmit(props, "map", "data");
+		const indexCluster = shallowRef(new AMap.IndexCluster(null, clone(toRaw(props.data), true), toDefinedRaw(restProps)));
+		watchEffect((onCleanup) => {
+			indexCluster.value.i = null;
+			indexCluster.value.setMap(map.value);
+			onCleanup(() => {
+				indexCluster.value.setMap(null);
+			});
+		});
+		watchEffect((onCleanup) => {
+			indexCluster.value.setData(clone(toRaw(props.data), true));
+			onCleanup(() => {
+				indexCluster.value.setData([]);
+			});
+		});
+		function getDefaultStyles() {
+			const instance = new AMap.IndexCluster();
+			const styles = instance.getStyles();
+			instance.setMap(null);
+			return styles;
+		}
+		watch(() => props.averageCenter, (val) => {
+			if (val !== void 0) indexCluster.value.setAverageCenter(val);
+		});
+		watch(() => props.clusterByZoomChange, (val) => {
+			indexCluster.value.clusterByZoomChange = val || false;
+		});
+		watch(() => props.customRender, (val) => {
+			indexCluster.value.customRender = val || null;
+		});
+		watch(() => props.gridSize, (val) => {
+			if (val !== void 0) indexCluster.value.setGridSize(val);
+		});
+		watch(() => props.maxZoom, (val) => {
+			if (val !== void 0) indexCluster.value.setMaxZoom(val);
+		});
+		watch(() => props.renderClusterMarker, (val) => {
+			indexCluster.value.renderClusterMarker = val || null;
+		});
+		watch(() => props.renderMarker, (val) => {
+			indexCluster.value.setRenderMarkerStyle(val || null);
+		});
+		watch(() => props.styles, (val) => {
+			indexCluster.value.setStyles(val ?? getDefaultStyles());
+		});
+		use_event_listeners_default(indexCluster, emits, indexClusterEvents);
+		__expose({ instance: indexCluster });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/overlay/info-window/info-window.vue
+var info_window_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.InfoWindow",
+	inheritAttrs: false,
+	__name: "info-window",
+	props: {
+		autoMove: {
+			type: Boolean,
+			default: void 0
+		},
+		avoid: {},
+		closeWhenClickMap: {
+			type: Boolean,
+			default: void 0
+		},
+		content: {},
+		extData: {},
+		isCustom: {
+			type: Boolean,
+			default: void 0
+		},
+		anchor: {},
+		innerOverlay: {
+			type: Boolean,
+			default: void 0
+		},
+		map: {},
+		noSelect: {
+			type: Boolean,
+			default: void 0
+		},
+		offset: {},
+		orientation: {},
+		position: {},
+		rotate: {},
+		scale: {},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		size: {},
+		zIndex: {},
+		zooms: {}
+	},
+	emits: ["close", "open"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const infoWindowEvents = [close, open];
+		const map = useMapInstance(props);
+		const restProps = shallowReactiveOmit(props, "map");
+		const infoWindow = shallowRef(new AMap.InfoWindow(toDefinedRaw(restProps)));
+		watchEffect((onCleanup) => {
+			map.value?.add(infoWindow.value);
+			onCleanup(() => {
+				map.value?.remove(infoWindow.value);
+			});
+		});
+		const slots = useSlots();
+		const hasChildren = computed(() => slots.default !== void 0);
+		watch(() => props.extData, (val) => {
+			infoWindow.value.setExtData(toRaw(val));
+		});
+		watch(shallowReactiveOmit(props, [
+			"map",
+			"anchor",
+			"content",
+			"offset",
+			"orientation",
+			"position",
+			"rotate",
+			"size",
+			"visible",
+			"zIndex",
+			"extData"
+		]), (val) => {
+			infoWindow.value.setOptions(toDefinedRaw(val));
+		});
+		useDOMOverlayAttributes(infoWindow, props, hasChildren);
+		use_event_listeners_default(infoWindow, emits, infoWindowEvents);
+		onUnmounted(() => infoWindow.value.destroy());
+		__expose({ instance: infoWindow });
+		return (_ctx, _cache) => {
+			return _ctx.$slots.default ? (openBlock(), createBlock(unref(custom_content_default), {
+				key: 0,
+				instance: infoWindow.value
+			}, {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+				_: 3
+			}, 8, ["instance"])) : createCommentVNode("v-if", true);
+		};
+	}
+});
+// src/overlay/label-marker/label-marker.vue
+var label_marker_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.LabelMarker",
+	inheritAttrs: false,
+	__name: "label-marker",
+	props: {
+		isTop: {
+			type: Boolean,
+			default: void 0
+		},
+		bubble: {
+			type: Boolean,
+			default: void 0
+		},
+		cursor: {},
+		draggable: {
+			type: Boolean,
+			default: void 0
+		},
+		extData: {},
+		icon: {},
+		innerOverlay: {
+			type: Boolean,
+			default: void 0
+		},
+		name: {},
+		noSelect: {
+			type: Boolean,
+			default: void 0
+		},
+		opacity: {},
+		orientation: {},
+		position: {},
+		rank: {},
+		richText: {},
+		rotation: {},
+		text: {},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		zIndex: {},
+		zooms: {}
+	},
+	emits: [
+		"click",
+		"mouseDown",
+		"mouseUp",
+		"mouseOver",
+		"mouseOut",
+		"mouseMove",
+		"touchStart",
+		"touchMove",
+		"touchEnd"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const labelMarkerEvents = [
+			click,
+			mouseMove,
+			mouseOver,
+			mouseOut,
+			mouseUp,
+			touchStart,
+			touchMove,
+			touchEnd
+		];
+		const labelsLayer = useLabelsLayerInstance();
+		const labelMarker = shallowRef(new AMap.LabelMarker(toDefinedRaw(props)));
+		watchEffect((onCleanup) => {
+			labelsLayer?.value?.add(labelMarker.value);
+			onCleanup(() => {
+				labelsLayer?.value?.remove(labelMarker.value);
+			});
+		});
+		watch(() => props.cursor, (val) => {
+			labelMarker.value.setCursor(val);
+		});
+		watch(() => props.extData, (val) => {
+			labelMarker.value.setExtData(toRaw(val));
+		});
+		watch(() => props.icon, (val) => {
+			labelMarker.value.setIcon(clone(toRaw(val)));
+		});
+		watch(() => props.name, (val) => {
+			if (val !== void 0) labelMarker.value.setName(val);
+		});
+		watch(() => props.opacity, (val) => {
+			labelMarker.value.setOpacity(val);
+		});
+		watch(() => props.orientation, (val) => {
+			labelMarker.value.setOrientation(val);
+		});
+		watch(() => props.position, (val) => {
+			if (val !== void 0) labelMarker.value.setPosition(clone(toRaw(val)));
+		});
+		watch(() => props.rank, (val) => {
+			if (val !== void 0) labelMarker.value.setRank(val);
+		});
+		watch(() => props.richText, (val) => {
+			labelMarker.value.setRichText(clone(toRaw(val)));
+		});
+		watch(() => props.rotation, (val) => {
+			if (val !== void 0) labelMarker.value.setRotation(val);
+		});
+		watch(() => props.text, (val) => {
+			if (val !== void 0) labelMarker.value.setText(clone(toRaw(val)));
+		});
+		watch(() => props.isTop, (val) => {
+			labelMarker.value.setTop(val);
+		});
+		watch(() => props.visible, (val) => {
+			labelMarker.value.setVisible(val);
+		});
+		watch(() => props.zooms, (val) => {
+			labelMarker.value.setZooms(clone(toRaw(val)));
+		});
+		watch(() => props.zIndex, (val) => {
+			if (val !== void 0) labelMarker.value.setzIndex(val);
+		});
+		use_event_listeners_default(labelMarker, emits, labelMarkerEvents);
+		__expose({ instance: labelMarker });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/overlay/marker-cluster/marker-cluster.vue
+var marker_cluster_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.MarkerCluster",
+	inheritAttrs: false,
+	__name: "marker-cluster",
+	props: {
+		data: {},
+		map: {},
+		gridSize: {},
+		minClusterSize: {},
+		maxZoom: {},
+		averageCenter: {
+			type: Boolean,
+			default: void 0
+		},
+		clusterByZoomChange: {
+			type: Boolean,
+			default: void 0
+		},
+		styles: {},
+		renderMarker: {},
+		renderClusterMarker: {}
+	},
+	emits: ["click"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const markerClusterEvents = [click];
+		const map = useMapInstance(props);
+		const restProps = shallowReactiveOmit(props, "map", "data");
+		const markerCluster = shallowRef(new AMap.MarkerCluster(null, clone(toRaw(props.data), true), toDefinedRaw(restProps)));
+		watchEffect((onCleanup) => {
+			markerCluster.value.i = null;
+			markerCluster.value.setMap(map.value);
+			onCleanup(() => {
+				markerCluster.value.setMap(null);
+			});
+		});
+		watchEffect((onCleanup) => {
+			markerCluster.value.setData(clone(toRaw(props.data), true));
+			onCleanup(() => {
+				markerCluster.value.setData([]);
+			});
+		});
+		function getDefaultStyles() {
+			const instance = new AMap.MarkerCluster();
+			const styles = instance.getStyles();
+			instance.setMap(null);
+			return styles;
+		}
+		watch(() => props.averageCenter, (val) => {
+			if (val !== void 0) markerCluster.value.setAverageCenter(val);
+		});
+		watch(() => props.gridSize, (val) => {
+			if (val !== void 0) markerCluster.value.setGridSize(val);
+		});
+		watch(() => props.maxZoom, (val) => {
+			if (val !== void 0) markerCluster.value.setMaxZoom(val);
+		});
+		watch(() => props.minClusterSize, (val) => {
+			if (val !== void 0) markerCluster.value.setMinClusterSize(val);
+		});
+		watch(() => props.renderClusterMarker, (val) => {
+			markerCluster.value.renderClusterMarker = val;
+		});
+		watch(() => props.renderMarker, (val) => {
+			markerCluster.value.setRenderMarkerStyle(val);
+		});
+		watch(() => props.styles, (val) => {
+			markerCluster.value.setStyles(val ?? getDefaultStyles());
+		});
+		use_event_listeners_default(markerCluster, emits, markerClusterEvents);
+		__expose({ instance: markerCluster });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/overlay/mass-marks/mass-marks.vue
+var mass_marks_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.MassMarks",
+	inheritAttrs: false,
+	__name: "mass-marks",
+	props: {
+		data: {},
+		map: {},
+		styles: {},
+		style: {},
+		zIndex: {},
+		opacity: {},
+		zooms: {},
+		cursor: {}
+	},
+	emits: [
+		"click",
+		"complete",
+		"dblClick",
+		"mouseDown",
+		"mouseMove",
+		"mouseOut",
+		"mouseOver",
+		"mouseUp",
+		"touchEnd",
+		"touchStart"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const massMarksEvents = [
+			click,
+			complete,
+			dblClick,
+			mouseDown,
+			mouseMove,
+			mouseOut,
+			mouseOver,
+			mouseUp,
+			touchEnd,
+			touchStart
+		];
+		const map = useMapInstance(props);
+		const restProps = shallowReactiveOmit(props, "map", "data");
+		const { styles, ...options } = toDefinedRaw(restProps);
+		const massMarks = shallowRef(new AMap.MassMarks(clone(toRaw(props.data)), {
+			...options,
+			style: clone(toRaw(styles))
+		}));
+		watchEffect((onCleanup) => {
+			massMarks.value.setMap(map.value);
+			onCleanup(() => {
+				massMarks.value.setMap(null);
+			});
+		});
+		watchEffect(() => {
+			massMarks.value.setData(clone(toRaw(props.data)));
+		});
+		watch(() => props.opacity, (val) => {
+			if (val !== void 0) massMarks.value.setOpacity(val);
+		});
+		watch(() => props.styles, (val) => {
+			if (val !== void 0) massMarks.value.setStyle(clone(toRaw(val)));
+		});
+		watch(() => props.zIndex, (val) => {
+			if (val !== void 0) massMarks.value.setzIndex(val);
+		});
+		watch(() => props.zooms, (val) => {
+			if (val !== void 0) massMarks.value.setZooms(clone(toRaw(val)));
+		});
+		use_event_listeners_default(massMarks, emits, massMarksEvents);
+		onUnmounted(() => massMarks.value.clear());
+		__expose({ instance: massMarks });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/overlay/overlay-group/overlay-group.vue
+var overlay_group_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.OverlayGroup",
+	inheritAttrs: false,
+	__name: "overlay-group",
+	props: {
+		map: {},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		overlays: { default: () => [] }
+	},
+	emits: [
+		"hide",
+		"show",
+		"click",
+		"dblClick",
+		"rightClick",
+		"mouseDown",
+		"mouseUp",
+		"mouseOver",
+		"mouseOut",
+		"mouseMove",
+		"moveStart",
+		"moveAlong",
+		"moveEnd",
+		"moving",
+		"dragStart",
+		"dragging",
+		"dragEnd",
+		"touchStart",
+		"touchMove",
+		"touchEnd"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const map = useMapInstance(props);
+		const overlayGroup = shallowRef(new AMap.OverlayGroup());
+		watch(() => [...props.overlays], (newOverlays) => {
+			const current = new Set(overlayGroup.value.getOverlays());
+			const next = new Set(newOverlays);
+			const toRemove = [...current].filter((o) => !next.has(o));
+			const toAdd = [...next].filter((o) => !current.has(o));
+			if (toRemove.length) overlayGroup.value.removeOverlays(toRemove);
+			if (toAdd.length) overlayGroup.value.addOverlays(toAdd);
+		}, {
+			deep: true,
+			immediate: true
+		});
+		const boundMap = /* @__PURE__ */ new Map();
+		watch(() => [...props.overlays], (newOverlays) => {
+			const nextOverlays = newOverlays ? [...new Set(newOverlays)] : [];
+			const nextSet = new Set(nextOverlays);
+			for (const [overlay, handlerMap] of boundMap) if (!nextSet.has(overlay)) {
+				for (const [eventType, handler] of handlerMap) overlay.off(lowercase(eventType), handler);
+				boundMap.delete(overlay);
+				if ("destroy" in overlay && typeof overlay.destroy === "function") overlay.destroy();
+			}
+			for (const overlay of nextOverlays) {
+				if (boundMap.has(overlay)) continue;
+				const eventTypes = overlay instanceof AMap.Marker ? domOverlayEvents : vectorOverlayEvents;
+				const handlerMap = /* @__PURE__ */ new Map();
+				for (const eventType of eventTypes) {
+					const handler = (event) => {
+						emits(eventType, event);
+					};
+					overlay.on(lowercase(eventType), handler);
+					handlerMap.set(eventType, handler);
+				}
+				boundMap.set(overlay, handlerMap);
+			}
+		}, {
+			deep: true,
+			immediate: true
+		});
+		watchEffect((onCleanup) => {
+			map.value?.add(overlayGroup.value);
+			onCleanup(() => {
+				map.value?.remove(overlayGroup.value);
+			});
+		});
+		watch(() => props.visible, (val) => {
+			if (val !== void 0) {
+				if (val) overlayGroup.value.show();
+				else overlayGroup.value.hide();
+			}
+		});
+		__expose({ instance: overlayGroup });
+		function dispose() {
+			for (const [overlay, handlerMap] of boundMap) {
+				for (const [eventType, handler] of handlerMap) overlay.off(lowercase(eventType), handler);
+				if ("destroy" in overlay && typeof overlay.destroy === "function") overlay.destroy();
+			}
+			boundMap.clear();
+		}
+		onUnmounted(() => {
+			dispose();
+			overlayGroup.value.clearOverlays();
+		});
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/overlay/polygon/polygon.vue
+var polygon_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.Polygon",
+	inheritAttrs: false,
+	__name: "polygon",
+	props: {
+		map: {},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		path: {},
+		roofColor: {},
+		wallColor: {},
+		async: {
+			type: Boolean,
+			default: void 0
+		},
+		bubble: {
+			type: Boolean,
+			default: void 0
+		},
+		extrusionHeight: {},
+		fillColor: {},
+		fillOpacity: {},
+		innerOverlay: {
+			type: Boolean,
+			default: void 0
+		},
+		noSelect: {
+			type: Boolean,
+			default: void 0
+		},
+		cursor: {},
+		draggable: {
+			type: Boolean,
+			default: void 0
+		},
+		extData: {},
+		strokeColor: {},
+		strokeDasharray: {},
+		strokeOpacity: {},
+		strokeStyle: {},
+		strokeWeight: {},
+		zIndex: {},
+		zooms: {}
+	},
+	emits: [
+		"hide",
+		"show",
+		"click",
+		"dblClick",
+		"rightClick",
+		"mouseDown",
+		"mouseUp",
+		"mouseOver",
+		"mouseOut",
+		"dragStart",
+		"dragging",
+		"dragEnd",
+		"touchStart",
+		"touchMove",
+		"touchEnd"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const polygonEvents = vectorOverlayEvents;
+		const map = useMapInstance(props);
+		const restProps = shallowReactiveOmit(props, "map");
+		const vectorLayer = useVectorLayerInstance();
+		const polygon = shallowRef(new AMap.Polygon(toDefinedRaw(restProps)));
+		watchEffect((onCleanup) => {
+			if (vectorLayer) vectorLayer.value.add(polygon.value);
+			else map.value?.add(polygon.value);
+			onCleanup(() => {
+				if (vectorLayer) vectorLayer.value.remove(polygon.value);
+				else map.value?.remove(polygon.value);
+			});
+		});
+		useVectorOverlayAttributes(polygon, props);
+		watch(() => props.path, (val) => {
+			polygon.value.setPath(toRaw(val));
+		});
+		watch(() => props.extrusionHeight, (val) => {
+			if (val !== void 0) polygon.value.setExtrusionHeight(toRaw(val));
+		});
+		watch(shallowReactiveOmit(props, [
+			"map",
+			"draggable",
+			"extData",
+			"visible",
+			"extrusionHeight",
+			"path"
+		]), (val) => {
+			polygon.value.setOptions(toDefinedRaw(val));
+		});
+		use_event_listeners_default(polygon, emits, polygonEvents);
+		onUnmounted(() => polygon.value.destroy());
+		__expose({ instance: polygon });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/overlay/polyline/polyline.vue
+var polyline_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.Polyline",
+	inheritAttrs: false,
+	__name: "polyline",
+	props: {
+		map: {},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		animate: {
+			type: Boolean,
+			default: void 0
+		},
+		dirImgGap: {},
+		path: {},
+		speed: {},
+		borderWeight: {},
+		dirColor: {},
+		dirImg: {},
+		geodesic: {
+			type: Boolean,
+			default: void 0
+		},
+		height: {},
+		isOutLine: {
+			type: Boolean,
+			default: void 0
+		},
+		lineCap: {},
+		lineGradient: {},
+		lineJoin: {},
+		outlineColor: {},
+		showDir: {
+			type: Boolean,
+			default: void 0
+		},
+		cursor: {},
+		draggable: {
+			type: Boolean,
+			default: void 0
+		},
+		extData: {},
+		strokeColor: {},
+		strokeDasharray: {},
+		strokeOpacity: {},
+		strokeStyle: {},
+		strokeWeight: {},
+		zIndex: {},
+		zooms: {}
+	},
+	emits: [
+		"hide",
+		"show",
+		"click",
+		"dblClick",
+		"rightClick",
+		"mouseDown",
+		"mouseUp",
+		"mouseOver",
+		"mouseOut",
+		"dragStart",
+		"dragging",
+		"dragEnd",
+		"touchStart",
+		"touchMove",
+		"touchEnd"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const polylineEvents = vectorOverlayEvents;
+		const map = useMapInstance(props);
+		const restProps = shallowReactiveOmit(props, "map");
+		const vectorLayer = useVectorLayerInstance();
+		const polyline = shallowRef(new AMap.Polyline(toDefinedRaw(restProps)));
+		watchEffect((onCleanup) => {
+			if (vectorLayer) vectorLayer.value.add(polyline.value);
+			else map.value?.add(polyline.value);
+			onCleanup(() => {
+				if (vectorLayer) vectorLayer.value.remove(polyline.value);
+				else map.value?.remove(polyline.value);
+			});
+		});
+		useVectorOverlayAttributes(polyline, props);
+		watch(() => props.path, (val) => {
+			polyline.value.setPath(toRaw(val));
+		});
+		watch(shallowReactiveOmit(props, [
+			"map",
+			"draggable",
+			"extData",
+			"visible",
+			"height",
+			"path"
+		]), (val) => {
+			polyline.value.setOptions(toDefinedRaw(val));
+		});
+		use_event_listeners_default(polyline, emits, polylineEvents);
+		onUnmounted(() => polyline.value.destroy());
+		__expose({ instance: polyline });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/overlay/rectangle/rectangle.vue
+var rectangle_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.Rectangle",
+	inheritAttrs: false,
+	__name: "rectangle",
+	props: {
+		map: {},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		bounds: {},
+		async: {
+			type: Boolean,
+			default: void 0
+		},
+		bubble: {
+			type: Boolean,
+			default: void 0
+		},
+		extrusionHeight: {},
+		fillColor: {},
+		fillOpacity: {},
+		innerOverlay: {
+			type: Boolean,
+			default: void 0
+		},
+		noSelect: {
+			type: Boolean,
+			default: void 0
+		},
+		cursor: {},
+		draggable: {
+			type: Boolean,
+			default: void 0
+		},
+		extData: {},
+		strokeColor: {},
+		strokeDasharray: {},
+		strokeOpacity: {},
+		strokeStyle: {},
+		strokeWeight: {},
+		zIndex: {},
+		zooms: {}
+	},
+	emits: [
+		"hide",
+		"show",
+		"click",
+		"dblClick",
+		"rightClick",
+		"mouseDown",
+		"mouseUp",
+		"mouseOver",
+		"mouseOut",
+		"dragStart",
+		"dragging",
+		"dragEnd",
+		"touchStart",
+		"touchMove",
+		"touchEnd"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const rectangleEvents = vectorOverlayEvents;
+		const map = useMapInstance(props);
+		const restProps = shallowReactiveOmit(props, "map");
+		const vectorLayer = useVectorLayerInstance();
+		const rectangle = shallowRef(new AMap.Rectangle(toDefinedRaw(restProps)));
+		watchEffect((onCleanup) => {
+			if (vectorLayer) vectorLayer.value.add(rectangle.value);
+			else map.value?.add(rectangle.value);
+			onCleanup(() => {
+				if (vectorLayer) vectorLayer.value.remove(rectangle.value);
+				else map.value?.remove(rectangle.value);
+			});
+		});
+		useVectorOverlayAttributes(rectangle, props);
+		watch(() => props.bounds, (val) => {
+			rectangle.value.setBounds(toRaw(val));
+		});
+		watch(shallowReactiveOmit(props, [
+			"map",
+			"draggable",
+			"extData",
+			"visible",
+			"bounds"
+		]), (val) => {
+			rectangle.value.setOptions(toDefinedRaw(val));
+		});
+		use_event_listeners_default(rectangle, emits, rectangleEvents);
+		onUnmounted(() => rectangle.value.destroy());
+		__expose({ instance: rectangle });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/overlay/text/text.vue
+var text_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.Text",
+	inheritAttrs: false,
+	__name: "text",
+	props: {
+		isTop: {
+			type: Boolean,
+			default: void 0
+		},
+		style: {},
+		text: {},
+		bubble: {
+			type: Boolean,
+			default: void 0
+		},
+		clickable: {
+			type: Boolean,
+			default: void 0
+		},
+		cursor: {},
+		draggable: {
+			type: Boolean,
+			default: void 0
+		},
+		extData: {},
+		icon: {},
+		title: {},
+		topWhenClick: {
+			type: Boolean,
+			default: void 0
+		},
+		label: {},
+		anchor: {},
+		innerOverlay: {
+			type: Boolean,
+			default: void 0
+		},
+		isCustom: {
+			type: Boolean,
+			default: void 0
+		},
+		map: {},
+		noSelect: {
+			type: Boolean,
+			default: void 0
+		},
+		offset: {},
+		orientation: {},
+		position: {},
+		rotate: {},
+		scale: {},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		content: {},
+		size: {},
+		zIndex: {},
+		zooms: {}
+	},
+	emits: [
+		"click",
+		"dblClick",
+		"rightClick",
+		"dragStart",
+		"dragging",
+		"dragEnd",
+		"mouseDown",
+		"mouseUp",
+		"mouseOver",
+		"mouseOut",
+		"mouseMove",
+		"moveStart",
+		"moveAlong",
+		"moveEnd",
+		"moving",
+		"touchStart",
+		"touchMove",
+		"touchEnd"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const textEvents = domOverlayEvents;
+		const map = useMapInstance(props);
+		const restProps = shallowReactiveOmit(props, "map");
+		const text = shallowRef(new AMap.Text(toDefinedRaw(restProps)));
+		watchEffect((onCleanup) => {
+			map.value?.add(text.value);
+			onCleanup(() => {
+				map.value?.remove(text.value);
+			});
+		});
+		const slots = useSlots();
+		const hasChildren = computed(() => slots.default !== void 0);
+		useMarkerAttributes(text, shallowReactiveOmit(props, [
+			"map",
+			"style",
+			"text"
+		]), hasChildren);
+		watch(() => props.style, (val) => {
+			if (val !== void 0) text.value.setStyle(clone(toRaw(val)));
+		});
+		watch([
+			hasChildren,
+			() => props.content,
+			() => props.text
+		], ([c1, c2, t1]) => {
+			if (c1) return;
+			if (c2 != null) text.value.setContent(c2);
+			else if (t1 !== void 0) text.value.setText(clone(toRaw(t1)));
+		}, { immediate: true });
+		use_event_listeners_default(text, emits, textEvents);
+		onUnmounted(() => text.value.destroy());
+		__expose({ instance: text });
+		return (_ctx, _cache) => {
+			return _ctx.$slots.default ? (openBlock(), createBlock(unref(custom_content_default), {
+				key: 0,
+				instance: text.value
+			}, {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+				_: 3
+			}, 8, ["instance"])) : createCommentVNode("v-if", true);
+		};
+	}
+});
+// src/tool/bezier-curve-editor/bezier-curve-editor.vue
+var bezier_curve_editor_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.BezierCurveEditor",
+	inheritAttrs: false,
+	__name: "bezier-curve-editor",
+	props: {
+		map: {},
+		target: {},
+		createOptions: {},
+		editOptions: {},
+		controlPoint: {},
+		midControlPoint: {},
+		bezierControlPoint: {},
+		bezierControlLine: {}
+	},
+	emits: [
+		"add",
+		"end",
+		"addNode",
+		"adjust",
+		"removeNode"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const bezierCurveEditorEvents = [
+			add,
+			end,
+			adjust,
+			addNode,
+			removeNode
+		];
+		const map = useMapInstance(props);
+		const restProps = shallowReactiveOmit(props, "map", "target");
+		const bezierCurveEditor = shallowRef(map.value ? new AMap.BezierCurveEditor(map.value, toValue(props.target), toDefinedRaw(restProps)) : null);
+		watchEffect((onCleanup) => {
+			if (!bezierCurveEditor.value && map.value) bezierCurveEditor.value = new AMap.BezierCurveEditor(map.value, toValue(props.target), toDefinedRaw(restProps));
+			onCleanup(() => {
+				bezierCurveEditor.value?.destroy();
+			});
+		});
+		watchEffect(() => {
+			bezierCurveEditor.value?.setTarget(toValue(props.target));
+		});
+		watch([() => props.createOptions, bezierCurveEditor], ([val, editor]) => {
+			if (val && editor) editor._normalPolylineStyle = AMap.extend(editor._normalPolylineStyle, clone(toRaw(val)));
+		});
+		watch([() => props.editOptions, bezierCurveEditor], ([val, editor]) => {
+			if (val && editor) editor._editingPolylineStyle = AMap.extend(editor._editingPolylineStyle, clone(toRaw(val)));
+		});
+		watch([() => props.controlPoint, bezierCurveEditor], ([val, editor]) => {
+			if (val && editor) editor.opts.controlPoint = toRaw(val);
+		});
+		watch([() => props.midControlPoint, bezierCurveEditor], ([val, editor]) => {
+			if (val && editor) editor.opts.midControlPoint = toRaw(val);
+		});
+		watch([() => props.bezierControlPoint, bezierCurveEditor], ([val, editor]) => {
+			if (val && editor) editor.opts.bezierControlPoint = toRaw(val);
+		});
+		watch([() => props.bezierControlLine, bezierCurveEditor], ([val, editor]) => {
+			if (val && editor) editor.opts.bezierControlLine = AMap.extend(editor.opts.bezierControlLine, toRaw(val));
+		});
+		use_event_listeners_default(bezierCurveEditor, emits, bezierCurveEditorEvents);
+		__expose({ instance: bezierCurveEditor });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/tool/circle-editor/circle-editor.vue
+var circle_editor_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.CircleEditor",
+	inheritAttrs: false,
+	__name: "circle-editor",
+	props: {
+		map: {},
+		target: {},
+		createOptions: {},
+		editOptions: {},
+		movePoint: {},
+		resizePoint: {}
+	},
+	emits: [
+		"add",
+		"end",
+		"adjust",
+		"move"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const circleEditorEvents = [
+			add,
+			end,
+			adjust,
+			move
+		];
+		const map = useMapInstance(props);
+		const restProps = shallowReactiveOmit(props, "map", "target");
+		const circleEditor = shallowRef(map.value ? new AMap.CircleEditor(map.value, toValue(props.target), toDefinedRaw(restProps)) : null);
+		watchEffect((onCleanup) => {
+			if (!circleEditor.value && map.value) circleEditor.value = new AMap.CircleEditor(map.value, toValue(props.target), toDefinedRaw(restProps));
+			onCleanup(() => {
+				circleEditor.value?.destroy();
+			});
+		});
+		watchEffect(() => {
+			circleEditor.value?.setTarget(toValue(props.target));
+		});
+		watch([() => props.createOptions, circleEditor], ([val, editor]) => {
+			if (val && editor) editor._normalCircleStyle = AMap.extend(editor._normalCircleStyle, clone(toRaw(val)));
+		});
+		watch([() => props.editOptions, circleEditor], ([val, editor]) => {
+			if (val && editor) editor._editStyle = AMap.extend(editor._editStyle, clone(toRaw(val)));
+		});
+		watch([() => props.movePoint, circleEditor], ([val, editor]) => {
+			if (val && editor) editor._opts.movePoint = toRaw(val);
+		});
+		watch([() => props.resizePoint, circleEditor], ([val, editor]) => {
+			if (val && editor) editor._opts.resizePoint = toRaw(val);
+		});
+		use_event_listeners_default(circleEditor, emits, circleEditorEvents);
+		__expose({ instance: circleEditor });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/tool/ellipse-editor/ellipse-editor.vue
+var ellipse_editor_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.EllipseEditor",
+	inheritAttrs: false,
+	__name: "ellipse-editor",
+	props: {
+		map: {},
+		target: {},
+		createOptions: {},
+		editOptions: {},
+		movePoint: {},
+		resizeXPoint: {},
+		resizeYPoint: {}
+	},
+	emits: [
+		"add",
+		"end",
+		"adjust",
+		"move"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const ellipseEditorEvents = [
+			add,
+			end,
+			adjust,
+			move
+		];
+		const map = useMapInstance(props);
+		const restProps = shallowReactiveOmit(props, "map", "target");
+		const ellipseEditor = shallowRef(map.value ? new AMap.EllipseEditor(map.value, toValue(props.target), toDefinedRaw(restProps)) : null);
+		watchEffect((onCleanup) => {
+			if (!ellipseEditor.value && map.value) ellipseEditor.value = new AMap.EllipseEditor(map.value, toValue(props.target), toDefinedRaw(restProps));
+			onCleanup(() => {
+				ellipseEditor.value?.destroy();
+			});
+		});
+		watchEffect(() => {
+			ellipseEditor.value?.setTarget(toValue(props.target));
+		});
+		watch([() => props.createOptions, ellipseEditor], ([val, editor]) => {
+			if (val && editor) editor._normalCircleStyle = AMap.extend(editor._normalCircleStyle, clone(toRaw(val)));
+		});
+		watch([() => props.editOptions, ellipseEditor], ([val, editor]) => {
+			if (val && editor) editor._editStyle = AMap.extend(editor._editStyle, clone(toRaw(val)));
+		});
+		watch([() => props.movePoint, ellipseEditor], ([val, editor]) => {
+			if (val && editor) editor._opts.movePoint = toRaw(val);
+		});
+		watch([() => props.resizeXPoint, ellipseEditor], ([val, editor]) => {
+			if (val && editor) editor._opts.resizeXPoint = toRaw(val);
+		});
+		watch([() => props.resizeYPoint, ellipseEditor], ([val, editor]) => {
+			if (val && editor) editor._opts.resizeYPoint = toRaw(val);
+		});
+		use_event_listeners_default(ellipseEditor, emits, ellipseEditorEvents);
+		__expose({ instance: ellipseEditor });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/tool/mouse-tool/mouse-tool.vue
+var mouse_tool_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.MouseTool",
+	inheritAttrs: false,
+	__name: "mouse-tool",
+	props: {
+		map: {},
+		clearOnClose: {
+			type: Boolean,
+			default: void 0
+		},
+		toolBubble: {
+			type: Boolean,
+			default: void 0
+		}
+	},
+	emits: ["draw"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const mouseToolEvents = [draw];
+		const map = useMapInstance(props);
+		const mouseTool = shallowRef(map.value ? new AMap.MouseTool(map.value, props.toolBubble) : null);
+		watchEffect((onCleanup) => {
+			if (!mouseTool.value && map.value) mouseTool.value = new AMap.MouseTool(map.value, props.toolBubble);
+			const dragEnable = map.value?.getStatus().dragEnable;
+			onCleanup(() => {
+				mouseTool.value?.close(props.clearOnClose);
+				map.value?.setStatus({ dragEnable });
+			});
+		});
+		watch([() => props.toolBubble, mouseTool], ([val, tool]) => {
+			if (val && tool) tool.overlayBubble = val || false;
+		});
+		use_event_listeners_default(mouseTool, emits, mouseToolEvents);
+		__expose({ instance: mouseTool });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/tool/polygon-editor/polygon-editor.vue
+var polygon_editor_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.PolygonEditor",
+	inheritAttrs: false,
+	__name: "polygon-editor",
+	props: {
+		map: {},
+		target: {},
+		createOptions: {},
+		editOptions: {},
+		controlPoint: {},
+		midControlPoint: {}
+	},
+	emits: [
+		"add",
+		"end",
+		"adjust",
+		"addNode",
+		"removeNode"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const polygonEditorEvents = [
+			add,
+			end,
+			adjust,
+			addNode,
+			removeNode
+		];
+		const map = useMapInstance(props);
+		const restProps = shallowReactiveOmit(props, "map", "target");
+		const polygonEditor = shallowRef(map.value ? new AMap.PolygonEditor(map.value, toValue(props.target), toDefinedRaw(restProps)) : null);
+		patchPolygonEditor();
+		watchEffect((onCleanup) => {
+			if (!polygonEditor.value && map.value) polygonEditor.value = new AMap.PolygonEditor(map.value, toValue(props.target), toDefinedRaw(restProps));
+			onCleanup(() => {
+				polygonEditor.value?.destroy();
+			});
+		});
+		watchEffect(() => {
+			polygonEditor.value?.setTarget(toValue(props.target));
+		});
+		watch([() => props.createOptions, polygonEditor], ([val, editor]) => {
+			if (val && editor) editor._opt.createOptions = clone(toRaw(val));
+		});
+		watch([() => props.editOptions, polygonEditor], ([val, editor]) => {
+			if (val && editor) editor._opt.editOptions = clone(toRaw(val));
+		});
+		watch([() => props.controlPoint, polygonEditor], ([val, editor]) => {
+			if (val && editor) {
+				editor.controlPoint = AMap.extend(editor.controlPoint, clone(toRaw(val)));
+				editor.movePoint = AMap.extend(editor.movePoint, clone(toRaw(val)));
+			}
+		});
+		watch([() => props.midControlPoint, polygonEditor], ([val, editor]) => {
+			if (val && editor) editor.midControlPoint = AMap.extend(editor.midControlPoint, clone(toRaw(val)));
+		});
+		use_event_listeners_default(polygonEditor, emits, polygonEditorEvents);
+		__expose({ instance: polygonEditor });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/tool/polyline-editor/polyline-editor.vue
+var polyline_editor_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.PolylineEditor",
+	inheritAttrs: false,
+	__name: "polyline-editor",
+	props: {
+		map: {},
+		target: {},
+		createOptions: {},
+		editOptions: {},
+		controlPoint: {},
+		midControlPoint: {}
+	},
+	emits: [
+		"add",
+		"end",
+		"adjust",
+		"addNode",
+		"removeNode"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const polylineEditorEvents = [
+			add,
+			end,
+			adjust,
+			addNode,
+			removeNode
+		];
+		const map = useMapInstance(props);
+		const restProps = shallowReactiveOmit(props, "map", "target");
+		const polylineEditor = shallowRef(map.value ? new AMap.PolylineEditor(map.value, toValue(props.target), toDefinedRaw(restProps)) : null);
+		watchEffect((onCleanup) => {
+			if (!polylineEditor.value && map.value) polylineEditor.value = new AMap.PolylineEditor(map.value, toValue(props.target), toDefinedRaw(restProps));
+			onCleanup(() => {
+				polylineEditor.value?.destroy();
+			});
+		});
+		watchEffect(() => {
+			polylineEditor.value?.setTarget(toValue(props.target));
+		});
+		watch([() => props.createOptions, polylineEditor], ([val, editor]) => {
+			if (val && editor) editor._defaultStyle = AMap.extend(editor._defaultStyle, clone(toRaw(val)));
+		});
+		watch([() => props.editOptions, polylineEditor], ([val, editor]) => {
+			if (val && editor) editor._selectStyle = AMap.extend(editor._selectStyle, clone(toRaw(val)));
+		});
+		watch([() => props.controlPoint, polylineEditor], ([val, editor]) => {
+			if (val && editor) editor._markerOptions = AMap.extend(editor._markerOptions, clone(toRaw(val)));
+		});
+		watch([() => props.midControlPoint, polylineEditor], ([val, editor]) => {
+			if (val && editor) editor._middleMarkerOptions = AMap.extend(editor._middleMarkerOptions, clone(toRaw(val)));
+		});
+		use_event_listeners_default(polylineEditor, emits, polylineEditorEvents);
+		__expose({ instance: polylineEditor });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/tool/ranging-tool/ranging-tool.vue
+var ranging_tool_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.RangingTool",
+	inheritAttrs: false,
+	__name: "ranging-tool",
+	props: {
+		map: {},
+		d: {},
+		endLabelOffset: {},
+		endLabelText: {},
+		endMarkerOptions: {},
+		lineOptions: {},
+		midLabelOffset: {},
+		midLabelText: {},
+		midMarkerOptions: {},
+		startLabelOffset: {},
+		startLabelText: {},
+		startMarkerOptions: {},
+		tmpLineOptions: {}
+	},
+	emits: [
+		"addNode",
+		"removeNode",
+		"end"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const rangingToolEvents = [
+			addNode,
+			removeNode,
+			end
+		];
+		const map = useMapInstance(props);
+		const restProps = shallowReactiveOmit(props, "map");
+		const rangingTool = shallowRef(map.value ? new AMap.RangingTool(map.value, toDefinedRaw(restProps)) : null);
+		watchEffect((onCleanup) => {
+			if (!rangingTool.value && map.value) rangingTool.value = new AMap.RangingTool(map.value, toDefinedRaw(restProps));
+			onCleanup(() => {
+				rangingTool.value?.turnOff(true);
+			});
+		});
+		watch(restProps, (val) => {
+			rangingTool.value?.setOptions(toDefinedRaw(val));
+		});
+		use_event_listeners_default(rangingTool, emits, rangingToolEvents);
+		__expose({ instance: rangingTool });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/tool/rectangle-editor/rectangle-editor.vue
+var rectangle_editor_default = /* @__PURE__ */ defineComponent({
+	name: "AMap.RectangleEditor",
+	inheritAttrs: false,
+	__name: "rectangle-editor",
+	props: {
+		map: {},
+		target: {},
+		createOptions: {},
+		editOptions: {},
+		southWestPoint: {},
+		northEastPoint: {}
+	},
+	emits: [
+		"add",
+		"end",
+		"adjust",
+		"move"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const rectangleEditorEvents = [
+			add,
+			end,
+			adjust,
+			move
+		];
+		const map = useMapInstance(props);
+		const restProps = shallowReactiveOmit(props, "map", "target");
+		const rectangleEditor = shallowRef(map.value ? new AMap.RectangleEditor(map.value, toValue(props.target), toDefinedRaw(restProps)) : null);
+		watchEffect((onCleanup) => {
+			if (!rectangleEditor.value && map.value) rectangleEditor.value = new AMap.RectangleEditor(map.value, toValue(props.target), toDefinedRaw(restProps));
+			onCleanup(() => {
+				rectangleEditor.value?.destroy();
+			});
+		});
+		watchEffect(() => {
+			rectangleEditor.value?.setTarget(toValue(props.target));
+		});
+		watch([() => props.createOptions, rectangleEditor], ([val, editor]) => {
+			if (val && editor) editor._normalRectangleStyle = AMap.extend(editor._normalRectangleStyle, clone(toRaw(val)));
+		});
+		watch([() => props.editOptions, rectangleEditor], ([val, editor]) => {
+			if (val && editor) editor._editStyle = AMap.extend(editor._editStyle, clone(toRaw(val)));
+		});
+		watch([() => props.northEastPoint, rectangleEditor], ([val, editor]) => {
+			if (val && editor) editor._opts.northEastPoint = toRaw(val);
+		});
+		watch([() => props.southWestPoint, rectangleEditor], ([val, editor]) => {
+			if (val && editor) editor._opts.southWestPoint = toRaw(val);
+		});
+		use_event_listeners_default(rectangleEditor, emits, rectangleEditorEvents);
+		__expose({ instance: rectangleEditor });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+export { api_loader_default as APILoader, bezier_curve_default as BezierCurve, bezier_curve_editor_default as BezierCurveEditor, buildings_default as BuildingLayer, buildings_default as Buildings, canvas_layer_default as CanvasLayer, circle_default as Circle, circle_editor_default as CircleEditor, circle_marker_default as CircleMarker, context_menu_default as ContextMenu, control_bar_default as ControlBar, country_default as Country, custom_layer_default as CustomLayer, district_layer_default as DistrictLayer, elastic_marker_default as ElasticMarker, ellipse_default as Ellipse, ellipse_editor_default as EllipseEditor, flexible_default as Flexible, gl_custom_layer_default as GLCustomLayer, geolocation_default as Geolocation, hawk_eye_default as HawkEye, heat_map_default as HeatMap, image_layer_default as ImageLayer, index_cluster_default as IndexCluster, indoor_map_default as IndoorMap, info_window_default as InfoWindow, label_marker_default as LabelMarker, labels_layer_default as LabelsLayer, layer_group_default as LayerGroup, LoadStatus, map_default as Map, map_type_default as MapType, mapbox_default as Mapbox, mapbox_vector_tile_layer_default as MapboxVectorTileLayer, mark_default as Mark, marker_default as Marker, marker_cluster_default as MarkerCluster, mass_marks_default as MassMarks, mouse_tool_default as MouseTool, overlay_group_default as OverlayGroup, polygon_default as Polygon, polygon_editor_default as PolygonEditor, polyline_default as Polyline, polyline_editor_default as PolylineEditor, province_default as Province, ranging_tool_default as RangingTool, rectangle_default as Rectangle, rectangle_editor_default as RectangleEditor, road_net_default as RoadNet, satellite_default as Satellite, scale_default as Scale, text_default as Text, tile_layer_default as TileLayer, tool_bar_default as ToolBar, traffic_default as Traffic, vector_layer_default as VectorLayer, wms_default as WMS, wmts_default as WMTS, world_default as World, shallowReactiveOmit, useAPILoader, useAPIStatus, use_instance_default as useInstance, useLabelsLayer, useMap, useMapInstance, useVectorLayer };