react-naver-maps-kit 1.2.0 → 1.3.0

package/dist/index.cjs

@@ -1,5 +1,33 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
 let react = require("react");
+react = __toESM(react);
 let react_jsx_runtime = require("react/jsx-runtime");
 let react_dom = require("react-dom");
 let module$1 = require("module");
@@ -33,27 +61,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;
@@ -78,7 +115,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}"]`);
@@ -96,7 +133,7 @@ function loadNaverMapsScript(options) {
 				restoreAuthFailure();
 			};
 			const handleReady = () => {
-				waitForNaverMapsReady(timeoutMs).then(() => {
+				waitForNaverMapsReady(timeoutMs, options.submodules).then(() => {
 					cleanup();
 					resolve();
 				}).catch((error) => {
@@ -146,7 +183,7 @@ function loadNaverMapsScript(options) {
 		};
 		const onLoad = () => {
 			script.dataset.reactNaverMapsKitLoaded = "true";
-			waitForNaverMapsReady(timeoutMs).then(() => {
+			waitForNaverMapsReady(timeoutMs, options.submodules).then(() => {
 				cleanup();
 				resolve();
 			}).catch((error) => {
@@ -269,13 +306,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__ */ (0, react_jsx_runtime.jsx)(NaverMapContext.Provider, {
 		value,
@@ -283,6 +322,28 @@ function NaverMapProvider({ children, autoLoad = true, onReady, onError, ncpKeyI
 	});
 }
 
+//#endregion
+//#region src/react/context/MapInstanceContext.tsx
+const MapInstanceContext = (0, react.createContext)(null);
+function useMapInstance() {
+	return (0, react.useContext)(MapInstanceContext);
+}
+function useMapInstanceRequired() {
+	const context = (0, react.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 = (0, react.useContext)(MapInstanceContext);
+	if (!context || context.type !== "map") return null;
+	return context.instance;
+}
+function usePanoramaInstance() {
+	const context = (0, react.useContext)(MapInstanceContext);
+	if (!context || context.type !== "panorama") return null;
+	return context.instance;
+}
+
 //#endregion
 //#region src/react/components/NaverMap.tsx
 const MAP_OPTION_KEYS = [
@@ -647,6 +708,7 @@ const NaverMapBase = (0, react.forwardRef)(function NaverMapInner(props, ref) {
 	if (!context) throw new Error("NaverMap must be used inside NaverMapProvider.");
 	const { sdkStatus, setMap, reloadSdk } = context;
 	const [mapReady, setMapReady] = (0, react.useState)(false);
+	const [localMapInstance, setLocalMapInstance] = (0, react.useState)(null);
 	const propsRef = (0, react.useRef)(props);
 	(0, react.useEffect)(() => {
 		propsRef.current = props;
@@ -791,6 +853,7 @@ const NaverMapBase = (0, react.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) => {
@@ -812,6 +875,7 @@ const NaverMapBase = (0, react.forwardRef)(function NaverMapInner(props, ref) {
 			mapRef.current = null;
 			appliedOptionsRef.current = {};
 			setMap(null);
+			setLocalMapInstance(null);
 			setMapReady(false);
 			propsRef.current.onMapDestroy?.();
 		};
@@ -843,15 +907,23 @@ const NaverMapBase = (0, react.forwardRef)(function NaverMapInner(props, ref) {
 		isControlledCenter,
 		isControlledZoom
 	]);
+	const mapInstanceContextValue = (0, react.useMemo)(() => ({
+		instance: localMapInstance,
+		setInstance: setLocalMapInstance,
+		type: "map"
+	}), [localMapInstance]);
 	if (sdkStatus === "error") return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(react_jsx_runtime.Fragment, { children: props.fallback ?? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
 		...divProps,
 		children: "지도를 불러올 수 없습니다."
 	}) });
 	if (sdkStatus === "loading") return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(react_jsx_runtime.Fragment, { children: props.fallback ?? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", { ...divProps }) });
-	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
-		ref: containerRef,
-		...divProps,
-		children: mapReady ? props.children : null
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(MapInstanceContext.Provider, {
+		value: mapInstanceContextValue,
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+			ref: containerRef,
+			...divProps,
+			children: mapReady ? props.children : null
+		})
 	});
 });
 NaverMapBase.displayName = "NaverMap";
@@ -1042,7 +1114,8 @@ function toLatLngLiteral(position) {
 	return null;
 }
 const Marker = (0, react.forwardRef)(function MarkerInner(props, ref) {
-	const { map: contextMap, sdkStatus } = useNaverMap();
+	const { sdkStatus } = useNaverMap();
+	const contextMap = useMapInstance()?.instance;
 	const clustererRegistry = (0, react.useContext)(ClustererContext);
 	const visibleIds = (0, react.useContext)(ClustererVisibilityContext);
 	const isInsideClusterer = clustererRegistry !== null && clustererRegistry.enabled;
@@ -2262,7 +2335,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 = (0, react.useRef)(/* @__PURE__ */ new Map());
 	const [registryVersion, setRegistryVersion] = (0, react.useState)(0);
 	const registry = (0, react.useMemo)(() => ({
@@ -2512,7 +2586,8 @@ function setInfoWindowOptionByKey(infoWindow, key, value) {
 	infoWindow.setOptions(key, value);
 }
 const InfoWindow = (0, react.forwardRef)(function InfoWindowInner(props, ref) {
-	const { map, sdkStatus } = useNaverMap();
+	const { sdkStatus } = useNaverMap();
+	const map = useMapInstance()?.instance;
 	const infoWindowRef = (0, react.useRef)(null);
 	const infoWindowEventListenersRef = (0, react.useRef)([]);
 	const onInfoWindowDestroyRef = (0, react.useRef)(props.onInfoWindowDestroy);
@@ -2786,7 +2861,8 @@ function buildCircleEventBindings(props) {
 	];
 }
 const Circle = (0, react.forwardRef)(function CircleInner(props, ref) {
-	const { map: contextMap, sdkStatus } = useNaverMap();
+	const { sdkStatus } = useNaverMap();
+	const contextMap = useMapInstance()?.instance;
 	const circleRef = (0, react.useRef)(null);
 	const circleEventListenersRef = (0, react.useRef)([]);
 	const onCircleDestroyRef = (0, react.useRef)(props.onCircleDestroy);
@@ -2998,7 +3074,8 @@ function buildEllipseEventBindings(props) {
 	];
 }
 const Ellipse = (0, react.forwardRef)(function EllipseInner(props, ref) {
-	const { map: contextMap, sdkStatus } = useNaverMap();
+	const { sdkStatus } = useNaverMap();
+	const contextMap = useMapInstance()?.instance;
 	const ellipseRef = (0, react.useRef)(null);
 	const ellipseEventListenersRef = (0, react.useRef)([]);
 	const onEllipseDestroyRef = (0, react.useRef)(props.onEllipseDestroy);
@@ -3162,7 +3239,8 @@ function buildGroundOverlayEventBindings(props) {
 	];
 }
 const GroundOverlay = (0, react.forwardRef)(function GroundOverlayInner(props, ref) {
-	const { map: contextMap, sdkStatus } = useNaverMap();
+	const { sdkStatus } = useNaverMap();
+	const contextMap = useMapInstance()?.instance;
 	const groundOverlayRef = (0, react.useRef)(null);
 	const groundOverlayEventListenersRef = (0, react.useRef)([]);
 	const onGroundOverlayDestroyRef = (0, react.useRef)(props.onGroundOverlayDestroy);
@@ -3200,7 +3278,12 @@ const GroundOverlay = (0, react.forwardRef)(function GroundOverlayInner(props, r
 		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]);
 	(0, react.useEffect)(() => {
 		if (sdkStatus !== "ready" || !targetMap || groundOverlayRef.current) return;
@@ -3366,7 +3449,8 @@ function buildPolygonEventBindings(props) {
 	];
 }
 const Polygon = (0, react.forwardRef)(function PolygonInner(props, ref) {
-	const { map: contextMap, sdkStatus } = useNaverMap();
+	const { sdkStatus } = useNaverMap();
+	const contextMap = useMapInstance()?.instance;
 	const polygonRef = (0, react.useRef)(null);
 	const polygonEventListenersRef = (0, react.useRef)([]);
 	const onPolygonDestroyRef = (0, react.useRef)(props.onPolygonDestroy);
@@ -3588,7 +3672,8 @@ function buildPolylineEventBindings(props) {
 	];
 }
 const Polyline = (0, react.forwardRef)(function PolylineInner(props, ref) {
-	const { map: contextMap, sdkStatus } = useNaverMap();
+	const { sdkStatus } = useNaverMap();
+	const contextMap = useMapInstance()?.instance;
 	const polylineRef = (0, react.useRef)(null);
 	const polylineEventListenersRef = (0, react.useRef)([]);
 	const onPolylineDestroyRef = (0, react.useRef)(props.onPolylineDestroy);
@@ -3798,7 +3883,8 @@ function buildRectangleEventBindings(props) {
 	];
 }
 const Rectangle = (0, react.forwardRef)(function RectangleInner(props, ref) {
-	const { map: contextMap, sdkStatus } = useNaverMap();
+	const { sdkStatus } = useNaverMap();
+	const contextMap = useMapInstance()?.instance;
 	const rectangleRef = (0, react.useRef)(null);
 	const rectangleEventListenersRef = (0, react.useRef)([]);
 	const onRectangleDestroyRef = (0, react.useRef)(props.onRectangleDestroy);
@@ -3935,7 +4021,8 @@ function buildGeoJsonEventBindings(props) {
 	];
 }
 const GeoJson = (0, react.forwardRef)(function GeoJsonInner(props, ref) {
-	const { map: contextMap, sdkStatus } = useNaverMap();
+	const { sdkStatus } = useNaverMap();
+	const contextMap = useMapInstance()?.instance;
 	const dataRef = (0, react.useRef)(null);
 	const dataEventListenersRef = (0, react.useRef)([]);
 	const onDataDestroyRef = (0, react.useRef)(props.onDataDestroy);
@@ -4083,7 +4170,8 @@ function parseXml(xmlString) {
 	return doc;
 }
 const Gpx = (0, react.forwardRef)(function GpxInner(props, ref) {
-	const { map: contextMap, sdkStatus } = useNaverMap();
+	const { sdkStatus } = useNaverMap();
+	const contextMap = useMapInstance()?.instance;
 	const dataRef = (0, react.useRef)(null);
 	const dataEventListenersRef = (0, react.useRef)([]);
 	const onDataDestroyRef = (0, react.useRef)(props.onDataDestroy);
@@ -4685,7 +4773,8 @@ function extractKmlFromKmz(arrayBuffer) {
 	return doc;
 }
 const Kmz = (0, react.forwardRef)(function KmzInner(props, ref) {
-	const { map: contextMap, sdkStatus } = useNaverMap();
+	const { sdkStatus } = useNaverMap();
+	const contextMap = useMapInstance()?.instance;
 	const dataRef = (0, react.useRef)(null);
 	const dataEventListenersRef = (0, react.useRef)([]);
 	const onDataDestroyRef = (0, react.useRef)(props.onDataDestroy);
@@ -4797,29 +4886,740 @@ const Kmz = (0, react.forwardRef)(function KmzInner(props, ref) {
 });
 Kmz.displayName = "Kmz";
 
+//#endregion
+//#region src/submodules/panorama/PanoramaContext.ts
+const PanoramaContext = (0, react.createContext)(null);
+function usePanorama() {
+	const value = (0, react.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 = (0, react.forwardRef)(function PanoramaInner(props, ref) {
+	const naverMapContext = NaverMapContext;
+	const context = react.default.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 = (0, react.useRef)(null);
+	const panoramaRef = (0, react.useRef)(null);
+	const eventListenersRef = (0, react.useRef)([]);
+	const onPanoramaDestroyRef = (0, react.useRef)(props.onPanoramaDestroy);
+	const [panoramaInstance, setPanoramaInstance] = (0, react.useState)(null);
+	const [panoramaReady, setPanoramaReady] = (0, react.useState)(false);
+	const propsRef = (0, react.useRef)(props);
+	(0, react.useEffect)(() => {
+		propsRef.current = props;
+	});
+	(0, react.useEffect)(() => {
+		onPanoramaDestroyRef.current = props.onPanoramaDestroy;
+	}, [props.onPanoramaDestroy]);
+	const initialPositionRef = (0, react.useRef)(props.position ?? props.defaultPosition);
+	const initialPovRef = (0, react.useRef)(props.pov ?? props.defaultPov);
+	const isControlledPosition = props.position !== void 0;
+	const isControlledPov = props.pov !== void 0;
+	const optionsSnapshot = (0, react.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 = (0, react.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);
+	}, []);
+	(0, react.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]);
+	(0, react.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]);
+	(0, react.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?.();
+		};
+	}, []);
+	(0, react.useEffect)(() => {
+		const panorama = panoramaRef.current;
+		if (!panorama) return;
+		if (Object.keys(optionsSnapshot).length > 0) panorama.setOptions(optionsSnapshot);
+	}, [optionsSnapshot]);
+	(0, react.useEffect)(() => {
+		const panorama = panoramaRef.current;
+		if (!panorama || !isControlledPosition || props.position === void 0) return;
+		panorama.setPosition(toLatLng(props.position));
+	}, [isControlledPosition, props.position]);
+	(0, react.useEffect)(() => {
+		const panorama = panoramaRef.current;
+		if (!panorama || !isControlledPov || props.pov === void 0) return;
+		panorama.setPov(props.pov);
+	}, [isControlledPov, props.pov]);
+	const panoramaContextValue = (0, react.useMemo)(() => ({
+		panorama: panoramaInstance,
+		setPanorama: setPanoramaInstance,
+		sdkStatus,
+		submodules
+	}), [
+		panoramaInstance,
+		sdkStatus,
+		submodules
+	]);
+	const mapInstanceContextValue = (0, react.useMemo)(() => ({
+		instance: panoramaInstance,
+		setInstance: setPanoramaInstance,
+		type: "panorama"
+	}), [panoramaInstance]);
+	const naverMapContextValue = (0, react.useMemo)(() => ({
+		...context,
+		map: panoramaInstance,
+		setMap: setPanoramaInstance
+	}), [context, panoramaInstance]);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(NaverMapContext.Provider, {
+		value: naverMapContextValue,
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(MapInstanceContext.Provider, {
+			value: mapInstanceContextValue,
+			children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(PanoramaContext.Provider, {
+				value: panoramaContextValue,
+				children: /* @__PURE__ */ (0, react_jsx_runtime.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 = (0, react.forwardRef)(function FlightSpotInner(props, ref) {
+	const { sdkStatus, submodules } = useNaverMap();
+	const contextMap = useMapInstance()?.instance;
+	let panoramaContext = null;
+	try {
+		panoramaContext = usePanorama();
+	} catch {}
+	const flightSpotRef = (0, react.useRef)(null);
+	const eventListenersRef = (0, react.useRef)([]);
+	const onFlightSpotDestroyRef = (0, react.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 = (0, react.useRef)(props);
+	(0, react.useEffect)(() => {
+		propsRef.current = props;
+	});
+	(0, react.useEffect)(() => {
+		onFlightSpotDestroyRef.current = props.onFlightSpotDestroy;
+	}, [props.onFlightSpotDestroy]);
+	const invokeFlightSpotMethod = (0, react.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 = (0, react.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?.();
+	}, []);
+	(0, react.useImperativeHandle)(ref, () => ({
+		getInstance: () => flightSpotRef.current,
+		getMap: (...args) => invokeFlightSpotMethod("getMap", ...args),
+		setMap: (...args) => invokeFlightSpotMethod("setMap", ...args)
+	}), [invokeFlightSpotMethod]);
+	(0, react.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
+	]);
+	(0, react.useEffect)(() => {
+		const flightSpot = flightSpotRef.current;
+		if (!flightSpot) return;
+		if (props.visible === false) flightSpot.setMap(null);
+		else if (targetMap) flightSpot.setMap(targetMap);
+	}, [props.visible, targetMap]);
+	(0, react.useEffect)(() => {
+		return () => {
+			teardownFlightSpot();
+		};
+	}, [teardownFlightSpot]);
+	return null;
+});
+FlightSpot.displayName = "FlightSpot";
+
+//#endregion
+//#region src/submodules/panorama/AroundControl.tsx
+const AroundControl = (0, react.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 = (0, react.useRef)(null);
+	const onAroundControlDestroyRef = (0, react.useRef)(props.onAroundControlDestroy);
+	const propsRef = (0, react.useRef)(props);
+	(0, react.useEffect)(() => {
+		propsRef.current = props;
+	});
+	(0, react.useEffect)(() => {
+		onAroundControlDestroyRef.current = props.onAroundControlDestroy;
+	}, [props.onAroundControlDestroy]);
+	const invokeAroundControlMethod = (0, react.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 = (0, react.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?.();
+	}, []);
+	(0, react.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]);
+	(0, react.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]);
+	(0, react.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
+	]);
+	(0, react.useEffect)(() => {
+		return () => {
+			teardownAroundControl();
+		};
+	}, [teardownAroundControl]);
+	return null;
+});
+AroundControl.displayName = "AroundControl";
+
+//#endregion
+//#region src/submodules/visualization/HeatMap.tsx
+const HeatMap = (0, react.forwardRef)(function HeatMap({ data, opacity, radius, colorMap, colorMapReverse, onHeatMapReady }, ref) {
+	const map = useMap();
+	const heatMapRef = (0, react.useRef)(null);
+	const onHeatMapReadyRef = (0, react.useRef)(onHeatMapReady);
+	onHeatMapReadyRef.current = onHeatMapReady;
+	const normalizeData = (0, react.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;
+	}, []);
+	(0, react.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();
+		}
+	}), []);
+	(0, react.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]);
+	(0, react.useEffect)(() => {
+		if (!heatMapRef.current) return;
+		const normalizedData = normalizeData(data);
+		heatMapRef.current.setData(normalizedData);
+		heatMapRef.current.redraw();
+	}, [data, normalizeData]);
+	(0, react.useEffect)(() => {
+		if (!heatMapRef.current || opacity === void 0) return;
+		heatMapRef.current.setOptions({ opacity });
+		heatMapRef.current.redraw();
+	}, [opacity]);
+	(0, react.useEffect)(() => {
+		if (!heatMapRef.current || radius === void 0) return;
+		heatMapRef.current.setOptions({ radius });
+		heatMapRef.current.redraw();
+	}, [radius]);
+	(0, react.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 = (0, react.forwardRef)(function DotMap({ data, opacity, radius, strokeWeight, strokeColor, strokeLineCap, strokeLineJoin, fillColor, onDotMapReady }, ref) {
+	const map = useMap();
+	const dotMapRef = (0, react.useRef)(null);
+	const onDotMapReadyRef = (0, react.useRef)(onDotMapReady);
+	onDotMapReadyRef.current = onDotMapReady;
+	const normalizeData = (0, react.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;
+	}, []);
+	(0, react.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();
+		}
+	}), []);
+	(0, react.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]);
+	(0, react.useEffect)(() => {
+		if (!dotMapRef.current) return;
+		const normalizedData = normalizeData(data);
+		dotMapRef.current.setData(normalizedData);
+		dotMapRef.current.redraw();
+	}, [data, normalizeData]);
+	(0, react.useEffect)(() => {
+		if (!dotMapRef.current || opacity === void 0) return;
+		dotMapRef.current.setOptions({ opacity });
+		dotMapRef.current.redraw();
+	}, [opacity]);
+	(0, react.useEffect)(() => {
+		if (!dotMapRef.current || radius === void 0) return;
+		dotMapRef.current.setOptions({ radius });
+		dotMapRef.current.redraw();
+	}, [radius]);
+	(0, react.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 = (0, react.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 = (0, react.useRef)(null);
+	const listenersRef = (0, react.useRef)([]);
+	const onDrawingManagerReadyRef = (0, react.useRef)(onDrawingManagerReady);
+	onDrawingManagerReadyRef.current = onDrawingManagerReady;
+	const eventPropsRef = (0, react.useRef)({
+		onDrawingAdded,
+		onDrawingRemoved,
+		onDrawingSelect,
+		onDrawingStart,
+		onDrawingCanceled
+	});
+	eventPropsRef.current = {
+		onDrawingAdded,
+		onDrawingRemoved,
+		onDrawingSelect,
+		onDrawingStart,
+		onDrawingCanceled
+	};
+	(0, react.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");
+		}
+	}), []);
+	(0, react.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]);
+	(0, react.useEffect)(() => {
+		if (!managerRef.current || drawingMode === void 0) return;
+		managerRef.current.setOptions({ drawingMode });
+	}, [drawingMode]);
+	return null;
+});
+
 //#endregion
 //#region src/index.ts
-const version = "1.2.0";
+const version = "1.3.0";
 
 //#endregion
+exports.AroundControl = AroundControl;
 exports.Circle = Circle;
 exports.ClustererContext = ClustererContext;
+exports.DotMap = DotMap;
+exports.DrawingManager = DrawingManager;
 exports.Ellipse = Ellipse;
+exports.FlightSpot = FlightSpot;
 exports.GeoJson = GeoJson;
 exports.Gpx = Gpx;
 exports.GroundOverlay = GroundOverlay;
+exports.HeatMap = HeatMap;
 exports.InfoWindow = InfoWindow;
 exports.Kmz = Kmz;
+exports.MapInstanceContext = MapInstanceContext;
 exports.Marker = Marker;
 exports.MarkerClusterer = MarkerClusterer;
 exports.NaverMap = NaverMap;
 exports.NaverMapContext = NaverMapContext;
 exports.NaverMapProvider = NaverMapProvider;
+exports.Panorama = Panorama;
+exports.PanoramaContext = PanoramaContext;
 exports.Polygon = Polygon;
 exports.Polyline = Polyline;
 exports.Rectangle = Rectangle;
 exports.loadNaverMapsScript = loadNaverMapsScript;
+exports.useMap = useMap;
+exports.useMapInstance = useMapInstance;
+exports.useMapInstanceRequired = useMapInstanceRequired;
 exports.useNaverMap = useNaverMap;
 exports.useNaverMapInstance = useNaverMapInstance;
+exports.usePanorama = usePanorama;
+exports.usePanoramaInstance = usePanoramaInstance;
 exports.version = version;
 //# sourceMappingURL=index.cjs.map