react-naver-maps-kit 1.1.1 → 1.3.0

package/dist/index.js

@@ -1,4 +1,4 @@
-import { createContext, forwardRef, memo, useCallback, useContext, useEffect, useId, useImperativeHandle, useLayoutEffect, useMemo, useRef, useState } from "react";
+import React, { createContext, forwardRef, memo, useCallback, useContext, useEffect, useId, useImperativeHandle, useLayoutEffect, useMemo, useRef, useState } from "react";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import { createPortal } from "react-dom";
 
@@ -31,27 +31,36 @@ function getClientKey(options) {
 	};
 	throw new Error("loadNaverMapsScript requires ncpKeyId. For backward compatibility, ncpClientId, govClientId, or finClientId can be provided.");
 }
-function isNaverMapsReady() {
+function isNaverMapsReady(submodules) {
 	if (typeof window === "undefined") return false;
-	const browserWindow = window;
-	return Boolean(browserWindow.naver?.maps);
+	const maps = window.naver?.maps;
+	if (!maps) return false;
+	if (submodules && submodules.length > 0) {
+		const submoduleMap = {
+			panorama: "Panorama",
+			geocoder: "Service",
+			drawing: "drawing",
+			visualization: "visualization"
+		};
+		for (const submodule of submodules) if (!maps[submoduleMap[submodule]]) return false;
+	}
+	return true;
 }
 function createScriptUrl(options) {
 	const clientKey = getClientKey(options);
-	const params = new URLSearchParams();
-	params.set(clientKey.param, clientKey.value);
-	if (options.submodules && options.submodules.length > 0) params.set("submodules", options.submodules.join(","));
-	return `${NAVER_MAPS_SCRIPT_BASE_URL}?${params.toString()}`;
+	const queryParts = [`${clientKey.param}=${encodeURIComponent(clientKey.value)}`];
+	if (options.submodules && options.submodules.length > 0) queryParts.push(`submodules=${options.submodules.join(",")}`);
+	return `${NAVER_MAPS_SCRIPT_BASE_URL}?${queryParts.join("&")}`;
 }
-function waitForNaverMapsReady(timeoutMs) {
+function waitForNaverMapsReady(timeoutMs, submodules) {
 	return new Promise((resolve, reject) => {
-		if (isNaverMapsReady()) {
+		if (isNaverMapsReady(submodules)) {
 			resolve();
 			return;
 		}
 		const startedAt = Date.now();
 		const intervalId = setInterval(() => {
-			if (isNaverMapsReady()) {
+			if (isNaverMapsReady(submodules)) {
 				clearInterval(intervalId);
 				resolve();
 				return;
@@ -76,7 +85,7 @@ function attachAuthFailureHandler(reject) {
 }
 function loadNaverMapsScript(options) {
 	if (typeof window === "undefined" || typeof document === "undefined") return Promise.reject(/* @__PURE__ */ new Error("loadNaverMapsScript can only run in a browser environment."));
-	if (isNaverMapsReady()) return Promise.resolve();
+	if (isNaverMapsReady(options.submodules)) return Promise.resolve();
 	const scriptUrl = createScriptUrl(options);
 	if (inFlightLoad && inFlightScriptUrl === scriptUrl) return inFlightLoad;
 	const existingScript = document.querySelector(`script[src="${scriptUrl}"]`);
@@ -94,7 +103,7 @@ function loadNaverMapsScript(options) {
 				restoreAuthFailure();
 			};
 			const handleReady = () => {
-				waitForNaverMapsReady(timeoutMs).then(() => {
+				waitForNaverMapsReady(timeoutMs, options.submodules).then(() => {
 					cleanup();
 					resolve();
 				}).catch((error) => {
@@ -144,7 +153,7 @@ function loadNaverMapsScript(options) {
 		};
 		const onLoad = () => {
 			script.dataset.reactNaverMapsKitLoaded = "true";
-			waitForNaverMapsReady(timeoutMs).then(() => {
+			waitForNaverMapsReady(timeoutMs, options.submodules).then(() => {
 				cleanup();
 				resolve();
 			}).catch((error) => {
@@ -267,13 +276,15 @@ function NaverMapProvider({ children, autoLoad = true, onReady, onError, ncpKeyI
 		setMap,
 		reloadSdk,
 		retrySdk: reloadSdk,
-		clearSdkError
+		clearSdkError,
+		submodules: submodules ?? []
 	}), [
 		clearSdkError,
 		map,
 		reloadSdk,
 		sdkError,
-		sdkStatus
+		sdkStatus,
+		submodules
 	]);
 	return /* @__PURE__ */ jsx(NaverMapContext.Provider, {
 		value,
@@ -281,6 +292,28 @@ function NaverMapProvider({ children, autoLoad = true, onReady, onError, ncpKeyI
 	});
 }
 
+//#endregion
+//#region src/react/context/MapInstanceContext.tsx
+const MapInstanceContext = createContext(null);
+function useMapInstance() {
+	return useContext(MapInstanceContext);
+}
+function useMapInstanceRequired() {
+	const context = useContext(MapInstanceContext);
+	if (!context) throw new Error("This component must be used inside NaverMap or Panorama. Make sure it is a child of <NaverMap> or <Panorama>.");
+	return context;
+}
+function useMap() {
+	const context = useContext(MapInstanceContext);
+	if (!context || context.type !== "map") return null;
+	return context.instance;
+}
+function usePanoramaInstance() {
+	const context = useContext(MapInstanceContext);
+	if (!context || context.type !== "panorama") return null;
+	return context.instance;
+}
+
 //#endregion
 //#region src/react/components/NaverMap.tsx
 const MAP_OPTION_KEYS = [
@@ -645,6 +678,7 @@ const NaverMapBase = forwardRef(function NaverMapInner(props, ref) {
 	if (!context) throw new Error("NaverMap must be used inside NaverMapProvider.");
 	const { sdkStatus, setMap, reloadSdk } = context;
 	const [mapReady, setMapReady] = useState(false);
+	const [localMapInstance, setLocalMapInstance] = useState(null);
 	const propsRef = useRef(props);
 	useEffect(() => {
 		propsRef.current = props;
@@ -789,6 +823,7 @@ const NaverMapBase = forwardRef(function NaverMapInner(props, ref) {
 		mapRef.current = mapInstance;
 		appliedOptionsRef.current = initOptions;
 		setMap(mapInstance);
+		setLocalMapInstance(mapInstance);
 		setMapReady(true);
 		propsRef.current.onMapReady?.(mapInstance);
 		const listeners = MAP_EVENT_BINDINGS.map((binding) => naver.maps.Event.addListener(mapInstance, binding.eventName, (event) => {
@@ -810,6 +845,7 @@ const NaverMapBase = forwardRef(function NaverMapInner(props, ref) {
 			mapRef.current = null;
 			appliedOptionsRef.current = {};
 			setMap(null);
+			setLocalMapInstance(null);
 			setMapReady(false);
 			propsRef.current.onMapDestroy?.();
 		};
@@ -841,15 +877,23 @@ const NaverMapBase = forwardRef(function NaverMapInner(props, ref) {
 		isControlledCenter,
 		isControlledZoom
 	]);
+	const mapInstanceContextValue = useMemo(() => ({
+		instance: localMapInstance,
+		setInstance: setLocalMapInstance,
+		type: "map"
+	}), [localMapInstance]);
 	if (sdkStatus === "error") return /* @__PURE__ */ jsx(Fragment, { children: props.fallback ?? /* @__PURE__ */ jsx("div", {
 		...divProps,
 		children: "지도를 불러올 수 없습니다."
 	}) });
 	if (sdkStatus === "loading") return /* @__PURE__ */ jsx(Fragment, { children: props.fallback ?? /* @__PURE__ */ jsx("div", { ...divProps }) });
-	return /* @__PURE__ */ jsx("div", {
-		ref: containerRef,
-		...divProps,
-		children: mapReady ? props.children : null
+	return /* @__PURE__ */ jsx(MapInstanceContext.Provider, {
+		value: mapInstanceContextValue,
+		children: /* @__PURE__ */ jsx("div", {
+			ref: containerRef,
+			...divProps,
+			children: mapReady ? props.children : null
+		})
 	});
 });
 NaverMapBase.displayName = "NaverMap";
@@ -1040,7 +1084,8 @@ function toLatLngLiteral(position) {
 	return null;
 }
 const Marker = forwardRef(function MarkerInner(props, ref) {
-	const { map: contextMap, sdkStatus } = useNaverMap();
+	const { sdkStatus } = useNaverMap();
+	const contextMap = useMapInstance()?.instance;
 	const clustererRegistry = useContext(ClustererContext);
 	const visibleIds = useContext(ClustererVisibilityContext);
 	const isInsideClusterer = clustererRegistry !== null && clustererRegistry.enabled;
@@ -2260,7 +2305,8 @@ function padBounds(bounds, padding) {
 */
 function MarkerClusterer(props) {
 	const { algorithm: algorithmProp, clusterIcon, onClusterClick, behavior, clusterData, enabled = true, children } = props;
-	const { map, sdkStatus } = useNaverMap();
+	const { sdkStatus } = useNaverMap();
+	const map = useMapInstance()?.instance;
 	const registryRef = useRef(/* @__PURE__ */ new Map());
 	const [registryVersion, setRegistryVersion] = useState(0);
 	const registry = useMemo(() => ({
@@ -2510,7 +2556,8 @@ function setInfoWindowOptionByKey(infoWindow, key, value) {
 	infoWindow.setOptions(key, value);
 }
 const InfoWindow = forwardRef(function InfoWindowInner(props, ref) {
-	const { map, sdkStatus } = useNaverMap();
+	const { sdkStatus } = useNaverMap();
+	const map = useMapInstance()?.instance;
 	const infoWindowRef = useRef(null);
 	const infoWindowEventListenersRef = useRef([]);
 	const onInfoWindowDestroyRef = useRef(props.onInfoWindowDestroy);
@@ -2784,7 +2831,8 @@ function buildCircleEventBindings(props) {
 	];
 }
 const Circle = forwardRef(function CircleInner(props, ref) {
-	const { map: contextMap, sdkStatus } = useNaverMap();
+	const { sdkStatus } = useNaverMap();
+	const contextMap = useMapInstance()?.instance;
 	const circleRef = useRef(null);
 	const circleEventListenersRef = useRef([]);
 	const onCircleDestroyRef = useRef(props.onCircleDestroy);
@@ -2996,7 +3044,8 @@ function buildEllipseEventBindings(props) {
 	];
 }
 const Ellipse = forwardRef(function EllipseInner(props, ref) {
-	const { map: contextMap, sdkStatus } = useNaverMap();
+	const { sdkStatus } = useNaverMap();
+	const contextMap = useMapInstance()?.instance;
 	const ellipseRef = useRef(null);
 	const ellipseEventListenersRef = useRef([]);
 	const onEllipseDestroyRef = useRef(props.onEllipseDestroy);
@@ -3160,7 +3209,8 @@ function buildGroundOverlayEventBindings(props) {
 	];
 }
 const GroundOverlay = forwardRef(function GroundOverlayInner(props, ref) {
-	const { map: contextMap, sdkStatus } = useNaverMap();
+	const { sdkStatus } = useNaverMap();
+	const contextMap = useMapInstance()?.instance;
 	const groundOverlayRef = useRef(null);
 	const groundOverlayEventListenersRef = useRef([]);
 	const onGroundOverlayDestroyRef = useRef(props.onGroundOverlayDestroy);
@@ -3198,7 +3248,12 @@ const GroundOverlay = forwardRef(function GroundOverlayInner(props, ref) {
 		getProjection: (...args) => invokeGroundOverlayMethod("getProjection", ...args),
 		getUrl: (...args) => invokeGroundOverlayMethod("getUrl", ...args),
 		setMap: (...args) => invokeGroundOverlayMethod("setMap", ...args),
-		setOpacity: (...args) => invokeGroundOverlayMethod("setOpacity", ...args)
+		setOpacity: (...args) => invokeGroundOverlayMethod("setOpacity", ...args),
+		setUrl: (url) => {
+			const groundOverlay = groundOverlayRef.current;
+			if (!groundOverlay) return void 0;
+			groundOverlay.setUrl?.(url);
+		}
 	}), [invokeGroundOverlayMethod]);
 	useEffect(() => {
 		if (sdkStatus !== "ready" || !targetMap || groundOverlayRef.current) return;
@@ -3364,7 +3419,8 @@ function buildPolygonEventBindings(props) {
 	];
 }
 const Polygon = forwardRef(function PolygonInner(props, ref) {
-	const { map: contextMap, sdkStatus } = useNaverMap();
+	const { sdkStatus } = useNaverMap();
+	const contextMap = useMapInstance()?.instance;
 	const polygonRef = useRef(null);
 	const polygonEventListenersRef = useRef([]);
 	const onPolygonDestroyRef = useRef(props.onPolygonDestroy);
@@ -3586,7 +3642,8 @@ function buildPolylineEventBindings(props) {
 	];
 }
 const Polyline = forwardRef(function PolylineInner(props, ref) {
-	const { map: contextMap, sdkStatus } = useNaverMap();
+	const { sdkStatus } = useNaverMap();
+	const contextMap = useMapInstance()?.instance;
 	const polylineRef = useRef(null);
 	const polylineEventListenersRef = useRef([]);
 	const onPolylineDestroyRef = useRef(props.onPolylineDestroy);
@@ -3796,7 +3853,8 @@ function buildRectangleEventBindings(props) {
 	];
 }
 const Rectangle = forwardRef(function RectangleInner(props, ref) {
-	const { map: contextMap, sdkStatus } = useNaverMap();
+	const { sdkStatus } = useNaverMap();
+	const contextMap = useMapInstance()?.instance;
 	const rectangleRef = useRef(null);
 	const rectangleEventListenersRef = useRef([]);
 	const onRectangleDestroyRef = useRef(props.onRectangleDestroy);
@@ -3886,10 +3944,1615 @@ const Rectangle = forwardRef(function RectangleInner(props, ref) {
 });
 Rectangle.displayName = "Rectangle";
 
+//#endregion
+//#region src/overlays/data/GeoJson.tsx
+function buildGeoJsonEventBindings(props) {
+	return [
+		{
+			eventName: "addfeature",
+			invoke: props.onAddFeature ? (event) => props.onAddFeature?.(event) : void 0
+		},
+		{
+			eventName: "removefeature",
+			invoke: props.onRemoveFeature ? (event) => props.onRemoveFeature?.(event) : void 0
+		},
+		{
+			eventName: "property_changed",
+			invoke: props.onPropertyChanged ? (event) => props.onPropertyChanged?.(event) : void 0
+		},
+		{
+			eventName: "click",
+			invoke: props.onClick ? (event) => props.onClick?.(event) : void 0
+		},
+		{
+			eventName: "dblclick",
+			invoke: props.onDblClick ? (event) => props.onDblClick?.(event) : void 0
+		},
+		{
+			eventName: "rightclick",
+			invoke: props.onRightClick ? (event) => props.onRightClick?.(event) : void 0
+		},
+		{
+			eventName: "mousedown",
+			invoke: props.onMouseDown ? (event) => props.onMouseDown?.(event) : void 0
+		},
+		{
+			eventName: "mouseup",
+			invoke: props.onMouseUp ? (event) => props.onMouseUp?.(event) : void 0
+		},
+		{
+			eventName: "mouseover",
+			invoke: props.onMouseOver ? (event) => props.onMouseOver?.(event) : void 0
+		},
+		{
+			eventName: "mouseout",
+			invoke: props.onMouseOut ? (event) => props.onMouseOut?.(event) : void 0
+		}
+	];
+}
+const GeoJson = forwardRef(function GeoJsonInner(props, ref) {
+	const { sdkStatus } = useNaverMap();
+	const contextMap = useMapInstance()?.instance;
+	const dataRef = useRef(null);
+	const dataEventListenersRef = useRef([]);
+	const onDataDestroyRef = useRef(props.onDataDestroy);
+	const prevDataRef = useRef(null);
+	useEffect(() => {
+		onDataDestroyRef.current = props.onDataDestroy;
+	}, [props.onDataDestroy]);
+	const invokeDataMethod = useCallback((methodName, ...args) => {
+		const data = dataRef.current;
+		if (!data) return;
+		const method = data[methodName];
+		if (typeof method !== "function") return;
+		return method.apply(data, args);
+	}, []);
+	const teardownData = useCallback(() => {
+		const data = dataRef.current;
+		if (!data) return;
+		try {
+			removeOverlayEventListeners(dataEventListenersRef.current);
+			dataEventListenersRef.current = [];
+			naver.maps.Event.clearInstanceListeners(data);
+		} catch (error) {
+			console.error("[react-naver-maps-kit] failed to clear GeoJson data layer listeners", error);
+		}
+		data.setMap(null);
+		dataRef.current = null;
+		prevDataRef.current = null;
+		onDataDestroyRef.current?.();
+	}, []);
+	useImperativeHandle(ref, () => ({
+		getInstance: () => dataRef.current,
+		getAllFeature: (...args) => invokeDataMethod("getAllFeature", ...args),
+		getFeatureById: (...args) => invokeDataMethod("getFeatureById", ...args),
+		getMap: (...args) => invokeDataMethod("getMap", ...args),
+		getStyle: (...args) => invokeDataMethod("getStyle", ...args),
+		overrideStyle: (...args) => invokeDataMethod("overrideStyle", ...args),
+		removeFeature: (...args) => invokeDataMethod("removeFeature", ...args),
+		revertStyle: (...args) => invokeDataMethod("revertStyle", ...args),
+		setStyle: (...args) => invokeDataMethod("setStyle", ...args),
+		toGeoJson: (...args) => invokeDataMethod("toGeoJson", ...args)
+	}), [invokeDataMethod]);
+	useEffect(() => {
+		if (sdkStatus !== "ready" || !contextMap || dataRef.current) return;
+		try {
+			const data = new naver.maps.Data();
+			data.setMap(contextMap);
+			if (props.style) data.setStyle(props.style);
+			const features = data.addGeoJson(props.data, props.autoStyle ?? true);
+			prevDataRef.current = props.data;
+			dataRef.current = data;
+			bindOverlayEventListeners(data, dataEventListenersRef, buildGeoJsonEventBindings(props));
+			props.onDataReady?.(data);
+			props.onFeaturesAdded?.(features);
+		} catch (error) {
+			const normalizedError = error instanceof Error ? error : /* @__PURE__ */ new Error("Failed to create naver.maps.Data instance for GeoJson.");
+			props.onDataError?.(normalizedError);
+		}
+	}, [sdkStatus, contextMap]);
+	useEffect(() => {
+		const data = dataRef.current;
+		if (!data || props.data === prevDataRef.current) return;
+		try {
+			if (prevDataRef.current) data.removeGeoJson(prevDataRef.current);
+			const features = data.addGeoJson(props.data, props.autoStyle ?? true);
+			prevDataRef.current = props.data;
+			props.onFeaturesAdded?.(features);
+		} catch (error) {
+			const normalizedError = error instanceof Error ? error : /* @__PURE__ */ new Error("Failed to update GeoJson data.");
+			props.onDataError?.(normalizedError);
+		}
+	}, [props.data, props.autoStyle]);
+	useEffect(() => {
+		const data = dataRef.current;
+		if (!data) return;
+		if (props.style) data.setStyle(props.style);
+	}, [props.style]);
+	useEffect(() => {
+		const data = dataRef.current;
+		if (!data) return;
+		bindOverlayEventListeners(data, dataEventListenersRef, buildGeoJsonEventBindings(props));
+		return () => {
+			removeOverlayEventListeners(dataEventListenersRef.current);
+			dataEventListenersRef.current = [];
+		};
+	}, [props]);
+	useEffect(() => {
+		return () => {
+			teardownData();
+		};
+	}, [teardownData]);
+	return null;
+});
+GeoJson.displayName = "GeoJson";
+
+//#endregion
+//#region src/overlays/data/Gpx.tsx
+function buildGpxEventBindings(props) {
+	return [
+		{
+			eventName: "addfeature",
+			invoke: props.onAddFeature ? (event) => props.onAddFeature?.(event) : void 0
+		},
+		{
+			eventName: "removefeature",
+			invoke: props.onRemoveFeature ? (event) => props.onRemoveFeature?.(event) : void 0
+		},
+		{
+			eventName: "property_changed",
+			invoke: props.onPropertyChanged ? (event) => props.onPropertyChanged?.(event) : void 0
+		},
+		{
+			eventName: "click",
+			invoke: props.onClick ? (event) => props.onClick?.(event) : void 0
+		},
+		{
+			eventName: "dblclick",
+			invoke: props.onDblClick ? (event) => props.onDblClick?.(event) : void 0
+		},
+		{
+			eventName: "rightclick",
+			invoke: props.onRightClick ? (event) => props.onRightClick?.(event) : void 0
+		},
+		{
+			eventName: "mousedown",
+			invoke: props.onMouseDown ? (event) => props.onMouseDown?.(event) : void 0
+		},
+		{
+			eventName: "mouseup",
+			invoke: props.onMouseUp ? (event) => props.onMouseUp?.(event) : void 0
+		},
+		{
+			eventName: "mouseover",
+			invoke: props.onMouseOver ? (event) => props.onMouseOver?.(event) : void 0
+		},
+		{
+			eventName: "mouseout",
+			invoke: props.onMouseOut ? (event) => props.onMouseOut?.(event) : void 0
+		}
+	];
+}
+function parseXml(xmlString) {
+	const doc = new DOMParser().parseFromString(xmlString, "application/xml");
+	const parseError = doc.querySelector("parsererror");
+	if (parseError) throw new Error(`XML parse error: ${parseError.textContent}`);
+	return doc;
+}
+const Gpx = forwardRef(function GpxInner(props, ref) {
+	const { sdkStatus } = useNaverMap();
+	const contextMap = useMapInstance()?.instance;
+	const dataRef = useRef(null);
+	const dataEventListenersRef = useRef([]);
+	const onDataDestroyRef = useRef(props.onDataDestroy);
+	const prevUrlRef = useRef(null);
+	const abortRef = useRef(null);
+	useEffect(() => {
+		onDataDestroyRef.current = props.onDataDestroy;
+	}, [props.onDataDestroy]);
+	const invokeDataMethod = useCallback((methodName, ...args) => {
+		const data = dataRef.current;
+		if (!data) return;
+		const method = data[methodName];
+		if (typeof method !== "function") return;
+		return method.apply(data, args);
+	}, []);
+	const teardownData = useCallback(() => {
+		abortRef.current?.abort();
+		abortRef.current = null;
+		const data = dataRef.current;
+		if (!data) return;
+		try {
+			removeOverlayEventListeners(dataEventListenersRef.current);
+			dataEventListenersRef.current = [];
+			naver.maps.Event.clearInstanceListeners(data);
+		} catch (error) {
+			console.error("[react-naver-maps-kit] failed to clear GPX data layer listeners", error);
+		}
+		data.setMap(null);
+		dataRef.current = null;
+		prevUrlRef.current = null;
+		onDataDestroyRef.current?.();
+	}, []);
+	useImperativeHandle(ref, () => ({
+		getInstance: () => dataRef.current,
+		getAllFeature: (...args) => invokeDataMethod("getAllFeature", ...args),
+		getFeatureById: (...args) => invokeDataMethod("getFeatureById", ...args),
+		getMap: (...args) => invokeDataMethod("getMap", ...args),
+		getStyle: (...args) => invokeDataMethod("getStyle", ...args),
+		overrideStyle: (...args) => invokeDataMethod("overrideStyle", ...args),
+		removeFeature: (...args) => invokeDataMethod("removeFeature", ...args),
+		revertStyle: (...args) => invokeDataMethod("revertStyle", ...args),
+		setStyle: (...args) => invokeDataMethod("setStyle", ...args),
+		toGeoJson: (...args) => invokeDataMethod("toGeoJson", ...args)
+	}), [invokeDataMethod]);
+	const loadAndAddGpx = useCallback(async (data, url, isInitial) => {
+		const controller = new AbortController();
+		abortRef.current = controller;
+		try {
+			const response = await fetch(url, { signal: controller.signal });
+			if (!response.ok) throw new Error(`Failed to fetch GPX: ${response.status} ${response.statusText}`);
+			const xmlDoc = parseXml(await response.text());
+			if (controller.signal.aborted) return;
+			if (!isInitial) data.getAllFeature().forEach((feature) => data.removeFeature(feature));
+			const features = data.addGpx(xmlDoc, props.autoStyle ?? true);
+			prevUrlRef.current = url;
+			props.onFeaturesAdded?.(features);
+		} catch (error) {
+			if (controller.signal.aborted) return;
+			const normalizedError = error instanceof Error ? error : /* @__PURE__ */ new Error("Failed to load GPX data.");
+			props.onDataError?.(normalizedError);
+		}
+	}, [
+		props.autoStyle,
+		props.onFeaturesAdded,
+		props.onDataError
+	]);
+	useEffect(() => {
+		if (sdkStatus !== "ready" || !contextMap || dataRef.current) return;
+		try {
+			const data = new naver.maps.Data();
+			data.setMap(contextMap);
+			if (props.style) data.setStyle(props.style);
+			dataRef.current = data;
+			bindOverlayEventListeners(data, dataEventListenersRef, buildGpxEventBindings(props));
+			props.onDataReady?.(data);
+			loadAndAddGpx(data, props.url, true);
+		} catch (error) {
+			const normalizedError = error instanceof Error ? error : /* @__PURE__ */ new Error("Failed to create naver.maps.Data instance.");
+			props.onDataError?.(normalizedError);
+		}
+	}, [sdkStatus, contextMap]);
+	useEffect(() => {
+		const data = dataRef.current;
+		if (!data || props.url === prevUrlRef.current) return;
+		abortRef.current?.abort();
+		loadAndAddGpx(data, props.url, false);
+	}, [props.url, loadAndAddGpx]);
+	useEffect(() => {
+		const data = dataRef.current;
+		if (!data) return;
+		if (props.style) data.setStyle(props.style);
+	}, [props.style]);
+	useEffect(() => {
+		const data = dataRef.current;
+		if (!data) return;
+		bindOverlayEventListeners(data, dataEventListenersRef, buildGpxEventBindings(props));
+		return () => {
+			removeOverlayEventListeners(dataEventListenersRef.current);
+			dataEventListenersRef.current = [];
+		};
+	}, [props]);
+	useEffect(() => {
+		return () => {
+			teardownData();
+		};
+	}, [teardownData]);
+	return null;
+});
+Gpx.displayName = "Gpx";
+
+//#endregion
+//#region ../../node_modules/.pnpm/fflate@0.8.2/node_modules/fflate/esm/browser.js
+var u8 = Uint8Array, u16 = Uint16Array, i32 = Int32Array;
+var fleb = new u8([
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	1,
+	1,
+	1,
+	1,
+	2,
+	2,
+	2,
+	2,
+	3,
+	3,
+	3,
+	3,
+	4,
+	4,
+	4,
+	4,
+	5,
+	5,
+	5,
+	5,
+	0,
+	0,
+	0,
+	0
+]);
+var fdeb = new u8([
+	0,
+	0,
+	0,
+	0,
+	1,
+	1,
+	2,
+	2,
+	3,
+	3,
+	4,
+	4,
+	5,
+	5,
+	6,
+	6,
+	7,
+	7,
+	8,
+	8,
+	9,
+	9,
+	10,
+	10,
+	11,
+	11,
+	12,
+	12,
+	13,
+	13,
+	0,
+	0
+]);
+var clim = new u8([
+	16,
+	17,
+	18,
+	0,
+	8,
+	7,
+	9,
+	6,
+	10,
+	5,
+	11,
+	4,
+	12,
+	3,
+	13,
+	2,
+	14,
+	1,
+	15
+]);
+var freb = function(eb, start) {
+	var b = new u16(31);
+	for (var i = 0; i < 31; ++i) b[i] = start += 1 << eb[i - 1];
+	var r = new i32(b[30]);
+	for (var i = 1; i < 30; ++i) for (var j = b[i]; j < b[i + 1]; ++j) r[j] = j - b[i] << 5 | i;
+	return {
+		b,
+		r
+	};
+};
+var _a = freb(fleb, 2), fl = _a.b, revfl = _a.r;
+fl[28] = 258, revfl[258] = 28;
+var _b = freb(fdeb, 0), fd = _b.b, revfd = _b.r;
+var rev = new u16(32768);
+for (var i = 0; i < 32768; ++i) {
+	var x = (i & 43690) >> 1 | (i & 21845) << 1;
+	x = (x & 52428) >> 2 | (x & 13107) << 2;
+	x = (x & 61680) >> 4 | (x & 3855) << 4;
+	rev[i] = ((x & 65280) >> 8 | (x & 255) << 8) >> 1;
+}
+var hMap = (function(cd, mb, r) {
+	var s = cd.length;
+	var i = 0;
+	var l = new u16(mb);
+	for (; i < s; ++i) if (cd[i]) ++l[cd[i] - 1];
+	var le = new u16(mb);
+	for (i = 1; i < mb; ++i) le[i] = le[i - 1] + l[i - 1] << 1;
+	var co;
+	if (r) {
+		co = new u16(1 << mb);
+		var rvb = 15 - mb;
+		for (i = 0; i < s; ++i) if (cd[i]) {
+			var sv = i << 4 | cd[i];
+			var r_1 = mb - cd[i];
+			var v = le[cd[i] - 1]++ << r_1;
+			for (var m = v | (1 << r_1) - 1; v <= m; ++v) co[rev[v] >> rvb] = sv;
+		}
+	} else {
+		co = new u16(s);
+		for (i = 0; i < s; ++i) if (cd[i]) co[i] = rev[le[cd[i] - 1]++] >> 15 - cd[i];
+	}
+	return co;
+});
+var flt = new u8(288);
+for (var i = 0; i < 144; ++i) flt[i] = 8;
+for (var i = 144; i < 256; ++i) flt[i] = 9;
+for (var i = 256; i < 280; ++i) flt[i] = 7;
+for (var i = 280; i < 288; ++i) flt[i] = 8;
+var fdt = new u8(32);
+for (var i = 0; i < 32; ++i) fdt[i] = 5;
+var flm = /* @__PURE__ */ hMap(flt, 9, 0), flrm = /* @__PURE__ */ hMap(flt, 9, 1);
+var fdm = /* @__PURE__ */ hMap(fdt, 5, 0), fdrm = /* @__PURE__ */ hMap(fdt, 5, 1);
+var max = function(a) {
+	var m = a[0];
+	for (var i = 1; i < a.length; ++i) if (a[i] > m) m = a[i];
+	return m;
+};
+var bits = function(d, p, m) {
+	var o = p / 8 | 0;
+	return (d[o] | d[o + 1] << 8) >> (p & 7) & m;
+};
+var bits16 = function(d, p) {
+	var o = p / 8 | 0;
+	return (d[o] | d[o + 1] << 8 | d[o + 2] << 16) >> (p & 7);
+};
+var shft = function(p) {
+	return (p + 7) / 8 | 0;
+};
+var slc = function(v, s, e) {
+	if (s == null || s < 0) s = 0;
+	if (e == null || e > v.length) e = v.length;
+	return new u8(v.subarray(s, e));
+};
+var ec = [
+	"unexpected EOF",
+	"invalid block type",
+	"invalid length/literal",
+	"invalid distance",
+	"stream finished",
+	"no stream handler",
+	,
+	"no callback",
+	"invalid UTF-8 data",
+	"extra field too long",
+	"date not in range 1980-2099",
+	"filename too long",
+	"stream finishing",
+	"invalid zip data"
+];
+var err = function(ind, msg, nt) {
+	var e = new Error(msg || ec[ind]);
+	e.code = ind;
+	if (Error.captureStackTrace) Error.captureStackTrace(e, err);
+	if (!nt) throw e;
+	return e;
+};
+var inflt = function(dat, st, buf, dict) {
+	var sl = dat.length, dl = dict ? dict.length : 0;
+	if (!sl || st.f && !st.l) return buf || new u8(0);
+	var noBuf = !buf;
+	var resize = noBuf || st.i != 2;
+	var noSt = st.i;
+	if (noBuf) buf = new u8(sl * 3);
+	var cbuf = function(l) {
+		var bl = buf.length;
+		if (l > bl) {
+			var nbuf = new u8(Math.max(bl * 2, l));
+			nbuf.set(buf);
+			buf = nbuf;
+		}
+	};
+	var final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;
+	var tbts = sl * 8;
+	do {
+		if (!lm) {
+			final = bits(dat, pos, 1);
+			var type = bits(dat, pos + 1, 3);
+			pos += 3;
+			if (!type) {
+				var s = shft(pos) + 4, l = dat[s - 4] | dat[s - 3] << 8, t = s + l;
+				if (t > sl) {
+					if (noSt) err(0);
+					break;
+				}
+				if (resize) cbuf(bt + l);
+				buf.set(dat.subarray(s, t), bt);
+				st.b = bt += l, st.p = pos = t * 8, st.f = final;
+				continue;
+			} else if (type == 1) lm = flrm, dm = fdrm, lbt = 9, dbt = 5;
+			else if (type == 2) {
+				var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
+				var tl = hLit + bits(dat, pos + 5, 31) + 1;
+				pos += 14;
+				var ldt = new u8(tl);
+				var clt = new u8(19);
+				for (var i = 0; i < hcLen; ++i) clt[clim[i]] = bits(dat, pos + i * 3, 7);
+				pos += hcLen * 3;
+				var clb = max(clt), clbmsk = (1 << clb) - 1;
+				var clm = hMap(clt, clb, 1);
+				for (var i = 0; i < tl;) {
+					var r = clm[bits(dat, pos, clbmsk)];
+					pos += r & 15;
+					var s = r >> 4;
+					if (s < 16) ldt[i++] = s;
+					else {
+						var c = 0, n = 0;
+						if (s == 16) n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i - 1];
+						else if (s == 17) n = 3 + bits(dat, pos, 7), pos += 3;
+						else if (s == 18) n = 11 + bits(dat, pos, 127), pos += 7;
+						while (n--) ldt[i++] = c;
+					}
+				}
+				var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
+				lbt = max(lt);
+				dbt = max(dt);
+				lm = hMap(lt, lbt, 1);
+				dm = hMap(dt, dbt, 1);
+			} else err(1);
+			if (pos > tbts) {
+				if (noSt) err(0);
+				break;
+			}
+		}
+		if (resize) cbuf(bt + 131072);
+		var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
+		var lpos = pos;
+		for (;; lpos = pos) {
+			var c = lm[bits16(dat, pos) & lms], sym = c >> 4;
+			pos += c & 15;
+			if (pos > tbts) {
+				if (noSt) err(0);
+				break;
+			}
+			if (!c) err(2);
+			if (sym < 256) buf[bt++] = sym;
+			else if (sym == 256) {
+				lpos = pos, lm = null;
+				break;
+			} else {
+				var add = sym - 254;
+				if (sym > 264) {
+					var i = sym - 257, b = fleb[i];
+					add = bits(dat, pos, (1 << b) - 1) + fl[i];
+					pos += b;
+				}
+				var d = dm[bits16(dat, pos) & dms], dsym = d >> 4;
+				if (!d) err(3);
+				pos += d & 15;
+				var dt = fd[dsym];
+				if (dsym > 3) {
+					var b = fdeb[dsym];
+					dt += bits16(dat, pos) & (1 << b) - 1, pos += b;
+				}
+				if (pos > tbts) {
+					if (noSt) err(0);
+					break;
+				}
+				if (resize) cbuf(bt + 131072);
+				var end = bt + add;
+				if (bt < dt) {
+					var shift = dl - dt, dend = Math.min(dt, end);
+					if (shift + bt < 0) err(3);
+					for (; bt < dend; ++bt) buf[bt] = dict[shift + bt];
+				}
+				for (; bt < end; ++bt) buf[bt] = buf[bt - dt];
+			}
+		}
+		st.l = lm, st.p = lpos, st.b = bt, st.f = final;
+		if (lm) final = 1, st.m = lbt, st.d = dm, st.n = dbt;
+	} while (!final);
+	return bt != buf.length && noBuf ? slc(buf, 0, bt) : buf.subarray(0, bt);
+};
+var et = /* @__PURE__ */ new u8(0);
+var b2 = function(d, b) {
+	return d[b] | d[b + 1] << 8;
+};
+var b4 = function(d, b) {
+	return (d[b] | d[b + 1] << 8 | d[b + 2] << 16 | d[b + 3] << 24) >>> 0;
+};
+var b8 = function(d, b) {
+	return b4(d, b) + b4(d, b + 4) * 4294967296;
+};
+/**
+* Expands DEFLATE data with no wrapper
+* @param data The data to decompress
+* @param opts The decompression options
+* @returns The decompressed version of the data
+*/
+function inflateSync(data, opts) {
+	return inflt(data, { i: 2 }, opts && opts.out, opts && opts.dictionary);
+}
+var td = typeof TextDecoder != "undefined" && /* @__PURE__ */ new TextDecoder();
+var tds = 0;
+try {
+	td.decode(et, { stream: true });
+	tds = 1;
+} catch (e) {}
+var dutf8 = function(d) {
+	for (var r = "", i = 0;;) {
+		var c = d[i++];
+		var eb = (c > 127) + (c > 223) + (c > 239);
+		if (i + eb > d.length) return {
+			s: r,
+			r: slc(d, i - 1)
+		};
+		if (!eb) r += String.fromCharCode(c);
+		else if (eb == 3) c = ((c & 15) << 18 | (d[i++] & 63) << 12 | (d[i++] & 63) << 6 | d[i++] & 63) - 65536, r += String.fromCharCode(55296 | c >> 10, 56320 | c & 1023);
+		else if (eb & 1) r += String.fromCharCode((c & 31) << 6 | d[i++] & 63);
+		else r += String.fromCharCode((c & 15) << 12 | (d[i++] & 63) << 6 | d[i++] & 63);
+	}
+};
+/**
+* Converts a Uint8Array to a string
+* @param dat The data to decode to string
+* @param latin1 Whether or not to interpret the data as Latin-1. This should
+*               not need to be true unless encoding to binary string.
+* @returns The original UTF-8/Latin-1 string
+*/
+function strFromU8(dat, latin1) {
+	if (latin1) {
+		var r = "";
+		for (var i = 0; i < dat.length; i += 16384) r += String.fromCharCode.apply(null, dat.subarray(i, i + 16384));
+		return r;
+	} else if (td) return td.decode(dat);
+	else {
+		var _a = dutf8(dat), s = _a.s, r = _a.r;
+		if (r.length) err(8);
+		return s;
+	}
+}
+var slzh = function(d, b) {
+	return b + 30 + b2(d, b + 26) + b2(d, b + 28);
+};
+var zh = function(d, b, z) {
+	var fnl = b2(d, b + 28), fn = strFromU8(d.subarray(b + 46, b + 46 + fnl), !(b2(d, b + 8) & 2048)), es = b + 46 + fnl, bs = b4(d, b + 20);
+	var _a = z && bs == 4294967295 ? z64e(d, es) : [
+		bs,
+		b4(d, b + 24),
+		b4(d, b + 42)
+	], sc = _a[0], su = _a[1], off = _a[2];
+	return [
+		b2(d, b + 10),
+		sc,
+		su,
+		fn,
+		es + b2(d, b + 30) + b2(d, b + 32),
+		off
+	];
+};
+var z64e = function(d, b) {
+	for (; b2(d, b) != 1; b += 4 + b2(d, b + 2));
+	return [
+		b8(d, b + 12),
+		b8(d, b + 4),
+		b8(d, b + 20)
+	];
+};
+/**
+* Synchronously decompresses a ZIP archive. Prefer using `unzip` for better
+* performance with more than one file.
+* @param data The raw compressed ZIP file
+* @param opts The ZIP extraction options
+* @returns The decompressed files
+*/
+function unzipSync(data, opts) {
+	var files = {};
+	var e = data.length - 22;
+	for (; b4(data, e) != 101010256; --e) if (!e || data.length - e > 65558) err(13);
+	var c = b2(data, e + 8);
+	if (!c) return {};
+	var o = b4(data, e + 16);
+	var z = o == 4294967295 || c == 65535;
+	if (z) {
+		var ze = b4(data, e - 12);
+		z = b4(data, ze) == 101075792;
+		if (z) {
+			c = b4(data, ze + 32);
+			o = b4(data, ze + 48);
+		}
+	}
+	var fltr = opts && opts.filter;
+	for (var i = 0; i < c; ++i) {
+		var _a = zh(data, o, z), c_2 = _a[0], sc = _a[1], su = _a[2], fn = _a[3], no = _a[4], off = _a[5], b = slzh(data, off);
+		o = no;
+		if (!fltr || fltr({
+			name: fn,
+			size: sc,
+			originalSize: su,
+			compression: c_2
+		})) if (!c_2) files[fn] = slc(data, b, b + sc);
+		else if (c_2 == 8) files[fn] = inflateSync(data.subarray(b, b + sc), { out: new u8(su) });
+		else err(14, "unknown compression type " + c_2);
+	}
+	return files;
+}
+
+//#endregion
+//#region src/overlays/data/Kmz.tsx
+function buildKmzEventBindings(props) {
+	return [
+		{
+			eventName: "addfeature",
+			invoke: props.onAddFeature ? (event) => props.onAddFeature?.(event) : void 0
+		},
+		{
+			eventName: "removefeature",
+			invoke: props.onRemoveFeature ? (event) => props.onRemoveFeature?.(event) : void 0
+		},
+		{
+			eventName: "property_changed",
+			invoke: props.onPropertyChanged ? (event) => props.onPropertyChanged?.(event) : void 0
+		},
+		{
+			eventName: "click",
+			invoke: props.onClick ? (event) => props.onClick?.(event) : void 0
+		},
+		{
+			eventName: "dblclick",
+			invoke: props.onDblClick ? (event) => props.onDblClick?.(event) : void 0
+		},
+		{
+			eventName: "rightclick",
+			invoke: props.onRightClick ? (event) => props.onRightClick?.(event) : void 0
+		},
+		{
+			eventName: "mousedown",
+			invoke: props.onMouseDown ? (event) => props.onMouseDown?.(event) : void 0
+		},
+		{
+			eventName: "mouseup",
+			invoke: props.onMouseUp ? (event) => props.onMouseUp?.(event) : void 0
+		},
+		{
+			eventName: "mouseover",
+			invoke: props.onMouseOver ? (event) => props.onMouseOver?.(event) : void 0
+		},
+		{
+			eventName: "mouseout",
+			invoke: props.onMouseOut ? (event) => props.onMouseOut?.(event) : void 0
+		}
+	];
+}
+function extractKmlFromKmz(arrayBuffer) {
+	const files = unzipSync(new Uint8Array(arrayBuffer));
+	const kmlFileName = Object.keys(files).find((name) => name.endsWith(".kml") || name === "doc.kml");
+	if (!kmlFileName) throw new Error("No KML file found in KMZ archive.");
+	const kmlBytes = files[kmlFileName];
+	const kmlString = new TextDecoder("utf-8").decode(kmlBytes);
+	const doc = new DOMParser().parseFromString(kmlString, "application/xml");
+	const parseError = doc.querySelector("parsererror");
+	if (parseError) throw new Error(`KML parse error: ${parseError.textContent}`);
+	return doc;
+}
+const Kmz = forwardRef(function KmzInner(props, ref) {
+	const { sdkStatus } = useNaverMap();
+	const contextMap = useMapInstance()?.instance;
+	const dataRef = useRef(null);
+	const dataEventListenersRef = useRef([]);
+	const onDataDestroyRef = useRef(props.onDataDestroy);
+	const prevUrlRef = useRef(null);
+	const abortRef = useRef(null);
+	useEffect(() => {
+		onDataDestroyRef.current = props.onDataDestroy;
+	}, [props.onDataDestroy]);
+	const invokeDataMethod = useCallback((methodName, ...args) => {
+		const data = dataRef.current;
+		if (!data) return;
+		const method = data[methodName];
+		if (typeof method !== "function") return;
+		return method.apply(data, args);
+	}, []);
+	const teardownData = useCallback(() => {
+		abortRef.current?.abort();
+		abortRef.current = null;
+		const data = dataRef.current;
+		if (!data) return;
+		try {
+			removeOverlayEventListeners(dataEventListenersRef.current);
+			dataEventListenersRef.current = [];
+			naver.maps.Event.clearInstanceListeners(data);
+		} catch (error) {
+			console.error("[react-naver-maps-kit] failed to clear KMZ data layer listeners", error);
+		}
+		data.setMap(null);
+		dataRef.current = null;
+		prevUrlRef.current = null;
+		onDataDestroyRef.current?.();
+	}, []);
+	useImperativeHandle(ref, () => ({
+		getInstance: () => dataRef.current,
+		getAllFeature: (...args) => invokeDataMethod("getAllFeature", ...args),
+		getFeatureById: (...args) => invokeDataMethod("getFeatureById", ...args),
+		getMap: (...args) => invokeDataMethod("getMap", ...args),
+		getStyle: (...args) => invokeDataMethod("getStyle", ...args),
+		overrideStyle: (...args) => invokeDataMethod("overrideStyle", ...args),
+		removeFeature: (...args) => invokeDataMethod("removeFeature", ...args),
+		revertStyle: (...args) => invokeDataMethod("revertStyle", ...args),
+		setStyle: (...args) => invokeDataMethod("setStyle", ...args),
+		toGeoJson: (...args) => invokeDataMethod("toGeoJson", ...args)
+	}), [invokeDataMethod]);
+	const loadAndAddKmz = useCallback(async (data, url, isInitial) => {
+		const controller = new AbortController();
+		abortRef.current = controller;
+		try {
+			const response = await fetch(url, { signal: controller.signal });
+			if (!response.ok) throw new Error(`Failed to fetch KMZ: ${response.status} ${response.statusText}`);
+			const arrayBuffer = await response.arrayBuffer();
+			if (controller.signal.aborted) return;
+			const kmlDoc = extractKmlFromKmz(arrayBuffer);
+			if (!isInitial) data.getAllFeature().forEach((feature) => data.removeFeature(feature));
+			const features = data.addKml(kmlDoc, props.autoStyle ?? true);
+			prevUrlRef.current = url;
+			props.onFeaturesAdded?.(features);
+		} catch (error) {
+			if (controller.signal.aborted) return;
+			const normalizedError = error instanceof Error ? error : /* @__PURE__ */ new Error("Failed to load KMZ data.");
+			props.onDataError?.(normalizedError);
+		}
+	}, [
+		props.autoStyle,
+		props.onFeaturesAdded,
+		props.onDataError
+	]);
+	useEffect(() => {
+		if (sdkStatus !== "ready" || !contextMap || dataRef.current) return;
+		try {
+			const data = new naver.maps.Data();
+			data.setMap(contextMap);
+			if (props.style) data.setStyle(props.style);
+			dataRef.current = data;
+			bindOverlayEventListeners(data, dataEventListenersRef, buildKmzEventBindings(props));
+			props.onDataReady?.(data);
+			loadAndAddKmz(data, props.url, true);
+		} catch (error) {
+			const normalizedError = error instanceof Error ? error : /* @__PURE__ */ new Error("Failed to create naver.maps.Data instance.");
+			props.onDataError?.(normalizedError);
+		}
+	}, [sdkStatus, contextMap]);
+	useEffect(() => {
+		const data = dataRef.current;
+		if (!data || props.url === prevUrlRef.current) return;
+		abortRef.current?.abort();
+		loadAndAddKmz(data, props.url, false);
+	}, [props.url, loadAndAddKmz]);
+	useEffect(() => {
+		const data = dataRef.current;
+		if (!data) return;
+		if (props.style) data.setStyle(props.style);
+	}, [props.style]);
+	useEffect(() => {
+		const data = dataRef.current;
+		if (!data) return;
+		bindOverlayEventListeners(data, dataEventListenersRef, buildKmzEventBindings(props));
+		return () => {
+			removeOverlayEventListeners(dataEventListenersRef.current);
+			dataEventListenersRef.current = [];
+		};
+	}, [props]);
+	useEffect(() => {
+		return () => {
+			teardownData();
+		};
+	}, [teardownData]);
+	return null;
+});
+Kmz.displayName = "Kmz";
+
+//#endregion
+//#region src/submodules/panorama/PanoramaContext.ts
+const PanoramaContext = createContext(null);
+function usePanorama() {
+	const value = useContext(PanoramaContext);
+	if (!value) throw new Error("usePanorama must be used within a Panorama component. Make sure you wrap your panorama-dependent components with <Panorama>.");
+	return value;
+}
+
+//#endregion
+//#region src/submodules/panorama/Panorama.tsx
+function toLatLng(position) {
+	if (!position) return position;
+	const pos = position;
+	if (typeof pos.lat === "number" && typeof pos.lng === "number") return new naver.maps.LatLng(pos.lat, pos.lng);
+	return position;
+}
+function toPanoramaOptions(props, convertLatLng = false, excludeControlled = false) {
+	const options = {};
+	if (props.size !== void 0) options.size = props.size;
+	if (props.panoId !== void 0) options.panoId = props.panoId;
+	if (!excludeControlled && props.position !== void 0) options.position = convertLatLng ? toLatLng(props.position) : props.position;
+	if (!excludeControlled && props.pov !== void 0) options.pov = props.pov;
+	if (props.visible !== void 0) options.visible = props.visible;
+	if (props.minScale !== void 0) options.minScale = props.minScale;
+	if (props.maxScale !== void 0) options.maxScale = props.maxScale;
+	if (props.minZoom !== void 0) options.minZoom = props.minZoom;
+	if (props.maxZoom !== void 0) options.maxZoom = props.maxZoom;
+	if (props.flightSpot !== void 0) options.flightSpot = props.flightSpot;
+	if (props.logoControl !== void 0) options.logoControl = props.logoControl;
+	if (props.logoControlOptions !== void 0) options.logoControlOptions = props.logoControlOptions;
+	if (props.zoomControl !== void 0) options.zoomControl = props.zoomControl;
+	if (props.zoomControlOptions !== void 0) options.zoomControlOptions = props.zoomControlOptions;
+	if (props.aroundControl !== void 0) options.aroundControl = props.aroundControl;
+	if (props.aroundControlOptions !== void 0) options.aroundControlOptions = props.aroundControlOptions;
+	return options;
+}
+function buildPanoramaEventBindings(props) {
+	return [
+		{
+			eventName: "init",
+			invoke: props.onInit ? () => props.onInit?.() : void 0
+		},
+		{
+			eventName: "pano_changed",
+			invoke: props.onPanoChanged ? () => props.onPanoChanged?.() : void 0
+		},
+		{
+			eventName: "pano_status",
+			invoke: props.onPanoStatus ? (event) => props.onPanoStatus?.(event) : void 0
+		},
+		{
+			eventName: "pov_changed",
+			invoke: props.onPovChanged ? () => props.onPovChanged?.() : void 0
+		}
+	];
+}
+function bindPanoramaEventListeners(panorama, listenersRef, bindings) {
+	if (listenersRef.current.length > 0) {
+		naver.maps.Event.removeListener(listenersRef.current);
+		listenersRef.current = [];
+	}
+	listenersRef.current = bindings.filter((binding) => typeof binding.invoke === "function").map((binding) => naver.maps.Event.addListener(panorama, binding.eventName, (event) => {
+		binding.invoke?.(event);
+	}));
+}
+const Panorama = forwardRef(function PanoramaInner(props, ref) {
+	const naverMapContext = NaverMapContext;
+	const context = React.useContext(naverMapContext);
+	if (!context) throw new Error("Panorama must be used inside NaverMapProvider.");
+	const { sdkStatus, submodules } = context;
+	if (sdkStatus === "ready" && !submodules.includes("panorama")) throw new Error("Panorama component requires \"panorama\" submodule. Add submodules={[\"panorama\"]} to your NaverMapProvider.");
+	const containerRef = useRef(null);
+	const panoramaRef = useRef(null);
+	const eventListenersRef = useRef([]);
+	const onPanoramaDestroyRef = useRef(props.onPanoramaDestroy);
+	const [panoramaInstance, setPanoramaInstance] = useState(null);
+	const [panoramaReady, setPanoramaReady] = useState(false);
+	const propsRef = useRef(props);
+	useEffect(() => {
+		propsRef.current = props;
+	});
+	useEffect(() => {
+		onPanoramaDestroyRef.current = props.onPanoramaDestroy;
+	}, [props.onPanoramaDestroy]);
+	const initialPositionRef = useRef(props.position ?? props.defaultPosition);
+	const initialPovRef = useRef(props.pov ?? props.defaultPov);
+	const isControlledPosition = props.position !== void 0;
+	const isControlledPov = props.pov !== void 0;
+	const optionsSnapshot = useMemo(() => toPanoramaOptions(props, false, true), [
+		props.size,
+		props.panoId,
+		props.visible,
+		props.minScale,
+		props.maxScale,
+		props.minZoom,
+		props.maxZoom,
+		props.flightSpot,
+		props.logoControl,
+		props.logoControlOptions,
+		props.zoomControl,
+		props.zoomControlOptions,
+		props.aroundControl,
+		props.aroundControlOptions
+	]);
+	const invokePanoramaMethod = useCallback((methodName, ...args) => {
+		const panorama = panoramaRef.current;
+		if (!panorama) return void 0;
+		const method = panorama[methodName];
+		if (typeof method !== "function") return void 0;
+		return method.apply(panorama, args);
+	}, []);
+	useImperativeHandle(ref, () => ({
+		getInstance: () => panoramaRef.current,
+		getElement: (...args) => invokePanoramaMethod("getElement", ...args),
+		getLocation: (...args) => invokePanoramaMethod("getLocation", ...args),
+		getMaxScale: (...args) => invokePanoramaMethod("getMaxScale", ...args),
+		getMaxZoom: (...args) => invokePanoramaMethod("getMaxZoom", ...args),
+		getMinScale: (...args) => invokePanoramaMethod("getMinScale", ...args),
+		getMinZoom: (...args) => invokePanoramaMethod("getMinZoom", ...args),
+		getOptions: (...args) => invokePanoramaMethod("getOptions", ...args),
+		getPanoId: (...args) => invokePanoramaMethod("getPanoId", ...args),
+		getPosition: (...args) => invokePanoramaMethod("getPosition", ...args),
+		getPov: (...args) => invokePanoramaMethod("getPov", ...args),
+		getProjection: (...args) => invokePanoramaMethod("getProjection", ...args),
+		getScale: (...args) => invokePanoramaMethod("getScale", ...args),
+		getSize: (...args) => invokePanoramaMethod("getSize", ...args),
+		getVisible: (...args) => invokePanoramaMethod("getVisible", ...args),
+		getZoom: (...args) => invokePanoramaMethod("getZoom", ...args),
+		setOptions: (...args) => invokePanoramaMethod("setOptions", ...args),
+		setPanoId: (...args) => invokePanoramaMethod("setPanoId", ...args),
+		setPanoIdWithPov: (...args) => invokePanoramaMethod("setPanoIdWithPov", ...args),
+		setPosition: (...args) => invokePanoramaMethod("setPosition", ...args),
+		setPov: (...args) => invokePanoramaMethod("setPov", ...args),
+		setScale: (...args) => invokePanoramaMethod("setScale", ...args),
+		setSize: (...args) => invokePanoramaMethod("setSize", ...args),
+		setVisible: (...args) => invokePanoramaMethod("setVisible", ...args),
+		setZoom: (...args) => invokePanoramaMethod("setZoom", ...args),
+		zoomIn: (...args) => invokePanoramaMethod("zoomIn", ...args),
+		zoomOut: (...args) => invokePanoramaMethod("zoomOut", ...args)
+	}), [invokePanoramaMethod]);
+	useEffect(() => {
+		if (sdkStatus !== "ready" || !containerRef.current || panoramaRef.current) return;
+		const container = containerRef.current;
+		try {
+			const initOpts = toPanoramaOptions(propsRef.current, true, true);
+			if (initialPositionRef.current !== void 0) initOpts.position = toLatLng(initialPositionRef.current);
+			if (initialPovRef.current !== void 0) initOpts.pov = initialPovRef.current;
+			const panorama = new naver.maps.Panorama(container, initOpts);
+			panoramaRef.current = panorama;
+			setPanoramaInstance(panorama);
+			setPanoramaReady(true);
+			bindPanoramaEventListeners(panorama, eventListenersRef, buildPanoramaEventBindings(propsRef.current));
+			propsRef.current.onPanoramaReady?.(panorama);
+		} catch (error) {
+			console.error("[Panorama] Failed to create panorama:", error);
+			const normalizedError = error instanceof Error ? error : /* @__PURE__ */ new Error("Failed to create naver.maps.Panorama instance.");
+			propsRef.current.onPanoramaError?.(normalizedError);
+		}
+	}, [sdkStatus]);
+	useEffect(() => {
+		return () => {
+			const container = containerRef.current;
+			try {
+				if (eventListenersRef.current.length > 0) {
+					naver.maps.Event.removeListener(eventListenersRef.current);
+					eventListenersRef.current = [];
+				}
+				if (panoramaRef.current) naver.maps.Event.clearInstanceListeners(panoramaRef.current);
+			} catch (error) {
+				console.error("[react-naver-maps-kit] failed to clear panorama listeners", error);
+			}
+			if (container) container.innerHTML = "";
+			panoramaRef.current = null;
+			setPanoramaInstance(null);
+			setPanoramaReady(false);
+			onPanoramaDestroyRef.current?.();
+		};
+	}, []);
+	useEffect(() => {
+		const panorama = panoramaRef.current;
+		if (!panorama) return;
+		if (Object.keys(optionsSnapshot).length > 0) panorama.setOptions(optionsSnapshot);
+	}, [optionsSnapshot]);
+	useEffect(() => {
+		const panorama = panoramaRef.current;
+		if (!panorama || !isControlledPosition || props.position === void 0) return;
+		panorama.setPosition(toLatLng(props.position));
+	}, [isControlledPosition, props.position]);
+	useEffect(() => {
+		const panorama = panoramaRef.current;
+		if (!panorama || !isControlledPov || props.pov === void 0) return;
+		panorama.setPov(props.pov);
+	}, [isControlledPov, props.pov]);
+	const panoramaContextValue = useMemo(() => ({
+		panorama: panoramaInstance,
+		setPanorama: setPanoramaInstance,
+		sdkStatus,
+		submodules
+	}), [
+		panoramaInstance,
+		sdkStatus,
+		submodules
+	]);
+	const mapInstanceContextValue = useMemo(() => ({
+		instance: panoramaInstance,
+		setInstance: setPanoramaInstance,
+		type: "panorama"
+	}), [panoramaInstance]);
+	const naverMapContextValue = useMemo(() => ({
+		...context,
+		map: panoramaInstance,
+		setMap: setPanoramaInstance
+	}), [context, panoramaInstance]);
+	return /* @__PURE__ */ jsx(NaverMapContext.Provider, {
+		value: naverMapContextValue,
+		children: /* @__PURE__ */ jsx(MapInstanceContext.Provider, {
+			value: mapInstanceContextValue,
+			children: /* @__PURE__ */ jsx(PanoramaContext.Provider, {
+				value: panoramaContextValue,
+				children: /* @__PURE__ */ jsx("div", {
+					ref: containerRef,
+					style: props.style,
+					className: props.className,
+					children: panoramaReady ? props.children : null
+				})
+			})
+		})
+	});
+});
+Panorama.displayName = "Panorama";
+
+//#endregion
+//#region src/submodules/panorama/FlightSpot.tsx
+const FlightSpot = forwardRef(function FlightSpotInner(props, ref) {
+	const { sdkStatus, submodules } = useNaverMap();
+	const contextMap = useMapInstance()?.instance;
+	let panoramaContext = null;
+	try {
+		panoramaContext = usePanorama();
+	} catch {}
+	const flightSpotRef = useRef(null);
+	const eventListenersRef = useRef([]);
+	const onFlightSpotDestroyRef = useRef(props.onFlightSpotDestroy);
+	const targetMap = props.map ?? panoramaContext?.panorama ?? contextMap;
+	const isInPanorama = panoramaContext !== null;
+	const effectiveSubmodules = panoramaContext?.submodules ?? submodules;
+	if (sdkStatus === "ready" && effectiveSubmodules && !effectiveSubmodules.includes("panorama")) throw new Error("FlightSpot component requires \"panorama\" submodule. Add submodules={[\"panorama\"]} to your NaverMapProvider.");
+	const propsRef = useRef(props);
+	useEffect(() => {
+		propsRef.current = props;
+	});
+	useEffect(() => {
+		onFlightSpotDestroyRef.current = props.onFlightSpotDestroy;
+	}, [props.onFlightSpotDestroy]);
+	const invokeFlightSpotMethod = useCallback((methodName, ...args) => {
+		const flightSpot = flightSpotRef.current;
+		if (!flightSpot) return void 0;
+		const method = flightSpot[methodName];
+		if (typeof method !== "function") return void 0;
+		return method.apply(flightSpot, args);
+	}, []);
+	const teardownFlightSpot = useCallback(() => {
+		const flightSpot = flightSpotRef.current;
+		if (!flightSpot) return;
+		try {
+			if (eventListenersRef.current.length > 0) {
+				naver.maps.Event.removeListener(eventListenersRef.current);
+				eventListenersRef.current = [];
+			}
+			naver.maps.Event.clearInstanceListeners(flightSpot);
+		} catch (error) {
+			console.error("[react-naver-maps-kit] failed to clear flightSpot listeners", error);
+		}
+		flightSpot.setMap(null);
+		flightSpotRef.current = null;
+		onFlightSpotDestroyRef.current?.();
+	}, []);
+	useImperativeHandle(ref, () => ({
+		getInstance: () => flightSpotRef.current,
+		getMap: (...args) => invokeFlightSpotMethod("getMap", ...args),
+		setMap: (...args) => invokeFlightSpotMethod("setMap", ...args)
+	}), [invokeFlightSpotMethod]);
+	useEffect(() => {
+		if (sdkStatus !== "ready" || flightSpotRef.current) return;
+		if (isInPanorama && !panoramaContext?.panorama) return;
+		try {
+			const flightSpot = new naver.maps.FlightSpot();
+			flightSpotRef.current = flightSpot;
+			if (propsRef.current.onPoiClicked) {
+				const listener = naver.maps.Event.addListener(flightSpot, "poi_clicked", (panoId) => {
+					propsRef.current.onPoiClicked?.(panoId);
+				});
+				eventListenersRef.current.push(listener);
+			}
+			if (propsRef.current.visible !== false && targetMap) flightSpot.setMap(targetMap);
+			propsRef.current.onFlightSpotReady?.(flightSpot);
+		} catch (error) {
+			const normalizedError = error instanceof Error ? error : /* @__PURE__ */ new Error("Failed to create naver.maps.FlightSpot instance.");
+			propsRef.current.onFlightSpotError?.(normalizedError);
+		}
+	}, [
+		sdkStatus,
+		isInPanorama,
+		panoramaContext?.panorama,
+		targetMap
+	]);
+	useEffect(() => {
+		const flightSpot = flightSpotRef.current;
+		if (!flightSpot) return;
+		if (props.visible === false) flightSpot.setMap(null);
+		else if (targetMap) flightSpot.setMap(targetMap);
+	}, [props.visible, targetMap]);
+	useEffect(() => {
+		return () => {
+			teardownFlightSpot();
+		};
+	}, [teardownFlightSpot]);
+	return null;
+});
+FlightSpot.displayName = "FlightSpot";
+
+//#endregion
+//#region src/submodules/panorama/AroundControl.tsx
+const AroundControl = forwardRef(function AroundControlInner(props, ref) {
+	const { panorama, sdkStatus, submodules } = usePanorama();
+	if (sdkStatus === "ready" && !submodules.includes("panorama")) throw new Error("AroundControl component requires \"panorama\" submodule. Add submodules={[\"panorama\"]} to your NaverMapProvider.");
+	const aroundControlRef = useRef(null);
+	const onAroundControlDestroyRef = useRef(props.onAroundControlDestroy);
+	const propsRef = useRef(props);
+	useEffect(() => {
+		propsRef.current = props;
+	});
+	useEffect(() => {
+		onAroundControlDestroyRef.current = props.onAroundControlDestroy;
+	}, [props.onAroundControlDestroy]);
+	const invokeAroundControlMethod = useCallback((methodName, ...args) => {
+		const aroundControl = aroundControlRef.current;
+		if (!aroundControl) return void 0;
+		const method = aroundControl[methodName];
+		if (typeof method !== "function") return void 0;
+		return method.apply(aroundControl, args);
+	}, []);
+	const teardownAroundControl = useCallback(() => {
+		const aroundControl = aroundControlRef.current;
+		if (!aroundControl) return;
+		try {
+			naver.maps.Event.clearInstanceListeners(aroundControl);
+		} catch (error) {
+			console.error("[react-naver-maps-kit] failed to clear aroundControl listeners", error);
+		}
+		aroundControl.setMap(null);
+		aroundControlRef.current = null;
+		onAroundControlDestroyRef.current?.();
+	}, []);
+	useImperativeHandle(ref, () => ({
+		getInstance: () => aroundControlRef.current,
+		getElement: (...args) => invokeAroundControlMethod("getElement", ...args),
+		getMap: (...args) => invokeAroundControlMethod("getMap", ...args),
+		getOptions: (...args) => invokeAroundControlMethod("getOptions", ...args),
+		html: (...args) => invokeAroundControlMethod("html", ...args),
+		setMap: (...args) => invokeAroundControlMethod("setMap", ...args),
+		setOptions: (...args) => invokeAroundControlMethod("setOptions", ...args),
+		setPosition: (...args) => invokeAroundControlMethod("setPosition", ...args)
+	}), [invokeAroundControlMethod]);
+	useEffect(() => {
+		if (sdkStatus !== "ready" || !panorama || aroundControlRef.current) return;
+		try {
+			const options = { position: propsRef.current.position ?? naver.maps.Position.TOP_RIGHT };
+			const aroundControl = new naver.maps.AroundControl(options);
+			aroundControlRef.current = aroundControl;
+			if (propsRef.current.visible !== false) aroundControl.setMap(panorama);
+			propsRef.current.onAroundControlReady?.(aroundControl);
+		} catch (error) {
+			const normalizedError = error instanceof Error ? error : /* @__PURE__ */ new Error("Failed to create naver.maps.AroundControl instance.");
+			propsRef.current.onAroundControlError?.(normalizedError);
+		}
+	}, [sdkStatus, panorama]);
+	useEffect(() => {
+		const aroundControl = aroundControlRef.current;
+		if (!aroundControl || !panorama) return;
+		const ctrl = aroundControl;
+		if (props.visible === false) ctrl.setMap(null);
+		else {
+			ctrl.setMap(panorama);
+			if (props.position !== void 0) aroundControl.setPosition(props.position);
+		}
+	}, [
+		props.visible,
+		props.position,
+		panorama
+	]);
+	useEffect(() => {
+		return () => {
+			teardownAroundControl();
+		};
+	}, [teardownAroundControl]);
+	return null;
+});
+AroundControl.displayName = "AroundControl";
+
+//#endregion
+//#region src/submodules/visualization/HeatMap.tsx
+const HeatMap = forwardRef(function HeatMap({ data, opacity, radius, colorMap, colorMapReverse, onHeatMapReady }, ref) {
+	const map = useMap();
+	const heatMapRef = useRef(null);
+	const onHeatMapReadyRef = useRef(onHeatMapReady);
+	onHeatMapReadyRef.current = onHeatMapReady;
+	const normalizeData = useCallback((inputData) => {
+		if (!inputData || inputData.length === 0) return [];
+		const first = inputData[0];
+		if (first instanceof naver.maps.LatLng) return inputData;
+		if (first instanceof naver.maps.visualization.WeightedLocation) return inputData;
+		if (Array.isArray(first)) return inputData;
+		if (typeof first === "object" && "lat" in first && "lng" in first) {
+			const items = inputData;
+			if (items.some((item) => item.weight !== void 0)) return items.map((item) => new naver.maps.visualization.WeightedLocation(item.lat, item.lng, item.weight ?? 1));
+			return items.map((item) => new naver.maps.LatLng(item.lat, item.lng));
+		}
+		return inputData;
+	}, []);
+	useImperativeHandle(ref, () => ({
+		getInstance: () => heatMapRef.current,
+		getMap: () => heatMapRef.current?.getMap() ?? null,
+		setData: (newData) => {
+			heatMapRef.current?.setData(newData);
+		},
+		addData: (newData) => {
+			heatMapRef.current?.addData(newData);
+		},
+		redraw: () => {
+			heatMapRef.current?.redraw();
+		}
+	}), []);
+	useEffect(() => {
+		if (!map) return;
+		if (typeof naver.maps.visualization?.HeatMap !== "function") {
+			console.warn("[HeatMap] visualization 서브모듈이 로드되지 않았습니다. NaverMapProvider에 submodules={['visualization']}을 추가하세요.");
+			return;
+		}
+		let heatMap = null;
+		let listener = null;
+		const createHeatMap = () => {
+			if (heatMapRef.current) return;
+			const normalizedData = normalizeData(data);
+			heatMap = new naver.maps.visualization.HeatMap({
+				map,
+				data: normalizedData,
+				opacity: opacity ?? .6,
+				radius: radius ?? 20,
+				colorMap,
+				colorMapReverse: colorMapReverse ?? false
+			});
+			heatMapRef.current = heatMap;
+			onHeatMapReadyRef.current?.(heatMap);
+		};
+		if (map.isReady) createHeatMap();
+		else listener = naver.maps.Event.addListener(map, "init", createHeatMap);
+		return () => {
+			if (listener) naver.maps.Event.removeListener(listener);
+			if (heatMap) heatMap.setMap(null);
+			heatMapRef.current = null;
+		};
+	}, [map]);
+	useEffect(() => {
+		if (!heatMapRef.current) return;
+		const normalizedData = normalizeData(data);
+		heatMapRef.current.setData(normalizedData);
+		heatMapRef.current.redraw();
+	}, [data, normalizeData]);
+	useEffect(() => {
+		if (!heatMapRef.current || opacity === void 0) return;
+		heatMapRef.current.setOptions({ opacity });
+		heatMapRef.current.redraw();
+	}, [opacity]);
+	useEffect(() => {
+		if (!heatMapRef.current || radius === void 0) return;
+		heatMapRef.current.setOptions({ radius });
+		heatMapRef.current.redraw();
+	}, [radius]);
+	useEffect(() => {
+		if (!heatMapRef.current || colorMap === void 0) return;
+		heatMapRef.current.setOptions({
+			colorMap,
+			colorMapReverse: colorMapReverse ?? false
+		});
+		heatMapRef.current.redraw();
+	}, [colorMap, colorMapReverse]);
+	return null;
+});
+
+//#endregion
+//#region src/submodules/visualization/DotMap.tsx
+const DotMap = forwardRef(function DotMap({ data, opacity, radius, strokeWeight, strokeColor, strokeLineCap, strokeLineJoin, fillColor, onDotMapReady }, ref) {
+	const map = useMap();
+	const dotMapRef = useRef(null);
+	const onDotMapReadyRef = useRef(onDotMapReady);
+	onDotMapReadyRef.current = onDotMapReady;
+	const normalizeData = useCallback((inputData) => {
+		if (!inputData || inputData.length === 0) return [];
+		const first = inputData[0];
+		if (first instanceof naver.maps.LatLng) return inputData;
+		if (Array.isArray(first)) return inputData;
+		if (typeof first === "object" && "lat" in first && "lng" in first) return inputData.map((item) => new naver.maps.LatLng(item.lat, item.lng));
+		return inputData;
+	}, []);
+	useImperativeHandle(ref, () => ({
+		getInstance: () => dotMapRef.current,
+		getMap: () => dotMapRef.current?.getMap() ?? null,
+		setData: (newData) => {
+			dotMapRef.current?.setData(newData);
+		},
+		addData: (newData) => {
+			dotMapRef.current?.addData(newData);
+		},
+		redraw: () => {
+			dotMapRef.current?.redraw();
+		}
+	}), []);
+	useEffect(() => {
+		if (!map) return;
+		if (typeof naver.maps.visualization?.DotMap !== "function") {
+			console.warn("[DotMap] visualization 서브모듈이 로드되지 않았습니다. NaverMapProvider에 submodules={['visualization']}을 추가하세요.");
+			return;
+		}
+		let dotMap = null;
+		let listener = null;
+		const createDotMap = () => {
+			if (dotMapRef.current) return;
+			const normalizedData = normalizeData(data);
+			dotMap = new naver.maps.visualization.DotMap({
+				map,
+				data: normalizedData,
+				opacity: opacity ?? .6,
+				radius: radius ?? 5,
+				strokeWeight: strokeWeight ?? 1,
+				strokeColor: strokeColor ?? "#fff",
+				strokeLineCap: strokeLineCap ?? "round",
+				strokeLineJoin: strokeLineJoin ?? "round",
+				fillColor: fillColor ?? "#ff0000"
+			});
+			dotMapRef.current = dotMap;
+			onDotMapReadyRef.current?.(dotMap);
+		};
+		if (map.isReady) createDotMap();
+		else listener = naver.maps.Event.addListener(map, "init", createDotMap);
+		return () => {
+			if (listener) naver.maps.Event.removeListener(listener);
+			if (dotMap) dotMap.setMap(null);
+			dotMapRef.current = null;
+		};
+	}, [map]);
+	useEffect(() => {
+		if (!dotMapRef.current) return;
+		const normalizedData = normalizeData(data);
+		dotMapRef.current.setData(normalizedData);
+		dotMapRef.current.redraw();
+	}, [data, normalizeData]);
+	useEffect(() => {
+		if (!dotMapRef.current || opacity === void 0) return;
+		dotMapRef.current.setOptions({ opacity });
+		dotMapRef.current.redraw();
+	}, [opacity]);
+	useEffect(() => {
+		if (!dotMapRef.current || radius === void 0) return;
+		dotMapRef.current.setOptions({ radius });
+		dotMapRef.current.redraw();
+	}, [radius]);
+	useEffect(() => {
+		if (!dotMapRef.current) return;
+		dotMapRef.current.setOptions({
+			strokeWeight,
+			strokeColor,
+			strokeLineCap,
+			strokeLineJoin,
+			fillColor
+		});
+		dotMapRef.current.redraw();
+	}, [
+		strokeWeight,
+		strokeColor,
+		strokeLineCap,
+		strokeLineJoin,
+		fillColor
+	]);
+	return null;
+});
+
+//#endregion
+//#region src/submodules/drawing/DrawingManager.tsx
+const DrawingManager = forwardRef(function DrawingManager({ drawingControl, drawingControlOptions, drawingMode, controlPointOptions, rectangleOptions, ellipseOptions, polylineOptions, arrowlineOptions, polygonOptions, markerOptions, onDrawingAdded, onDrawingRemoved, onDrawingSelect, onDrawingStart, onDrawingCanceled, onDrawingManagerReady }, ref) {
+	const map = useMap();
+	const managerRef = useRef(null);
+	const listenersRef = useRef([]);
+	const onDrawingManagerReadyRef = useRef(onDrawingManagerReady);
+	onDrawingManagerReadyRef.current = onDrawingManagerReady;
+	const eventPropsRef = useRef({
+		onDrawingAdded,
+		onDrawingRemoved,
+		onDrawingSelect,
+		onDrawingStart,
+		onDrawingCanceled
+	});
+	eventPropsRef.current = {
+		onDrawingAdded,
+		onDrawingRemoved,
+		onDrawingSelect,
+		onDrawingStart,
+		onDrawingCanceled
+	};
+	useImperativeHandle(ref, () => ({
+		getInstance: () => managerRef.current,
+		getMap: () => managerRef.current?.getMap() ?? null,
+		getDrawings: () => managerRef.current?.getDrawings() ?? {},
+		getDrawing: (id) => managerRef.current?.getDrawing(id),
+		addDrawing: (overlay, mode, id) => {
+			managerRef.current?.addDrawing(overlay, mode, id);
+		},
+		removeDrawing: (overlayOrId) => {
+			managerRef.current?.removeDrawing(overlayOrId);
+		},
+		toGeoJson: () => managerRef.current?.toGeoJson() ?? {},
+		setDrawingMode: (mode) => {
+			managerRef.current?.setOptions({ drawingMode: mode });
+		},
+		getDrawingMode: () => {
+			return managerRef.current?.getOptions("drawingMode");
+		}
+	}), []);
+	useEffect(() => {
+		if (!map) return;
+		if (typeof naver.maps.drawing?.DrawingManager !== "function") {
+			console.warn("[DrawingManager] drawing 서브모듈이 로드되지 않았습니다. NaverMapProvider에 submodules={['drawing']}을 추가하세요.");
+			return;
+		}
+		let manager = null;
+		const createManager = () => {
+			if (managerRef.current) return;
+			const options = { map };
+			if (drawingControl !== void 0) options.drawingControl = drawingControl;
+			if (drawingControlOptions) options.drawingControlOptions = drawingControlOptions;
+			if (drawingMode) options.drawingMode = drawingMode;
+			if (controlPointOptions) options.controlPointOptions = controlPointOptions;
+			if (rectangleOptions) options.rectangleOptions = rectangleOptions;
+			if (ellipseOptions) options.ellipseOptions = ellipseOptions;
+			if (polylineOptions) options.polylineOptions = polylineOptions;
+			if (arrowlineOptions) options.arrowlineOptions = arrowlineOptions;
+			if (polygonOptions) options.polygonOptions = polygonOptions;
+			if (markerOptions) options.markerOptions = markerOptions;
+			manager = new naver.maps.drawing.DrawingManager(options);
+			managerRef.current = manager;
+			const listeners = [];
+			const addedListener = manager.addListener(naver.maps.drawing.DrawingEvents.ADD, (overlay) => {
+				eventPropsRef.current.onDrawingAdded?.(overlay);
+			});
+			listeners.push(addedListener);
+			const removedListener = manager.addListener(naver.maps.drawing.DrawingEvents.REMOVE, (overlay) => {
+				eventPropsRef.current.onDrawingRemoved?.(overlay);
+			});
+			listeners.push(removedListener);
+			const selectListener = manager.addListener(naver.maps.drawing.DrawingEvents.SELECT, (overlay) => {
+				eventPropsRef.current.onDrawingSelect?.(overlay);
+			});
+			listeners.push(selectListener);
+			const startListener = manager.addListener(naver.maps.drawing.DrawingEvents.START, (overlay) => {
+				eventPropsRef.current.onDrawingStart?.(overlay);
+			});
+			listeners.push(startListener);
+			const canceledListener = manager.addListener(naver.maps.drawing.DrawingEvents.CANCLE, (overlay) => {
+				eventPropsRef.current.onDrawingCanceled?.(overlay);
+			});
+			listeners.push(canceledListener);
+			listenersRef.current = listeners;
+			onDrawingManagerReadyRef.current?.(manager);
+		};
+		if (map.isReady) createManager();
+		else {
+			const listener = naver.maps.Event.addListener(map, "init", createManager);
+			return () => {
+				naver.maps.Event.removeListener(listener);
+				listenersRef.current.forEach((l) => naver.maps.Event.removeListener(l));
+				if (manager) manager.destroy();
+				managerRef.current = null;
+			};
+		}
+		return () => {
+			listenersRef.current.forEach((l) => naver.maps.Event.removeListener(l));
+			if (manager) manager.destroy();
+			managerRef.current = null;
+		};
+	}, [map]);
+	useEffect(() => {
+		if (!managerRef.current || drawingMode === void 0) return;
+		managerRef.current.setOptions({ drawingMode });
+	}, [drawingMode]);
+	return null;
+});
+
 //#endregion
 //#region src/index.ts
-const version = "0.0.1";
+const version = "1.3.0";
 
 //#endregion
-export { Circle, ClustererContext, Ellipse, GroundOverlay, InfoWindow, Marker, MarkerClusterer, NaverMap, NaverMapContext, NaverMapProvider, Polygon, Polyline, Rectangle, loadNaverMapsScript, useNaverMap, useNaverMapInstance, version };
+export { AroundControl, Circle, ClustererContext, DotMap, DrawingManager, Ellipse, FlightSpot, GeoJson, Gpx, GroundOverlay, HeatMap, InfoWindow, Kmz, MapInstanceContext, Marker, MarkerClusterer, NaverMap, NaverMapContext, NaverMapProvider, Panorama, PanoramaContext, Polygon, Polyline, Rectangle, loadNaverMapsScript, useMap, useMapInstance, useMapInstanceRequired, useNaverMap, useNaverMapInstance, usePanorama, usePanoramaInstance, version };
 //# sourceMappingURL=index.js.map