react-naver-maps-kit 1.0.0

package/dist/index.js

@@ -0,0 +1,2631 @@
+import { createContext, forwardRef, memo, useCallback, useContext, useEffect, useImperativeHandle, useLayoutEffect, useMemo, useRef, useState } from "react";
+import { Fragment, jsx } from "react/jsx-runtime";
+import { createPortal } from "react-dom";
+
+//#region src/core/loader/loadNaverMapsScript.ts
+const NAVER_MAPS_SCRIPT_BASE_URL = "https://oapi.map.naver.com/openapi/v3/maps.js";
+let inFlightLoad = null;
+let inFlightScriptUrl = null;
+function getClientKey(options) {
+	if (options.ncpKeyId) return {
+		param: "ncpKeyId",
+		value: options.ncpKeyId
+	};
+	const legacy = [
+		{
+			param: "ncpClientId",
+			value: options.ncpClientId
+		},
+		{
+			param: "govClientId",
+			value: options.govClientId
+		},
+		{
+			param: "finClientId",
+			value: options.finClientId
+		}
+	].find((candidate) => Boolean(candidate.value));
+	if (legacy?.value) return {
+		param: legacy.param,
+		value: legacy.value
+	};
+	throw new Error("loadNaverMapsScript requires ncpKeyId. For backward compatibility, ncpClientId, govClientId, or finClientId can be provided.");
+}
+function isNaverMapsReady() {
+	if (typeof window === "undefined") return false;
+	const browserWindow = window;
+	return Boolean(browserWindow.naver?.maps);
+}
+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()}`;
+}
+function waitForNaverMapsReady(timeoutMs) {
+	return new Promise((resolve, reject) => {
+		if (isNaverMapsReady()) {
+			resolve();
+			return;
+		}
+		const startedAt = Date.now();
+		const intervalId = setInterval(() => {
+			if (isNaverMapsReady()) {
+				clearInterval(intervalId);
+				resolve();
+				return;
+			}
+			if (Date.now() - startedAt >= timeoutMs) {
+				clearInterval(intervalId);
+				reject(/* @__PURE__ */ new Error(`Timed out after ${timeoutMs}ms while waiting for window.naver.maps.`));
+			}
+		}, 50);
+	});
+}
+function attachAuthFailureHandler(reject) {
+	const browserWindow = window;
+	const previousAuthFailure = browserWindow.navermap_authFailure;
+	browserWindow.navermap_authFailure = () => {
+		reject(/* @__PURE__ */ new Error("Naver Maps authentication failed. Check your client key and allowed domains."));
+		if (previousAuthFailure) previousAuthFailure();
+	};
+	return () => {
+		browserWindow.navermap_authFailure = previousAuthFailure;
+	};
+}
+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();
+	const scriptUrl = createScriptUrl(options);
+	if (inFlightLoad && inFlightScriptUrl === scriptUrl) return inFlightLoad;
+	const existingScript = document.querySelector(`script[src="${scriptUrl}"]`);
+	if (existingScript) {
+		const trackedPromise = new Promise((resolve, reject) => {
+			const existingScriptWithState = existingScript;
+			const timeoutMs = options.timeoutMs ?? 1e4;
+			const restoreAuthFailure = attachAuthFailureHandler(reject);
+			const timeoutId = setTimeout(() => {
+				restoreAuthFailure();
+				reject(/* @__PURE__ */ new Error(`Timed out after ${timeoutMs}ms while waiting for Naver Maps script.`));
+			}, timeoutMs);
+			const cleanup = () => {
+				clearTimeout(timeoutId);
+				restoreAuthFailure();
+			};
+			const handleReady = () => {
+				waitForNaverMapsReady(timeoutMs).then(() => {
+					cleanup();
+					resolve();
+				}).catch((error) => {
+					cleanup();
+					reject(error instanceof Error ? error : /* @__PURE__ */ new Error("Naver Maps is not ready."));
+				});
+			};
+			const onLoad = () => {
+				handleReady();
+			};
+			const onError = () => {
+				cleanup();
+				reject(/* @__PURE__ */ new Error("Failed to load Naver Maps script."));
+			};
+			if (existingScript.dataset.reactNaverMapsKitLoaded === "true") {
+				handleReady();
+				return;
+			}
+			if (existingScriptWithState.readyState === "loaded" || existingScriptWithState.readyState === "complete") {
+				handleReady();
+				return;
+			}
+			existingScript.addEventListener("load", onLoad, { once: true });
+			existingScript.addEventListener("error", onError, { once: true });
+		}).finally(() => {
+			inFlightLoad = null;
+			inFlightScriptUrl = null;
+		});
+		inFlightLoad = trackedPromise;
+		inFlightScriptUrl = scriptUrl;
+		return trackedPromise;
+	}
+	const trackedPromise = new Promise((resolve, reject) => {
+		const timeoutMs = options.timeoutMs ?? 1e4;
+		const script = document.createElement("script");
+		const restoreAuthFailure = attachAuthFailureHandler(reject);
+		const timeoutId = setTimeout(() => {
+			cleanup();
+			script.remove();
+			reject(/* @__PURE__ */ new Error(`Timed out after ${timeoutMs}ms while loading Naver Maps script.`));
+		}, timeoutMs);
+		const cleanup = () => {
+			script.removeEventListener("load", onLoad);
+			script.removeEventListener("error", onError);
+			clearTimeout(timeoutId);
+			restoreAuthFailure();
+		};
+		const onLoad = () => {
+			script.dataset.reactNaverMapsKitLoaded = "true";
+			waitForNaverMapsReady(timeoutMs).then(() => {
+				cleanup();
+				resolve();
+			}).catch((error) => {
+				cleanup();
+				reject(error instanceof Error ? error : /* @__PURE__ */ new Error("Naver Maps is not ready."));
+			});
+		};
+		const onError = () => {
+			cleanup();
+			reject(/* @__PURE__ */ new Error("Failed to load Naver Maps script."));
+		};
+		script.src = scriptUrl;
+		script.setAttribute("data-react-naver-maps-kit", "true");
+		script.type = "text/javascript";
+		script.async = true;
+		script.defer = true;
+		if (options.nonce) script.nonce = options.nonce;
+		script.addEventListener("load", onLoad);
+		script.addEventListener("error", onError);
+		document.head.append(script);
+	}).finally(() => {
+		inFlightLoad = null;
+		inFlightScriptUrl = null;
+	});
+	inFlightLoad = trackedPromise;
+	inFlightScriptUrl = scriptUrl;
+	return trackedPromise;
+}
+
+//#endregion
+//#region src/react/provider/NaverMapProvider.tsx
+const NaverMapContext = createContext(null);
+function NaverMapProvider({ children, autoLoad = true, onReady, onError, ncpKeyId, ncpClientId, govClientId, finClientId, submodules, timeoutMs, nonce }) {
+	const [sdkStatus, setSdkStatus] = useState("idle");
+	const [sdkError, setSdkError] = useState(null);
+	const [map, setMap] = useState(null);
+	const mountedRef = useRef(true);
+	const inFlightLoadRef = useRef(null);
+	useEffect(() => {
+		mountedRef.current = true;
+		return () => {
+			mountedRef.current = false;
+		};
+	}, []);
+	useEffect(() => {
+		if (typeof window === "undefined") return;
+		const browserWindow = window;
+		const previousAuthFailure = browserWindow.navermap_authFailure;
+		browserWindow.navermap_authFailure = () => {
+			const error = /* @__PURE__ */ new Error("Naver Maps authentication failed. Check key type (ncpKeyId) and allowed domain settings.");
+			if (mountedRef.current) {
+				setSdkStatus("error");
+				setSdkError(error);
+			}
+			onError?.(error);
+			if (previousAuthFailure) previousAuthFailure();
+		};
+		return () => {
+			browserWindow.navermap_authFailure = previousAuthFailure;
+		};
+	}, [onError]);
+	const reloadSdk = useCallback(async () => {
+		if (inFlightLoadRef.current) return inFlightLoadRef.current;
+		if (mountedRef.current) {
+			setSdkStatus("loading");
+			setSdkError(null);
+		}
+		const loadPromise = loadNaverMapsScript({
+			ncpKeyId,
+			ncpClientId,
+			govClientId,
+			finClientId,
+			submodules,
+			timeoutMs,
+			nonce
+		}).then(() => {
+			if (mountedRef.current) {
+				setSdkStatus("ready");
+				setSdkError(null);
+			}
+			onReady?.();
+		}).catch((error) => {
+			const normalizedError = error instanceof Error ? error : /* @__PURE__ */ new Error("Failed to load Naver Maps SDK.");
+			if (mountedRef.current) {
+				setSdkStatus("error");
+				setSdkError(normalizedError);
+			}
+			onError?.(normalizedError);
+			throw normalizedError;
+		}).finally(() => {
+			inFlightLoadRef.current = null;
+		});
+		inFlightLoadRef.current = loadPromise;
+		return loadPromise;
+	}, [
+		finClientId,
+		govClientId,
+		ncpClientId,
+		ncpKeyId,
+		nonce,
+		onError,
+		onReady,
+		submodules,
+		timeoutMs
+	]);
+	useEffect(() => {
+		if (!autoLoad) return;
+		reloadSdk().catch(() => void 0);
+	}, [autoLoad, reloadSdk]);
+	const clearSdkError = useCallback(() => {
+		if (mountedRef.current) {
+			setSdkError(null);
+			setSdkStatus((current) => current === "error" ? "idle" : current);
+		}
+	}, []);
+	const value = useMemo(() => ({
+		sdkStatus,
+		sdkError,
+		map,
+		setMap,
+		reloadSdk,
+		retrySdk: reloadSdk,
+		clearSdkError
+	}), [
+		clearSdkError,
+		map,
+		reloadSdk,
+		sdkError,
+		sdkStatus
+	]);
+	return /* @__PURE__ */ jsx(NaverMapContext.Provider, {
+		value,
+		children
+	});
+}
+
+//#endregion
+//#region src/react/components/NaverMap.tsx
+const MAP_OPTION_KEYS = [
+	"background",
+	"baseTileOpacity",
+	"bounds",
+	"center",
+	"zoom",
+	"disableDoubleClickZoom",
+	"disableDoubleTapZoom",
+	"disableKineticPan",
+	"disableTwoFingerTapZoom",
+	"draggable",
+	"keyboardShortcuts",
+	"logoControl",
+	"logoControlOptions",
+	"mapDataControl",
+	"mapDataControlOptions",
+	"mapTypeControl",
+	"mapTypeControlOptions",
+	"mapTypeId",
+	"mapTypes",
+	"maxBounds",
+	"maxZoom",
+	"minZoom",
+	"padding",
+	"pinchZoom",
+	"resizeOrigin",
+	"scaleControl",
+	"scaleControlOptions",
+	"scrollWheel",
+	"size",
+	"overlayZoomEffect",
+	"tileSpare",
+	"tileTransition",
+	"tileDuration",
+	"zoomControl",
+	"zoomControlOptions",
+	"zoomOrigin",
+	"blankTileImage",
+	"gl",
+	"customStyleId"
+];
+const MAP_OPTION_KEY_SET = new Set(MAP_OPTION_KEYS);
+const MAP_EVENT_PROP_KEY_SET = new Set([
+	"onAddLayer",
+	"onBoundsChanged",
+	"onCenterChanged",
+	"onCenterPointChanged",
+	"onClick",
+	"onDblClick",
+	"onDoubleTap",
+	"onDrag",
+	"onDragEnd",
+	"onDragStart",
+	"onIdle",
+	"onInit",
+	"onKeyDown",
+	"onKeyUp",
+	"onLongTap",
+	"onMapTypeChanged",
+	"onMapTypeIdChanged",
+	"onMouseDown",
+	"onMouseMove",
+	"onMouseOut",
+	"onMouseOver",
+	"onMouseUp",
+	"onPanning",
+	"onPinch",
+	"onPinchEnd",
+	"onPinchStart",
+	"onProjectionChanged",
+	"onRemoveLayer",
+	"onResize",
+	"onRightClick",
+	"onSingleTap",
+	"onTouchEnd",
+	"onTouchMove",
+	"onTouchStart",
+	"onTwoFingerTap",
+	"onWheel",
+	"onZoomChanged",
+	"onZooming",
+	"onZoomStart"
+]);
+const MAP_EVENT_BINDINGS = [
+	{
+		prop: "onAddLayer",
+		eventName: "addLayer",
+		hasPayload: true
+	},
+	{
+		prop: "onBoundsChanged",
+		eventName: "bounds_changed",
+		hasPayload: true
+	},
+	{
+		prop: "onCenterChanged",
+		eventName: "center_changed",
+		hasPayload: true
+	},
+	{
+		prop: "onCenterPointChanged",
+		eventName: "centerPoint_changed",
+		hasPayload: true
+	},
+	{
+		prop: "onClick",
+		eventName: "click",
+		hasPayload: true
+	},
+	{
+		prop: "onDblClick",
+		eventName: "dblclick",
+		hasPayload: true
+	},
+	{
+		prop: "onDoubleTap",
+		eventName: "doubletap",
+		hasPayload: true
+	},
+	{
+		prop: "onDrag",
+		eventName: "drag",
+		hasPayload: true
+	},
+	{
+		prop: "onDragEnd",
+		eventName: "dragend",
+		hasPayload: true
+	},
+	{
+		prop: "onDragStart",
+		eventName: "dragstart",
+		hasPayload: true
+	},
+	{
+		prop: "onIdle",
+		eventName: "idle",
+		hasPayload: false
+	},
+	{
+		prop: "onInit",
+		eventName: "init",
+		hasPayload: false
+	},
+	{
+		prop: "onKeyDown",
+		eventName: "keydown",
+		hasPayload: true
+	},
+	{
+		prop: "onKeyUp",
+		eventName: "keyup",
+		hasPayload: true
+	},
+	{
+		prop: "onLongTap",
+		eventName: "longtap",
+		hasPayload: true
+	},
+	{
+		prop: "onMapTypeChanged",
+		eventName: "mapType_changed",
+		hasPayload: true
+	},
+	{
+		prop: "onMapTypeIdChanged",
+		eventName: "mapTypeId_changed",
+		hasPayload: true
+	},
+	{
+		prop: "onMouseDown",
+		eventName: "mousedown",
+		hasPayload: true
+	},
+	{
+		prop: "onMouseMove",
+		eventName: "mousemove",
+		hasPayload: true
+	},
+	{
+		prop: "onMouseOut",
+		eventName: "mouseout",
+		hasPayload: true
+	},
+	{
+		prop: "onMouseOver",
+		eventName: "mouseover",
+		hasPayload: true
+	},
+	{
+		prop: "onMouseUp",
+		eventName: "mouseup",
+		hasPayload: true
+	},
+	{
+		prop: "onPanning",
+		eventName: "panning",
+		hasPayload: false
+	},
+	{
+		prop: "onPinch",
+		eventName: "pinch",
+		hasPayload: true
+	},
+	{
+		prop: "onPinchEnd",
+		eventName: "pinchend",
+		hasPayload: true
+	},
+	{
+		prop: "onPinchStart",
+		eventName: "pinchstart",
+		hasPayload: true
+	},
+	{
+		prop: "onProjectionChanged",
+		eventName: "projection_changed",
+		hasPayload: true
+	},
+	{
+		prop: "onRemoveLayer",
+		eventName: "removeLayer",
+		hasPayload: true
+	},
+	{
+		prop: "onResize",
+		eventName: "resize",
+		hasPayload: false
+	},
+	{
+		prop: "onRightClick",
+		eventName: "rightclick",
+		hasPayload: true
+	},
+	{
+		prop: "onSingleTap",
+		eventName: "singletap",
+		hasPayload: true
+	},
+	{
+		prop: "onTouchEnd",
+		eventName: "touchend",
+		hasPayload: true
+	},
+	{
+		prop: "onTouchMove",
+		eventName: "touchmove",
+		hasPayload: true
+	},
+	{
+		prop: "onTouchStart",
+		eventName: "touchstart",
+		hasPayload: true
+	},
+	{
+		prop: "onTwoFingerTap",
+		eventName: "twofingertap",
+		hasPayload: true
+	},
+	{
+		prop: "onWheel",
+		eventName: "wheel",
+		hasPayload: true
+	},
+	{
+		prop: "onZoomChanged",
+		eventName: "zoom_changed",
+		hasPayload: true
+	},
+	{
+		prop: "onZooming",
+		eventName: "zooming",
+		hasPayload: false
+	},
+	{
+		prop: "onZoomStart",
+		eventName: "zoomstart",
+		hasPayload: false
+	}
+];
+const NON_DIV_KEYS = new Set([
+	"onMapReady",
+	"onMapDestroy",
+	"onMapError",
+	"retryOnError",
+	"retryDelayMs",
+	"fallback",
+	"defaultCenter",
+	"defaultZoom",
+	"children"
+]);
+function toCenterSignature(center) {
+	if (!center) return "";
+	if (typeof center === "object") {
+		const candidate = center;
+		const rawLat = candidate.lat;
+		const rawLng = candidate.lng;
+		const lat = typeof rawLat === "function" ? rawLat() : rawLat;
+		const lng = typeof rawLng === "function" ? rawLng() : rawLng;
+		if (typeof lat === "number" && typeof lng === "number") return `latlng:${lat},${lng}`;
+		const rawX = candidate.x;
+		const rawY = candidate.y;
+		const x = typeof rawX === "function" ? rawX() : rawX;
+		const y = typeof rawY === "function" ? rawY() : rawY;
+		if (typeof x === "number" && typeof y === "number") return `xy:${x},${y}`;
+	}
+	return String(center);
+}
+function areValuesEqual(left, right) {
+	if (left === right) return true;
+	if (left === null || right === null || left === void 0 || right === void 0) return false;
+	if (typeof left === "object" && typeof right === "object") {
+		const leftCenter = toCenterSignature(left);
+		const rightCenter = toCenterSignature(right);
+		if (leftCenter !== "" && rightCenter !== "") return leftCenter === rightCenter;
+		return JSON.stringify(left) === JSON.stringify(right);
+	}
+	return false;
+}
+function getChangedOptions(previous, next) {
+	const keys = new Set([...Object.keys(previous), ...Object.keys(next)]);
+	const changed = [];
+	for (const key of keys) {
+		const typedKey = key;
+		const previousValue = previous[typedKey];
+		const nextValue = next[typedKey];
+		if (!areValuesEqual(previousValue, nextValue) && nextValue !== void 0) changed.push([key, nextValue]);
+	}
+	return Object.fromEntries(changed);
+}
+function getDivProps(props) {
+	const entries = [];
+	for (const [key, value] of Object.entries(props)) {
+		if (NON_DIV_KEYS.has(key) || MAP_OPTION_KEY_SET.has(key) || MAP_EVENT_PROP_KEY_SET.has(key)) continue;
+		entries.push([key, value]);
+	}
+	return Object.fromEntries(entries);
+}
+/**
+* memo 비교: children과 함수(콜백)는 skip.
+* - children: React element는 JSON.stringify 불가
+* - 함수: ref를 통해 항상 최신 값을 읽으므로 비교 불필요
+*/
+function areNaverMapPropsEqual(previousProps, nextProps) {
+	const keys = new Set([...Object.keys(previousProps), ...Object.keys(nextProps)]);
+	for (const key of keys) {
+		if (key === "children") continue;
+		const previousValue = previousProps[key];
+		const nextValue = nextProps[key];
+		if (typeof previousValue === "function" && typeof nextValue === "function") continue;
+		if (!areValuesEqual(previousValue, nextValue)) return false;
+	}
+	return true;
+}
+const NaverMapBase = forwardRef(function NaverMapInner(props, ref) {
+	const context = useContext(NaverMapContext);
+	if (!context) throw new Error("NaverMap must be used inside NaverMapProvider.");
+	const { sdkStatus, setMap, reloadSdk } = context;
+	const [mapReady, setMapReady] = useState(false);
+	const propsRef = useRef(props);
+	useEffect(() => {
+		propsRef.current = props;
+	});
+	const initialCenterRef = useRef(props.center ?? props.defaultCenter);
+	const initialZoomRef = useRef(props.zoom ?? props.defaultZoom);
+	const isControlledCenter = props.center !== void 0;
+	const isControlledZoom = props.zoom !== void 0;
+	const mapOptions = useMemo(() => {
+		const entries = [];
+		for (const key of MAP_OPTION_KEYS) {
+			const value = props[key];
+			if (value !== void 0) entries.push([key, value]);
+		}
+		return Object.fromEntries(entries);
+	}, [
+		props.background,
+		props.baseTileOpacity,
+		props.bounds,
+		props.center,
+		props.zoom,
+		props.disableDoubleClickZoom,
+		props.disableDoubleTapZoom,
+		props.disableKineticPan,
+		props.disableTwoFingerTapZoom,
+		props.draggable,
+		props.keyboardShortcuts,
+		props.logoControl,
+		props.logoControlOptions,
+		props.mapDataControl,
+		props.mapDataControlOptions,
+		props.mapTypeControl,
+		props.mapTypeControlOptions,
+		props.mapTypeId,
+		props.mapTypes,
+		props.maxBounds,
+		props.maxZoom,
+		props.minZoom,
+		props.padding,
+		props.pinchZoom,
+		props.resizeOrigin,
+		props.scaleControl,
+		props.scaleControlOptions,
+		props.scrollWheel,
+		props.size,
+		props.overlayZoomEffect,
+		props.tileSpare,
+		props.tileTransition,
+		props.tileDuration,
+		props.zoomControl,
+		props.zoomControlOptions,
+		props.zoomOrigin,
+		props.blankTileImage,
+		props.gl,
+		props.customStyleId
+	]);
+	const divProps = useMemo(() => getDivProps(props), [props]);
+	const containerRef = useRef(null);
+	const mapRef = useRef(null);
+	const appliedOptionsRef = useRef({});
+	const retryTimerRef = useRef(null);
+	const mapOptionsRef = useRef(mapOptions);
+	mapOptionsRef.current = mapOptions;
+	const invokeMapMethod = useCallback((methodName, ...args) => {
+		const mapInstance = mapRef.current;
+		if (!mapInstance) return;
+		const method = mapInstance[methodName];
+		if (typeof method !== "function") return;
+		return method.apply(mapInstance, args);
+	}, []);
+	useImperativeHandle(ref, () => ({
+		getInstance: () => mapRef.current,
+		addOverlayPane: (name, elementOrZIndex) => {
+			mapRef.current?.addOverlayPane?.(name, elementOrZIndex);
+		},
+		addPane: (...args) => invokeMapMethod("addPane", ...args),
+		autoResize: (...args) => invokeMapMethod("autoResize", ...args),
+		destroy: (...args) => {
+			const mapInstance = mapRef.current;
+			if (!mapInstance) return;
+			try {
+				return mapInstance.destroy?.(...args);
+			} catch {
+				return;
+			}
+		},
+		fitBounds: (...args) => invokeMapMethod("fitBounds", ...args),
+		getBounds: (...args) => invokeMapMethod("getBounds", ...args),
+		getCenter: (...args) => invokeMapMethod("getCenter", ...args),
+		getCenterPoint: (...args) => invokeMapMethod("getCenterPoint", ...args),
+		getElement: (...args) => invokeMapMethod("getElement", ...args),
+		getMapTypeId: (...args) => invokeMapMethod("getMapTypeId", ...args),
+		getMaxZoom: (...args) => invokeMapMethod("getMaxZoom", ...args),
+		getMinZoom: (...args) => invokeMapMethod("getMinZoom", ...args),
+		getOptions: (...args) => invokeMapMethod("getOptions", ...args),
+		getPanes: (...args) => invokeMapMethod("getPanes", ...args),
+		getPrimitiveProjection: (...args) => invokeMapMethod("getPrimitiveProjection", ...args),
+		getProjection: (...args) => invokeMapMethod("getProjection", ...args),
+		getSize: (...args) => invokeMapMethod("getSize", ...args),
+		getZoom: (...args) => invokeMapMethod("getZoom", ...args),
+		morph: (...args) => invokeMapMethod("morph", ...args),
+		panBy: (...args) => invokeMapMethod("panBy", ...args),
+		panTo: (...args) => invokeMapMethod("panTo", ...args),
+		panToBounds: (...args) => invokeMapMethod("panToBounds", ...args),
+		refresh: (...args) => invokeMapMethod("refresh", ...args),
+		removeOverlayPane: (name) => {
+			mapRef.current?.removeOverlayPane?.(name);
+		},
+		removePane: (...args) => invokeMapMethod("removePane", ...args),
+		setCenter: (...args) => invokeMapMethod("setCenter", ...args),
+		setCenterPoint: (...args) => invokeMapMethod("setCenterPoint", ...args),
+		setMapTypeId: (...args) => invokeMapMethod("setMapTypeId", ...args),
+		setOptions: (...args) => invokeMapMethod("setOptions", ...args),
+		setSize: (...args) => invokeMapMethod("setSize", ...args),
+		setZoom: (...args) => invokeMapMethod("setZoom", ...args),
+		stop: (...args) => invokeMapMethod("stop", ...args),
+		updateBy: (...args) => invokeMapMethod("updateBy", ...args),
+		zoomBy: (...args) => invokeMapMethod("zoomBy", ...args)
+	}), [invokeMapMethod]);
+	useEffect(() => {
+		if (sdkStatus !== "ready" || !containerRef.current) return;
+		const container = containerRef.current;
+		const initOptions = { ...mapOptionsRef.current };
+		if (initOptions.center === void 0 && initialCenterRef.current !== void 0) initOptions.center = initialCenterRef.current;
+		if (initOptions.zoom === void 0 && initialZoomRef.current !== void 0) initOptions.zoom = initialZoomRef.current;
+		let mapInstance;
+		try {
+			mapInstance = new naver.maps.Map(container, initOptions);
+		} catch (error) {
+			const normalizedError = error instanceof Error ? error : /* @__PURE__ */ new Error("Failed to create naver.maps.Map instance.");
+			propsRef.current.onMapError?.(normalizedError);
+			if (propsRef.current.retryOnError) retryTimerRef.current = setTimeout(() => {
+				reloadSdk().catch(() => void 0);
+			}, propsRef.current.retryDelayMs ?? 1e3);
+			return () => {
+				if (retryTimerRef.current) {
+					clearTimeout(retryTimerRef.current);
+					retryTimerRef.current = null;
+				}
+			};
+		}
+		mapRef.current = mapInstance;
+		appliedOptionsRef.current = initOptions;
+		setMap(mapInstance);
+		setMapReady(true);
+		propsRef.current.onMapReady?.(mapInstance);
+		const listeners = MAP_EVENT_BINDINGS.map((binding) => naver.maps.Event.addListener(mapInstance, binding.eventName, (event) => {
+			const handler = propsRef.current[binding.prop];
+			if (typeof handler !== "function") return;
+			if (binding.hasPayload) handler(event);
+			else handler();
+		}));
+		return () => {
+			try {
+				naver.maps.Event.removeListener(listeners);
+				naver.maps.Event.clearInstanceListeners(mapInstance);
+			} catch {}
+			if (retryTimerRef.current) {
+				clearTimeout(retryTimerRef.current);
+				retryTimerRef.current = null;
+			}
+			container.innerHTML = "";
+			mapRef.current = null;
+			appliedOptionsRef.current = {};
+			setMap(null);
+			setMapReady(false);
+			propsRef.current.onMapDestroy?.();
+		};
+	}, [
+		sdkStatus,
+		setMap,
+		reloadSdk
+	]);
+	useEffect(() => {
+		const mapInstance = mapRef.current;
+		if (!mapInstance) return;
+		const changed = getChangedOptions(appliedOptionsRef.current, mapOptions);
+		if (Object.keys(changed).length === 0) {
+			appliedOptionsRef.current = mapOptions;
+			return;
+		}
+		const { center: changedCenter, zoom: changedZoom, mapTypeId: changedMapTypeId, ...otherChanged } = changed;
+		const savedCenter = !isControlledCenter ? mapInstance.getCenter() : null;
+		const savedZoom = !isControlledZoom ? mapInstance.getZoom() : null;
+		if (Object.keys(otherChanged).length > 0) mapInstance.setOptions(otherChanged);
+		if (changedMapTypeId !== void 0 && mapOptions.mapTypeId !== void 0) mapInstance.setMapTypeId(mapOptions.mapTypeId);
+		if (isControlledCenter && changedCenter !== void 0) mapInstance.setCenter(changedCenter);
+		if (isControlledZoom && changedZoom !== void 0 && mapOptions.zoom !== void 0) mapInstance.setZoom(mapOptions.zoom);
+		if (savedCenter) mapInstance.setCenter(savedCenter);
+		if (savedZoom !== null) mapInstance.setZoom(savedZoom);
+		appliedOptionsRef.current = mapOptions;
+	}, [
+		mapOptions,
+		isControlledCenter,
+		isControlledZoom
+	]);
+	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
+	});
+});
+NaverMapBase.displayName = "NaverMap";
+const NaverMap = memo(NaverMapBase, areNaverMapPropsEqual);
+
+//#endregion
+//#region src/react/hooks/useNaverMap.ts
+function useNaverMap(options = {}) {
+	const context = useContext(NaverMapContext);
+	if (!context) throw new Error("useNaverMap must be used within NaverMapProvider.");
+	if (options.requireReady && context.sdkStatus !== "ready") throw new Error(`Naver Maps SDK is not ready. Current status: ${context.sdkStatus}.`);
+	if (options.requireMapInstance && !context.map) throw new Error("Naver map instance is not available yet.");
+	return context;
+}
+function useNaverMapInstance(options = {}) {
+	return useNaverMap({
+		requireReady: options.requireReady,
+		requireMapInstance: false
+	}).map;
+}
+
+//#endregion
+//#region src/overlays/marker/Marker.tsx
+function pickHtmlIconAnchor(icon) {
+	if ("anchor" in icon) return icon.anchor;
+}
+function pickHtmlIconSize(icon) {
+	if ("size" in icon) return icon.size;
+}
+function resolveMarkerIcon(icon, childrenContainer, hasChildren) {
+	if (!hasChildren || !childrenContainer) return icon;
+	const iconObject = typeof icon === "object" && icon !== null ? icon : void 0;
+	return {
+		content: childrenContainer,
+		anchor: iconObject ? pickHtmlIconAnchor(iconObject) : void 0,
+		size: iconObject ? pickHtmlIconSize(iconObject) : void 0
+	};
+}
+function toMarkerOptions(props, targetMap, icon) {
+	const options = {
+		position: props.position,
+		icon
+	};
+	if (targetMap) options.map = targetMap;
+	if (props.animation !== void 0) options.animation = props.animation;
+	if (props.shape !== void 0) options.shape = props.shape;
+	if (props.title !== void 0) options.title = props.title;
+	if (props.cursor !== void 0) options.cursor = props.cursor;
+	if (props.clickable !== void 0) options.clickable = props.clickable;
+	if (props.draggable !== void 0) options.draggable = props.draggable;
+	if (props.visible !== void 0) options.visible = props.visible;
+	if (props.zIndex !== void 0) options.zIndex = props.zIndex;
+	return options;
+}
+function buildMarkerEventBindings(props) {
+	return [
+		{
+			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: "touchstart",
+			invoke: props.onTouchStart ? (event) => props.onTouchStart?.(event) : void 0
+		},
+		{
+			eventName: "touchend",
+			invoke: props.onTouchEnd ? (event) => props.onTouchEnd?.(event) : void 0
+		},
+		{
+			eventName: "dragstart",
+			invoke: props.onDragStart ? (event) => props.onDragStart?.(event) : void 0
+		},
+		{
+			eventName: "drag",
+			invoke: props.onDrag ? (event) => props.onDrag?.(event) : void 0
+		},
+		{
+			eventName: "dragend",
+			invoke: props.onDragEnd ? (event) => props.onDragEnd?.(event) : void 0
+		},
+		{
+			eventName: "clickable_changed",
+			invoke: props.onClickableChanged ? (event) => props.onClickableChanged?.(event) : void 0
+		},
+		{
+			eventName: "cursor_changed",
+			invoke: props.onCursorChanged ? (event) => props.onCursorChanged?.(event) : void 0
+		},
+		{
+			eventName: "draggable_changed",
+			invoke: props.onDraggableChanged ? (event) => props.onDraggableChanged?.(event) : void 0
+		},
+		{
+			eventName: "icon_changed",
+			invoke: props.onIconChanged ? (event) => props.onIconChanged?.(event) : void 0
+		},
+		{
+			eventName: "icon_loaded",
+			invoke: props.onIconLoaded ? (event) => props.onIconLoaded?.(event) : void 0
+		},
+		{
+			eventName: "position_changed",
+			invoke: props.onPositionChanged ? (event) => props.onPositionChanged?.(event) : void 0
+		},
+		{
+			eventName: "shape_changed",
+			invoke: props.onShapeChanged ? (event) => props.onShapeChanged?.(event) : void 0
+		},
+		{
+			eventName: "title_changed",
+			invoke: props.onTitleChanged ? (event) => props.onTitleChanged?.(event) : void 0
+		},
+		{
+			eventName: "visible_changed",
+			invoke: props.onVisibleChanged ? (event) => props.onVisibleChanged?.(event) : void 0
+		},
+		{
+			eventName: "zIndex_changed",
+			invoke: props.onZIndexChanged ? (event) => props.onZIndexChanged?.(event) : void 0
+		}
+	];
+}
+function bindMarkerEventListeners(marker, 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(marker, binding.eventName, (event) => {
+		binding.invoke?.(event);
+	}));
+}
+const Marker = forwardRef(function MarkerInner(props, ref) {
+	const { map: contextMap, sdkStatus } = useNaverMap();
+	const markerRef = useRef(null);
+	const markerEventListenersRef = useRef([]);
+	const onMarkerDestroyRef = useRef(props.onMarkerDestroy);
+	const [markerDiv, setMarkerDiv] = useState(null);
+	const [portalReady, setPortalReady] = useState(false);
+	const hasChildren = props.children !== void 0 && props.children !== null;
+	const targetMap = props.map ?? contextMap;
+	useEffect(() => {
+		onMarkerDestroyRef.current = props.onMarkerDestroy;
+	}, [props.onMarkerDestroy]);
+	useEffect(() => {
+		if (typeof document === "undefined") return;
+		setMarkerDiv(document.createElement("div"));
+	}, []);
+	useEffect(() => {
+		if (!hasChildren || !markerDiv) {
+			setPortalReady(false);
+			return;
+		}
+		const updateReadyState = () => {
+			setPortalReady(markerDiv.childNodes.length > 0);
+		};
+		updateReadyState();
+		const observer = new MutationObserver(updateReadyState);
+		observer.observe(markerDiv, {
+			childList: true,
+			subtree: true
+		});
+		return () => {
+			observer.disconnect();
+		};
+	}, [hasChildren, markerDiv]);
+	const invokeMarkerMethod = useCallback((methodName, ...args) => {
+		const marker = markerRef.current;
+		if (!marker) return;
+		const method = marker[methodName];
+		if (typeof method !== "function") return;
+		return method.apply(marker, args);
+	}, []);
+	const teardownMarker = useCallback(() => {
+		const marker = markerRef.current;
+		if (!marker) return;
+		try {
+			if (markerEventListenersRef.current.length > 0) {
+				naver.maps.Event.removeListener(markerEventListenersRef.current);
+				markerEventListenersRef.current = [];
+			}
+			naver.maps.Event.clearInstanceListeners(marker);
+		} catch (error) {
+			console.error("[react-naver-maps-kit] failed to clear marker listeners", error);
+		}
+		marker.setMap(null);
+		markerRef.current = null;
+		onMarkerDestroyRef.current?.();
+	}, []);
+	useImperativeHandle(ref, () => ({
+		getInstance: () => markerRef.current,
+		getAnimation: (...args) => invokeMarkerMethod("getAnimation", ...args),
+		getClickable: (...args) => invokeMarkerMethod("getClickable", ...args),
+		getCursor: (...args) => invokeMarkerMethod("getCursor", ...args),
+		getDraggable: (...args) => invokeMarkerMethod("getDraggable", ...args),
+		getDrawingRect: (...args) => invokeMarkerMethod("getDrawingRect", ...args),
+		getElement: (...args) => invokeMarkerMethod("getElement", ...args),
+		getIcon: (...args) => invokeMarkerMethod("getIcon", ...args),
+		getMap: (...args) => invokeMarkerMethod("getMap", ...args),
+		getOptions: (...args) => invokeMarkerMethod("getOptions", ...args),
+		getPanes: (...args) => invokeMarkerMethod("getPanes", ...args),
+		getPosition: (...args) => invokeMarkerMethod("getPosition", ...args),
+		getProjection: (...args) => invokeMarkerMethod("getProjection", ...args),
+		getShape: (...args) => invokeMarkerMethod("getShape", ...args),
+		getTitle: (...args) => invokeMarkerMethod("getTitle", ...args),
+		getVisible: (...args) => invokeMarkerMethod("getVisible", ...args),
+		getZIndex: (...args) => invokeMarkerMethod("getZIndex", ...args),
+		setAnimation: (...args) => invokeMarkerMethod("setAnimation", ...args),
+		setClickable: (...args) => invokeMarkerMethod("setClickable", ...args),
+		setCursor: (...args) => invokeMarkerMethod("setCursor", ...args),
+		setDraggable: (...args) => invokeMarkerMethod("setDraggable", ...args),
+		setIcon: (...args) => invokeMarkerMethod("setIcon", ...args),
+		setMap: (...args) => invokeMarkerMethod("setMap", ...args),
+		setOptions: (...args) => invokeMarkerMethod("setOptions", ...args),
+		setPosition: (...args) => invokeMarkerMethod("setPosition", ...args),
+		setShape: (...args) => invokeMarkerMethod("setShape", ...args),
+		setTitle: (...args) => invokeMarkerMethod("setTitle", ...args),
+		setVisible: (...args) => invokeMarkerMethod("setVisible", ...args),
+		setZIndex: (...args) => invokeMarkerMethod("setZIndex", ...args)
+	}), [invokeMarkerMethod]);
+	useEffect(() => {
+		if (sdkStatus !== "ready" || !targetMap || markerRef.current) return;
+		if (hasChildren && !portalReady) return;
+		try {
+			const resolvedIcon = resolveMarkerIcon(props.icon, markerDiv, hasChildren);
+			const marker = new naver.maps.Marker(toMarkerOptions(props, targetMap, resolvedIcon));
+			markerRef.current = marker;
+			if (props.collisionBehavior !== void 0) marker.setOptions("collisionBehavior", props.collisionBehavior);
+			if (props.collisionBoxSize !== void 0) marker.setOptions("collisionBoxSize", props.collisionBoxSize);
+			bindMarkerEventListeners(marker, markerEventListenersRef, buildMarkerEventBindings(props));
+			props.onMarkerReady?.(marker);
+		} catch (error) {
+			const normalizedError = error instanceof Error ? error : /* @__PURE__ */ new Error("Failed to create naver.maps.Marker instance.");
+			props.onMarkerError?.(normalizedError);
+		}
+	}, [
+		hasChildren,
+		markerDiv,
+		portalReady,
+		props,
+		sdkStatus,
+		targetMap
+	]);
+	useLayoutEffect(() => {
+		const marker = markerRef.current;
+		if (!marker || !targetMap) return;
+		const rafId = requestAnimationFrame(() => {
+			const nextOptions = toMarkerOptions(props, targetMap, hasChildren && portalReady ? resolveMarkerIcon(props.icon, markerDiv, hasChildren) : props.icon);
+			marker.setOptions(nextOptions);
+			if (props.collisionBehavior !== void 0) marker.setOptions("collisionBehavior", props.collisionBehavior);
+			if (props.collisionBoxSize !== void 0) marker.setOptions("collisionBoxSize", props.collisionBoxSize);
+		});
+		return () => {
+			cancelAnimationFrame(rafId);
+		};
+	}, [
+		hasChildren,
+		markerDiv,
+		portalReady,
+		props,
+		targetMap
+	]);
+	useEffect(() => {
+		const marker = markerRef.current;
+		if (!marker) return;
+		bindMarkerEventListeners(marker, markerEventListenersRef, buildMarkerEventBindings(props));
+		return () => {
+			if (markerEventListenersRef.current.length > 0) {
+				naver.maps.Event.removeListener(markerEventListenersRef.current);
+				markerEventListenersRef.current = [];
+			}
+		};
+	}, [props]);
+	useEffect(() => {
+		return () => {
+			teardownMarker();
+		};
+	}, [teardownMarker]);
+	if (!hasChildren || !markerDiv) return null;
+	return createPortal(props.children, markerDiv);
+});
+Marker.displayName = "Marker";
+
+//#endregion
+//#region src/overlays/infowindow/InfoWindow.tsx
+function toInfoWindowOptions(props) {
+	const { anchorColor, anchorSize, anchorSkew, backgroundColor, borderColor, borderWidth, disableAnchor, disableAutoPan, maxWidth, pixelOffset, position, zIndex } = props;
+	const options = {};
+	if (anchorColor !== void 0) options.anchorColor = anchorColor;
+	if (anchorSize !== void 0) options.anchorSize = anchorSize;
+	if (anchorSkew !== void 0) options.anchorSkew = anchorSkew;
+	if (backgroundColor !== void 0) options.backgroundColor = backgroundColor;
+	if (borderColor !== void 0) options.borderColor = borderColor;
+	if (borderWidth !== void 0) options.borderWidth = borderWidth;
+	if (disableAnchor !== void 0) options.disableAnchor = disableAnchor;
+	if (disableAutoPan !== void 0) options.disableAutoPan = disableAutoPan;
+	if (maxWidth !== void 0) options.maxWidth = maxWidth;
+	if (pixelOffset !== void 0) options.pixelOffset = pixelOffset;
+	if (position !== void 0) options.position = position;
+	if (zIndex !== void 0) options.zIndex = zIndex;
+	return options;
+}
+function resolveInfoWindowContent(content, childrenContainer, hasChildren) {
+	if (hasChildren && childrenContainer) return childrenContainer;
+	if (content !== void 0) return content;
+	return "";
+}
+function buildInfoWindowEventBindings(props) {
+	return [
+		{
+			eventName: "open",
+			invoke: props.onOpen ? (event) => props.onOpen?.(event) : void 0
+		},
+		{
+			eventName: "close",
+			invoke: props.onClose ? (event) => props.onClose?.(event) : void 0
+		},
+		{
+			eventName: "anchorColor_changed",
+			invoke: props.onAnchorColorChanged ? (event) => props.onAnchorColorChanged?.(event) : void 0
+		},
+		{
+			eventName: "anchorSize_changed",
+			invoke: props.onAnchorSizeChanged ? (event) => props.onAnchorSizeChanged?.(event) : void 0
+		},
+		{
+			eventName: "anchorSkew_changed",
+			invoke: props.onAnchorSkewChanged ? (event) => props.onAnchorSkewChanged?.(event) : void 0
+		},
+		{
+			eventName: "backgroundColor_changed",
+			invoke: props.onBackgroundColorChanged ? (event) => props.onBackgroundColorChanged?.(event) : void 0
+		},
+		{
+			eventName: "borderColor_changed",
+			invoke: props.onBorderColorChanged ? (event) => props.onBorderColorChanged?.(event) : void 0
+		},
+		{
+			eventName: "borderWidth_changed",
+			invoke: props.onBorderWidthChanged ? (event) => props.onBorderWidthChanged?.(event) : void 0
+		},
+		{
+			eventName: "content_changed",
+			invoke: props.onContentChanged ? (event) => props.onContentChanged?.(event) : void 0
+		},
+		{
+			eventName: "disableAnchor_changed",
+			invoke: props.onDisableAnchorChanged ? (event) => props.onDisableAnchorChanged?.(event) : void 0
+		},
+		{
+			eventName: "disableAutoPan_changed",
+			invoke: props.onDisableAutoPanChanged ? (event) => props.onDisableAutoPanChanged?.(event) : void 0
+		},
+		{
+			eventName: "maxWidth_changed",
+			invoke: props.onMaxWidthChanged ? (event) => props.onMaxWidthChanged?.(event) : void 0
+		},
+		{
+			eventName: "pixelOffset_changed",
+			invoke: props.onPixelOffsetChanged ? (event) => props.onPixelOffsetChanged?.(event) : void 0
+		},
+		{
+			eventName: "position_changed",
+			invoke: props.onPositionChanged ? (event) => props.onPositionChanged?.(event) : void 0
+		},
+		{
+			eventName: "zIndex_changed",
+			invoke: props.onZIndexChanged ? (event) => props.onZIndexChanged?.(event) : void 0
+		}
+	];
+}
+function bindInfoWindowEventListeners(infoWindow, 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(infoWindow, binding.eventName, (event) => {
+		binding.invoke?.(event);
+	}));
+}
+function setInfoWindowOptionByKey(infoWindow, key, value) {
+	infoWindow.setOptions(key, value);
+}
+const InfoWindow = forwardRef(function InfoWindowInner(props, ref) {
+	const { map, sdkStatus } = useNaverMap();
+	const infoWindowRef = useRef(null);
+	const infoWindowEventListenersRef = useRef([]);
+	const onInfoWindowDestroyRef = useRef(props.onInfoWindowDestroy);
+	const childrenContainer = useMemo(() => {
+		if (typeof document === "undefined") return null;
+		return document.createElement("div");
+	}, []);
+	const visible = props.visible ?? true;
+	const hasChildren = props.children !== void 0 && props.children !== null;
+	const optionSnapshot = useMemo(() => toInfoWindowOptions(props), [props]);
+	useEffect(() => {
+		onInfoWindowDestroyRef.current = props.onInfoWindowDestroy;
+	}, [props.onInfoWindowDestroy]);
+	const invokeInfoWindowMethod = useCallback((methodName, ...args) => {
+		const infoWindow = infoWindowRef.current;
+		if (!infoWindow) return;
+		const method = infoWindow[methodName];
+		if (typeof method !== "function") return;
+		return method.apply(infoWindow, args);
+	}, []);
+	const teardownInfoWindow = useCallback(() => {
+		const infoWindow = infoWindowRef.current;
+		if (!infoWindow) return;
+		try {
+			if (infoWindowEventListenersRef.current.length > 0) {
+				naver.maps.Event.removeListener(infoWindowEventListenersRef.current);
+				infoWindowEventListenersRef.current = [];
+			}
+			naver.maps.Event.clearInstanceListeners(infoWindow);
+		} catch (error) {
+			console.error("[react-naver-maps-kit] failed to clear infoWindow listeners", error);
+		}
+		infoWindow.close();
+		infoWindow.setMap(null);
+		infoWindowRef.current = null;
+		onInfoWindowDestroyRef.current?.();
+	}, []);
+	useImperativeHandle(ref, () => ({
+		getInstance: () => infoWindowRef.current,
+		close: (...args) => invokeInfoWindowMethod("close", ...args),
+		getContent: (...args) => invokeInfoWindowMethod("getContent", ...args),
+		getContentElement: (...args) => invokeInfoWindowMethod("getContentElement", ...args),
+		getMap: (...args) => invokeInfoWindowMethod("getMap", ...args),
+		getOptions: (...args) => invokeInfoWindowMethod("getOptions", ...args),
+		getPanes: (...args) => invokeInfoWindowMethod("getPanes", ...args),
+		getPosition: (...args) => invokeInfoWindowMethod("getPosition", ...args),
+		getProjection: (...args) => invokeInfoWindowMethod("getProjection", ...args),
+		getZIndex: (...args) => invokeInfoWindowMethod("getZIndex", ...args),
+		open: (...args) => invokeInfoWindowMethod("open", ...args),
+		setContent: (...args) => invokeInfoWindowMethod("setContent", ...args),
+		setMap: (...args) => invokeInfoWindowMethod("setMap", ...args),
+		setOptions: (...args) => invokeInfoWindowMethod("setOptions", ...args),
+		setPosition: (...args) => invokeInfoWindowMethod("setPosition", ...args),
+		setZIndex: (...args) => invokeInfoWindowMethod("setZIndex", ...args)
+	}), [invokeInfoWindowMethod]);
+	useEffect(() => {
+		if (sdkStatus !== "ready" || !map || infoWindowRef.current) return;
+		try {
+			const infoWindow = new naver.maps.InfoWindow({
+				...optionSnapshot,
+				content: resolveInfoWindowContent(props.content, childrenContainer, hasChildren)
+			});
+			if (props.autoPanPadding !== void 0) setInfoWindowOptionByKey(infoWindow, "autoPanPadding", props.autoPanPadding);
+			infoWindowRef.current = infoWindow;
+			bindInfoWindowEventListeners(infoWindow, infoWindowEventListenersRef, buildInfoWindowEventBindings(props));
+			props.onInfoWindowReady?.(infoWindow);
+		} catch (error) {
+			const normalizedError = error instanceof Error ? error : /* @__PURE__ */ new Error("Failed to create naver.maps.InfoWindow instance.");
+			props.onInfoWindowError?.(normalizedError);
+		}
+	}, [
+		childrenContainer,
+		hasChildren,
+		map,
+		optionSnapshot,
+		props,
+		sdkStatus
+	]);
+	useEffect(() => {
+		const infoWindow = infoWindowRef.current;
+		if (!infoWindow) return;
+		const resolvedContent = resolveInfoWindowContent(props.content, childrenContainer, hasChildren);
+		infoWindow.setOptions({
+			...optionSnapshot,
+			content: resolvedContent
+		});
+		infoWindow.setContent(resolvedContent);
+		if (props.autoPanPadding !== void 0) setInfoWindowOptionByKey(infoWindow, "autoPanPadding", props.autoPanPadding);
+		if (props.position) infoWindow.setPosition(props.position);
+		if (!map || !visible) {
+			infoWindow.close();
+			return;
+		}
+		if (props.anchor) {
+			infoWindow.open(map, props.anchor);
+			return;
+		}
+		if (props.position) {
+			infoWindow.open(map, props.position);
+			return;
+		}
+		infoWindow.open(map);
+	}, [
+		childrenContainer,
+		hasChildren,
+		map,
+		optionSnapshot,
+		props.anchor,
+		props.content,
+		props.position,
+		props.autoPanPadding,
+		visible
+	]);
+	useEffect(() => {
+		const infoWindow = infoWindowRef.current;
+		if (!infoWindow) return;
+		bindInfoWindowEventListeners(infoWindow, infoWindowEventListenersRef, buildInfoWindowEventBindings(props));
+		return () => {
+			if (infoWindowEventListenersRef.current.length > 0) {
+				naver.maps.Event.removeListener(infoWindowEventListenersRef.current);
+				infoWindowEventListenersRef.current = [];
+			}
+		};
+	}, [props]);
+	useEffect(() => {
+		return () => {
+			teardownInfoWindow();
+		};
+	}, [teardownInfoWindow]);
+	if (!hasChildren || !childrenContainer) return null;
+	return createPortal(props.children, childrenContainer);
+});
+InfoWindow.displayName = "InfoWindow";
+
+//#endregion
+//#region src/overlays/shared/overlayUtils.ts
+function bindOverlayEventListeners(target, 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(target, binding.eventName, (event) => {
+		binding.invoke?.(event);
+	}));
+}
+function removeOverlayEventListeners(listeners) {
+	if (listeners.length > 0) naver.maps.Event.removeListener(listeners);
+}
+
+//#endregion
+//#region src/overlays/circle/Circle.tsx
+function toCircleOptions(props, targetMap) {
+	const options = { center: props.center };
+	if (targetMap) options.map = targetMap;
+	if (props.radius !== void 0) options.radius = props.radius;
+	if (props.strokeWeight !== void 0) options.strokeWeight = props.strokeWeight;
+	if (props.strokeOpacity !== void 0) options.strokeOpacity = props.strokeOpacity;
+	if (props.strokeColor !== void 0) options.strokeColor = props.strokeColor;
+	if (props.strokeStyle !== void 0) options.strokeStyle = props.strokeStyle;
+	if (props.strokeLineCap !== void 0) options.strokeLineCap = props.strokeLineCap;
+	if (props.strokeLineJoin !== void 0) options.strokeLineJoin = props.strokeLineJoin;
+	if (props.fillColor !== void 0) options.fillColor = props.fillColor;
+	if (props.fillOpacity !== void 0) options.fillOpacity = props.fillOpacity;
+	if (props.clickable !== void 0) options.clickable = props.clickable;
+	if (props.visible !== void 0) options.visible = props.visible;
+	if (props.zIndex !== void 0) options.zIndex = props.zIndex;
+	return options;
+}
+function buildCircleEventBindings(props) {
+	return [
+		{
+			eventName: "click",
+			invoke: props.onClick ? (event) => props.onClick?.(event) : void 0
+		},
+		{
+			eventName: "dblclick",
+			invoke: props.onDblClick ? (event) => props.onDblClick?.(event) : void 0
+		},
+		{
+			eventName: "mousedown",
+			invoke: props.onMouseDown ? (event) => props.onMouseDown?.(event) : void 0
+		},
+		{
+			eventName: "mousemove",
+			invoke: props.onMouseMove ? (event) => props.onMouseMove?.(event) : void 0
+		},
+		{
+			eventName: "mouseout",
+			invoke: props.onMouseOut ? (event) => props.onMouseOut?.(event) : void 0
+		},
+		{
+			eventName: "mouseover",
+			invoke: props.onMouseOver ? (event) => props.onMouseOver?.(event) : void 0
+		},
+		{
+			eventName: "mouseup",
+			invoke: props.onMouseUp ? (event) => props.onMouseUp?.(event) : void 0
+		},
+		{
+			eventName: "rightclick",
+			invoke: props.onRightClick ? (event) => props.onRightClick?.(event) : void 0
+		},
+		{
+			eventName: "touchstart",
+			invoke: props.onTouchStart ? (event) => props.onTouchStart?.(event) : void 0
+		},
+		{
+			eventName: "touchmove",
+			invoke: props.onTouchMove ? (event) => props.onTouchMove?.(event) : void 0
+		},
+		{
+			eventName: "touchend",
+			invoke: props.onTouchEnd ? (event) => props.onTouchEnd?.(event) : void 0
+		},
+		{
+			eventName: "center_changed",
+			invoke: props.onCenterChanged ? (event) => props.onCenterChanged?.(event) : void 0
+		},
+		{
+			eventName: "clickable_changed",
+			invoke: props.onClickableChanged ? (event) => props.onClickableChanged?.(event) : void 0
+		},
+		{
+			eventName: "fillColor_changed",
+			invoke: props.onFillColorChanged ? (event) => props.onFillColorChanged?.(event) : void 0
+		},
+		{
+			eventName: "fillOpacity_changed",
+			invoke: props.onFillOpacityChanged ? (event) => props.onFillOpacityChanged?.(event) : void 0
+		},
+		{
+			eventName: "map_changed",
+			invoke: props.onMapChanged ? (event) => props.onMapChanged?.(event) : void 0
+		},
+		{
+			eventName: "radius_changed",
+			invoke: props.onRadiusChanged ? (event) => props.onRadiusChanged?.(event) : void 0
+		},
+		{
+			eventName: "strokeColor_changed",
+			invoke: props.onStrokeColorChanged ? (event) => props.onStrokeColorChanged?.(event) : void 0
+		},
+		{
+			eventName: "strokeLineCap_changed",
+			invoke: props.onStrokeLineCapChanged ? (event) => props.onStrokeLineCapChanged?.(event) : void 0
+		},
+		{
+			eventName: "strokeLineJoin_changed",
+			invoke: props.onStrokeLineJoinChanged ? (event) => props.onStrokeLineJoinChanged?.(event) : void 0
+		},
+		{
+			eventName: "strokeOpacity_changed",
+			invoke: props.onStrokeOpacityChanged ? (event) => props.onStrokeOpacityChanged?.(event) : void 0
+		},
+		{
+			eventName: "strokeStyle_changed",
+			invoke: props.onStrokeStyleChanged ? (event) => props.onStrokeStyleChanged?.(event) : void 0
+		},
+		{
+			eventName: "strokeWeight_changed",
+			invoke: props.onStrokeWeightChanged ? (event) => props.onStrokeWeightChanged?.(event) : void 0
+		},
+		{
+			eventName: "visible_changed",
+			invoke: props.onVisibleChanged ? (event) => props.onVisibleChanged?.(event) : void 0
+		},
+		{
+			eventName: "zIndex_changed",
+			invoke: props.onZIndexChanged ? (event) => props.onZIndexChanged?.(event) : void 0
+		}
+	];
+}
+const Circle = forwardRef(function CircleInner(props, ref) {
+	const { map: contextMap, sdkStatus } = useNaverMap();
+	const circleRef = useRef(null);
+	const circleEventListenersRef = useRef([]);
+	const onCircleDestroyRef = useRef(props.onCircleDestroy);
+	const targetMap = props.map ?? contextMap;
+	useEffect(() => {
+		onCircleDestroyRef.current = props.onCircleDestroy;
+	}, [props.onCircleDestroy]);
+	const invokeCircleMethod = useCallback((methodName, ...args) => {
+		const circle = circleRef.current;
+		if (!circle) return;
+		const method = circle[methodName];
+		if (typeof method !== "function") return;
+		return method.apply(circle, args);
+	}, []);
+	const teardownCircle = useCallback(() => {
+		const circle = circleRef.current;
+		if (!circle) return;
+		try {
+			removeOverlayEventListeners(circleEventListenersRef.current);
+			circleEventListenersRef.current = [];
+			naver.maps.Event.clearInstanceListeners(circle);
+		} catch (error) {
+			console.error("[react-naver-maps-kit] failed to clear circle listeners", error);
+		}
+		circle.setMap(null);
+		circleRef.current = null;
+		onCircleDestroyRef.current?.();
+	}, []);
+	useImperativeHandle(ref, () => ({
+		getInstance: () => circleRef.current,
+		getAreaSize: (...args) => invokeCircleMethod("getAreaSize", ...args),
+		getBounds: (...args) => invokeCircleMethod("getBounds", ...args),
+		getCenter: (...args) => invokeCircleMethod("getCenter", ...args),
+		getClickable: (...args) => invokeCircleMethod("getClickable", ...args),
+		getDrawingRect: (...args) => invokeCircleMethod("getDrawingRect", ...args),
+		getElement: (...args) => invokeCircleMethod("getElement", ...args),
+		getMap: (...args) => invokeCircleMethod("getMap", ...args),
+		getOptions: (...args) => invokeCircleMethod("getOptions", ...args),
+		getPanes: (...args) => invokeCircleMethod("getPanes", ...args),
+		getProjection: (...args) => invokeCircleMethod("getProjection", ...args),
+		getRadius: (...args) => invokeCircleMethod("getRadius", ...args),
+		getStyles: (...args) => invokeCircleMethod("getStyles", ...args),
+		getVisible: (...args) => invokeCircleMethod("getVisible", ...args),
+		getZIndex: (...args) => invokeCircleMethod("getZIndex", ...args),
+		setCenter: (...args) => invokeCircleMethod("setCenter", ...args),
+		setClickable: (...args) => invokeCircleMethod("setClickable", ...args),
+		setMap: (...args) => invokeCircleMethod("setMap", ...args),
+		setOptions: (...args) => invokeCircleMethod("setOptions", ...args),
+		setRadius: (...args) => invokeCircleMethod("setRadius", ...args),
+		setStyles: (...args) => invokeCircleMethod("setStyles", ...args),
+		setVisible: (...args) => invokeCircleMethod("setVisible", ...args),
+		setZIndex: (...args) => invokeCircleMethod("setZIndex", ...args)
+	}), [invokeCircleMethod]);
+	useEffect(() => {
+		if (sdkStatus !== "ready" || !targetMap || circleRef.current) return;
+		try {
+			const circle = new naver.maps.Circle(toCircleOptions(props, targetMap));
+			circleRef.current = circle;
+			bindOverlayEventListeners(circle, circleEventListenersRef, buildCircleEventBindings(props));
+			props.onCircleReady?.(circle);
+		} catch (error) {
+			const normalizedError = error instanceof Error ? error : /* @__PURE__ */ new Error("Failed to create naver.maps.Circle instance.");
+			props.onCircleError?.(normalizedError);
+		}
+	}, [
+		props,
+		sdkStatus,
+		targetMap
+	]);
+	useEffect(() => {
+		const circle = circleRef.current;
+		if (!circle || !targetMap) return;
+		circle.setOptions(toCircleOptions(props, targetMap));
+	}, [props, targetMap]);
+	useEffect(() => {
+		const circle = circleRef.current;
+		if (!circle) return;
+		bindOverlayEventListeners(circle, circleEventListenersRef, buildCircleEventBindings(props));
+		return () => {
+			removeOverlayEventListeners(circleEventListenersRef.current);
+			circleEventListenersRef.current = [];
+		};
+	}, [props]);
+	useEffect(() => {
+		return () => {
+			teardownCircle();
+		};
+	}, [teardownCircle]);
+	return null;
+});
+Circle.displayName = "Circle";
+
+//#endregion
+//#region src/overlays/ellipse/Ellipse.tsx
+function toEllipseOptions(props, targetMap) {
+	const options = { bounds: props.bounds };
+	if (targetMap) options.map = targetMap;
+	if (props.strokeWeight !== void 0) options.strokeWeight = props.strokeWeight;
+	if (props.strokeOpacity !== void 0) options.strokeOpacity = props.strokeOpacity;
+	if (props.strokeColor !== void 0) options.strokeColor = props.strokeColor;
+	if (props.strokeStyle !== void 0) options.strokeStyle = props.strokeStyle;
+	if (props.strokeLineCap !== void 0) options.strokeLineCap = props.strokeLineCap;
+	if (props.strokeLineJoin !== void 0) options.strokeLineJoin = props.strokeLineJoin;
+	if (props.fillColor !== void 0) options.fillColor = props.fillColor;
+	if (props.fillOpacity !== void 0) options.fillOpacity = props.fillOpacity;
+	if (props.clickable !== void 0) options.clickable = props.clickable;
+	if (props.visible !== void 0) options.visible = props.visible;
+	if (props.zIndex !== void 0) options.zIndex = props.zIndex;
+	return options;
+}
+function buildEllipseEventBindings(props) {
+	return [
+		{
+			eventName: "click",
+			invoke: props.onClick ? (event) => props.onClick?.(event) : void 0
+		},
+		{
+			eventName: "dblclick",
+			invoke: props.onDblClick ? (event) => props.onDblClick?.(event) : void 0
+		},
+		{
+			eventName: "mousedown",
+			invoke: props.onMouseDown ? (event) => props.onMouseDown?.(event) : void 0
+		},
+		{
+			eventName: "mousemove",
+			invoke: props.onMouseMove ? (event) => props.onMouseMove?.(event) : void 0
+		},
+		{
+			eventName: "mouseout",
+			invoke: props.onMouseOut ? (event) => props.onMouseOut?.(event) : void 0
+		},
+		{
+			eventName: "mouseover",
+			invoke: props.onMouseOver ? (event) => props.onMouseOver?.(event) : void 0
+		},
+		{
+			eventName: "mouseup",
+			invoke: props.onMouseUp ? (event) => props.onMouseUp?.(event) : void 0
+		},
+		{
+			eventName: "rightclick",
+			invoke: props.onRightClick ? (event) => props.onRightClick?.(event) : void 0
+		},
+		{
+			eventName: "touchstart",
+			invoke: props.onTouchStart ? (event) => props.onTouchStart?.(event) : void 0
+		},
+		{
+			eventName: "touchmove",
+			invoke: props.onTouchMove ? (event) => props.onTouchMove?.(event) : void 0
+		},
+		{
+			eventName: "touchend",
+			invoke: props.onTouchEnd ? (event) => props.onTouchEnd?.(event) : void 0
+		},
+		{
+			eventName: "bounds_changed",
+			invoke: props.onBoundsChanged ? (event) => props.onBoundsChanged?.(event) : void 0
+		},
+		{
+			eventName: "clickable_changed",
+			invoke: props.onClickableChanged ? (event) => props.onClickableChanged?.(event) : void 0
+		},
+		{
+			eventName: "fillColor_changed",
+			invoke: props.onFillColorChanged ? (event) => props.onFillColorChanged?.(event) : void 0
+		},
+		{
+			eventName: "fillOpacity_changed",
+			invoke: props.onFillOpacityChanged ? (event) => props.onFillOpacityChanged?.(event) : void 0
+		},
+		{
+			eventName: "map_changed",
+			invoke: props.onMapChanged ? (event) => props.onMapChanged?.(event) : void 0
+		},
+		{
+			eventName: "strokeColor_changed",
+			invoke: props.onStrokeColorChanged ? (event) => props.onStrokeColorChanged?.(event) : void 0
+		},
+		{
+			eventName: "strokeLineCap_changed",
+			invoke: props.onStrokeLineCapChanged ? (event) => props.onStrokeLineCapChanged?.(event) : void 0
+		},
+		{
+			eventName: "strokeLineJoin_changed",
+			invoke: props.onStrokeLineJoinChanged ? (event) => props.onStrokeLineJoinChanged?.(event) : void 0
+		},
+		{
+			eventName: "strokeOpacity_changed",
+			invoke: props.onStrokeOpacityChanged ? (event) => props.onStrokeOpacityChanged?.(event) : void 0
+		},
+		{
+			eventName: "strokeStyle_changed",
+			invoke: props.onStrokeStyleChanged ? (event) => props.onStrokeStyleChanged?.(event) : void 0
+		},
+		{
+			eventName: "strokeWeight_changed",
+			invoke: props.onStrokeWeightChanged ? (event) => props.onStrokeWeightChanged?.(event) : void 0
+		},
+		{
+			eventName: "visible_changed",
+			invoke: props.onVisibleChanged ? (event) => props.onVisibleChanged?.(event) : void 0
+		},
+		{
+			eventName: "zIndex_changed",
+			invoke: props.onZIndexChanged ? (event) => props.onZIndexChanged?.(event) : void 0
+		}
+	];
+}
+const Ellipse = forwardRef(function EllipseInner(props, ref) {
+	const { map: contextMap, sdkStatus } = useNaverMap();
+	const ellipseRef = useRef(null);
+	const ellipseEventListenersRef = useRef([]);
+	const onEllipseDestroyRef = useRef(props.onEllipseDestroy);
+	const targetMap = props.map ?? contextMap;
+	useEffect(() => {
+		onEllipseDestroyRef.current = props.onEllipseDestroy;
+	}, [props.onEllipseDestroy]);
+	const invokeEllipseMethod = useCallback((methodName, ...args) => {
+		const ellipse = ellipseRef.current;
+		if (!ellipse) return;
+		const method = ellipse[methodName];
+		if (typeof method !== "function") return;
+		return method.apply(ellipse, args);
+	}, []);
+	const teardownEllipse = useCallback(() => {
+		const ellipse = ellipseRef.current;
+		if (!ellipse) return;
+		try {
+			removeOverlayEventListeners(ellipseEventListenersRef.current);
+			ellipseEventListenersRef.current = [];
+			naver.maps.Event.clearInstanceListeners(ellipse);
+		} catch (error) {
+			console.error("[react-naver-maps-kit] failed to clear ellipse listeners", error);
+		}
+		ellipse.setMap(null);
+		ellipseRef.current = null;
+		onEllipseDestroyRef.current?.();
+	}, []);
+	useImperativeHandle(ref, () => ({
+		getInstance: () => ellipseRef.current,
+		getAreaSize: (...args) => invokeEllipseMethod("getAreaSize", ...args),
+		getBounds: (...args) => invokeEllipseMethod("getBounds", ...args),
+		getClickable: (...args) => invokeEllipseMethod("getClickable", ...args),
+		getDrawingRect: (...args) => invokeEllipseMethod("getDrawingRect", ...args),
+		getElement: (...args) => invokeEllipseMethod("getElement", ...args),
+		getMap: (...args) => invokeEllipseMethod("getMap", ...args),
+		getOptions: (...args) => invokeEllipseMethod("getOptions", ...args),
+		getPanes: (...args) => invokeEllipseMethod("getPanes", ...args),
+		getProjection: (...args) => invokeEllipseMethod("getProjection", ...args),
+		getStyles: (...args) => invokeEllipseMethod("getStyles", ...args),
+		getVisible: (...args) => invokeEllipseMethod("getVisible", ...args),
+		getZIndex: (...args) => invokeEllipseMethod("getZIndex", ...args),
+		setBounds: (...args) => invokeEllipseMethod("setBounds", ...args),
+		setClickable: (...args) => invokeEllipseMethod("setClickable", ...args),
+		setMap: (...args) => invokeEllipseMethod("setMap", ...args),
+		setOptions: (...args) => invokeEllipseMethod("setOptions", ...args),
+		setStyles: (...args) => invokeEllipseMethod("setStyles", ...args),
+		setVisible: (...args) => invokeEllipseMethod("setVisible", ...args),
+		setZIndex: (...args) => invokeEllipseMethod("setZIndex", ...args)
+	}), [invokeEllipseMethod]);
+	useEffect(() => {
+		if (sdkStatus !== "ready" || !targetMap || ellipseRef.current) return;
+		try {
+			const ellipse = new naver.maps.Ellipse(toEllipseOptions(props, targetMap));
+			ellipseRef.current = ellipse;
+			bindOverlayEventListeners(ellipse, ellipseEventListenersRef, buildEllipseEventBindings(props));
+			props.onEllipseReady?.(ellipse);
+		} catch (error) {
+			const normalizedError = error instanceof Error ? error : /* @__PURE__ */ new Error("Failed to create naver.maps.Ellipse instance.");
+			props.onEllipseError?.(normalizedError);
+		}
+	}, [
+		props,
+		sdkStatus,
+		targetMap
+	]);
+	useEffect(() => {
+		const ellipse = ellipseRef.current;
+		if (!ellipse || !targetMap) return;
+		ellipse.setOptions(toEllipseOptions(props, targetMap));
+	}, [props, targetMap]);
+	useEffect(() => {
+		const ellipse = ellipseRef.current;
+		if (!ellipse) return;
+		bindOverlayEventListeners(ellipse, ellipseEventListenersRef, buildEllipseEventBindings(props));
+		return () => {
+			removeOverlayEventListeners(ellipseEventListenersRef.current);
+			ellipseEventListenersRef.current = [];
+		};
+	}, [props]);
+	useEffect(() => {
+		return () => {
+			teardownEllipse();
+		};
+	}, [teardownEllipse]);
+	return null;
+});
+Ellipse.displayName = "Ellipse";
+
+//#endregion
+//#region src/overlays/ground-overlay/GroundOverlay.tsx
+function toGroundOverlayOptions(props, targetMap) {
+	const options = {};
+	if (targetMap) options.map = targetMap;
+	if (props.clickable !== void 0) options.clickable = props.clickable;
+	if (props.opacity !== void 0) options.opacity = props.opacity;
+	return options;
+}
+function buildGroundOverlayEventBindings(props) {
+	return [
+		{
+			eventName: "click",
+			invoke: props.onClick ? (event) => props.onClick?.(event) : void 0
+		},
+		{
+			eventName: "dblclick",
+			invoke: props.onDblClick ? (event) => props.onDblClick?.(event) : void 0
+		},
+		{
+			eventName: "mousedown",
+			invoke: props.onMouseDown ? (event) => props.onMouseDown?.(event) : void 0
+		},
+		{
+			eventName: "mousemove",
+			invoke: props.onMouseMove ? (event) => props.onMouseMove?.(event) : void 0
+		},
+		{
+			eventName: "mouseout",
+			invoke: props.onMouseOut ? (event) => props.onMouseOut?.(event) : void 0
+		},
+		{
+			eventName: "mouseover",
+			invoke: props.onMouseOver ? (event) => props.onMouseOver?.(event) : void 0
+		},
+		{
+			eventName: "mouseup",
+			invoke: props.onMouseUp ? (event) => props.onMouseUp?.(event) : void 0
+		},
+		{
+			eventName: "rightclick",
+			invoke: props.onRightClick ? (event) => props.onRightClick?.(event) : void 0
+		},
+		{
+			eventName: "touchstart",
+			invoke: props.onTouchStart ? (event) => props.onTouchStart?.(event) : void 0
+		},
+		{
+			eventName: "touchmove",
+			invoke: props.onTouchMove ? (event) => props.onTouchMove?.(event) : void 0
+		},
+		{
+			eventName: "touchend",
+			invoke: props.onTouchEnd ? (event) => props.onTouchEnd?.(event) : void 0
+		},
+		{
+			eventName: "bounds_changed",
+			invoke: props.onBoundsChanged ? (event) => props.onBoundsChanged?.(event) : void 0
+		},
+		{
+			eventName: "clickable_changed",
+			invoke: props.onClickableChanged ? (event) => props.onClickableChanged?.(event) : void 0
+		},
+		{
+			eventName: "map_changed",
+			invoke: props.onMapChanged ? (event) => props.onMapChanged?.(event) : void 0
+		},
+		{
+			eventName: "opacity_changed",
+			invoke: props.onOpacityChanged ? (event) => props.onOpacityChanged?.(event) : void 0
+		}
+	];
+}
+const GroundOverlay = forwardRef(function GroundOverlayInner(props, ref) {
+	const { map: contextMap, sdkStatus } = useNaverMap();
+	const groundOverlayRef = useRef(null);
+	const groundOverlayEventListenersRef = useRef([]);
+	const onGroundOverlayDestroyRef = useRef(props.onGroundOverlayDestroy);
+	const targetMap = props.map ?? contextMap;
+	useEffect(() => {
+		onGroundOverlayDestroyRef.current = props.onGroundOverlayDestroy;
+	}, [props.onGroundOverlayDestroy]);
+	const invokeGroundOverlayMethod = useCallback((methodName, ...args) => {
+		const groundOverlay = groundOverlayRef.current;
+		if (!groundOverlay) return;
+		const method = groundOverlay[methodName];
+		if (typeof method !== "function") return;
+		return method.apply(groundOverlay, args);
+	}, []);
+	const teardownGroundOverlay = useCallback(() => {
+		const groundOverlay = groundOverlayRef.current;
+		if (!groundOverlay) return;
+		try {
+			removeOverlayEventListeners(groundOverlayEventListenersRef.current);
+			groundOverlayEventListenersRef.current = [];
+			naver.maps.Event.clearInstanceListeners(groundOverlay);
+		} catch (error) {
+			console.error("[react-naver-maps-kit] failed to clear ground overlay listeners", error);
+		}
+		groundOverlay.setMap(null);
+		groundOverlayRef.current = null;
+		onGroundOverlayDestroyRef.current?.();
+	}, []);
+	useImperativeHandle(ref, () => ({
+		getInstance: () => groundOverlayRef.current,
+		getBounds: (...args) => invokeGroundOverlayMethod("getBounds", ...args),
+		getMap: (...args) => invokeGroundOverlayMethod("getMap", ...args),
+		getOpacity: (...args) => invokeGroundOverlayMethod("getOpacity", ...args),
+		getPanes: (...args) => invokeGroundOverlayMethod("getPanes", ...args),
+		getProjection: (...args) => invokeGroundOverlayMethod("getProjection", ...args),
+		getUrl: (...args) => invokeGroundOverlayMethod("getUrl", ...args),
+		setMap: (...args) => invokeGroundOverlayMethod("setMap", ...args),
+		setOpacity: (...args) => invokeGroundOverlayMethod("setOpacity", ...args)
+	}), [invokeGroundOverlayMethod]);
+	useEffect(() => {
+		if (sdkStatus !== "ready" || !targetMap || groundOverlayRef.current) return;
+		try {
+			const groundOverlay = new naver.maps.GroundOverlay(props.url, props.bounds, toGroundOverlayOptions(props, targetMap));
+			groundOverlayRef.current = groundOverlay;
+			bindOverlayEventListeners(groundOverlay, groundOverlayEventListenersRef, buildGroundOverlayEventBindings(props));
+			props.onGroundOverlayReady?.(groundOverlay);
+		} catch (error) {
+			const normalizedError = error instanceof Error ? error : /* @__PURE__ */ new Error("Failed to create naver.maps.GroundOverlay instance.");
+			props.onGroundOverlayError?.(normalizedError);
+		}
+	}, [
+		props,
+		sdkStatus,
+		targetMap
+	]);
+	useEffect(() => {
+		const groundOverlay = groundOverlayRef.current;
+		if (!groundOverlay || !targetMap) return;
+		groundOverlay.setMap(targetMap);
+		if (props.opacity !== void 0) groundOverlay.setOpacity(props.opacity);
+		groundOverlay.setOptions?.(toGroundOverlayOptions(props, targetMap));
+	}, [props, targetMap]);
+	useEffect(() => {
+		const groundOverlay = groundOverlayRef.current;
+		if (!groundOverlay) return;
+		bindOverlayEventListeners(groundOverlay, groundOverlayEventListenersRef, buildGroundOverlayEventBindings(props));
+		return () => {
+			removeOverlayEventListeners(groundOverlayEventListenersRef.current);
+			groundOverlayEventListenersRef.current = [];
+		};
+	}, [props]);
+	useEffect(() => {
+		return () => {
+			teardownGroundOverlay();
+		};
+	}, [teardownGroundOverlay]);
+	return null;
+});
+GroundOverlay.displayName = "GroundOverlay";
+
+//#endregion
+//#region src/overlays/polygon/Polygon.tsx
+function toPolygonOptions(props, targetMap) {
+	const options = { paths: props.paths };
+	if (targetMap) options.map = targetMap;
+	if (props.strokeWeight !== void 0) options.strokeWeight = props.strokeWeight;
+	if (props.strokeOpacity !== void 0) options.strokeOpacity = props.strokeOpacity;
+	if (props.strokeColor !== void 0) options.strokeColor = props.strokeColor;
+	if (props.strokeStyle !== void 0) options.strokeStyle = props.strokeStyle;
+	if (props.strokeLineCap !== void 0) options.strokeLineCap = props.strokeLineCap;
+	if (props.strokeLineJoin !== void 0) options.strokeLineJoin = props.strokeLineJoin;
+	if (props.fillColor !== void 0) options.fillColor = props.fillColor;
+	if (props.fillOpacity !== void 0) options.fillOpacity = props.fillOpacity;
+	if (props.clickable !== void 0) options.clickable = props.clickable;
+	if (props.visible !== void 0) options.visible = props.visible;
+	if (props.zIndex !== void 0) options.zIndex = props.zIndex;
+	return options;
+}
+function buildPolygonEventBindings(props) {
+	return [
+		{
+			eventName: "click",
+			invoke: props.onClick ? (event) => props.onClick?.(event) : void 0
+		},
+		{
+			eventName: "dblclick",
+			invoke: props.onDblClick ? (event) => props.onDblClick?.(event) : void 0
+		},
+		{
+			eventName: "mousedown",
+			invoke: props.onMouseDown ? (event) => props.onMouseDown?.(event) : void 0
+		},
+		{
+			eventName: "mousemove",
+			invoke: props.onMouseMove ? (event) => props.onMouseMove?.(event) : void 0
+		},
+		{
+			eventName: "mouseout",
+			invoke: props.onMouseOut ? (event) => props.onMouseOut?.(event) : void 0
+		},
+		{
+			eventName: "mouseover",
+			invoke: props.onMouseOver ? (event) => props.onMouseOver?.(event) : void 0
+		},
+		{
+			eventName: "mouseup",
+			invoke: props.onMouseUp ? (event) => props.onMouseUp?.(event) : void 0
+		},
+		{
+			eventName: "rightclick",
+			invoke: props.onRightClick ? (event) => props.onRightClick?.(event) : void 0
+		},
+		{
+			eventName: "touchstart",
+			invoke: props.onTouchStart ? (event) => props.onTouchStart?.(event) : void 0
+		},
+		{
+			eventName: "touchmove",
+			invoke: props.onTouchMove ? (event) => props.onTouchMove?.(event) : void 0
+		},
+		{
+			eventName: "touchend",
+			invoke: props.onTouchEnd ? (event) => props.onTouchEnd?.(event) : void 0
+		},
+		{
+			eventName: "clickable_changed",
+			invoke: props.onClickableChanged ? (event) => props.onClickableChanged?.(event) : void 0
+		},
+		{
+			eventName: "fillColor_changed",
+			invoke: props.onFillColorChanged ? (event) => props.onFillColorChanged?.(event) : void 0
+		},
+		{
+			eventName: "fillOpacity_changed",
+			invoke: props.onFillOpacityChanged ? (event) => props.onFillOpacityChanged?.(event) : void 0
+		},
+		{
+			eventName: "map_changed",
+			invoke: props.onMapChanged ? (event) => props.onMapChanged?.(event) : void 0
+		},
+		{
+			eventName: "path_changed",
+			invoke: props.onPathChanged ? (event) => props.onPathChanged?.(event) : void 0
+		},
+		{
+			eventName: "paths_changed",
+			invoke: props.onPathsChanged ? (event) => props.onPathsChanged?.(event) : void 0
+		},
+		{
+			eventName: "strokeColor_changed",
+			invoke: props.onStrokeColorChanged ? (event) => props.onStrokeColorChanged?.(event) : void 0
+		},
+		{
+			eventName: "strokeLineCap_changed",
+			invoke: props.onStrokeLineCapChanged ? (event) => props.onStrokeLineCapChanged?.(event) : void 0
+		},
+		{
+			eventName: "strokeLineJoin_changed",
+			invoke: props.onStrokeLineJoinChanged ? (event) => props.onStrokeLineJoinChanged?.(event) : void 0
+		},
+		{
+			eventName: "strokeOpacity_changed",
+			invoke: props.onStrokeOpacityChanged ? (event) => props.onStrokeOpacityChanged?.(event) : void 0
+		},
+		{
+			eventName: "strokeStyle_changed",
+			invoke: props.onStrokeStyleChanged ? (event) => props.onStrokeStyleChanged?.(event) : void 0
+		},
+		{
+			eventName: "strokeWeight_changed",
+			invoke: props.onStrokeWeightChanged ? (event) => props.onStrokeWeightChanged?.(event) : void 0
+		},
+		{
+			eventName: "visible_changed",
+			invoke: props.onVisibleChanged ? (event) => props.onVisibleChanged?.(event) : void 0
+		},
+		{
+			eventName: "zIndex_changed",
+			invoke: props.onZIndexChanged ? (event) => props.onZIndexChanged?.(event) : void 0
+		}
+	];
+}
+const Polygon = forwardRef(function PolygonInner(props, ref) {
+	const { map: contextMap, sdkStatus } = useNaverMap();
+	const polygonRef = useRef(null);
+	const polygonEventListenersRef = useRef([]);
+	const onPolygonDestroyRef = useRef(props.onPolygonDestroy);
+	const targetMap = props.map ?? contextMap;
+	useEffect(() => {
+		onPolygonDestroyRef.current = props.onPolygonDestroy;
+	}, [props.onPolygonDestroy]);
+	const invokePolygonMethod = useCallback((methodName, ...args) => {
+		const polygon = polygonRef.current;
+		if (!polygon) return;
+		const method = polygon[methodName];
+		if (typeof method !== "function") return;
+		return method.apply(polygon, args);
+	}, []);
+	const teardownPolygon = useCallback(() => {
+		const polygon = polygonRef.current;
+		if (!polygon) return;
+		try {
+			removeOverlayEventListeners(polygonEventListenersRef.current);
+			polygonEventListenersRef.current = [];
+			naver.maps.Event.clearInstanceListeners(polygon);
+		} catch (error) {
+			console.error("[react-naver-maps-kit] failed to clear polygon listeners", error);
+		}
+		polygon.setMap(null);
+		polygonRef.current = null;
+		onPolygonDestroyRef.current?.();
+	}, []);
+	useImperativeHandle(ref, () => ({
+		getInstance: () => polygonRef.current,
+		getAreaSize: (...args) => invokePolygonMethod("getAreaSize", ...args),
+		getBounds: (...args) => invokePolygonMethod("getBounds", ...args),
+		getClickable: (...args) => invokePolygonMethod("getClickable", ...args),
+		getDrawingRect: (...args) => invokePolygonMethod("getDrawingRect", ...args),
+		getElement: (...args) => invokePolygonMethod("getElement", ...args),
+		getMap: (...args) => invokePolygonMethod("getMap", ...args),
+		getOptions: (...args) => invokePolygonMethod("getOptions", ...args),
+		getPanes: (...args) => invokePolygonMethod("getPanes", ...args),
+		getPath: (...args) => invokePolygonMethod("getPath", ...args),
+		getPaths: (...args) => invokePolygonMethod("getPaths", ...args),
+		getProjection: (...args) => invokePolygonMethod("getProjection", ...args),
+		getStyles: (...args) => invokePolygonMethod("getStyles", ...args),
+		getVisible: (...args) => invokePolygonMethod("getVisible", ...args),
+		getZIndex: (...args) => invokePolygonMethod("getZIndex", ...args),
+		setClickable: (...args) => invokePolygonMethod("setClickable", ...args),
+		setMap: (...args) => invokePolygonMethod("setMap", ...args),
+		setOptions: (...args) => invokePolygonMethod("setOptions", ...args),
+		setPath: (...args) => invokePolygonMethod("setPath", ...args),
+		setPaths: (...args) => invokePolygonMethod("setPaths", ...args),
+		setStyles: (...args) => invokePolygonMethod("setStyles", ...args),
+		setVisible: (...args) => invokePolygonMethod("setVisible", ...args),
+		setZIndex: (...args) => invokePolygonMethod("setZIndex", ...args)
+	}), [invokePolygonMethod]);
+	useEffect(() => {
+		if (sdkStatus !== "ready" || !targetMap || polygonRef.current) return;
+		try {
+			const polygon = new naver.maps.Polygon(toPolygonOptions(props, targetMap));
+			polygonRef.current = polygon;
+			bindOverlayEventListeners(polygon, polygonEventListenersRef, buildPolygonEventBindings(props));
+			props.onPolygonReady?.(polygon);
+		} catch (error) {
+			const normalizedError = error instanceof Error ? error : /* @__PURE__ */ new Error("Failed to create naver.maps.Polygon instance.");
+			props.onPolygonError?.(normalizedError);
+		}
+	}, [
+		props,
+		sdkStatus,
+		targetMap
+	]);
+	useEffect(() => {
+		const polygon = polygonRef.current;
+		if (!polygon || !targetMap) return;
+		polygon.setOptions(toPolygonOptions(props, targetMap));
+	}, [props, targetMap]);
+	useEffect(() => {
+		const polygon = polygonRef.current;
+		if (!polygon) return;
+		bindOverlayEventListeners(polygon, polygonEventListenersRef, buildPolygonEventBindings(props));
+		return () => {
+			removeOverlayEventListeners(polygonEventListenersRef.current);
+			polygonEventListenersRef.current = [];
+		};
+	}, [props]);
+	useEffect(() => {
+		return () => {
+			teardownPolygon();
+		};
+	}, [teardownPolygon]);
+	return null;
+});
+Polygon.displayName = "Polygon";
+
+//#endregion
+//#region src/overlays/polyline/Polyline.tsx
+function toPolylineOptions(props, targetMap) {
+	const options = { path: props.path };
+	if (targetMap) options.map = targetMap;
+	if (props.strokeWeight !== void 0) options.strokeWeight = props.strokeWeight;
+	if (props.strokeOpacity !== void 0) options.strokeOpacity = props.strokeOpacity;
+	if (props.strokeColor !== void 0) options.strokeColor = props.strokeColor;
+	if (props.strokeStyle !== void 0) options.strokeStyle = props.strokeStyle;
+	if (props.strokeLineCap !== void 0) options.strokeLineCap = props.strokeLineCap;
+	if (props.strokeLineJoin !== void 0) options.strokeLineJoin = props.strokeLineJoin;
+	if (props.clickable !== void 0) options.clickable = props.clickable;
+	if (props.visible !== void 0) options.visible = props.visible;
+	if (props.zIndex !== void 0) options.zIndex = props.zIndex;
+	if (props.startIcon !== void 0) options.startIcon = props.startIcon;
+	if (props.startIconSize !== void 0) options.startIconSize = props.startIconSize;
+	if (props.endIcon !== void 0) options.endIcon = props.endIcon;
+	if (props.endIconSize !== void 0) options.endIconSize = props.endIconSize;
+	return options;
+}
+function buildPolylineEventBindings(props) {
+	return [
+		{
+			eventName: "click",
+			invoke: props.onClick ? (event) => props.onClick?.(event) : void 0
+		},
+		{
+			eventName: "dblclick",
+			invoke: props.onDblClick ? (event) => props.onDblClick?.(event) : void 0
+		},
+		{
+			eventName: "mousedown",
+			invoke: props.onMouseDown ? (event) => props.onMouseDown?.(event) : void 0
+		},
+		{
+			eventName: "mousemove",
+			invoke: props.onMouseMove ? (event) => props.onMouseMove?.(event) : void 0
+		},
+		{
+			eventName: "mouseout",
+			invoke: props.onMouseOut ? (event) => props.onMouseOut?.(event) : void 0
+		},
+		{
+			eventName: "mouseover",
+			invoke: props.onMouseOver ? (event) => props.onMouseOver?.(event) : void 0
+		},
+		{
+			eventName: "mouseup",
+			invoke: props.onMouseUp ? (event) => props.onMouseUp?.(event) : void 0
+		},
+		{
+			eventName: "rightclick",
+			invoke: props.onRightClick ? (event) => props.onRightClick?.(event) : void 0
+		},
+		{
+			eventName: "touchstart",
+			invoke: props.onTouchStart ? (event) => props.onTouchStart?.(event) : void 0
+		},
+		{
+			eventName: "touchmove",
+			invoke: props.onTouchMove ? (event) => props.onTouchMove?.(event) : void 0
+		},
+		{
+			eventName: "touchend",
+			invoke: props.onTouchEnd ? (event) => props.onTouchEnd?.(event) : void 0
+		},
+		{
+			eventName: "clickable_changed",
+			invoke: props.onClickableChanged ? (event) => props.onClickableChanged?.(event) : void 0
+		},
+		{
+			eventName: "endIcon_changed",
+			invoke: props.onEndIconChanged ? (event) => props.onEndIconChanged?.(event) : void 0
+		},
+		{
+			eventName: "endIconSize_changed",
+			invoke: props.onEndIconSizeChanged ? (event) => props.onEndIconSizeChanged?.(event) : void 0
+		},
+		{
+			eventName: "map_changed",
+			invoke: props.onMapChanged ? (event) => props.onMapChanged?.(event) : void 0
+		},
+		{
+			eventName: "path_changed",
+			invoke: props.onPathChanged ? (event) => props.onPathChanged?.(event) : void 0
+		},
+		{
+			eventName: "startIcon_changed",
+			invoke: props.onStartIconChanged ? (event) => props.onStartIconChanged?.(event) : void 0
+		},
+		{
+			eventName: "startIconSize_changed",
+			invoke: props.onStartIconSizeChanged ? (event) => props.onStartIconSizeChanged?.(event) : void 0
+		},
+		{
+			eventName: "strokeColor_changed",
+			invoke: props.onStrokeColorChanged ? (event) => props.onStrokeColorChanged?.(event) : void 0
+		},
+		{
+			eventName: "strokeLineCap_changed",
+			invoke: props.onStrokeLineCapChanged ? (event) => props.onStrokeLineCapChanged?.(event) : void 0
+		},
+		{
+			eventName: "strokeLineJoin_changed",
+			invoke: props.onStrokeLineJoinChanged ? (event) => props.onStrokeLineJoinChanged?.(event) : void 0
+		},
+		{
+			eventName: "strokeOpacity_changed",
+			invoke: props.onStrokeOpacityChanged ? (event) => props.onStrokeOpacityChanged?.(event) : void 0
+		},
+		{
+			eventName: "strokeStyle_changed",
+			invoke: props.onStrokeStyleChanged ? (event) => props.onStrokeStyleChanged?.(event) : void 0
+		},
+		{
+			eventName: "strokeWeight_changed",
+			invoke: props.onStrokeWeightChanged ? (event) => props.onStrokeWeightChanged?.(event) : void 0
+		},
+		{
+			eventName: "visible_changed",
+			invoke: props.onVisibleChanged ? (event) => props.onVisibleChanged?.(event) : void 0
+		},
+		{
+			eventName: "zIndex_changed",
+			invoke: props.onZIndexChanged ? (event) => props.onZIndexChanged?.(event) : void 0
+		}
+	];
+}
+const Polyline = forwardRef(function PolylineInner(props, ref) {
+	const { map: contextMap, sdkStatus } = useNaverMap();
+	const polylineRef = useRef(null);
+	const polylineEventListenersRef = useRef([]);
+	const onPolylineDestroyRef = useRef(props.onPolylineDestroy);
+	const targetMap = props.map ?? contextMap;
+	useEffect(() => {
+		onPolylineDestroyRef.current = props.onPolylineDestroy;
+	}, [props.onPolylineDestroy]);
+	const invokePolylineMethod = useCallback((methodName, ...args) => {
+		const polyline = polylineRef.current;
+		if (!polyline) return;
+		const method = polyline[methodName];
+		if (typeof method !== "function") return;
+		return method.apply(polyline, args);
+	}, []);
+	const teardownPolyline = useCallback(() => {
+		const polyline = polylineRef.current;
+		if (!polyline) return;
+		try {
+			removeOverlayEventListeners(polylineEventListenersRef.current);
+			polylineEventListenersRef.current = [];
+			naver.maps.Event.clearInstanceListeners(polyline);
+		} catch (error) {
+			console.error("[react-naver-maps-kit] failed to clear polyline listeners", error);
+		}
+		polyline.setMap(null);
+		polylineRef.current = null;
+		onPolylineDestroyRef.current?.();
+	}, []);
+	useImperativeHandle(ref, () => ({
+		getInstance: () => polylineRef.current,
+		getBounds: (...args) => invokePolylineMethod("getBounds", ...args),
+		getClickable: (...args) => invokePolylineMethod("getClickable", ...args),
+		getDistance: (...args) => invokePolylineMethod("getDistance", ...args),
+		getDrawingRect: (...args) => invokePolylineMethod("getDrawingRect", ...args),
+		getElement: (...args) => invokePolylineMethod("getElement", ...args),
+		getMap: (...args) => invokePolylineMethod("getMap", ...args),
+		getOptions: (...args) => invokePolylineMethod("getOptions", ...args),
+		getPanes: (...args) => invokePolylineMethod("getPanes", ...args),
+		getPath: (...args) => invokePolylineMethod("getPath", ...args),
+		getProjection: (...args) => invokePolylineMethod("getProjection", ...args),
+		getStyles: (...args) => invokePolylineMethod("getStyles", ...args),
+		getVisible: (...args) => invokePolylineMethod("getVisible", ...args),
+		getZIndex: (...args) => invokePolylineMethod("getZIndex", ...args),
+		setClickable: (...args) => invokePolylineMethod("setClickable", ...args),
+		setMap: (...args) => invokePolylineMethod("setMap", ...args),
+		setOptions: (...args) => invokePolylineMethod("setOptions", ...args),
+		setPath: (...args) => invokePolylineMethod("setPath", ...args),
+		setStyles: (...args) => invokePolylineMethod("setStyles", ...args),
+		setVisible: (...args) => invokePolylineMethod("setVisible", ...args),
+		setZIndex: (...args) => invokePolylineMethod("setZIndex", ...args)
+	}), [invokePolylineMethod]);
+	useEffect(() => {
+		if (sdkStatus !== "ready" || !targetMap || polylineRef.current) return;
+		try {
+			const polyline = new naver.maps.Polyline(toPolylineOptions(props, targetMap));
+			polylineRef.current = polyline;
+			bindOverlayEventListeners(polyline, polylineEventListenersRef, buildPolylineEventBindings(props));
+			props.onPolylineReady?.(polyline);
+		} catch (error) {
+			const normalizedError = error instanceof Error ? error : /* @__PURE__ */ new Error("Failed to create naver.maps.Polyline instance.");
+			props.onPolylineError?.(normalizedError);
+		}
+	}, [
+		props,
+		sdkStatus,
+		targetMap
+	]);
+	useEffect(() => {
+		const polyline = polylineRef.current;
+		if (!polyline || !targetMap) return;
+		polyline.setOptions(toPolylineOptions(props, targetMap));
+	}, [props, targetMap]);
+	useEffect(() => {
+		const polyline = polylineRef.current;
+		if (!polyline) return;
+		bindOverlayEventListeners(polyline, polylineEventListenersRef, buildPolylineEventBindings(props));
+		return () => {
+			removeOverlayEventListeners(polylineEventListenersRef.current);
+			polylineEventListenersRef.current = [];
+		};
+	}, [props]);
+	useEffect(() => {
+		return () => {
+			teardownPolyline();
+		};
+	}, [teardownPolyline]);
+	return null;
+});
+Polyline.displayName = "Polyline";
+
+//#endregion
+//#region src/overlays/rectangle/Rectangle.tsx
+function toRectangleOptions(props, targetMap) {
+	const options = { bounds: props.bounds };
+	if (targetMap) options.map = targetMap;
+	if (props.strokeWeight !== void 0) options.strokeWeight = props.strokeWeight;
+	if (props.strokeOpacity !== void 0) options.strokeOpacity = props.strokeOpacity;
+	if (props.strokeColor !== void 0) options.strokeColor = props.strokeColor;
+	if (props.strokeStyle !== void 0) options.strokeStyle = props.strokeStyle;
+	if (props.strokeLineCap !== void 0) options.strokeLineCap = props.strokeLineCap;
+	if (props.strokeLineJoin !== void 0) options.strokeLineJoin = props.strokeLineJoin;
+	if (props.fillColor !== void 0) options.fillColor = props.fillColor;
+	if (props.fillOpacity !== void 0) options.fillOpacity = props.fillOpacity;
+	if (props.clickable !== void 0) options.clickable = props.clickable;
+	if (props.visible !== void 0) options.visible = props.visible;
+	if (props.zIndex !== void 0) options.zIndex = props.zIndex;
+	return options;
+}
+function buildRectangleEventBindings(props) {
+	return [
+		{
+			eventName: "click",
+			invoke: props.onClick ? (event) => props.onClick?.(event) : void 0
+		},
+		{
+			eventName: "dblclick",
+			invoke: props.onDblClick ? (event) => props.onDblClick?.(event) : void 0
+		},
+		{
+			eventName: "mousedown",
+			invoke: props.onMouseDown ? (event) => props.onMouseDown?.(event) : void 0
+		},
+		{
+			eventName: "mousemove",
+			invoke: props.onMouseMove ? (event) => props.onMouseMove?.(event) : void 0
+		},
+		{
+			eventName: "mouseout",
+			invoke: props.onMouseOut ? (event) => props.onMouseOut?.(event) : void 0
+		},
+		{
+			eventName: "mouseover",
+			invoke: props.onMouseOver ? (event) => props.onMouseOver?.(event) : void 0
+		},
+		{
+			eventName: "mouseup",
+			invoke: props.onMouseUp ? (event) => props.onMouseUp?.(event) : void 0
+		},
+		{
+			eventName: "rightclick",
+			invoke: props.onRightClick ? (event) => props.onRightClick?.(event) : void 0
+		},
+		{
+			eventName: "touchstart",
+			invoke: props.onTouchStart ? (event) => props.onTouchStart?.(event) : void 0
+		},
+		{
+			eventName: "touchmove",
+			invoke: props.onTouchMove ? (event) => props.onTouchMove?.(event) : void 0
+		},
+		{
+			eventName: "touchend",
+			invoke: props.onTouchEnd ? (event) => props.onTouchEnd?.(event) : void 0
+		},
+		{
+			eventName: "bounds_changed",
+			invoke: props.onBoundsChanged ? (event) => props.onBoundsChanged?.(event) : void 0
+		},
+		{
+			eventName: "clickable_changed",
+			invoke: props.onClickableChanged ? (event) => props.onClickableChanged?.(event) : void 0
+		},
+		{
+			eventName: "fillColor_changed",
+			invoke: props.onFillColorChanged ? (event) => props.onFillColorChanged?.(event) : void 0
+		},
+		{
+			eventName: "fillOpacity_changed",
+			invoke: props.onFillOpacityChanged ? (event) => props.onFillOpacityChanged?.(event) : void 0
+		},
+		{
+			eventName: "map_changed",
+			invoke: props.onMapChanged ? (event) => props.onMapChanged?.(event) : void 0
+		},
+		{
+			eventName: "strokeColor_changed",
+			invoke: props.onStrokeColorChanged ? (event) => props.onStrokeColorChanged?.(event) : void 0
+		},
+		{
+			eventName: "strokeLineCap_changed",
+			invoke: props.onStrokeLineCapChanged ? (event) => props.onStrokeLineCapChanged?.(event) : void 0
+		},
+		{
+			eventName: "strokeLineJoin_changed",
+			invoke: props.onStrokeLineJoinChanged ? (event) => props.onStrokeLineJoinChanged?.(event) : void 0
+		},
+		{
+			eventName: "strokeOpacity_changed",
+			invoke: props.onStrokeOpacityChanged ? (event) => props.onStrokeOpacityChanged?.(event) : void 0
+		},
+		{
+			eventName: "strokeStyle_changed",
+			invoke: props.onStrokeStyleChanged ? (event) => props.onStrokeStyleChanged?.(event) : void 0
+		},
+		{
+			eventName: "strokeWeight_changed",
+			invoke: props.onStrokeWeightChanged ? (event) => props.onStrokeWeightChanged?.(event) : void 0
+		},
+		{
+			eventName: "visible_changed",
+			invoke: props.onVisibleChanged ? (event) => props.onVisibleChanged?.(event) : void 0
+		},
+		{
+			eventName: "zIndex_changed",
+			invoke: props.onZIndexChanged ? (event) => props.onZIndexChanged?.(event) : void 0
+		}
+	];
+}
+const Rectangle = forwardRef(function RectangleInner(props, ref) {
+	const { map: contextMap, sdkStatus } = useNaverMap();
+	const rectangleRef = useRef(null);
+	const rectangleEventListenersRef = useRef([]);
+	const onRectangleDestroyRef = useRef(props.onRectangleDestroy);
+	const targetMap = props.map ?? contextMap;
+	useEffect(() => {
+		onRectangleDestroyRef.current = props.onRectangleDestroy;
+	}, [props.onRectangleDestroy]);
+	const invokeRectangleMethod = useCallback((methodName, ...args) => {
+		const rectangle = rectangleRef.current;
+		if (!rectangle) return;
+		const method = rectangle[methodName];
+		if (typeof method !== "function") return;
+		return method.apply(rectangle, args);
+	}, []);
+	const teardownRectangle = useCallback(() => {
+		const rectangle = rectangleRef.current;
+		if (!rectangle) return;
+		try {
+			removeOverlayEventListeners(rectangleEventListenersRef.current);
+			rectangleEventListenersRef.current = [];
+			naver.maps.Event.clearInstanceListeners(rectangle);
+		} catch (error) {
+			console.error("[react-naver-maps-kit] failed to clear rectangle listeners", error);
+		}
+		rectangle.setMap(null);
+		rectangleRef.current = null;
+		onRectangleDestroyRef.current?.();
+	}, []);
+	useImperativeHandle(ref, () => ({
+		getInstance: () => rectangleRef.current,
+		getAreaSize: (...args) => invokeRectangleMethod("getAreaSize", ...args),
+		getBounds: (...args) => invokeRectangleMethod("getBounds", ...args),
+		getClickable: (...args) => invokeRectangleMethod("getClickable", ...args),
+		getDrawingRect: (...args) => invokeRectangleMethod("getDrawingRect", ...args),
+		getElement: (...args) => invokeRectangleMethod("getElement", ...args),
+		getMap: (...args) => invokeRectangleMethod("getMap", ...args),
+		getOptions: (...args) => invokeRectangleMethod("getOptions", ...args),
+		getPanes: (...args) => invokeRectangleMethod("getPanes", ...args),
+		getProjection: (...args) => invokeRectangleMethod("getProjection", ...args),
+		getStyles: (...args) => invokeRectangleMethod("getStyles", ...args),
+		getVisible: (...args) => invokeRectangleMethod("getVisible", ...args),
+		getZIndex: (...args) => invokeRectangleMethod("getZIndex", ...args),
+		setBounds: (...args) => invokeRectangleMethod("setBounds", ...args),
+		setClickable: (...args) => invokeRectangleMethod("setClickable", ...args),
+		setMap: (...args) => invokeRectangleMethod("setMap", ...args),
+		setOptions: (...args) => invokeRectangleMethod("setOptions", ...args),
+		setStyles: (...args) => invokeRectangleMethod("setStyles", ...args),
+		setVisible: (...args) => invokeRectangleMethod("setVisible", ...args),
+		setZIndex: (...args) => invokeRectangleMethod("setZIndex", ...args)
+	}), [invokeRectangleMethod]);
+	useEffect(() => {
+		if (sdkStatus !== "ready" || !targetMap || rectangleRef.current) return;
+		try {
+			const rectangle = new naver.maps.Rectangle(toRectangleOptions(props, targetMap));
+			rectangleRef.current = rectangle;
+			bindOverlayEventListeners(rectangle, rectangleEventListenersRef, buildRectangleEventBindings(props));
+			props.onRectangleReady?.(rectangle);
+		} catch (error) {
+			const normalizedError = error instanceof Error ? error : /* @__PURE__ */ new Error("Failed to create naver.maps.Rectangle instance.");
+			props.onRectangleError?.(normalizedError);
+		}
+	}, [
+		props,
+		sdkStatus,
+		targetMap
+	]);
+	useEffect(() => {
+		const rectangle = rectangleRef.current;
+		if (!rectangle || !targetMap) return;
+		rectangle.setOptions(toRectangleOptions(props, targetMap));
+	}, [props, targetMap]);
+	useEffect(() => {
+		const rectangle = rectangleRef.current;
+		if (!rectangle) return;
+		bindOverlayEventListeners(rectangle, rectangleEventListenersRef, buildRectangleEventBindings(props));
+		return () => {
+			removeOverlayEventListeners(rectangleEventListenersRef.current);
+			rectangleEventListenersRef.current = [];
+		};
+	}, [props]);
+	useEffect(() => {
+		return () => {
+			teardownRectangle();
+		};
+	}, [teardownRectangle]);
+	return null;
+});
+Rectangle.displayName = "Rectangle";
+
+//#endregion
+//#region src/index.ts
+const version = "0.0.1";
+
+//#endregion
+export { Circle, Ellipse, GroundOverlay, InfoWindow, Marker, NaverMap, NaverMapContext, NaverMapProvider, Polygon, Polyline, Rectangle, loadNaverMapsScript, useNaverMap, useNaverMapInstance, version };
+//# sourceMappingURL=index.js.map