@cn-map/gaode-react 0.0.0-stage → 0.0.1

package/dist/index.js

@@ -0,0 +1,2264 @@
+import { a as splitProps, c as useEventListeners, i as resolveTarget, n as useMap, o as syncProperty, r as useMapInstance, s as useLazyInit, t as MapContext } from "./context-ChPGCKoP.js";
+import { LoadStatus, getAPIStatus, load, reset, subscribeAPIStatus } from "@cn-map/gaode-jsapi-loader";
+import { createContext, use, useCallback, useEffect, useEffectEvent, useId, useImperativeHandle, useInsertionEffect, useLayoutEffect, useRef, useState, useSyncExternalStore } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { clone, eventToProp, eventsToProps, 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";
+import { createPortal } from "react-dom";
+// src/api-loader/context.ts
+function useAPIStatus(type) {
+	const statusRef = useRef({ ...getAPIStatus() });
+	const getSnapshot = () => {
+		const currentStatus = getAPIStatus();
+		if (JSON.stringify(statusRef.current) !== JSON.stringify(currentStatus)) statusRef.current = { ...currentStatus };
+		return type ? statusRef.current[type] : statusRef.current;
+	};
+	return useSyncExternalStore(subscribeAPIStatus, getSnapshot, getSnapshot);
+}
+// src/api-loader/use-api-loader.ts
+/**
+* 加载高德地图依赖的 Hook
+* @param {APILoaderOptions} config - 加载高德地图API的配置项
+* @param {boolean} [resetOnUnmount=false] - 组件卸载时是否重置全局 JSAPI 状态
+*/
+const useAPILoader = (config, resetOnUnmount = false) => {
+	const [error, setError] = useState(null);
+	useEffect(() => {
+		const { apiKey, ...rest } = config;
+		load({
+			key: apiKey,
+			...rest
+		}).catch((err) => {
+			if (err instanceof Error || err instanceof Event) setError(err);
+			else throw new Error(`Unexpected error when loading API`, { cause: err });
+		});
+	}, [config, setError]);
+	useEffect(() => {
+		return () => {
+			if (resetOnUnmount) reset();
+		};
+	}, []);
+	return [useAPIStatus(), error];
+};
+// src/api-loader/api-loader.tsx
+/**
+* APILoader 用于加载高德地图依赖
+*/
+const APILoader = ({ children, resetOnUnmount = false, ...config }) => {
+	const [status, error] = useAPILoader(config, resetOnUnmount);
+	return /* @__PURE__ */ jsx(Fragment, { children: typeof children === "function" ? children(status, error) : children });
+};
+// src/map/map.tsx
+const mapEvents = [
+	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
+];
+const mapStatusKeys = [
+	"allBubble",
+	"animateEnable",
+	"doubleClickZoom",
+	"dragEnable",
+	"features",
+	"isHotspot",
+	"jogEnable",
+	"keyboardEnable",
+	"pickWhenMoving",
+	"pitchEnable",
+	"rotateEnable",
+	"scrollWheel",
+	"showBuildingBlock",
+	"touchZoom",
+	"touchZoomCenter",
+	"zoomEnable",
+	"zoomSpeed"
+];
+function getContainer(container) {
+	return typeof container === "function" ? container() : typeof container === "string" ? document.getElementById(container) : container;
+}
+const Map$1 = ({ ref, className, style, children, immediately, duration, id, ...props }) => {
+	patchMap();
+	const [eventProps, restProps] = splitProps(props, eventsToProps(mapEvents));
+	const containerId = `map-gaode-${useId()}`;
+	const containerRef = useRef(getContainer(restProps.container));
+	const [map, setMap] = useState(null);
+	useLayoutEffect(() => {
+		if (restProps.container) containerRef.current = getContainer(restProps.container);
+		if (!containerRef.current) return;
+		try {
+			const instance = new AMap.Map(containerRef.current, restProps);
+			setMap(instance);
+			return () => {
+				instance.clearInfoWindow();
+				instance.clearMap();
+				instance.destroy();
+			};
+		} catch (e) {
+			logger.error("init map error", e);
+		}
+	}, [restProps.container]);
+	const setContainer = useCallback((node) => {
+		if (!node) return;
+		containerRef.current = node;
+	}, []);
+	useLayoutEffect(() => {
+		const prevCursor = containerRef.current?.style.getPropertyValue("cursor");
+		const prevBackgroundColor = containerRef.current?.style.getPropertyValue("background-color");
+		return () => {
+			containerRef.current?.classList.remove("amap-container");
+			if (prevCursor) containerRef.current?.style.setProperty("cursor", prevCursor);
+			else containerRef.current?.style.removeProperty("cursor");
+			if (prevBackgroundColor) containerRef.current?.style.setProperty("background-color", prevBackgroundColor);
+			else containerRef.current?.style.removeProperty("background-color");
+		};
+	}, [restProps.container]);
+	useImperativeHandle(ref, () => map, [map]);
+	const { center, labelRejectMask, mapStyle, mask, pitch, rotation, zoom, zooms, layers, showLabel, defaultCursor, overseaDataType, poiIcon, roofColor, showIndoorMap, showOversea, skyColor, terrain, vdataProxy, vectorMapForeign, viewMode, wallColor, WebGLParams } = restProps;
+	useLayoutEffect(() => {
+		if (center !== void 0 && !map?.getCenter().equals(center)) map?.setCenter(clone(center), typeof immediately === "boolean" ? immediately : immediately?.center, typeof duration === "number" ? duration : duration?.center);
+	}, [center]);
+	useLayoutEffect(() => {
+		if (pitch !== void 0 && pitch !== map?.getPitch()) map?.setPitch(pitch, typeof immediately === "boolean" ? immediately : immediately?.pitch, typeof duration === "number" ? duration : duration?.pitch);
+	}, [pitch]);
+	useLayoutEffect(() => {
+		if (rotation !== void 0 && rotation !== map?.getRotation()) map?.setRotation(rotation, typeof immediately === "boolean" ? immediately : immediately?.rotation, typeof duration === "number" ? duration : duration?.rotation);
+	}, [rotation]);
+	useLayoutEffect(() => {
+		if (zoom !== void 0 && zoom !== map?.getZoom()) map?.setZoom(zoom, typeof immediately === "boolean" ? immediately : immediately?.zoom, typeof duration === "number" ? duration : duration?.zoom);
+	}, [zoom]);
+	useLayoutEffect(() => {
+		if (zooms !== void 0) map?.setZooms(clone(zooms));
+	}, [zooms]);
+	useLayoutEffect(() => {
+		if (labelRejectMask !== void 0) map?.setLabelRejectMask(labelRejectMask);
+	}, [labelRejectMask]);
+	useLayoutEffect(() => {
+		if (mapStyle !== void 0 && mapStyle !== map?.getMapStyle()) map?.setMapStyle(mapStyle);
+	}, [mapStyle]);
+	useLayoutEffect(() => {
+		if (mask !== void 0) map?.setMask(clone(mask));
+	}, [mask]);
+	useLayoutEffect(() => {
+		if (layers !== void 0) map?.setLayers(layers);
+	}, [layers]);
+	useLayoutEffect(() => {
+		if (showLabel !== void 0) {
+			map?.set("showLabel", showLabel);
+			map?.setNeedUpdate(true);
+		}
+	}, [showLabel]);
+	mapStatusKeys.forEach((key) => {
+		useLayoutEffect(() => {
+			map?.setStatus({ [key]: restProps[key] });
+		}, [restProps[key]]);
+	});
+	useEventListeners(map, eventProps, mapEvents);
+	return /* @__PURE__ */ jsxs(Fragment, { children: [props.container ? null : /* @__PURE__ */ jsx("div", {
+		ref: setContainer,
+		className,
+		id: id || containerId,
+		style: {
+			width: "100%",
+			height: "100%",
+			...style
+		}
+	}), /* @__PURE__ */ jsx(MapContext, {
+		value: map,
+		children
+	})] });
+};
+// src/control/control/control.ts
+const controlEvents = [hide, show];
+function useControlAttributes(control, props) {
+	useLayoutEffect(() => {
+		if (props.visible !== void 0) {
+			if (props.visible) control.show();
+			else control.hide();
+		}
+	}, [props.visible]);
+}
+// src/control/control-bar/control-bar.ts
+const controlBarEvents = controlEvents;
+const ControlBar = ({ ref, map: _map, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(controlBarEvents));
+	const controlBar = useLazyInit(() => new AMap.ControlBar(restProps));
+	useLayoutEffect(() => {
+		if (!map) return;
+		map.addControl(controlBar);
+		return () => {
+			map.removeControl(controlBar);
+		};
+	}, [map]);
+	useImperativeHandle(ref, () => controlBar, []);
+	useControlAttributes(controlBar, restProps);
+	useEventListeners(controlBar, eventProps, controlBarEvents);
+	return null;
+};
+// src/control/geolocation/geolocation.ts
+const geolocationEvents = [
+	...controlEvents,
+	complete,
+	error
+];
+const Geolocation = ({ ref, map: _map, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(geolocationEvents));
+	const geolocation = useLazyInit(() => new AMap.Geolocation(restProps));
+	useLayoutEffect(() => {
+		if (!map) return;
+		map.addControl(geolocation);
+		return () => {
+			map.removeControl(geolocation);
+		};
+	}, [map]);
+	useImperativeHandle(ref, () => geolocation, []);
+	useControlAttributes(geolocation, restProps);
+	useEventListeners(geolocation, eventProps, geolocationEvents);
+	return null;
+};
+// src/control/hawk-eye/hawk-eye.ts
+const hawkEyeEvents = controlEvents;
+const HawkEye = ({ ref, map: _map, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(hawkEyeEvents));
+	const hawkEye = useLazyInit(() => new AMap.HawkEye(restProps));
+	useLayoutEffect(() => {
+		if (!map) return;
+		map.addControl(hawkEye);
+		return () => {
+			map.removeControl(hawkEye);
+		};
+	}, [map]);
+	useImperativeHandle(ref, () => hawkEye, []);
+	useControlAttributes(hawkEye, restProps);
+	useEventListeners(hawkEye, eventProps, hawkEyeEvents);
+	return null;
+};
+// src/control/map-type/map-type.ts
+const mapTypeEvents = controlEvents;
+const MapType = ({ ref, map: _map, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(mapTypeEvents));
+	const mapType = useLazyInit(() => new AMap.MapType(restProps));
+	useLayoutEffect(() => {
+		if (!map) return;
+		map.addControl(mapType);
+		return () => {
+			mapType._config.layerInfos.forEach((layerInfo) => {
+				layerInfo.layer.setMap(null);
+				layerInfo.layer.destroy();
+			});
+			map.removeControl(mapType);
+		};
+	}, [map]);
+	useImperativeHandle(ref, () => mapType, []);
+	useControlAttributes(mapType, restProps);
+	useEventListeners(mapType, eventProps, mapTypeEvents);
+	return null;
+};
+// src/control/scale/scale.ts
+const scaleEvents = controlEvents;
+const Scale = ({ ref, map: _map, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(scaleEvents));
+	const scale = useLazyInit(() => new AMap.Scale(restProps));
+	useLayoutEffect(() => {
+		if (!map) return;
+		map.addControl(scale);
+		return () => {
+			map.removeControl(scale);
+		};
+	}, [map]);
+	useImperativeHandle(ref, () => scale, []);
+	useControlAttributes(scale, restProps);
+	useEventListeners(scale, eventProps, scaleEvents);
+	return null;
+};
+// src/control/tool-bar/tool-bar.ts
+const toolBarEvents = controlEvents;
+const ToolBar = ({ ref, map: _map, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(toolBarEvents));
+	const toolBar = useLazyInit(() => new AMap.ToolBar(restProps));
+	useLayoutEffect(() => {
+		if (!map) return;
+		map.addControl(toolBar);
+		return () => {
+			map.removeControl(toolBar);
+		};
+	}, [map]);
+	useImperativeHandle(ref, () => toolBar, []);
+	useControlAttributes(toolBar, restProps);
+	useEventListeners(toolBar, eventProps, toolBarEvents);
+	return null;
+};
+// src/layer/layer/layer.ts
+const layerEvents = [complete];
+function useLayerAttributes(layer, props) {
+	const { opacity, zooms, zIndex, visible } = props;
+	useLayoutEffect(() => {
+		if (opacity !== void 0) layer.setOpacity(opacity);
+	}, [opacity]);
+	useLayoutEffect(() => {
+		if (zooms !== void 0) layer.setZooms(zooms);
+	}, [zooms]);
+	useLayoutEffect(() => {
+		if (zIndex !== void 0) layer.setzIndex(zIndex);
+	}, [zIndex]);
+	useLayoutEffect(() => {
+		if (visible !== void 0) {
+			if (visible) layer.show();
+			else layer.hide();
+		}
+	}, [visible]);
+}
+// src/layer/buildings/buildings.ts
+const Buildings = ({ ref, map: _map, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(layerEvents));
+	const buildings = useLazyInit(() => new AMap.Buildings(restProps));
+	useLayoutEffect(() => {
+		if (!map) return;
+		buildings.setMap(map);
+		return () => {
+			buildings.setMap(null);
+		};
+	}, [map]);
+	useEffect(() => {
+		return () => {
+			buildings.destroy();
+		};
+	}, []);
+	useImperativeHandle(ref, () => buildings, []);
+	useLayerAttributes(buildings, restProps);
+	useLayoutEffect(() => {
+		if (restProps.style !== void 0) buildings.setStyle(restProps.style);
+	}, [restProps.style]);
+	useEventListeners(buildings, eventProps, layerEvents);
+	return null;
+};
+// src/layer/canvas-layer/canvas-layer.ts
+const CanvasLayer = ({ ref, map: _map, canvas, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(layerEvents));
+	const canvasLayer = useLazyInit(() => new AMap.CanvasLayer({
+		...restProps,
+		canvas: resolveTarget(canvas)
+	}));
+	useLayoutEffect(() => {
+		if (!map) return;
+		canvasLayer.setMap(map);
+		return () => {
+			canvasLayer.setMap(null);
+		};
+	}, [map]);
+	useEffect(() => {
+		return () => {
+			canvasLayer.destroy();
+		};
+	}, []);
+	useImperativeHandle(ref, () => canvasLayer, []);
+	useLayerAttributes(canvasLayer, restProps);
+	useLayoutEffect(() => {
+		if (!map) return;
+		canvasLayer.setBounds(restProps.bounds);
+	}, [map, restProps.bounds]);
+	useLayoutEffect(() => {
+		if (canvas !== void 0) canvasLayer.setCanvas(resolveTarget(canvas));
+	}, [canvas]);
+	useEventListeners(canvasLayer, eventProps, layerEvents);
+	return null;
+};
+// src/layer/custom-layer/custom-layer.ts
+function toggleVisibility(customLayer, visible) {
+	if (visible !== void 0) {
+		if (visible) {
+			customLayer.canvas.style.visibility = "visible";
+			customLayer.canvas.style.display = "block";
+		} else {
+			customLayer.canvas.style.visibility = "hidden";
+			customLayer.canvas.style.display = "none";
+		}
+	}
+}
+const CustomLayer = ({ ref, map: _map, element, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(layerEvents));
+	const customLayer = useLazyInit(() => new AMap.CustomLayer(resolveTarget(element), restProps));
+	useLayoutEffect(() => {
+		if (!map) return;
+		customLayer.setMap(map);
+		return () => {
+			customLayer.setMap(null);
+		};
+	}, [map]);
+	useEffect(() => {
+		return () => {
+			customLayer.destroy();
+		};
+	}, []);
+	useImperativeHandle(ref, () => customLayer, []);
+	useLayerAttributes(customLayer, restProps);
+	useLayoutEffect(() => {
+		syncProperty(customLayer, "render", restProps.render || customLayer.render);
+	}, [restProps.render]);
+	useLayoutEffect(() => {
+		toggleVisibility(customLayer, restProps.visible);
+	}, [restProps.visible]);
+	useEventListeners(customLayer, eventProps, layerEvents);
+	return null;
+};
+// src/layer/district-layer/district-layer/district-layer.ts
+function useDistrictLayerAttributes(districtLayer, props) {
+	useLayerAttributes(districtLayer, props);
+	useLayoutEffect(() => {
+		if (props.adcode !== void 0) districtLayer.setAdcode(props.adcode);
+	}, [props.adcode]);
+	useLayoutEffect(() => {
+		if (props.SOC !== void 0) districtLayer.setSOC(props.SOC);
+	}, [props.SOC]);
+	useLayoutEffect(() => {
+		if (props.styles !== void 0) districtLayer.setStyles(props.styles);
+	}, [props.styles]);
+}
+const DistrictLayer = ({ ref, map: _map, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(layerEvents));
+	const districtLayer = useLazyInit(() => new AMap.DistrictLayer(restProps));
+	useLayoutEffect(() => {
+		if (!map) return;
+		districtLayer.setMap(map);
+		return () => {
+			districtLayer.setMap(null);
+		};
+	}, [map]);
+	useEffect(() => {
+		return () => {
+			districtLayer.destroy();
+		};
+	}, []);
+	useImperativeHandle(ref, () => districtLayer, []);
+	useDistrictLayerAttributes(districtLayer, restProps);
+	useEventListeners(districtLayer, eventProps, layerEvents);
+	return null;
+};
+// src/layer/district-layer/country/country.ts
+const Country = ({ ref, map: _map, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(layerEvents));
+	const country = useLazyInit(() => new AMap.DistrictLayer.Country(restProps));
+	useLayoutEffect(() => {
+		if (!map) return;
+		country.setMap(map);
+		return () => {
+			country.setMap(null);
+		};
+	}, [map]);
+	useEffect(() => {
+		return () => {
+			country.destroy();
+		};
+	}, []);
+	useImperativeHandle(ref, () => country, []);
+	useDistrictLayerAttributes(country, restProps);
+	useEventListeners(country, eventProps, layerEvents);
+	return null;
+};
+// src/layer/district-layer/province/province.ts
+const Province = ({ ref, map: _map, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(layerEvents));
+	const province = useLazyInit(() => new AMap.DistrictLayer.Province(restProps));
+	useLayoutEffect(() => {
+		if (!map) return;
+		province.setMap(map);
+		return () => {
+			province.setMap(null);
+		};
+	}, [map]);
+	useEffect(() => {
+		return () => {
+			province.destroy();
+		};
+	}, []);
+	useImperativeHandle(ref, () => province, []);
+	useDistrictLayerAttributes(province, restProps);
+	useEventListeners(province, eventProps, layerEvents);
+	return null;
+};
+// src/layer/district-layer/world/world.ts
+const World = ({ ref, map: _map, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(layerEvents));
+	const world = useLazyInit(() => new AMap.DistrictLayer.World(restProps));
+	useLayoutEffect(() => {
+		if (!map) return;
+		world.setMap(map);
+		return () => {
+			world.setMap(null);
+		};
+	}, [map]);
+	useEffect(() => {
+		return () => {
+			world.destroy();
+		};
+	}, []);
+	useImperativeHandle(ref, () => world, []);
+	useDistrictLayerAttributes(world, restProps);
+	useEventListeners(world, eventProps, layerEvents);
+	return null;
+};
+// src/layer/gl-custom-layer/gl-custom-layer.ts
+const GLCustomLayer = ({ ref, map: _map, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(layerEvents));
+	const glCustomLayer = useLazyInit(() => new AMap.GLCustomLayer(restProps));
+	useLayoutEffect(() => {
+		if (!map) return;
+		glCustomLayer.setMap(map);
+		return () => {
+			glCustomLayer.setMap(null);
+		};
+	}, [map]);
+	useInsertionEffect(() => {
+		return () => {
+			glCustomLayer.destroy();
+		};
+	}, []);
+	useImperativeHandle(ref, () => glCustomLayer, []);
+	const { init, render, ...rest } = restProps;
+	useLayerAttributes(glCustomLayer, rest);
+	useLayoutEffect(() => {
+		syncProperty(glCustomLayer, "init", init || glCustomLayer.init);
+	}, [init]);
+	useLayoutEffect(() => {
+		syncProperty(glCustomLayer, "render", render || glCustomLayer.render);
+	}, [render]);
+	useEventListeners(glCustomLayer, eventProps, layerEvents);
+	return null;
+};
+// src/layer/heat-map/heat-map.ts
+const HeatMap = ({ ref, map: _map, ...props }) => {
+	const map = useMapInstance(_map);
+	const heatMap = useLazyInit(() => new AMap.HeatMap(null, props));
+	useLayoutEffect(() => {
+		if (!map) return;
+		heatMap.setMap(map);
+		return () => {
+			heatMap.setMap(null);
+		};
+	}, [map]);
+	useEffect(() => {
+		return () => {
+			heatMap._renderLayer?._render.setMap(null);
+			heatMap._renderLayer?._render.render.destroy();
+		};
+	}, []);
+	useImperativeHandle(ref, () => heatMap, []);
+	const { visible, zIndex, dataset, ...rest } = props;
+	useLayoutEffect(() => {
+		if (visible !== void 0) {
+			if (visible) heatMap.show();
+			else heatMap.hide();
+		}
+	}, [visible]);
+	useLayoutEffect(() => {
+		if (zIndex !== void 0) heatMap.setzIndex(zIndex);
+	}, [zIndex]);
+	useLayoutEffect(() => {
+		if (dataset) heatMap.setDataSet(clone(dataset, true));
+	}, [dataset]);
+	useLayoutEffect(() => {
+		heatMap.setOptions(rest);
+	}, [rest]);
+	return null;
+};
+// src/layer/image-layer/image-layer.ts
+const ImageLayer = ({ ref, map: _map, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(layerEvents));
+	const imageLayer = useLazyInit(() => new AMap.ImageLayer(restProps));
+	useLayoutEffect(() => {
+		if (!map) return;
+		imageLayer.setMap(map);
+		return () => {
+			imageLayer.setMap(null);
+		};
+	}, [map]);
+	useEffect(() => {
+		return () => imageLayer.destroy();
+	}, []);
+	useImperativeHandle(ref, () => imageLayer, []);
+	const { bounds, url, tileUrl } = restProps;
+	useLayerAttributes(imageLayer, restProps);
+	useLayoutEffect(() => {
+		if (!map) return;
+		imageLayer.setBounds(bounds);
+	}, [map, bounds]);
+	useLayoutEffect(() => {
+		if (!map) return;
+		imageLayer.setImageUrl(url || tileUrl);
+	}, [
+		map,
+		url,
+		tileUrl
+	]);
+	useEventListeners(imageLayer, eventProps, layerEvents);
+	return null;
+};
+// src/layer/indoor-map/indoor-map.ts
+const indoorMapEvents = [...layerEvents, click];
+const IndoorMap = ({ ref, map: _map, POIId, floor, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(indoorMapEvents));
+	const indoorMap = useLazyInit(() => map?.indoorMap ?? new AMap.IndoorMap(restProps));
+	useLayoutEffect(() => {
+		if (!map) return;
+		if (map?.indoorMap) return;
+		const { animateEnable } = map.getStatus();
+		const before = [...map.getEvents()?.moveend ?? []];
+		indoorMap.setMap(map);
+		const moveEndFns = [...map.getEvents()?.moveend ?? []].filter((a) => !before?.some((b) => b.fn === a.fn && b.context === a.context));
+		return () => {
+			moveEndFns?.forEach(({ fn, context }) => {
+				map.off("moveend", fn, context);
+			});
+			if (indoorMap.e$) map?.removeControl(indoorMap.e$);
+			indoorMap.VR.labelsLayer?.setMap(null);
+			map?.removeLayer(indoorMap);
+			map?.setStatus({ animateEnable });
+			delete map.im().Yh.indoor;
+		};
+	}, [map]);
+	useEffect(() => {
+		if (map && POIId) {
+			indoorMap.showIndoorMap(POIId, floor);
+			indoorMap.getSource()?.JR?.(POIId, floor);
+		}
+	}, [
+		POIId,
+		floor,
+		map
+	]);
+	useEffect(() => {
+		if (!map) return;
+		if (map?.indoorMap) return;
+		return () => {
+			indoorMap.VR.labelsLayer?.destroy();
+			indoorMap.destroy();
+		};
+	}, []);
+	useImperativeHandle(ref, () => indoorMap, []);
+	const { hideFloorBar } = restProps;
+	useLayerAttributes(indoorMap, restProps);
+	useLayoutEffect(() => {
+		if (hideFloorBar !== void 0) {
+			if (hideFloorBar) indoorMap.hideFloorBar();
+			else indoorMap.showFloorBar();
+		}
+	}, [hideFloorBar]);
+	useEventListeners(indoorMap, eventProps, indoorMapEvents);
+	return null;
+};
+// src/layer/labels-layer/context.ts
+const EMPTY$1 = Symbol("No LabelsLayer");
+const LabelsLayerContext = createContext(EMPTY$1);
+/**
+* 获取LabelsLayer实例 hook
+*/
+function useLabelsLayer() {
+	const context = use(LabelsLayerContext);
+	if (context === EMPTY$1) throw lostContextError("`AMap.LabelsLayer`");
+	return context;
+}
+/**
+* 获取LabelsLayer实例
+*/
+function useLabelsLayerInstance() {
+	const context = use(LabelsLayerContext);
+	return context === EMPTY$1 ? null : context;
+}
+// src/layer/labels-layer/labels-layer.tsx
+const LabelsLayer = ({ ref, map: _map, children, labelMarkers, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(layerEvents));
+	const labelsLayer = useLazyInit(() => new AMap.LabelsLayer(restProps));
+	useLayoutEffect(() => {
+		if (!map) return;
+		labelsLayer.setMap(map);
+		return () => {
+			labelsLayer.setMap(null);
+		};
+	}, [map]);
+	useLayoutEffect(() => {
+		if (!labelMarkers) return;
+		labelsLayer.add(labelMarkers);
+		return () => {
+			labelsLayer.remove(labelMarkers);
+		};
+	}, [labelMarkers]);
+	useEffect(() => {
+		return () => {
+			labelsLayer.destroy();
+		};
+	}, []);
+	useImperativeHandle(ref, () => labelsLayer, []);
+	useLayoutEffect(() => {
+		if (restProps.allowCollision !== void 0) labelsLayer.setAllowCollision(restProps.allowCollision);
+	}, [restProps.allowCollision]);
+	useLayoutEffect(() => {
+		if (restProps.collision !== void 0) labelsLayer.setCollision(restProps.collision);
+	}, [restProps.collision]);
+	useLayerAttributes(labelsLayer, restProps);
+	useEventListeners(labelsLayer, eventProps, layerEvents);
+	if (labelMarkers !== void 0) return null;
+	return /* @__PURE__ */ jsx(LabelsLayerContext, {
+		value: labelsLayer,
+		children
+	});
+};
+// src/layer/layer-group/layer-group.ts
+const layerGroupEvents = layerEvents;
+const LayerGroup = ({ ref, map: _map, layers, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps] = splitProps(props, eventsToProps(layerGroupEvents));
+	const layerGroup = useLazyInit(() => new AMap.LayerGroup());
+	useLayoutEffect(() => {
+		layerGroup.setMap(map);
+		return () => {
+			layerGroup.setMap(null);
+		};
+	}, [map]);
+	const mountedLayersRef = useRef(/* @__PURE__ */ new Set());
+	useEffect(() => {
+		const nextLayers = layers ? Array.from(new Set(layers)) : [];
+		const nextLayerSet = new Set(nextLayers);
+		const layersToRemove = Array.from(mountedLayersRef.current).filter((layer) => !nextLayerSet.has(layer));
+		const layersToAdd = nextLayers.filter((layer) => !mountedLayersRef.current.has(layer));
+		if (layersToRemove.length > 0) layerGroup.removeLayers(layersToRemove);
+		if (layersToAdd.length > 0) layerGroup.addLayers(layersToAdd);
+		mountedLayersRef.current = nextLayerSet;
+	}, [layerGroup, layers]);
+	useEffect(() => {
+		return () => {
+			const mountedLayers = Array.from(mountedLayersRef.current);
+			mountedLayersRef.current.clear();
+			if (mountedLayers.length > 0) layerGroup.removeLayers(mountedLayers);
+			for (const layer of mountedLayers) if ("destroy" in layer && typeof layer.destroy === "function") layer.destroy();
+		};
+	}, [layerGroup]);
+	const boundLayersRef = useRef(/* @__PURE__ */ new Map());
+	const getHandler = useEffectEvent((eventType) => {
+		return eventProps[eventToProp(eventType)];
+	});
+	useEffect(() => {
+		const nextLayers = layers ? Array.from(new Set(layers)) : [];
+		const nextLayerSet = new Set(nextLayers);
+		for (const [layer, handlerMap] of boundLayersRef.current) if (!nextLayerSet.has(layer)) {
+			for (const [eventType, handler] of handlerMap) layer.off(lowercase(eventType), handler);
+			boundLayersRef.current.delete(layer);
+			if ("destroy" in layer && typeof layer.destroy === "function") layer.destroy();
+		}
+		for (const layer of nextLayers) {
+			if (boundLayersRef.current.has(layer)) continue;
+			const handlerMap = /* @__PURE__ */ new Map();
+			for (const eventType of layerGroupEvents) {
+				const handler = (event) => {
+					getHandler(eventType)?.(event);
+				};
+				layer.on(lowercase(eventType), handler);
+				handlerMap.set(eventType, handler);
+			}
+			boundLayersRef.current.set(layer, handlerMap);
+		}
+	}, [layers]);
+	useEffect(() => {
+		const boundLayers = boundLayersRef.current;
+		return () => {
+			for (const [layer, handlerMap] of boundLayers) {
+				for (const [eventType, handler] of handlerMap) layer.off(lowercase(eventType), handler);
+				if ("destroy" in layer && typeof layer.destroy === "function") layer.destroy();
+			}
+			boundLayers.clear();
+		};
+	}, []);
+	useImperativeHandle(ref, () => layerGroup, [layerGroup]);
+	useLayoutEffect(() => {
+		if (props.visible !== void 0) {
+			if (props.visible) layerGroup.show();
+			else layerGroup.hide();
+		}
+	}, [layerGroup, props.visible]);
+	return null;
+};
+// src/layer/mapbox/mapbox.ts
+const Mapbox = ({ ref, map: _map, children, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(layerEvents));
+	const mapbox = useLazyInit(() => new AMap.Mapbox(restProps));
+	useLayoutEffect(() => {
+		if (!map) return;
+		mapbox.setMap(map);
+		return () => {
+			mapbox.setMap(null);
+		};
+	}, [map]);
+	useEffect(() => {
+		return () => {
+			mapbox.destroy();
+		};
+	}, []);
+	useImperativeHandle(ref, () => mapbox, []);
+	useLayerAttributes(mapbox, restProps);
+	useEventListeners(mapbox, eventProps, layerEvents);
+	return children;
+};
+// src/layer/tile-layer/tile-layer/tile-layer.ts
+function useTileLayerAttributes(tileLayer, props) {
+	useLayerAttributes(tileLayer, props);
+	useLayoutEffect(() => {
+		if (typeof props.getTileUrl === "string") tileLayer.setTileUrl(props.getTileUrl);
+	}, [props.getTileUrl]);
+}
+const TileLayer = ({ ref, map: _map, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(layerEvents));
+	const tileLayer = useLazyInit(() => new AMap.TileLayer(restProps));
+	useLayoutEffect(() => {
+		if (!map) return;
+		tileLayer.setMap(map);
+		return () => {
+			tileLayer.setMap(null);
+		};
+	}, [map]);
+	useEffect(() => {
+		return () => {
+			tileLayer.destroy();
+		};
+	}, []);
+	useImperativeHandle(ref, () => tileLayer, []);
+	useTileLayerAttributes(tileLayer, restProps);
+	useEventListeners(tileLayer, eventProps, layerEvents);
+	return null;
+};
+// src/layer/mapbox-vector-tile-layer/mapbox-vector-tile-layer.ts
+const MapboxVectorTileLayer = ({ ref, map: _map, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(layerEvents));
+	const mvtLayer = useLazyInit(() => new AMap.MapboxVectorTileLayer(restProps));
+	useLayoutEffect(() => {
+		if (!map) return;
+		mvtLayer.setMap(map);
+		return () => {
+			mvtLayer.getLabelsLayer().setMap(null);
+			mvtLayer.setMap(null);
+		};
+	}, [map]);
+	useEffect(() => {
+		return () => {
+			mvtLayer.getLabelsLayer().destroy();
+			mvtLayer.destroy();
+		};
+	}, []);
+	useImperativeHandle(ref, () => mvtLayer, []);
+	useTileLayerAttributes(mvtLayer, restProps);
+	useLayoutEffect(() => {
+		if (restProps.styles !== void 0) mvtLayer.setStyle(restProps.styles);
+	}, [restProps.styles]);
+	useEventListeners(mvtLayer, eventProps, layerEvents);
+	return null;
+};
+// src/layer/tile-layer/flexible/flexible.ts
+const Flexible = ({ ref, map: _map, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(layerEvents));
+	const flexible = useLazyInit(() => new AMap.TileLayer.Flexible(restProps));
+	useLayoutEffect(() => {
+		if (!map) return;
+		flexible.setMap(map);
+		return () => {
+			flexible.setMap(null);
+		};
+	}, [map]);
+	useEffect(() => {
+		return () => {
+			flexible.destroy();
+		};
+	}, []);
+	useImperativeHandle(ref, () => flexible, []);
+	useTileLayerAttributes(flexible, restProps);
+	useEventListeners(flexible, eventProps, layerEvents);
+	return null;
+};
+// src/layer/tile-layer/mark/mark.ts
+const Mark = ({ ref, map: _map, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(layerEvents));
+	const mark = useLazyInit(() => new AMap.TileLayer.Mark(restProps));
+	useLayoutEffect(() => {
+		if (!map) return;
+		mark.setMap(map);
+		return () => {
+			mark.setMap(null);
+		};
+	}, [map]);
+	useEffect(() => {
+		return () => {
+			mark.destroy();
+		};
+	}, []);
+	useImperativeHandle(ref, () => mark, []);
+	useTileLayerAttributes(mark, restProps);
+	useEventListeners(mark, eventProps, layerEvents);
+	return null;
+};
+// src/layer/tile-layer/road-net/road-net.ts
+const RoadNet = ({ ref, map: _map, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(layerEvents));
+	const roadNet = useLazyInit(() => new AMap.TileLayer.RoadNet(restProps));
+	useLayoutEffect(() => {
+		if (!map) return;
+		roadNet.setMap(map);
+		return () => {
+			roadNet.setMap(null);
+		};
+	}, [map]);
+	useEffect(() => {
+		return () => {
+			roadNet.destroy();
+		};
+	}, []);
+	useImperativeHandle(ref, () => roadNet, []);
+	useTileLayerAttributes(roadNet, restProps);
+	useEventListeners(roadNet, eventProps, layerEvents);
+	return null;
+};
+// src/layer/tile-layer/satellite/satellite.ts
+const Satellite = ({ ref, map: _map, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(layerEvents));
+	const satellite = useLazyInit(() => new AMap.TileLayer.Satellite(restProps));
+	useLayoutEffect(() => {
+		if (!map) return;
+		satellite.setMap(map);
+		return () => {
+			satellite.setMap(null);
+		};
+	}, [map]);
+	useEffect(() => {
+		return () => {
+			satellite.destroy();
+		};
+	}, []);
+	useImperativeHandle(ref, () => satellite, []);
+	useTileLayerAttributes(satellite, restProps);
+	useEventListeners(satellite, eventProps, layerEvents);
+	return null;
+};
+// src/layer/tile-layer/traffic/traffic.ts
+const Traffic = ({ ref, map: _map, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(layerEvents));
+	const traffic = useLazyInit(() => new AMap.TileLayer.Traffic(restProps));
+	useLayoutEffect(() => {
+		if (!map) return;
+		traffic.setMap(map);
+		return () => {
+			traffic.setMap(null);
+		};
+	}, [map]);
+	useEffect(() => {
+		return () => {
+			traffic.destroy();
+		};
+	}, []);
+	useImperativeHandle(ref, () => traffic, []);
+	useLayerAttributes(traffic, restProps);
+	useEventListeners(traffic, eventProps, layerEvents);
+	return null;
+};
+// src/layer/tile-layer/wms/wms.ts
+const Wms = ({ ref, map: _map, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(layerEvents));
+	const wms = useLazyInit(() => new AMap.TileLayer.WMS(restProps));
+	useLayoutEffect(() => {
+		if (!map) return;
+		wms.setMap(map);
+		return () => {
+			wms.setMap(null);
+		};
+	}, [map]);
+	useEffect(() => {
+		return () => {
+			wms.destroy();
+		};
+	}, []);
+	useImperativeHandle(ref, () => wms, []);
+	useTileLayerAttributes(wms, restProps);
+	useLayoutEffect(() => {
+		if (restProps.params !== void 0) wms.setParams(restProps.params);
+	}, [restProps.params]);
+	useLayoutEffect(() => {
+		if (restProps.url !== void 0) wms.setUrl(restProps.url);
+	}, [restProps.url]);
+	useEventListeners(wms, eventProps, layerEvents);
+	return null;
+};
+// src/layer/tile-layer/wmts/wmts.ts
+const Wmts = ({ ref, map: _map, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(layerEvents));
+	const wmts = useLazyInit(() => new AMap.TileLayer.WMTS(restProps));
+	useLayoutEffect(() => {
+		if (!map) return;
+		wmts.setMap(map);
+		return () => {
+			wmts.setMap(null);
+		};
+	}, [map]);
+	useEffect(() => {
+		return () => {
+			wmts.destroy();
+		};
+	}, []);
+	useImperativeHandle(ref, () => wmts, []);
+	useTileLayerAttributes(wmts, restProps);
+	useLayoutEffect(() => {
+		if (restProps.params !== void 0) wmts.setParams(restProps.params);
+	}, [restProps.params]);
+	useLayoutEffect(() => {
+		if (restProps.url !== void 0) wmts.setUrl(restProps.url);
+	}, [restProps.url]);
+	useEventListeners(wmts, eventProps, layerEvents);
+	return null;
+};
+// src/layer/vector-layer/context.ts
+const EMPTY = Symbol("No VectorLayer");
+const VectorLayerContext = createContext(EMPTY);
+/**
+* 获取VectorLayer实例 hook
+*/
+function useVectorLayer() {
+	const context = use(VectorLayerContext);
+	if (context === EMPTY) throw lostContextError("`AMap.VectorLayer`");
+	return context;
+}
+/**
+* 获取VectorLayer实例
+*/
+function useVectorLayerInstance() {
+	const context = use(VectorLayerContext);
+	return context === EMPTY ? null : context;
+}
+// src/layer/vector-layer/vector-layer.tsx
+const VectorLayer = ({ ref, map: _map, children, ...props }) => {
+	const map = useMapInstance(_map);
+	const vectorLayer = useLazyInit(() => new AMap.VectorLayer(props));
+	useLayoutEffect(() => {
+		if (!map) return;
+		vectorLayer.setMap(map);
+		return () => {
+			vectorLayer.setMap(null);
+		};
+	}, [map]);
+	useEffect(() => {
+		return () => {
+			vectorLayer.destroy();
+		};
+	}, []);
+	useImperativeHandle(ref, () => vectorLayer, []);
+	useLayerAttributes(vectorLayer, props);
+	const sourceReady = useSyncExternalStore(() => () => {}, () => !!vectorLayer?.getSource());
+	return /* @__PURE__ */ jsx(VectorLayerContext, {
+		value: vectorLayer,
+		children: sourceReady ? children : null
+	});
+};
+// 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) {
+	const { draggable, extData, visible } = props;
+	useLayoutEffect(() => {
+		if (draggable !== void 0) overlay.setDraggable(draggable);
+	}, [draggable]);
+	useLayoutEffect(() => {
+		overlay.setExtData(extData);
+	}, [extData]);
+	useLayoutEffect(() => {
+		if (visible !== void 0) {
+			if (visible) overlay.show();
+			else overlay.hide();
+		}
+	}, [visible]);
+}
+// src/overlay/bezier-curve/bezier-curve.ts
+const bezierCurveEvents = vectorOverlayEvents;
+const BezierCurve = ({ ref, map: _map, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(bezierCurveEvents));
+	const vectorLayer = useVectorLayerInstance();
+	const bezierCurve = useLazyInit(() => new AMap.BezierCurve(restProps));
+	useLayoutEffect(() => {
+		if (vectorLayer) {
+			vectorLayer.add(bezierCurve);
+			return () => {
+				vectorLayer.remove(bezierCurve);
+			};
+		} else {
+			map?.add(bezierCurve);
+			return () => {
+				map?.remove(bezierCurve);
+			};
+		}
+	}, [vectorLayer, map]);
+	useEffect(() => {
+		return () => bezierCurve.destroy();
+	}, []);
+	useImperativeHandle(ref, () => bezierCurve, []);
+	const { draggable, extData, visible, path, ...rest } = restProps;
+	useVectorOverlayAttributes(bezierCurve, restProps);
+	useLayoutEffect(() => {
+		bezierCurve.setOptions(rest);
+	}, [rest]);
+	useLayoutEffect(() => {
+		bezierCurve.setPath(path);
+	}, [path]);
+	useEventListeners(bezierCurve, eventProps, bezierCurveEvents);
+	return null;
+};
+// src/overlay/circle/circle.ts
+const circleEvents = vectorOverlayEvents;
+const Circle = ({ ref, map: _map, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(circleEvents));
+	const vectorLayer = useVectorLayerInstance();
+	const circle = useLazyInit(() => new AMap.Circle(restProps));
+	useLayoutEffect(() => {
+		if (vectorLayer) {
+			vectorLayer.add(circle);
+			return () => {
+				vectorLayer.remove(circle);
+			};
+		} else {
+			map?.add(circle);
+			return () => {
+				map?.remove(circle);
+			};
+		}
+	}, [vectorLayer, map]);
+	useEffect(() => {
+		return () => circle.destroy();
+	}, []);
+	useImperativeHandle(ref, () => circle, []);
+	const { draggable, extData, visible, center, radius, ...rest } = restProps;
+	useVectorOverlayAttributes(circle, restProps);
+	useLayoutEffect(() => {
+		if (center !== void 0) circle.setCenter(center);
+	}, [center]);
+	useLayoutEffect(() => {
+		if (radius !== void 0) circle.setRadius(radius);
+	}, [radius]);
+	useLayoutEffect(() => {
+		circle.setOptions(rest);
+	}, [rest]);
+	useEventListeners(circle, eventProps, circleEvents);
+	return null;
+};
+// src/overlay/circle-marker/circle-marker.ts
+const circleMarkerEvents = vectorOverlayEvents;
+const CircleMarker = ({ ref, map: _map, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(circleMarkerEvents));
+	const vectorLayer = useVectorLayerInstance();
+	const circleMarker = useLazyInit(() => new AMap.CircleMarker(restProps));
+	useLayoutEffect(() => {
+		if (vectorLayer) {
+			vectorLayer.add(circleMarker);
+			return () => {
+				vectorLayer.remove(circleMarker);
+			};
+		} else {
+			map?.add(circleMarker);
+			return () => {
+				map?.remove(circleMarker);
+			};
+		}
+	}, [vectorLayer, map]);
+	useEffect(() => {
+		return () => circleMarker.destroy();
+	}, []);
+	useImperativeHandle(ref, () => circleMarker, []);
+	const { draggable, extData, visible, center, radius, ...rest } = restProps;
+	useVectorOverlayAttributes(circleMarker, restProps);
+	useLayoutEffect(() => {
+		if (center !== void 0) circleMarker.setCenter(center);
+	}, [center]);
+	useLayoutEffect(() => {
+		if (radius !== void 0) circleMarker.setRadius(radius);
+	}, [radius]);
+	useLayoutEffect(() => {
+		circleMarker.setOptions(rest);
+	}, [rest]);
+	useEventListeners(circleMarker, eventProps, circleMarkerEvents);
+	return null;
+};
+// src/overlay/dom-overlay/custom-content.tsx
+function CustomContent({ instance, children }) {
+	const dom = useLazyInit(() => document.createElement("div"));
+	useLayoutEffect(() => {
+		instance.setContent(dom);
+	}, [children]);
+	useEffect(() => {
+		return () => {
+			dom.remove();
+		};
+	}, []);
+	return createPortal(children, dom);
+}
+// 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, children) {
+	const { anchor, content, offset, orientation, position, rotate, size, visible, zIndex } = props;
+	useLayoutEffect(() => {
+		overlay.setAnchor(anchor);
+	}, [anchor]);
+	useLayoutEffect(() => {
+		if (children == null) overlay.setContent(content);
+	}, [children, content]);
+	useLayoutEffect(() => {
+		overlay.setOffset(clone(offset));
+	}, [offset]);
+	useLayoutEffect(() => {
+		overlay.setOrientation(orientation);
+	}, [orientation]);
+	useLayoutEffect(() => {
+		if (position !== void 0) overlay.setPosition(clone(position));
+	}, [position]);
+	useLayoutEffect(() => {
+		if (rotate !== void 0) overlay.setAngle(rotate);
+	}, [rotate]);
+	useLayoutEffect(() => {
+		if (size !== void 0) overlay.setSize(clone(size));
+	}, [size]);
+	useLayoutEffect(() => {
+		if (visible !== void 0) {
+			if (visible) overlay.show();
+			else overlay.hide();
+		}
+	}, [visible]);
+	useLayoutEffect(() => {
+		if (zIndex !== void 0) overlay.setzIndex(zIndex);
+	}, [zIndex]);
+}
+// src/overlay/context-menu/context-menu.tsx
+const contextMenuEvents = [close, open];
+const ContextMenu = ({ ref, map, children, ...props }) => {
+	const [eventProps, restProps] = splitProps(props, eventsToProps(contextMenuEvents));
+	patchContextMenu();
+	const contextMenu = useLazyInit(() => new AMap.ContextMenu(restProps));
+	useEffect(() => {
+		return () => {
+			if (contextMenu?._parent?._container?.contains(contextMenu.getContentDom())) contextMenu.remove();
+			contextMenu.destroy();
+		};
+	}, []);
+	useImperativeHandle(ref, () => contextMenu, []);
+	useDOMOverlayAttributes(contextMenu, restProps, children);
+	useEventListeners(contextMenu, eventProps, contextMenuEvents);
+	return children ? /* @__PURE__ */ jsx(CustomContent, {
+		instance: contextMenu,
+		children
+	}) : null;
+};
+// src/overlay/marker/marker.tsx
+const markerEvents = domOverlayEvents;
+function useMarkerAttributes(marker, props, children) {
+	const { anchor, content, offset, orientation, position, rotate, size, visible, zIndex, clickable, cursor, draggable, extData, icon, label, title, isTop, ...rest } = props;
+	useLayoutEffect(() => {
+		marker.setClickable(clickable);
+	}, [clickable]);
+	useLayoutEffect(() => {
+		marker.setCursor(cursor);
+	}, [cursor]);
+	useLayoutEffect(() => {
+		if (draggable !== void 0) marker.setDraggable(draggable);
+	}, [draggable]);
+	useLayoutEffect(() => {
+		marker.setExtData(extData);
+	}, [extData]);
+	useLayoutEffect(() => {
+		marker.setIcon(clone(icon));
+	}, [icon]);
+	useLayoutEffect(() => {
+		if (label !== void 0) marker.setLabel(clone(label));
+	}, [label]);
+	useLayoutEffect(() => {
+		if (title !== void 0) marker.setTitle(clone(title));
+	}, [title]);
+	useLayoutEffect(() => {
+		marker.setTop(isTop);
+	}, [isTop]);
+	useLayoutEffect(() => {
+		marker.setOptions(rest);
+	}, [rest]);
+	useDOMOverlayAttributes(marker, props, children);
+}
+const Marker = ({ ref, map: _map, children, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(markerEvents));
+	const marker = useLazyInit(() => new AMap.Marker(restProps));
+	useLayoutEffect(() => {
+		map?.add(marker);
+		return () => {
+			map?.remove(marker);
+		};
+	}, [map]);
+	useEffect(() => {
+		return () => marker.destroy();
+	}, []);
+	useImperativeHandle(ref, () => marker, []);
+	useMarkerAttributes(marker, restProps, children);
+	useEventListeners(marker, eventProps, markerEvents);
+	return children ? /* @__PURE__ */ jsx(CustomContent, {
+		instance: marker,
+		children
+	}) : null;
+};
+// src/overlay/elastic-marker/elastic-marker.ts
+const elasticMarkerEvents = markerEvents;
+const ElasticMarker = ({ ref, map: _map, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(elasticMarkerEvents));
+	const elasticMarker = useLazyInit(() => new AMap.ElasticMarker(restProps));
+	useLayoutEffect(() => {
+		map?.add(elasticMarker);
+		return () => {
+			map?.remove(elasticMarker);
+		};
+	}, [map]);
+	useEffect(() => {
+		return () => elasticMarker.destroy();
+	}, []);
+	useImperativeHandle(ref, () => elasticMarker, []);
+	const { styles, zoomStyleMapping, ...rest } = restProps;
+	useLayoutEffect(() => {
+		if (zoomStyleMapping !== void 0) elasticMarker.setMapping(clone(zoomStyleMapping));
+	}, [zoomStyleMapping]);
+	useLayoutEffect(() => {
+		if (styles !== void 0) elasticMarker.setStyle(clone(styles));
+	}, [styles]);
+	useMarkerAttributes(elasticMarker, rest);
+	useEventListeners(elasticMarker, eventProps, elasticMarkerEvents);
+	return null;
+};
+// src/overlay/ellipse/ellipse.ts
+const ellipseEvents = vectorOverlayEvents;
+const Ellipse = ({ ref, map: _map, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(ellipseEvents));
+	const vectorLayer = useVectorLayerInstance();
+	const ellipse = useLazyInit(() => new AMap.Ellipse(restProps));
+	useLayoutEffect(() => {
+		if (vectorLayer) {
+			vectorLayer.add(ellipse);
+			return () => {
+				vectorLayer.remove(ellipse);
+			};
+		} else {
+			map?.add(ellipse);
+			return () => {
+				map?.remove(ellipse);
+			};
+		}
+	}, [vectorLayer, map]);
+	useEffect(() => {
+		return () => ellipse.destroy();
+	}, []);
+	useImperativeHandle(ref, () => ellipse, []);
+	const { draggable, extData, visible, center, radius, ...rest } = restProps;
+	useVectorOverlayAttributes(ellipse, restProps);
+	useLayoutEffect(() => {
+		if (center !== void 0) ellipse.setCenter(center);
+	}, [center]);
+	useLayoutEffect(() => {
+		if (radius !== void 0) ellipse.setRadius(radius);
+	}, [radius]);
+	useLayoutEffect(() => {
+		ellipse.setOptions(rest);
+	}, [rest]);
+	useEventListeners(ellipse, eventProps, ellipseEvents);
+	return null;
+};
+// src/overlay/index-cluster/index-cluster.ts
+const indexClusterEvents = [click];
+const IndexCluster = ({ ref, map: _map, data, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(indexClusterEvents));
+	const indexCluster = useLazyInit(() => new AMap.IndexCluster(null, clone(data, true), restProps));
+	useLayoutEffect(() => {
+		syncProperty(indexCluster, "i", null);
+		indexCluster.setMap(map);
+		return () => {
+			indexCluster.setMap(null);
+		};
+	}, [map]);
+	useEffect(() => {
+		indexCluster?.setData(clone(data, true));
+		return () => {
+			indexCluster.setData([]);
+		};
+	}, [data]);
+	useImperativeHandle(ref, () => indexCluster, []);
+	const { averageCenter, clusterByZoomChange, customRender, gridSize, maxZoom, renderClusterMarker, renderMarker, styles } = restProps;
+	useLayoutEffect(() => {
+		if (averageCenter !== void 0) indexCluster.setAverageCenter(averageCenter);
+	}, [averageCenter]);
+	useLayoutEffect(() => {
+		syncProperty(indexCluster, "clusterByZoomChange", clusterByZoomChange || false);
+	}, [clusterByZoomChange]);
+	useLayoutEffect(() => {
+		syncProperty(indexCluster, "customRender", customRender || null);
+	}, [customRender]);
+	useLayoutEffect(() => {
+		if (gridSize !== void 0) indexCluster.setGridSize(gridSize);
+	}, [gridSize]);
+	useLayoutEffect(() => {
+		if (maxZoom !== void 0) indexCluster.setMaxZoom(maxZoom);
+	}, [maxZoom]);
+	useLayoutEffect(() => {
+		syncProperty(indexCluster, "renderClusterMarker", renderClusterMarker || null);
+	}, [renderClusterMarker]);
+	useLayoutEffect(() => {
+		indexCluster.setRenderMarkerStyle(renderMarker || null);
+	}, [renderMarker]);
+	useLayoutEffect(() => {
+		if (styles !== void 0) {
+			indexCluster.setStyles(styles);
+			return;
+		}
+		const markerCluster = new AMap.IndexCluster();
+		const defaultStyles = markerCluster.getStyles();
+		markerCluster.setMap(null);
+		indexCluster.setStyles(defaultStyles);
+	}, [styles]);
+	useEventListeners(indexCluster, eventProps, indexClusterEvents);
+	return null;
+};
+// src/overlay/info-window/info-window.tsx
+const infoWindowEvents = [close, open];
+const InfoWindow = ({ ref, map: _map, children, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(infoWindowEvents));
+	const infoWindow = useLazyInit(() => new AMap.InfoWindow(restProps));
+	useLayoutEffect(() => {
+		map?.add(infoWindow);
+		return () => {
+			map?.remove(infoWindow);
+		};
+	}, [map]);
+	useEffect(() => {
+		return () => infoWindow.destroy();
+	}, []);
+	useImperativeHandle(ref, () => infoWindow, []);
+	const { anchor, content, offset, orientation, position, rotate, size, visible, zIndex, extData, ...rest } = restProps;
+	useLayoutEffect(() => {
+		infoWindow.setExtData(extData);
+	}, [extData]);
+	useLayoutEffect(() => {
+		infoWindow.setOptions(rest);
+	}, [rest]);
+	useDOMOverlayAttributes(infoWindow, restProps, children);
+	useEventListeners(infoWindow, eventProps, infoWindowEvents);
+	return children ? /* @__PURE__ */ jsx(CustomContent, {
+		instance: infoWindow,
+		children
+	}) : null;
+};
+// src/overlay/label-marker/label-marker.ts
+const labelMarkerEvents = [
+	click,
+	mouseMove,
+	mouseOver,
+	mouseOut,
+	mouseDown,
+	mouseUp,
+	touchStart,
+	touchMove,
+	touchEnd
+];
+const LabelMarker = ({ ref, ...props }) => {
+	const [eventProps, restProps] = splitProps(props, eventsToProps(labelMarkerEvents));
+	const labelsLayer = useLabelsLayerInstance();
+	const labelMarker = useLazyInit(() => new AMap.LabelMarker(restProps));
+	useEffect(() => {
+		labelsLayer?.add(labelMarker);
+		return () => {
+			labelsLayer?.remove(labelMarker);
+		};
+	}, [labelsLayer]);
+	useImperativeHandle(ref, () => labelMarker, []);
+	const { cursor, extData, icon, name, opacity, orientation, position, rank, richText, rotation, text, isTop, visible, zooms, zIndex } = restProps;
+	useLayoutEffect(() => {
+		labelMarker.setCursor(cursor);
+	}, [cursor]);
+	useLayoutEffect(() => {
+		labelMarker.setExtData(extData);
+	}, [extData]);
+	useLayoutEffect(() => {
+		labelMarker.setIcon(clone(icon));
+	}, [icon]);
+	useLayoutEffect(() => {
+		if (name !== void 0) labelMarker.setName(name);
+	}, [name]);
+	useLayoutEffect(() => {
+		labelMarker.setOpacity(opacity);
+	}, [opacity]);
+	useLayoutEffect(() => {
+		labelMarker.setOrientation(orientation);
+	}, [orientation]);
+	useLayoutEffect(() => {
+		if (position !== void 0) labelMarker.setPosition(clone(position));
+	}, [position]);
+	useLayoutEffect(() => {
+		if (rank !== void 0) labelMarker.setRank(rank);
+	}, [rank]);
+	useLayoutEffect(() => {
+		labelMarker.setRichText(clone(richText));
+	}, [richText]);
+	useLayoutEffect(() => {
+		if (rotation !== void 0) labelMarker.setRotation(rotation);
+	}, [rotation]);
+	useLayoutEffect(() => {
+		if (text !== void 0) labelMarker.setText(clone(text));
+	}, [text]);
+	useLayoutEffect(() => {
+		labelMarker.setTop(isTop);
+	}, [isTop]);
+	useLayoutEffect(() => {
+		labelMarker.setVisible(visible);
+	}, [visible]);
+	useLayoutEffect(() => {
+		labelMarker.setZooms(clone(zooms));
+	}, [zooms]);
+	useLayoutEffect(() => {
+		if (zIndex !== void 0) labelMarker.setzIndex(zIndex);
+	}, [zIndex]);
+	useEventListeners(labelMarker, eventProps, labelMarkerEvents);
+	return null;
+};
+// src/overlay/marker-cluster/marker-cluster.ts
+const markerClusterEvents = [click];
+const MarkerCluster = ({ ref, map: _map, data, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(markerClusterEvents));
+	const markerCluster = useLazyInit(() => new AMap.MarkerCluster(null, clone(data, true), restProps));
+	useLayoutEffect(() => {
+		syncProperty(markerCluster, "i", null);
+		markerCluster.setMap(map);
+		return () => {
+			markerCluster.setMap(null);
+		};
+	}, [map]);
+	useEffect(() => {
+		markerCluster?.setData(clone(data, true));
+		return () => {
+			markerCluster.setData([]);
+		};
+	}, [data]);
+	useImperativeHandle(ref, () => markerCluster, []);
+	const { averageCenter, gridSize, maxZoom, minClusterSize, renderClusterMarker, renderMarker, styles } = restProps;
+	useLayoutEffect(() => {
+		if (averageCenter !== void 0) markerCluster.setAverageCenter(averageCenter);
+	}, [averageCenter]);
+	useLayoutEffect(() => {
+		if (gridSize !== void 0) markerCluster.setGridSize(gridSize);
+	}, [gridSize]);
+	useLayoutEffect(() => {
+		if (maxZoom !== void 0) markerCluster.setMaxZoom(maxZoom);
+	}, [maxZoom]);
+	useLayoutEffect(() => {
+		if (minClusterSize !== void 0) markerCluster.setMinClusterSize(minClusterSize);
+	}, [minClusterSize]);
+	useLayoutEffect(() => {
+		syncProperty(markerCluster, "renderClusterMarker", renderClusterMarker);
+	}, [renderClusterMarker]);
+	useLayoutEffect(() => {
+		markerCluster.setRenderMarkerStyle(renderMarker);
+	}, [renderMarker]);
+	useLayoutEffect(() => {
+		if (styles !== void 0) {
+			markerCluster.setStyles(styles);
+			return;
+		}
+		const markerClusterInstance = new AMap.MarkerCluster();
+		const defaultStyles = markerClusterInstance.getStyles();
+		markerClusterInstance.setMap(null);
+		markerCluster.setStyles(defaultStyles);
+	}, [styles]);
+	useEventListeners(markerCluster, eventProps, markerClusterEvents);
+	return null;
+};
+// src/overlay/mass-marks/mass-marks.ts
+const massMarksEvents = [
+	click,
+	complete,
+	dblClick,
+	mouseDown,
+	mouseMove,
+	mouseOut,
+	mouseOver,
+	mouseUp,
+	touchEnd,
+	touchStart
+];
+const MassMarks = ({ ref, map: _map, data, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(massMarksEvents));
+	const massMarks = useLazyInit(() => new AMap.MassMarks(clone(data), restProps));
+	useLayoutEffect(() => {
+		massMarks.setMap(map);
+		return () => {
+			massMarks.setMap(null);
+		};
+	}, [map]);
+	useEffect(() => {
+		massMarks.setData(clone(data));
+	}, [data]);
+	useEffect(() => {
+		return () => {
+			massMarks.clear();
+		};
+	}, []);
+	useImperativeHandle(ref, () => massMarks, []);
+	const { opacity, style, zIndex, zooms } = restProps;
+	useLayoutEffect(() => {
+		if (opacity !== void 0) massMarks.setOpacity(opacity);
+	}, [opacity]);
+	useLayoutEffect(() => {
+		if (style !== void 0) massMarks.setStyle(clone(style));
+	}, [style]);
+	useLayoutEffect(() => {
+		if (zIndex !== void 0) massMarks.setzIndex(zIndex);
+	}, [zIndex]);
+	useLayoutEffect(() => {
+		if (zooms !== void 0) massMarks.setZooms(clone(zooms));
+	}, [zooms]);
+	useEventListeners(massMarks, eventProps, massMarksEvents);
+	return null;
+};
+// src/overlay/overlay-group/overlay-group.ts
+const overlayGroupEvents = [.../* @__PURE__ */ new Set([...vectorOverlayEvents, ...domOverlayEvents])];
+const OverlayGroup = ({ ref, visible, map: _map, overlays, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps] = splitProps(props, eventsToProps(overlayGroupEvents));
+	const overlayGroup = useLazyInit(() => new AMap.OverlayGroup());
+	useLayoutEffect(() => {
+		if (!map) return;
+		map.add(overlayGroup);
+		return () => {
+			map.remove(overlayGroup);
+		};
+	}, [map]);
+	const mountedOverlaysRef = useRef(/* @__PURE__ */ new Set());
+	useEffect(() => {
+		const nextOverlays = overlays ? Array.from(new Set(overlays)) : [];
+		const nextOverlaySet = new Set(nextOverlays);
+		const overlaysToRemove = Array.from(mountedOverlaysRef.current).filter((overlay) => !nextOverlaySet.has(overlay));
+		const overlaysToAdd = nextOverlays.filter((overlay) => !mountedOverlaysRef.current.has(overlay));
+		if (overlaysToRemove.length > 0) overlayGroup.removeOverlays(overlaysToRemove);
+		if (overlaysToAdd.length > 0) overlayGroup.addOverlays(overlaysToAdd);
+		mountedOverlaysRef.current = nextOverlaySet;
+	}, [overlayGroup, overlays]);
+	useEffect(() => {
+		return () => {
+			mountedOverlaysRef.current.clear();
+			overlayGroup.clearOverlays();
+		};
+	}, [overlayGroup]);
+	const boundOverlaysRef = useRef(/* @__PURE__ */ new Map());
+	const getHandler = useEffectEvent((eventType) => {
+		return eventProps[eventToProp(eventType)];
+	});
+	useEffect(() => {
+		const nextOverlays = overlays ? Array.from(new Set(overlays)) : [];
+		const nextOverlaySet = new Set(nextOverlays);
+		for (const [overlay, handlerMap] of boundOverlaysRef.current) if (!nextOverlaySet.has(overlay)) {
+			for (const [eventType, handler] of handlerMap) overlay.off(lowercase(eventType), handler);
+			boundOverlaysRef.current.delete(overlay);
+			if ("destroy" in overlay && typeof overlay.destroy === "function") overlay.destroy();
+		}
+		for (const overlay of nextOverlays) {
+			if (boundOverlaysRef.current.has(overlay)) continue;
+			const handlerMap = /* @__PURE__ */ new Map();
+			const eventTypes = overlay instanceof AMap.Marker ? domOverlayEvents : vectorOverlayEvents;
+			for (const eventType of eventTypes) {
+				const handler = (event) => {
+					getHandler(eventType)?.(event);
+				};
+				overlay.on(lowercase(eventType), handler);
+				handlerMap.set(eventType, handler);
+			}
+			boundOverlaysRef.current.set(overlay, handlerMap);
+		}
+	}, [overlays]);
+	useEffect(() => {
+		const boundOverlays = boundOverlaysRef.current;
+		return () => {
+			for (const [overlay, handlerMap] of boundOverlays) {
+				for (const [eventType, handler] of handlerMap) overlay.off(lowercase(eventType), handler);
+				if ("destroy" in overlay && typeof overlay.destroy === "function") overlay.destroy();
+			}
+			boundOverlays.clear();
+		};
+	}, []);
+	useImperativeHandle(ref, () => overlayGroup, [overlayGroup]);
+	useLayoutEffect(() => {
+		if (visible !== void 0) {
+			if (visible) overlayGroup.show();
+			else overlayGroup.hide();
+		}
+	}, [overlayGroup, visible]);
+	return null;
+};
+// src/overlay/polygon/polygon.ts
+const polygonEvents = vectorOverlayEvents;
+const Polygon = ({ ref, map: _map, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(polygonEvents));
+	const vectorLayer = useVectorLayerInstance();
+	const polygon = useLazyInit(() => new AMap.Polygon(restProps));
+	useLayoutEffect(() => {
+		if (vectorLayer) {
+			vectorLayer.add(polygon);
+			return () => {
+				vectorLayer.remove(polygon);
+			};
+		} else {
+			map?.add(polygon);
+			return () => {
+				map?.remove(polygon);
+			};
+		}
+	}, [vectorLayer, map]);
+	useEffect(() => {
+		return () => polygon.destroy();
+	}, []);
+	useImperativeHandle(ref, () => polygon, []);
+	const { draggable, extData, visible, extrusionHeight, path, ...rest } = restProps;
+	useVectorOverlayAttributes(polygon, restProps);
+	useLayoutEffect(() => {
+		if (extrusionHeight !== void 0) polygon.setExtrusionHeight(extrusionHeight);
+	}, [extrusionHeight]);
+	useLayoutEffect(() => {
+		polygon.setOptions(rest);
+	}, [rest]);
+	useLayoutEffect(() => {
+		polygon.setPath(path);
+	}, [path]);
+	useEventListeners(polygon, eventProps, polygonEvents);
+	return null;
+};
+// src/overlay/polyline/polyline.ts
+const polylineEvents = vectorOverlayEvents;
+const Polyline = ({ ref, map: _map, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(polylineEvents));
+	const vectorLayer = useVectorLayerInstance();
+	const polyline = useLazyInit(() => new AMap.Polyline(restProps));
+	useLayoutEffect(() => {
+		if (vectorLayer) {
+			vectorLayer.add(polyline);
+			return () => {
+				vectorLayer.remove(polyline);
+			};
+		} else {
+			map?.add(polyline);
+			return () => {
+				map?.remove(polyline);
+			};
+		}
+	}, [vectorLayer, map]);
+	useEffect(() => {
+		return () => polyline.destroy();
+	}, []);
+	useImperativeHandle(ref, () => polyline, []);
+	const { draggable, extData, visible, height, path, ...rest } = restProps;
+	useVectorOverlayAttributes(polyline, restProps);
+	useLayoutEffect(() => {
+		polyline.setOptions(rest);
+	}, [rest]);
+	useLayoutEffect(() => {
+		polyline.setPath(path);
+	}, [path]);
+	useEventListeners(polyline, eventProps, polylineEvents);
+	return null;
+};
+// src/overlay/rectangle/rectangle.ts
+const rectangleEvents = vectorOverlayEvents;
+const Rectangle = ({ ref, map: _map, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(rectangleEvents));
+	const vectorLayer = useVectorLayerInstance();
+	const rectangle = useLazyInit(() => new AMap.Rectangle(restProps));
+	useLayoutEffect(() => {
+		if (vectorLayer) {
+			vectorLayer.add(rectangle);
+			return () => {
+				vectorLayer.remove(rectangle);
+			};
+		} else {
+			map?.add(rectangle);
+			return () => {
+				map?.remove(rectangle);
+			};
+		}
+	}, [vectorLayer, map]);
+	useEffect(() => {
+		return () => rectangle.destroy();
+	}, []);
+	useImperativeHandle(ref, () => rectangle, []);
+	const { draggable, extData, visible, bounds, ...rest } = restProps;
+	useVectorOverlayAttributes(rectangle, restProps);
+	useLayoutEffect(() => {
+		rectangle.setOptions(rest);
+	}, [rest]);
+	useLayoutEffect(() => {
+		rectangle.setBounds(bounds);
+	}, [bounds]);
+	useEventListeners(rectangle, eventProps, rectangleEvents);
+	return null;
+};
+// src/overlay/text/text.tsx
+const textEvents = markerEvents;
+const Text = ({ ref, map: _map, children, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(textEvents));
+	const text = useLazyInit(() => new AMap.Text(restProps));
+	useLayoutEffect(() => {
+		map?.add(text);
+		return () => {
+			map?.remove(text);
+		};
+	}, [map]);
+	useEffect(() => {
+		return () => text.destroy();
+	}, []);
+	useImperativeHandle(ref, () => text, []);
+	const { style, text: _text, ...rest } = restProps;
+	useLayoutEffect(() => {
+		if (style !== void 0) text.setStyle(clone(style));
+	}, [style]);
+	useMarkerAttributes(text, rest, children);
+	useLayoutEffect(() => {
+		if (children ?? props.content) return;
+		if (_text !== void 0) text.setText(clone(_text));
+	}, [
+		_text,
+		children,
+		rest.content
+	]);
+	useEventListeners(text, eventProps, textEvents);
+	return children ? /* @__PURE__ */ jsx(CustomContent, {
+		instance: text,
+		children
+	}) : null;
+};
+// src/tool/bezier-curve-editor/bezier-curve-editor.ts
+const bezierCurveEditorEvents = [
+	add,
+	end,
+	adjust,
+	addNode,
+	removeNode
+];
+const BezierCurveEditor = ({ ref, map: _map, target, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(bezierCurveEditorEvents));
+	const bezierCurveEditorRef = useRef(null);
+	useLayoutEffect(() => {
+		if (!map) return;
+		bezierCurveEditorRef.current = new AMap.BezierCurveEditor(map, resolveTarget(target) ?? void 0, restProps);
+		return () => {
+			bezierCurveEditorRef.current?.destroy();
+			bezierCurveEditorRef.current = null;
+		};
+	}, [map]);
+	useEffect(() => {
+		bezierCurveEditorRef.current?.setTarget(resolveTarget(target) ?? void 0);
+	}, [target]);
+	const getBezierCurveEditor = useCallback(() => bezierCurveEditorRef.current, []);
+	useImperativeHandle(ref, getBezierCurveEditor);
+	useLayoutEffect(() => {
+		const editor = getBezierCurveEditor();
+		if (restProps.createOptions && editor) editor._normalPolylineStyle = AMap.extend(editor._normalPolylineStyle, clone(restProps.createOptions));
+	}, [restProps.createOptions]);
+	useLayoutEffect(() => {
+		const editor = getBezierCurveEditor();
+		if (restProps.editOptions && editor) editor._editingPolylineStyle = AMap.extend(editor._editingPolylineStyle, clone(restProps.editOptions));
+	}, [restProps.editOptions]);
+	useLayoutEffect(() => {
+		const editor = getBezierCurveEditor();
+		if (restProps.controlPoint && editor) editor.opts.controlPoint = clone(restProps.controlPoint);
+	}, [restProps.controlPoint]);
+	useLayoutEffect(() => {
+		const editor = getBezierCurveEditor();
+		if (restProps.midControlPoint && editor) editor.opts.midControlPoint = clone(restProps.midControlPoint);
+	}, [restProps.midControlPoint]);
+	useLayoutEffect(() => {
+		const editor = getBezierCurveEditor();
+		if (restProps.bezierControlPoint && editor) editor.opts.bezierControlPoint = restProps.bezierControlPoint;
+	}, [restProps.bezierControlPoint]);
+	useLayoutEffect(() => {
+		const editor = getBezierCurveEditor();
+		if (restProps.bezierControlLine && editor) editor.opts.bezierControlLine = AMap.extend(editor.opts.bezierControlLine, restProps.bezierControlLine);
+	}, [restProps.bezierControlLine]);
+	useEventListeners(getBezierCurveEditor, eventProps, bezierCurveEditorEvents);
+	return null;
+};
+// src/tool/circle-editor/circle-editor.ts
+const circleEditorEvents = [
+	add,
+	end,
+	adjust,
+	move
+];
+const CircleEditor = ({ ref, map: _map, target, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(circleEditorEvents));
+	const circleEditorRef = useRef(null);
+	useLayoutEffect(() => {
+		if (!map) return;
+		circleEditorRef.current = new AMap.CircleEditor(map, resolveTarget(target) ?? void 0, restProps);
+		return () => {
+			circleEditorRef.current?.destroy();
+			circleEditorRef.current = null;
+		};
+	}, [map]);
+	useEffect(() => {
+		circleEditorRef.current?.setTarget(resolveTarget(target) ?? void 0);
+	}, [target]);
+	const getCircleEditor = useCallback(() => circleEditorRef.current, []);
+	useImperativeHandle(ref, getCircleEditor);
+	useLayoutEffect(() => {
+		const editor = getCircleEditor();
+		if (restProps.createOptions && editor) editor._normalCircleStyle = AMap.extend(editor._normalCircleStyle, clone(restProps.createOptions));
+	}, [restProps.createOptions]);
+	useLayoutEffect(() => {
+		const editor = getCircleEditor();
+		if (restProps.editOptions && editor) editor._editStyle = AMap.extend(editor._editStyle, clone(restProps.editOptions));
+	}, [restProps.editOptions]);
+	useLayoutEffect(() => {
+		const editor = getCircleEditor();
+		if (restProps.movePoint && editor) editor._opts.movePoint = restProps.movePoint;
+	}, [restProps.movePoint]);
+	useLayoutEffect(() => {
+		const editor = getCircleEditor();
+		if (restProps.resizePoint && editor) editor._opts.resizePoint = restProps.resizePoint;
+	}, [restProps.resizePoint]);
+	useEventListeners(getCircleEditor, eventProps, circleEditorEvents);
+	return null;
+};
+// src/tool/ellipse-editor/ellipse-editor.ts
+const ellipseEditorEvents = [
+	add,
+	end,
+	adjust,
+	move
+];
+const EllipseEditor = ({ ref, map: _map, target, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(ellipseEditorEvents));
+	const ellipseEditorRef = useRef(null);
+	useLayoutEffect(() => {
+		if (!map) return;
+		ellipseEditorRef.current = new AMap.EllipseEditor(map, resolveTarget(target) ?? void 0, restProps);
+		return () => {
+			ellipseEditorRef.current?.destroy();
+			ellipseEditorRef.current = null;
+		};
+	}, [map]);
+	useEffect(() => {
+		ellipseEditorRef.current?.setTarget(resolveTarget(target) ?? void 0);
+	}, [target]);
+	const getEllipseEditor = useCallback(() => ellipseEditorRef.current, []);
+	useImperativeHandle(ref, getEllipseEditor);
+	useLayoutEffect(() => {
+		const editor = getEllipseEditor();
+		if (restProps.createOptions && editor) editor._normalCircleStyle = AMap.extend(editor._normalCircleStyle, clone(restProps.createOptions));
+	}, [restProps.createOptions]);
+	useLayoutEffect(() => {
+		const editor = getEllipseEditor();
+		if (restProps.editOptions && editor) editor._editStyle = AMap.extend(editor._editStyle, clone(restProps.editOptions));
+	}, [restProps.editOptions]);
+	useLayoutEffect(() => {
+		const editor = getEllipseEditor();
+		if (restProps.movePoint && editor) editor._opts.movePoint = restProps.movePoint;
+	}, [restProps.movePoint]);
+	useLayoutEffect(() => {
+		const editor = getEllipseEditor();
+		if (restProps.resizeXPoint && editor) editor._opts.resizeXPoint = restProps.resizeXPoint;
+	}, [restProps.resizeXPoint]);
+	useLayoutEffect(() => {
+		const editor = getEllipseEditor();
+		if (restProps.resizeYPoint && editor) editor._opts.resizeYPoint = restProps.resizeYPoint;
+	}, [restProps.resizeYPoint]);
+	useEventListeners(getEllipseEditor, eventProps, ellipseEditorEvents);
+	return null;
+};
+// src/tool/mouse-tool/mouse-tool.ts
+const mouseToolEvents = [draw];
+const MouseTool = ({ ref, map: _map, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(mouseToolEvents));
+	const { toolBubble, clearOnClose } = restProps;
+	const mouseToolRef = useRef(null);
+	useLayoutEffect(() => {
+		if (!map) return;
+		const dragEnable = map.getStatus().dragEnable;
+		mouseToolRef.current = new AMap.MouseTool(map, toolBubble);
+		return () => {
+			mouseToolRef.current?.close(clearOnClose);
+			map.setStatus({ dragEnable });
+			mouseToolRef.current = null;
+		};
+	}, [map]);
+	const getMouseTool = useCallback(() => mouseToolRef.current, []);
+	useImperativeHandle(ref, getMouseTool);
+	useLayoutEffect(() => {
+		const mouseToolInstance = getMouseTool();
+		if (mouseToolInstance) mouseToolInstance.overlayBubble = restProps.toolBubble || false;
+	}, [restProps.toolBubble]);
+	useEventListeners(getMouseTool, eventProps, mouseToolEvents);
+	return null;
+};
+// src/tool/polygon-editor/polygon-editor.ts
+const polygonEditorEvents = [
+	add,
+	end,
+	adjust,
+	addNode,
+	removeNode
+];
+const PolygonEditor = ({ ref, map: _map, target, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(polygonEditorEvents));
+	const polygonEditorRef = useRef(null);
+	useLayoutEffect(() => {
+		if (!map) return;
+		polygonEditorRef.current = new AMap.PolygonEditor(map, resolveTarget(target) ?? void 0, restProps);
+		patchPolygonEditor();
+		return () => {
+			polygonEditorRef.current?.destroy();
+			polygonEditorRef.current = null;
+		};
+	}, [map]);
+	useEffect(() => {
+		polygonEditorRef.current?.setTarget(resolveTarget(target) ?? void 0);
+	}, [target]);
+	const getPolygonEditor = useCallback(() => polygonEditorRef.current, []);
+	useImperativeHandle(ref, getPolygonEditor);
+	useLayoutEffect(() => {
+		const editor = getPolygonEditor();
+		if (restProps.createOptions && editor) editor._opt.createOptions = clone(restProps.createOptions);
+	}, [restProps.createOptions]);
+	useLayoutEffect(() => {
+		const editor = getPolygonEditor();
+		if (restProps.editOptions && editor) editor._opt.editOptions = clone(restProps.editOptions);
+	}, [restProps.editOptions]);
+	useLayoutEffect(() => {
+		const editor = getPolygonEditor();
+		if (restProps.controlPoint && editor) {
+			editor.controlPoint = AMap.extend(editor.controlPoint, clone(restProps.controlPoint));
+			editor.movePoint = AMap.extend(editor.movePoint, clone(restProps.controlPoint));
+		}
+	}, [restProps.controlPoint]);
+	useLayoutEffect(() => {
+		const editor = getPolygonEditor();
+		if (restProps.midControlPoint && editor) editor.midControlPoint = AMap.extend(editor.midControlPoint, clone(restProps.midControlPoint));
+	}, [restProps.midControlPoint]);
+	useEventListeners(getPolygonEditor, eventProps, polygonEditorEvents);
+	return null;
+};
+// src/tool/polyline-editor/polyline-editor.ts
+const polylineEditorEvents = [
+	add,
+	end,
+	adjust,
+	addNode,
+	removeNode
+];
+const PolylineEditor = ({ ref, map: _map, target, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(polylineEditorEvents));
+	const polylineEditorRef = useRef(null);
+	useLayoutEffect(() => {
+		if (!map) return;
+		polylineEditorRef.current = new AMap.PolylineEditor(map, resolveTarget(target) ?? void 0, restProps);
+		return () => {
+			polylineEditorRef.current?.destroy();
+			polylineEditorRef.current = null;
+		};
+	}, [map]);
+	useEffect(() => {
+		polylineEditorRef.current?.setTarget(resolveTarget(target) ?? void 0);
+	}, [target]);
+	const getPolylineEditor = useCallback(() => polylineEditorRef.current, []);
+	useImperativeHandle(ref, getPolylineEditor);
+	useLayoutEffect(() => {
+		const editor = getPolylineEditor();
+		if (restProps.createOptions && editor) editor._defaultStyle = AMap.extend(editor._defaultStyle, clone(restProps.createOptions));
+	}, [restProps.createOptions]);
+	useLayoutEffect(() => {
+		const editor = getPolylineEditor();
+		if (restProps.editOptions && editor) editor._selectStyle = AMap.extend(editor._selectStyle, clone(restProps.editOptions));
+	}, [restProps.editOptions]);
+	useLayoutEffect(() => {
+		const editor = getPolylineEditor();
+		if (restProps.controlPoint && editor) editor._markerOptions = AMap.extend(editor._markerOptions, clone(restProps.controlPoint));
+	}, [restProps.controlPoint]);
+	useLayoutEffect(() => {
+		const editor = getPolylineEditor();
+		if (restProps.midControlPoint && editor) editor._middleMarkerOptions = AMap.extend(editor._middleMarkerOptions, clone(restProps.midControlPoint));
+	}, [restProps.midControlPoint]);
+	useEventListeners(getPolylineEditor, eventProps, polylineEditorEvents);
+	return null;
+};
+// src/tool/ranging-tool/ranging-tool.ts
+const rangingToolEvents = [
+	addNode,
+	removeNode,
+	end
+];
+const RangingTool = ({ ref, map: _map, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(rangingToolEvents));
+	const rangingToolRef = useRef(null);
+	useLayoutEffect(() => {
+		if (!map) return;
+		rangingToolRef.current = new AMap.RangingTool(map, restProps);
+		return () => {
+			rangingToolRef.current?.turnOff(true);
+			rangingToolRef.current = null;
+		};
+	}, [map]);
+	const getRangingTool = useCallback(() => rangingToolRef.current, []);
+	useImperativeHandle(ref, getRangingTool);
+	useLayoutEffect(() => {
+		getRangingTool()?.setOptions(restProps);
+	}, [restProps]);
+	useEventListeners(getRangingTool, eventProps, rangingToolEvents);
+	return null;
+};
+// src/tool/rectangle-editor/rectangle-editor.ts
+const rectangleEditorEvents = [
+	add,
+	end,
+	adjust,
+	move
+];
+const RectangleEditor = ({ ref, map: _map, target, ...props }) => {
+	const map = useMapInstance(_map);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(rectangleEditorEvents));
+	const rectangleEditorRef = useRef(null);
+	useLayoutEffect(() => {
+		if (!map) return;
+		rectangleEditorRef.current = new AMap.RectangleEditor(map, resolveTarget(target) ?? void 0, restProps);
+		return () => {
+			rectangleEditorRef.current?.destroy();
+			rectangleEditorRef.current = null;
+		};
+	}, [map]);
+	useEffect(() => {
+		rectangleEditorRef.current?.setTarget(resolveTarget(target) ?? void 0);
+	}, [target]);
+	const getRectangleEditor = useCallback(() => rectangleEditorRef.current, []);
+	useImperativeHandle(ref, getRectangleEditor);
+	useLayoutEffect(() => {
+		const editor = getRectangleEditor();
+		if (restProps.createOptions && editor) editor._normalRectangleStyle = AMap.extend(editor._normalRectangleStyle, clone(restProps.createOptions));
+	}, [restProps.createOptions]);
+	useLayoutEffect(() => {
+		const editor = getRectangleEditor();
+		if (restProps.editOptions && editor) editor._editStyle = AMap.extend(editor._editStyle, clone(restProps.editOptions));
+	}, [restProps.editOptions]);
+	useLayoutEffect(() => {
+		const editor = getRectangleEditor();
+		if (restProps.northEastPoint && editor) editor._opts.northEastPoint = restProps.northEastPoint;
+	}, [restProps.northEastPoint]);
+	useLayoutEffect(() => {
+		const editor = getRectangleEditor();
+		if (restProps.southWestPoint && editor) editor._opts.southWestPoint = restProps.southWestPoint;
+	}, [restProps.southWestPoint]);
+	useEventListeners(getRectangleEditor, eventProps, rectangleEditorEvents);
+	return null;
+};
+export { APILoader, BezierCurve, BezierCurveEditor, Buildings as BuildingLayer, Buildings, CanvasLayer, Circle, CircleEditor, CircleMarker, ContextMenu, ControlBar, Country, CustomLayer, DistrictLayer, ElasticMarker, Ellipse, EllipseEditor, Flexible, GLCustomLayer, Geolocation, HawkEye, HeatMap, ImageLayer, IndexCluster, IndoorMap, InfoWindow, LabelMarker, LabelsLayer, LayerGroup, LoadStatus, Map$1 as Map, MapType, Mapbox, MapboxVectorTileLayer, Mark, Marker, MarkerCluster, MassMarks, MouseTool, OverlayGroup, Polygon, PolygonEditor, Polyline, PolylineEditor, Province, RangingTool, Rectangle, RectangleEditor, RoadNet, Satellite, Scale, Text, TileLayer, ToolBar, Traffic, VectorLayer, Wms as WMS, Wmts as WMTS, World, splitProps, useAPILoader, useAPIStatus, useLabelsLayer, useLazyInit, useMap, useMapInstance, useVectorLayer };