kor-mapi 0.1.0

package/dist/chunk-222QLGRB.js

@@ -0,0 +1,1884 @@
+// src/providers/base/HandleRegistry.ts
+var HandleRegistry = class {
+  map = /* @__PURE__ */ new Map();
+  counter = 0;
+  register(value) {
+    const id = ++this.counter;
+    this.map.set(id, value);
+    return id;
+  }
+  get(id) {
+    const value = this.map.get(id);
+    if (value === void 0) throw new Error(`Handle ${id} not found in registry`);
+    return value;
+  }
+  delete(id) {
+    this.map.delete(id);
+  }
+  has(id) {
+    return this.map.has(id);
+  }
+};
+var eventListenerCounter = 0;
+function makeEventListener(type) {
+  return { _type: type, _id: ++eventListenerCounter };
+}
+function makeHandle(id) {
+  return { _handleId: id };
+}
+
+// src/core/errors.ts
+var KorMapError = class extends Error {
+  provider;
+  originalError;
+  constructor(message, options) {
+    super(message, { cause: options?.cause });
+    this.name = "KorMapError";
+    this.provider = options?.provider;
+    this.originalError = options?.cause;
+  }
+};
+var ProviderLoadError = class extends KorMapError {
+  constructor(provider, cause) {
+    super(`Failed to load ${provider} Maps SDK`, { provider, cause });
+    this.name = "ProviderLoadError";
+  }
+};
+var ProviderNotSupportedError = class extends KorMapError {
+  feature;
+  constructor(provider, feature) {
+    super(`Feature "${feature}" is not supported by provider "${provider}"`, { provider });
+    this.name = "ProviderNotSupportedError";
+    this.feature = feature;
+  }
+};
+var ConfigurationError = class extends KorMapError {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigurationError";
+  }
+};
+
+// src/providers/kakao/KakaoLoader.ts
+var loadPromise = null;
+function loadKakaoSdk(appKey) {
+  if (loadPromise) return loadPromise;
+  loadPromise = new Promise((resolve, reject) => {
+    if (typeof window !== "undefined" && window.kakao?.maps?.Map) {
+      resolve();
+      return;
+    }
+    const script = document.createElement("script");
+    script.type = "text/javascript";
+    script.src = `//dapi.kakao.com/v2/maps/sdk.js?appkey=${encodeURIComponent(appKey)}&autoload=false`;
+    script.onload = () => {
+      window.kakao.maps.load(() => resolve());
+    };
+    script.onerror = () => {
+      loadPromise = null;
+      reject(new ProviderLoadError("kakao", new Error("Kakao Maps SDK script failed to load")));
+    };
+    document.head.appendChild(script);
+  });
+  return loadPromise;
+}
+
+// src/utils/coordinateUtils.ts
+var FACADE_MIN = 7;
+var FACADE_MAX = 19;
+var KAKAO_MIN = 1;
+var KAKAO_MAX = 13;
+var KAKAO_OFFSET = 20;
+function clampFacadeZoom(zoom) {
+  return Math.max(FACADE_MIN, Math.min(FACADE_MAX, zoom));
+}
+function toGoogleZoom(facadeZoom) {
+  return clampFacadeZoom(facadeZoom);
+}
+function fromGoogleZoom(googleZoom) {
+  return clampFacadeZoom(googleZoom);
+}
+function toNaverZoom(facadeZoom) {
+  return Math.round(clampFacadeZoom(facadeZoom));
+}
+function fromNaverZoom(naverZoom) {
+  return Math.round(clampFacadeZoom(naverZoom));
+}
+function toKakaoZoom(facadeZoom) {
+  const clamped = clampFacadeZoom(facadeZoom);
+  return Math.max(KAKAO_MIN, Math.min(KAKAO_MAX, Math.round(KAKAO_OFFSET - clamped)));
+}
+function fromKakaoZoom(kakaoZoom) {
+  const clamped = Math.max(KAKAO_MIN, Math.min(KAKAO_MAX, Math.round(kakaoZoom)));
+  return Math.round(clampFacadeZoom(KAKAO_OFFSET - clamped));
+}
+
+// src/providers/kakao/KakaoAdapter.ts
+function toKakaoMapType(type) {
+  switch (type) {
+    case "satellite" /* SATELLITE */:
+      return kakao.maps.MapTypeId.SKYVIEW;
+    case "hybrid" /* HYBRID */:
+      return kakao.maps.MapTypeId.HYBRID;
+    // Kakao TERRAIN is an overlay type, not a standalone base map — use ROADMAP
+    default:
+      return kakao.maps.MapTypeId.ROADMAP;
+  }
+}
+function fromKakaoMapType(typeId) {
+  if (typeId === kakao.maps.MapTypeId.SKYVIEW) return "satellite" /* SATELLITE */;
+  if (typeId === kakao.maps.MapTypeId.HYBRID) return "hybrid" /* HYBRID */;
+  if (typeId === kakao.maps.MapTypeId.TERRAIN) return "terrain" /* TERRAIN */;
+  return "roadmap" /* ROADMAP */;
+}
+var FACADE_TO_KAKAO_EVENT = {
+  click: "click",
+  dblclick: "dblclick",
+  rightclick: "rightclick",
+  mousemove: "mousemove",
+  drag: "drag",
+  dragstart: "dragstart",
+  dragend: "dragend",
+  zoom_changed: "zoom_changed",
+  center_changed: "center_changed",
+  bounds_changed: "bounds_changed",
+  tilesloaded: "tilesloaded"
+  // 'idle' is synthesized below — not in this map
+};
+var SUPPORTED_FEATURES = [];
+var POINTER_EVENTS = /* @__PURE__ */ new Set(["click", "dblclick", "rightclick"]);
+var KakaoAdapter = class {
+  provider = "kakao";
+  map;
+  markerReg = new HandleRegistry();
+  overlayReg = new HandleRegistry();
+  infoWindowReg = new HandleRegistry();
+  // Listener bookkeeping: handle id → [ { event, nativeHandler } ]
+  markerListeners = /* @__PURE__ */ new Map();
+  // idle synthesis: debounce timer
+  idleTimer = null;
+  idleHandlers = [];
+  get nativeMap() {
+    return this.map;
+  }
+  async init(container, config) {
+    const appKey = resolveAppKey(config.apiKey);
+    await loadKakaoSdk(appKey);
+    const center = config.center ?? { lat: 37.5665, lng: 126.978 };
+    const zoom = config.zoom ?? 10;
+    this.map = new kakao.maps.Map(container, {
+      center: new kakao.maps.LatLng(center.lat, center.lng),
+      level: toKakaoZoom(zoom),
+      minLevel: 1,
+      maxLevel: 13,
+      ...config.mapType && { mapTypeId: toKakaoMapType(config.mapType) }
+    });
+  }
+  destroy() {
+    if (this.map) ;
+  }
+  // -------------------------------------------------------------------------
+  // Camera
+  // -------------------------------------------------------------------------
+  setCenter(latlng) {
+    this.map.setCenter(new kakao.maps.LatLng(latlng.lat, latlng.lng));
+  }
+  getCenter() {
+    const c = this.map.getCenter();
+    return { lat: c.getLat(), lng: c.getLng() };
+  }
+  setZoom(zoom) {
+    const level = toKakaoZoom(zoom);
+    if (level !== this.map.getLevel()) {
+      this.map.setLevel(level);
+    }
+  }
+  getZoom() {
+    return fromKakaoZoom(this.map.getLevel());
+  }
+  getBounds() {
+    const b = this.map.getBounds();
+    const sw = b.getSouthWest();
+    const ne = b.getNorthEast();
+    return {
+      sw: { lat: sw.getLat(), lng: sw.getLng() },
+      ne: { lat: ne.getLat(), lng: ne.getLng() }
+    };
+  }
+  fitBounds(bounds, options) {
+    const kb = new kakao.maps.LatLngBounds(
+      new kakao.maps.LatLng(bounds.sw.lat, bounds.sw.lng),
+      new kakao.maps.LatLng(bounds.ne.lat, bounds.ne.lng)
+    );
+    const p = normalizePadding(options?.padding);
+    this.map.setBounds(kb, p.top, p.right, p.bottom, p.left);
+  }
+  panTo(latlng, _options) {
+    this.map.panTo(new kakao.maps.LatLng(latlng.lat, latlng.lng));
+  }
+  panBy(x, y) {
+    this.map.panBy(x, y);
+  }
+  // -------------------------------------------------------------------------
+  // Map type
+  // -------------------------------------------------------------------------
+  setMapType(type) {
+    const level = this.map.getLevel();
+    this.map.setMapTypeId(toKakaoMapType(type));
+    if (this.map.getLevel() !== level) this.map.setLevel(level);
+  }
+  getMapType() {
+    const raw = this.map.getMapTypeId();
+    return fromKakaoMapType(raw);
+  }
+  // -------------------------------------------------------------------------
+  // Capability
+  // -------------------------------------------------------------------------
+  supports(feature) {
+    return SUPPORTED_FEATURES.includes(feature);
+  }
+  // -------------------------------------------------------------------------
+  // Events
+  // -------------------------------------------------------------------------
+  on(event, handler) {
+    const listener = makeEventListener(event);
+    if (event === "idle") {
+      this.idleHandlers.push(handler);
+      this._ensureIdleSynthesis();
+    } else {
+      const kakaoEvent = FACADE_TO_KAKAO_EVENT[event];
+      if (kakaoEvent) {
+        const wrapped = POINTER_EVENTS.has(event) ? (e) => handler({ latlng: { lat: e.latLng.getLat(), lng: e.latLng.getLng() } }) : handler;
+        kakao.maps.event.addListener(this.map, kakaoEvent, wrapped);
+      }
+    }
+    return listener;
+  }
+  once(event, handler) {
+    const wrapper = (...args) => {
+      this.off(event, listener);
+      handler(...args);
+    };
+    const listener = this.on(event, wrapper);
+    return listener;
+  }
+  off(event, _listener) {
+    if (event === "idle") {
+      this.idleHandlers.length = 0;
+    }
+  }
+  _ensureIdleSynthesis() {
+    const synthesize = () => {
+      if (this.idleTimer !== null) clearTimeout(this.idleTimer);
+      this.idleTimer = setTimeout(() => {
+        for (const h of this.idleHandlers) h();
+      }, 150);
+    };
+    kakao.maps.event.addListener(this.map, "center_changed", synthesize);
+    kakao.maps.event.addListener(this.map, "zoom_changed", synthesize);
+  }
+  // -------------------------------------------------------------------------
+  // Markers
+  // -------------------------------------------------------------------------
+  addMarker(options) {
+    const kakaoOptions = {
+      map: this.map,
+      position: new kakao.maps.LatLng(options.position.lat, options.position.lng),
+      title: options.title,
+      draggable: options.draggable,
+      clickable: options.clickable,
+      zIndex: options.zIndex,
+      opacity: options.opacity
+    };
+    if (options.icon) {
+      kakaoOptions.image = buildMarkerImage(options.icon);
+    }
+    const marker = new kakao.maps.Marker(kakaoOptions);
+    if (options.visible === false) marker.setVisible(false);
+    if (options.label) {
+      this._addLabelOverlay(marker, options.label.text, options.label);
+    }
+    const id = this.markerReg.register(marker);
+    this.markerListeners.set(id, []);
+    return makeHandle(id);
+  }
+  removeMarker(handle) {
+    const marker = this.markerReg.get(handle._handleId);
+    marker.setMap(null);
+    this.markerReg.delete(handle._handleId);
+    this.markerListeners.delete(handle._handleId);
+  }
+  updateMarker(handle, options) {
+    const marker = this.markerReg.get(handle._handleId);
+    if (options.position) marker.setPosition(new kakao.maps.LatLng(options.position.lat, options.position.lng));
+    if (options.icon !== void 0) marker.setImage(buildMarkerImage(options.icon));
+    if (options.title !== void 0) marker.setTitle(options.title);
+    if (options.draggable !== void 0) marker.setDraggable(options.draggable);
+    if (options.clickable !== void 0) marker.setClickable(options.clickable);
+    if (options.zIndex !== void 0) marker.setZIndex(options.zIndex);
+    if (options.opacity !== void 0) marker.setOpacity(options.opacity);
+    if (options.visible !== void 0) marker.setVisible(options.visible);
+  }
+  addMarkerEvent(handle, event, handler) {
+    const marker = this.markerReg.get(handle._handleId);
+    kakao.maps.event.addListener(marker, event, handler);
+    const listener = makeEventListener(event);
+    return listener;
+  }
+  removeMarkerEvent(handle, event, _listener) {
+    const marker = this.markerReg.get(handle._handleId);
+    kakao.maps.event.removeListener(marker, event, () => void 0);
+  }
+  // -------------------------------------------------------------------------
+  // InfoWindow
+  // -------------------------------------------------------------------------
+  openInfoWindow(options, anchor) {
+    const iw = new kakao.maps.InfoWindow({
+      content: options.content,
+      position: options.position ? new kakao.maps.LatLng(options.position.lat, options.position.lng) : void 0,
+      zIndex: options.zIndex,
+      removable: false
+    });
+    const marker = anchor ? this.markerReg.get(anchor._handleId) : void 0;
+    iw.open(this.map, marker);
+    const id = this.infoWindowReg.register(iw);
+    return makeHandle(id);
+  }
+  closeInfoWindow(handle) {
+    this.infoWindowReg.get(handle._handleId).close();
+  }
+  updateInfoWindow(handle, options) {
+    const iw = this.infoWindowReg.get(handle._handleId);
+    if (options.content !== void 0) iw.setContent(options.content);
+    if (options.position) iw.setPosition(new kakao.maps.LatLng(options.position.lat, options.position.lng));
+    if (options.zIndex !== void 0) iw.setZIndex(options.zIndex);
+  }
+  isInfoWindowOpen(_handle) {
+    return this.infoWindowReg.has(_handle._handleId);
+  }
+  // -------------------------------------------------------------------------
+  // Vector overlays
+  // -------------------------------------------------------------------------
+  addPolyline(options) {
+    const polyline = new kakao.maps.Polyline({
+      map: this.map,
+      path: toKakaoPath(options.path),
+      strokeWeight: options.strokeWeight,
+      strokeColor: options.strokeColor,
+      strokeOpacity: options.strokeOpacity,
+      strokeStyle: options.strokeStyle,
+      zIndex: options.zIndex
+    });
+    return makeHandle(this.overlayReg.register(polyline));
+  }
+  removePolyline(handle) {
+    this.overlayReg.get(handle._handleId).setMap(null);
+    this.overlayReg.delete(handle._handleId);
+  }
+  updatePolyline(handle, options) {
+    this.overlayReg.get(handle._handleId).setOptions({
+      strokeWeight: options.strokeWeight,
+      strokeColor: options.strokeColor,
+      strokeOpacity: options.strokeOpacity
+    });
+  }
+  addPolygon(options) {
+    const polygon = new kakao.maps.Polygon({
+      map: this.map,
+      path: toKakaoPath(options.paths),
+      strokeWeight: options.strokeWeight,
+      strokeColor: options.strokeColor,
+      strokeOpacity: options.strokeOpacity,
+      fillColor: options.fillColor,
+      fillOpacity: options.fillOpacity,
+      zIndex: options.zIndex
+    });
+    return makeHandle(this.overlayReg.register(polygon));
+  }
+  removePolygon(handle) {
+    this.overlayReg.get(handle._handleId).setMap(null);
+    this.overlayReg.delete(handle._handleId);
+  }
+  updatePolygon(handle, options) {
+    this.overlayReg.get(handle._handleId).setOptions({
+      strokeColor: options.strokeColor,
+      fillColor: options.fillColor,
+      fillOpacity: options.fillOpacity
+    });
+  }
+  addCircle(options) {
+    const circle = new kakao.maps.Circle({
+      map: this.map,
+      center: new kakao.maps.LatLng(options.center.lat, options.center.lng),
+      radius: options.radius,
+      strokeWeight: options.strokeWeight,
+      strokeColor: options.strokeColor,
+      strokeOpacity: options.strokeOpacity,
+      fillColor: options.fillColor,
+      fillOpacity: options.fillOpacity,
+      zIndex: options.zIndex
+    });
+    return makeHandle(this.overlayReg.register(circle));
+  }
+  removeCircle(handle) {
+    this.overlayReg.get(handle._handleId).setMap(null);
+    this.overlayReg.delete(handle._handleId);
+  }
+  updateCircle(handle, options) {
+    const circle = this.overlayReg.get(handle._handleId);
+    if (options.center) circle.setCenter(new kakao.maps.LatLng(options.center.lat, options.center.lng));
+    if (options.radius !== void 0) circle.setRadius(options.radius);
+    circle.setOptions({
+      strokeColor: options.strokeColor,
+      fillColor: options.fillColor,
+      fillOpacity: options.fillOpacity
+    });
+  }
+  addRectangle(options) {
+    const rect = new kakao.maps.Rectangle({
+      map: this.map,
+      bounds: new kakao.maps.LatLngBounds(
+        new kakao.maps.LatLng(options.bounds.sw.lat, options.bounds.sw.lng),
+        new kakao.maps.LatLng(options.bounds.ne.lat, options.bounds.ne.lng)
+      ),
+      strokeWeight: options.strokeWeight,
+      strokeColor: options.strokeColor,
+      strokeOpacity: options.strokeOpacity,
+      fillColor: options.fillColor,
+      fillOpacity: options.fillOpacity,
+      zIndex: options.zIndex
+    });
+    return makeHandle(this.overlayReg.register(rect));
+  }
+  removeRectangle(handle) {
+    this.overlayReg.get(handle._handleId).setMap(null);
+    this.overlayReg.delete(handle._handleId);
+  }
+  updateRectangle(handle, options) {
+    this.overlayReg.get(handle._handleId).setOptions({
+      strokeColor: options.strokeColor,
+      fillColor: options.fillColor,
+      fillOpacity: options.fillOpacity
+    });
+  }
+  addCustomOverlay(options) {
+    const overlay = new kakao.maps.CustomOverlay({
+      position: new kakao.maps.LatLng(options.position.lat, options.position.lng),
+      content: options.content,
+      xAnchor: 0,
+      yAnchor: 0,
+      zIndex: options.zIndex ?? 100
+    });
+    overlay.setMap(this.map);
+    return makeHandle(this.overlayReg.register(overlay));
+  }
+  removeCustomOverlay(handle) {
+    this.overlayReg.get(handle._handleId).setMap(null);
+    this.overlayReg.delete(handle._handleId);
+  }
+  addTileLayer(options) {
+    const tileSize = options.tileSize ?? 256;
+    const tileLayer = new kakao.maps.TileLayer({
+      getTile: (x, y, z) => {
+        const img = document.createElement("img");
+        img.src = options.getTileUrl({ x, y }, z);
+        img.width = tileSize;
+        img.height = tileSize;
+        if (options.opacity !== void 0) img.style.opacity = String(options.opacity);
+        return img;
+      }
+    });
+    tileLayer.setMap(this.map);
+    return makeHandle(this.overlayReg.register(tileLayer));
+  }
+  removeTileLayer(handle) {
+    this.overlayReg.get(handle._handleId).setMap(null);
+    this.overlayReg.delete(handle._handleId);
+  }
+  // -------------------------------------------------------------------------
+  // Projection
+  // -------------------------------------------------------------------------
+  getProjection() {
+    return {
+      fromLatLngToPoint: (latlng) => ({ x: latlng.lng, y: latlng.lat }),
+      fromPointToLatLng: (point) => ({ lat: point.y, lng: point.x }),
+      fromLatLngToDivPixel: (latlng) => ({ x: latlng.lng, y: latlng.lat })
+    };
+  }
+  // -------------------------------------------------------------------------
+  // Private helpers
+  // -------------------------------------------------------------------------
+  _addLabelOverlay(marker, text, label) {
+    const div = document.createElement("div");
+    div.textContent = text;
+    div.style.cssText = [
+      "position:absolute",
+      "white-space:nowrap",
+      "pointer-events:none",
+      `color:${label?.color ?? "#000"}`,
+      `font-size:${label?.fontSize ?? "12px"}`,
+      `font-weight:${label?.fontWeight ?? "normal"}`
+    ].join(";");
+    const LabelOverlay = class extends kakao.maps.AbstractOverlay {
+      onAdd() {
+        this.getPanels().overlayLayer.appendChild(div);
+      }
+      onRemove() {
+        div.parentNode?.removeChild(div);
+      }
+      draw() {
+        const proj = this.getProjection();
+        const pos = marker.getPosition();
+        const pt = proj.containerPointFromCoords(pos);
+        div.style.left = `${pt.x}px`;
+        div.style.top = `${pt.y - 20}px`;
+      }
+    };
+    new LabelOverlay().setMap(this.map);
+  }
+};
+function resolveAppKey(apiKey) {
+  if (typeof apiKey === "string") return apiKey;
+  if (apiKey.appKey) return apiKey.appKey;
+  throw new ConfigurationError("Kakao Maps requires an appKey");
+}
+function normalizePadding(padding) {
+  if (padding === void 0) return { top: 0, right: 0, bottom: 0, left: 0 };
+  if (typeof padding === "number") return { top: padding, right: padding, bottom: padding, left: padding };
+  return { top: padding.top ?? 0, right: padding.right ?? 0, bottom: padding.bottom ?? 0, left: padding.left ?? 0 };
+}
+function toKakaoLatLng(latlng) {
+  return new kakao.maps.LatLng(latlng.lat, latlng.lng);
+}
+function toKakaoPath(path) {
+  if (path.length === 0) return [];
+  const first = path[0];
+  if (Array.isArray(first)) {
+    return path.map((ring) => ring.map(toKakaoLatLng));
+  }
+  return path.map(toKakaoLatLng);
+}
+function buildMarkerImage(icon) {
+  if (!icon) throw new Error("icon is required");
+  const url = typeof icon === "string" ? icon : icon.url;
+  const size = typeof icon === "object" && icon.size ? new kakao.maps.Size(icon.size.width, icon.size.height) : new kakao.maps.Size(24, 35);
+  const opts = {};
+  if (typeof icon === "object") {
+    if (icon.anchor) opts.offset = new kakao.maps.Point(icon.anchor.x, icon.anchor.y);
+    if (icon.origin) opts.spriteOrigin = new kakao.maps.Point(icon.origin.x, icon.origin.y);
+    if (icon.scaledSize) opts.spriteSize = new kakao.maps.Size(icon.scaledSize.width, icon.scaledSize.height);
+  }
+  return new kakao.maps.MarkerImage(url, size, opts);
+}
+
+// src/providers/naver/NaverLoader.ts
+var loadPromise2 = null;
+function loadNaverSdk(clientId, submodules = []) {
+  if (loadPromise2) return loadPromise2;
+  loadPromise2 = new Promise((resolve, reject) => {
+    if (typeof window !== "undefined" && window.naver?.maps?.Map) {
+      resolve();
+      return;
+    }
+    const params = new URLSearchParams({ ncpKeyId: clientId });
+    if (submodules.length > 0) params.set("submodules", submodules.join(","));
+    const script = document.createElement("script");
+    script.type = "text/javascript";
+    script.src = `https://oapi.map.naver.com/openapi/v3/maps.js?${params.toString()}`;
+    script.onload = () => resolve();
+    script.onerror = () => {
+      loadPromise2 = null;
+      reject(new ProviderLoadError("naver", new Error("Naver Maps SDK script failed to load")));
+    };
+    document.head.appendChild(script);
+  });
+  return loadPromise2;
+}
+
+// src/providers/naver/NaverAdapter.ts
+function toNaverMapType(type) {
+  switch (type) {
+    case "satellite" /* SATELLITE */:
+      return naver.maps.MapTypeId.SATELLITE;
+    case "hybrid" /* HYBRID */:
+      return naver.maps.MapTypeId.HYBRID;
+    case "terrain" /* TERRAIN */:
+      return naver.maps.MapTypeId.TERRAIN;
+    default:
+      return naver.maps.MapTypeId.NORMAL;
+  }
+}
+function fromNaverMapType(typeId) {
+  if (typeId === naver.maps.MapTypeId.SATELLITE) return "satellite" /* SATELLITE */;
+  if (typeId === naver.maps.MapTypeId.HYBRID) return "hybrid" /* HYBRID */;
+  if (typeId === naver.maps.MapTypeId.TERRAIN) return "terrain" /* TERRAIN */;
+  return "roadmap" /* ROADMAP */;
+}
+var FACADE_TO_NAVER_EVENT = {
+  click: "click",
+  dblclick: "dblclick",
+  rightclick: "rightclick",
+  mousemove: "mousemove",
+  drag: "drag",
+  dragstart: "dragstart",
+  dragend: "dragend",
+  zoom_changed: "zoom_changed",
+  center_changed: "center_changed",
+  bounds_changed: "bounds_changed",
+  idle: "idle",
+  tilesloaded: "tilesloaded"
+};
+var SUPPORTED_FEATURES2 = [];
+var POINTER_EVENTS2 = /* @__PURE__ */ new Set(["click", "dblclick", "rightclick"]);
+var NaverAdapter = class {
+  provider = "naver";
+  map;
+  markerReg = new HandleRegistry();
+  overlayReg = new HandleRegistry();
+  infoWindowReg = new HandleRegistry();
+  get nativeMap() {
+    return this.map;
+  }
+  async init(container, config) {
+    const clientId = resolveClientId(config.apiKey);
+    await loadNaverSdk(clientId);
+    const center = config.center ?? { lat: 37.5665, lng: 126.978 };
+    const zoom = config.zoom ?? 10;
+    const mapTarget = container.id ? container.id : container;
+    this.map = new naver.maps.Map(mapTarget, {
+      center: new naver.maps.LatLng(center.lat, center.lng),
+      zoom: toNaverZoom(zoom),
+      minZoom: 7,
+      maxZoom: 19,
+      ...config.mapType && { mapTypeId: toNaverMapType(config.mapType) }
+    });
+  }
+  destroy() {
+    if (this.map) this.map.destroy();
+  }
+  // -------------------------------------------------------------------------
+  // Camera
+  // -------------------------------------------------------------------------
+  setCenter(latlng) {
+    this.map.setCenter(new naver.maps.LatLng(latlng.lat, latlng.lng));
+  }
+  getCenter() {
+    const c = this.map.getCenter();
+    return { lat: c.lat(), lng: c.lng() };
+  }
+  setZoom(zoom) {
+    this.map.setZoom(toNaverZoom(zoom), true);
+  }
+  getZoom() {
+    return fromNaverZoom(this.map.getZoom());
+  }
+  getBounds() {
+    const b = this.map.getBounds();
+    const sw = b.getSW();
+    const ne = b.getNE();
+    return {
+      sw: { lat: sw.lat(), lng: sw.lng() },
+      ne: { lat: ne.lat(), lng: ne.lng() }
+    };
+  }
+  fitBounds(bounds, options) {
+    const nb = new naver.maps.LatLngBounds(
+      new naver.maps.LatLng(bounds.sw.lat, bounds.sw.lng),
+      new naver.maps.LatLng(bounds.ne.lat, bounds.ne.lng)
+    );
+    const padding = normalizePaddingForNaver(options?.padding);
+    this.map.fitBounds(nb, { padding });
+  }
+  panTo(latlng, options) {
+    this.map.panTo(new naver.maps.LatLng(latlng.lat, latlng.lng), {
+      duration: options?.duration
+    });
+  }
+  panBy(x, y) {
+    this.map.panBy(x, y);
+  }
+  // -------------------------------------------------------------------------
+  // Map type
+  // -------------------------------------------------------------------------
+  setMapType(type) {
+    this.map.setMapTypeId(toNaverMapType(type));
+  }
+  getMapType() {
+    return fromNaverMapType(this.map.getMapTypeId());
+  }
+  // -------------------------------------------------------------------------
+  // Capability
+  // -------------------------------------------------------------------------
+  supports(feature) {
+    return SUPPORTED_FEATURES2.includes(feature);
+  }
+  // -------------------------------------------------------------------------
+  // Events
+  // -------------------------------------------------------------------------
+  on(event, handler) {
+    const naverEvent = FACADE_TO_NAVER_EVENT[event];
+    if (naverEvent) {
+      const wrapped = POINTER_EVENTS2.has(event) ? (e) => handler({ latlng: { lat: e.coord.lat(), lng: e.coord.lng() } }) : handler;
+      naver.maps.Event.addListener(this.map, naverEvent, wrapped);
+    }
+    return makeEventListener(event);
+  }
+  once(event, handler) {
+    const wrapper = (...args) => {
+      this.off(event, listener);
+      handler(...args);
+    };
+    const listener = this.on(event, wrapper);
+    return listener;
+  }
+  off(event, _listener) {
+  }
+  // -------------------------------------------------------------------------
+  // Markers
+  // -------------------------------------------------------------------------
+  addMarker(options) {
+    const icon = buildNaverIcon(options.icon);
+    const marker = new naver.maps.Marker({
+      map: this.map,
+      position: new naver.maps.LatLng(options.position.lat, options.position.lng),
+      icon,
+      title: options.title,
+      zIndex: options.zIndex,
+      visible: options.visible,
+      draggable: options.draggable,
+      opacity: options.opacity,
+      clickable: options.clickable,
+      animation: options.animation ? options.animation === "bounce" /* BOUNCE */ ? naver.maps.Animation.BOUNCE : naver.maps.Animation.DROP : void 0
+    });
+    const id = this.markerReg.register(marker);
+    return makeHandle(id);
+  }
+  removeMarker(handle) {
+    this.markerReg.get(handle._handleId).setMap(null);
+    this.markerReg.delete(handle._handleId);
+  }
+  updateMarker(handle, options) {
+    const marker = this.markerReg.get(handle._handleId);
+    if (options.position) marker.setPosition(new naver.maps.LatLng(options.position.lat, options.position.lng));
+    if (options.icon !== void 0) marker.setIcon(buildNaverIcon(options.icon) ?? "");
+    if (options.title !== void 0) marker.setTitle(options.title);
+    if (options.visible !== void 0) marker.setVisible(options.visible);
+    if (options.draggable !== void 0) marker.setDraggable(options.draggable);
+    if (options.clickable !== void 0) marker.setClickable(options.clickable);
+    if (options.zIndex !== void 0) marker.setZIndex(options.zIndex);
+    if (options.opacity !== void 0) marker.setOpacity(options.opacity);
+    if (options.animation !== void 0) {
+      marker.setAnimation(
+        options.animation === null ? null : options.animation === "bounce" /* BOUNCE */ ? naver.maps.Animation.BOUNCE : naver.maps.Animation.DROP
+      );
+    }
+  }
+  addMarkerEvent(handle, event, handler) {
+    const marker = this.markerReg.get(handle._handleId);
+    naver.maps.Event.addListener(marker, event, handler);
+    return makeEventListener(event);
+  }
+  removeMarkerEvent(handle, event, _listener) {
+  }
+  // -------------------------------------------------------------------------
+  // InfoWindow
+  // -------------------------------------------------------------------------
+  openInfoWindow(options, anchor) {
+    const iw = new naver.maps.InfoWindow({
+      content: options.content,
+      position: options.position ? new naver.maps.LatLng(options.position.lat, options.position.lng) : void 0,
+      maxWidth: options.maxWidth,
+      zIndex: options.zIndex
+    });
+    const marker = anchor ? this.markerReg.get(anchor._handleId) : void 0;
+    iw.open(this.map, marker);
+    return makeHandle(this.infoWindowReg.register(iw));
+  }
+  closeInfoWindow(handle) {
+    this.infoWindowReg.get(handle._handleId).close();
+  }
+  updateInfoWindow(handle, options) {
+    const iw = this.infoWindowReg.get(handle._handleId);
+    if (options.content !== void 0) iw.setContent(options.content);
+    if (options.position) iw.setPosition(new naver.maps.LatLng(options.position.lat, options.position.lng));
+    if (options.zIndex !== void 0) iw.setZIndex(options.zIndex);
+  }
+  isInfoWindowOpen(handle) {
+    return this.infoWindowReg.get(handle._handleId).getMap() !== null;
+  }
+  // -------------------------------------------------------------------------
+  // Vector overlays
+  // -------------------------------------------------------------------------
+  addPolyline(options) {
+    const polyline = new naver.maps.Polyline({
+      map: this.map,
+      path: toNaverPath(options.path),
+      strokeWeight: options.strokeWeight,
+      strokeColor: options.strokeColor,
+      strokeOpacity: options.strokeOpacity,
+      strokeStyle: options.strokeStyle,
+      geodesic: options.geodesic,
+      clickable: options.clickable,
+      zIndex: options.zIndex,
+      visible: options.visible
+    });
+    return makeHandle(this.overlayReg.register(polyline));
+  }
+  removePolyline(handle) {
+    this.overlayReg.get(handle._handleId).setMap(null);
+    this.overlayReg.delete(handle._handleId);
+  }
+  updatePolyline(handle, options) {
+    this.overlayReg.get(handle._handleId).setOptions({
+      strokeColor: options.strokeColor,
+      strokeWeight: options.strokeWeight,
+      strokeOpacity: options.strokeOpacity
+    });
+  }
+  addPolygon(options) {
+    const polygon = new naver.maps.Polygon({
+      map: this.map,
+      paths: toNaverPath(options.paths),
+      strokeWeight: options.strokeWeight,
+      strokeColor: options.strokeColor,
+      strokeOpacity: options.strokeOpacity,
+      fillColor: options.fillColor,
+      fillOpacity: options.fillOpacity,
+      geodesic: options.geodesic,
+      clickable: options.clickable,
+      zIndex: options.zIndex,
+      visible: options.visible
+    });
+    return makeHandle(this.overlayReg.register(polygon));
+  }
+  removePolygon(handle) {
+    this.overlayReg.get(handle._handleId).setMap(null);
+    this.overlayReg.delete(handle._handleId);
+  }
+  updatePolygon(handle, options) {
+    this.overlayReg.get(handle._handleId).setOptions({
+      strokeColor: options.strokeColor,
+      fillColor: options.fillColor,
+      fillOpacity: options.fillOpacity
+    });
+  }
+  addCircle(options) {
+    const circle = new naver.maps.Circle({
+      map: this.map,
+      center: new naver.maps.LatLng(options.center.lat, options.center.lng),
+      radius: options.radius,
+      strokeWeight: options.strokeWeight,
+      strokeColor: options.strokeColor,
+      strokeOpacity: options.strokeOpacity,
+      fillColor: options.fillColor,
+      fillOpacity: options.fillOpacity,
+      clickable: options.clickable,
+      zIndex: options.zIndex,
+      visible: options.visible
+    });
+    return makeHandle(this.overlayReg.register(circle));
+  }
+  removeCircle(handle) {
+    this.overlayReg.get(handle._handleId).setMap(null);
+    this.overlayReg.delete(handle._handleId);
+  }
+  updateCircle(handle, options) {
+    const circle = this.overlayReg.get(handle._handleId);
+    if (options.center) circle.setCenter(new naver.maps.LatLng(options.center.lat, options.center.lng));
+    if (options.radius !== void 0) circle.setRadius(options.radius);
+    circle.setOptions({
+      strokeColor: options.strokeColor,
+      fillColor: options.fillColor,
+      fillOpacity: options.fillOpacity
+    });
+  }
+  addRectangle(options) {
+    const rect = new naver.maps.Rectangle({
+      map: this.map,
+      bounds: new naver.maps.LatLngBounds(
+        new naver.maps.LatLng(options.bounds.sw.lat, options.bounds.sw.lng),
+        new naver.maps.LatLng(options.bounds.ne.lat, options.bounds.ne.lng)
+      ),
+      strokeWeight: options.strokeWeight,
+      strokeColor: options.strokeColor,
+      strokeOpacity: options.strokeOpacity,
+      fillColor: options.fillColor,
+      fillOpacity: options.fillOpacity,
+      clickable: options.clickable,
+      zIndex: options.zIndex,
+      visible: options.visible
+    });
+    return makeHandle(this.overlayReg.register(rect));
+  }
+  removeRectangle(handle) {
+    this.overlayReg.get(handle._handleId).setMap(null);
+    this.overlayReg.delete(handle._handleId);
+  }
+  updateRectangle(handle, options) {
+    this.overlayReg.get(handle._handleId).setOptions({
+      strokeColor: options.strokeColor,
+      fillColor: options.fillColor,
+      fillOpacity: options.fillOpacity
+    });
+  }
+  addCustomOverlay(options) {
+    const self = this;
+    const CustomOverlayClass = class extends naver.maps.OverlayView {
+      onAdd() {
+        this.getPanes().overlayLayer.appendChild(options.content);
+      }
+      onRemove() {
+        options.content.parentNode?.removeChild(options.content);
+      }
+      draw() {
+        const proj = this.getProjection();
+        const pt = proj.fromCoordToOffset(
+          new naver.maps.LatLng(options.position.lat, options.position.lng)
+        );
+        options.content.style.left = `${pt.x}px`;
+        options.content.style.top = `${pt.y}px`;
+        options.content.style.position = "absolute";
+      }
+    };
+    const overlay = new CustomOverlayClass();
+    overlay.setMap(self.map);
+    return makeHandle(this.overlayReg.register(overlay));
+  }
+  removeCustomOverlay(handle) {
+    this.overlayReg.get(handle._handleId).setMap(null);
+    this.overlayReg.delete(handle._handleId);
+  }
+  addTileLayer(options) {
+    const tileSize = options.tileSize ?? 256;
+    const layer = new naver.maps.ImageTileLayer({
+      getTileUrl: (x, y, z) => options.getTileUrl({ x, y }, z),
+      tileSize: new naver.maps.Size(tileSize, tileSize),
+      minZoom: options.minZoom,
+      maxZoom: options.maxZoom,
+      opacity: options.opacity,
+      zIndex: options.zIndex
+    });
+    layer.setMap(this.map);
+    return makeHandle(this.overlayReg.register(layer));
+  }
+  removeTileLayer(handle) {
+    this.overlayReg.get(handle._handleId).setMap(null);
+    this.overlayReg.delete(handle._handleId);
+  }
+  // -------------------------------------------------------------------------
+  // Projection
+  // -------------------------------------------------------------------------
+  getProjection() {
+    const proj = this.map.getProjection();
+    return {
+      fromLatLngToPoint: (latlng) => {
+        const pt = proj.fromCoordToOffset(new naver.maps.LatLng(latlng.lat, latlng.lng));
+        return { x: pt.x, y: pt.y };
+      },
+      fromPointToLatLng: (point) => {
+        const c = proj.fromOffsetToCoord(new naver.maps.Point(point.x, point.y));
+        return { lat: c.lat(), lng: c.lng() };
+      },
+      fromLatLngToDivPixel: (latlng) => {
+        const pt = proj.fromCoordToOffset(new naver.maps.LatLng(latlng.lat, latlng.lng));
+        return { x: pt.x, y: pt.y };
+      }
+    };
+  }
+};
+function resolveClientId(apiKey) {
+  if (typeof apiKey === "string") return apiKey;
+  if (apiKey.clientId) return apiKey.clientId;
+  throw new ConfigurationError("Naver Maps requires a clientId");
+}
+function normalizePaddingForNaver(padding) {
+  if (padding === void 0) return 0;
+  if (typeof padding === "number") return padding;
+  return { top: padding.top, right: padding.right, bottom: padding.bottom, left: padding.left };
+}
+function toNaverLatLng(latlng) {
+  return new naver.maps.LatLng(latlng.lat, latlng.lng);
+}
+function toNaverPath(path) {
+  if (path.length === 0) return [];
+  const first = path[0];
+  if (Array.isArray(first)) {
+    return path.map((ring) => ring.map(toNaverLatLng));
+  }
+  return path.map(toNaverLatLng);
+}
+function buildNaverIcon(icon) {
+  if (!icon) return void 0;
+  if (typeof icon === "string") return icon;
+  return {
+    url: icon.url,
+    size: icon.size ? new naver.maps.Size(icon.size.width, icon.size.height) : void 0,
+    scaledSize: icon.scaledSize ? new naver.maps.Size(icon.scaledSize.width, icon.scaledSize.height) : void 0,
+    origin: icon.origin ? new naver.maps.Point(icon.origin.x, icon.origin.y) : void 0,
+    anchor: icon.anchor ? new naver.maps.Point(icon.anchor.x, icon.anchor.y) : void 0
+  };
+}
+
+// src/providers/google/GoogleLoader.ts
+var loadPromise3 = null;
+function loadGoogleSdk(apiKey, libraries = ["marker"]) {
+  if (loadPromise3) return loadPromise3;
+  loadPromise3 = new Promise((resolve, reject) => {
+    if (typeof window !== "undefined" && window.google?.maps?.Map) {
+      resolve();
+      return;
+    }
+    const params = new URLSearchParams({ key: apiKey, loading: "async" });
+    if (libraries.length > 0) params.set("libraries", libraries.join(","));
+    const callbackName = `__korMapiGoogleMapsCallback__`;
+    params.set("callback", callbackName);
+    window[callbackName] = () => {
+      delete window[callbackName];
+      resolve();
+    };
+    const script = document.createElement("script");
+    script.type = "text/javascript";
+    script.async = true;
+    script.defer = true;
+    script.src = `https://maps.googleapis.com/maps/api/js?${params.toString()}`;
+    script.onerror = () => {
+      loadPromise3 = null;
+      delete window[callbackName];
+      reject(new ProviderLoadError("google", new Error("Google Maps SDK script failed to load")));
+    };
+    document.head.appendChild(script);
+  });
+  return loadPromise3;
+}
+
+// src/providers/google/GoogleAdapter.ts
+var FACADE_TO_GOOGLE_TYPE = {
+  ["roadmap" /* ROADMAP */]: "roadmap",
+  ["satellite" /* SATELLITE */]: "satellite",
+  ["hybrid" /* HYBRID */]: "hybrid",
+  ["terrain" /* TERRAIN */]: "terrain"
+};
+var GOOGLE_TO_FACADE_TYPE = {
+  roadmap: "roadmap" /* ROADMAP */,
+  satellite: "satellite" /* SATELLITE */,
+  hybrid: "hybrid" /* HYBRID */,
+  terrain: "terrain" /* TERRAIN */
+};
+var FACADE_TO_GOOGLE_EVENT = {
+  click: "click",
+  dblclick: "dblclick",
+  rightclick: "rightclick",
+  mousemove: "mousemove",
+  drag: "drag",
+  dragstart: "dragstart",
+  dragend: "dragend",
+  zoom_changed: "zoom_changed",
+  center_changed: "center_changed",
+  bounds_changed: "bounds_changed",
+  idle: "idle",
+  tilesloaded: "tilesloaded"
+};
+var SUPPORTED_FEATURES3 = ["elevation", "streetview", "heatmap", "drawing", "mapStyles", "tilt", "heading", "trafficLayer"];
+var POINTER_EVENTS3 = /* @__PURE__ */ new Set(["click", "dblclick", "rightclick"]);
+var GoogleAdapter = class {
+  provider = "google";
+  map;
+  markerReg = new HandleRegistry();
+  overlayReg = new HandleRegistry();
+  infoWindowReg = new HandleRegistry();
+  // Track MapsEventListeners for proper cleanup
+  eventListeners = /* @__PURE__ */ new Map();
+  eventListenerIdCounter = 0;
+  get nativeMap() {
+    return this.map;
+  }
+  async init(container, config) {
+    const apiKey = resolveApiKey(config.apiKey);
+    await loadGoogleSdk(apiKey);
+    const center = config.center ?? { lat: 37.5665, lng: 126.978 };
+    const zoom = config.zoom ?? 10;
+    this.map = new google.maps.Map(container, {
+      center: new google.maps.LatLng(center.lat, center.lng),
+      zoom: toGoogleZoom(zoom),
+      minZoom: 7,
+      maxZoom: 19,
+      mapId: config.mapId ?? "DEMO_MAP_ID",
+      ...config.mapType && { mapTypeId: FACADE_TO_GOOGLE_TYPE[config.mapType] }
+    });
+  }
+  destroy() {
+    for (const listener of this.eventListeners.values()) {
+      listener.remove();
+    }
+    this.eventListeners.clear();
+  }
+  // -------------------------------------------------------------------------
+  // Camera
+  // -------------------------------------------------------------------------
+  setCenter(latlng) {
+    this.map.setCenter(new google.maps.LatLng(latlng.lat, latlng.lng));
+  }
+  getCenter() {
+    const c = this.map.getCenter();
+    if (!c) return { lat: 0, lng: 0 };
+    return { lat: c.lat(), lng: c.lng() };
+  }
+  setZoom(zoom) {
+    this.map.setZoom(toGoogleZoom(zoom));
+  }
+  getZoom() {
+    return fromGoogleZoom(this.map.getZoom() ?? 10);
+  }
+  getBounds() {
+    const b = this.map.getBounds();
+    if (!b) return { sw: { lat: 0, lng: 0 }, ne: { lat: 0, lng: 0 } };
+    const sw = b.getSouthWest();
+    const ne = b.getNorthEast();
+    return {
+      sw: { lat: sw.lat(), lng: sw.lng() },
+      ne: { lat: ne.lat(), lng: ne.lng() }
+    };
+  }
+  fitBounds(bounds, options) {
+    const gb = new google.maps.LatLngBounds(
+      new google.maps.LatLng(bounds.sw.lat, bounds.sw.lng),
+      new google.maps.LatLng(bounds.ne.lat, bounds.ne.lng)
+    );
+    const padding = normalizePaddingForGoogle(options?.padding);
+    this.map.fitBounds(gb, padding);
+  }
+  panTo(latlng, _options) {
+    this.map.panTo(new google.maps.LatLng(latlng.lat, latlng.lng));
+  }
+  panBy(x, y) {
+    this.map.panBy(x, y);
+  }
+  // -------------------------------------------------------------------------
+  // Map type
+  // -------------------------------------------------------------------------
+  setMapType(type) {
+    this.map.setMapTypeId(FACADE_TO_GOOGLE_TYPE[type]);
+  }
+  getMapType() {
+    return GOOGLE_TO_FACADE_TYPE[this.map.getMapTypeId()] ?? "roadmap" /* ROADMAP */;
+  }
+  // -------------------------------------------------------------------------
+  // Capability
+  // -------------------------------------------------------------------------
+  supports(feature) {
+    return SUPPORTED_FEATURES3.includes(feature);
+  }
+  // -------------------------------------------------------------------------
+  // Events
+  // -------------------------------------------------------------------------
+  on(event, handler) {
+    const googleEvent = FACADE_TO_GOOGLE_EVENT[event];
+    const listener = makeEventListener(event);
+    if (googleEvent) {
+      const wrapped = POINTER_EVENTS3.has(event) ? (e) => handler({ latlng: { lat: e.latLng?.lat() ?? 0, lng: e.latLng?.lng() ?? 0 } }) : handler;
+      const mapsListener = google.maps.event.addListener(
+        this.map,
+        googleEvent,
+        wrapped
+      );
+      this.eventListeners.set(++this.eventListenerIdCounter, mapsListener);
+    }
+    return listener;
+  }
+  once(event, handler) {
+    const wrapper = (...args) => {
+      this.off(event, listener);
+      handler(...args);
+    };
+    const listener = this.on(event, wrapper);
+    return listener;
+  }
+  off(_event, _listener) {
+  }
+  // -------------------------------------------------------------------------
+  // Markers
+  // -------------------------------------------------------------------------
+  addMarker(options) {
+    const content = buildAdvancedMarkerContent(options);
+    const marker = new google.maps.marker.AdvancedMarkerElement({
+      map: this.map,
+      position: { lat: options.position.lat, lng: options.position.lng },
+      title: options.title ?? "",
+      content,
+      gmpClickable: options.clickable ?? true,
+      gmpDraggable: options.draggable ?? false,
+      zIndex: options.zIndex ?? null
+    });
+    if (options.visible === false) marker.map = null;
+    if (options.opacity !== void 0 && marker.content) marker.content.style.opacity = String(options.opacity);
+    return makeHandle(this.markerReg.register(marker));
+  }
+  removeMarker(handle) {
+    this.markerReg.get(handle._handleId).map = null;
+    this.markerReg.delete(handle._handleId);
+  }
+  updateMarker(handle, options) {
+    const marker = this.markerReg.get(handle._handleId);
+    if (options.position) marker.position = { lat: options.position.lat, lng: options.position.lng };
+    if (options.title !== void 0) marker.title = options.title ?? "";
+    if (options.zIndex !== void 0) marker.zIndex = options.zIndex ?? null;
+    if (options.draggable !== void 0) marker.gmpDraggable = options.draggable;
+    if (options.clickable !== void 0) marker.gmpClickable = options.clickable;
+    if (options.icon !== void 0) marker.content = buildAdvancedMarkerContent(options) ?? null;
+    if (options.visible !== void 0) {
+      marker.map = options.visible ? this.map : null;
+    }
+    if (options.opacity !== void 0 && marker.content) marker.content.style.opacity = String(options.opacity);
+  }
+  addMarkerEvent(handle, event, handler) {
+    const marker = this.markerReg.get(handle._handleId);
+    marker.addListener(event, handler);
+    return makeEventListener(event);
+  }
+  removeMarkerEvent(_handle, _event, _listener) {
+  }
+  // -------------------------------------------------------------------------
+  // InfoWindow
+  // -------------------------------------------------------------------------
+  openInfoWindow(options, anchor) {
+    const iw = new google.maps.InfoWindow({
+      content: options.content,
+      position: options.position ? new google.maps.LatLng(options.position.lat, options.position.lng) : void 0,
+      maxWidth: options.maxWidth,
+      disableAutoPan: options.disableAutoPan,
+      zIndex: options.zIndex
+    });
+    const advMarker = anchor ? this.markerReg.get(anchor._handleId) : void 0;
+    iw.open({ map: this.map, anchor: advMarker });
+    return makeHandle(this.infoWindowReg.register(iw));
+  }
+  closeInfoWindow(handle) {
+    this.infoWindowReg.get(handle._handleId).close();
+  }
+  updateInfoWindow(handle, options) {
+    const iw = this.infoWindowReg.get(handle._handleId);
+    if (options.content !== void 0) iw.setContent(options.content);
+    if (options.position) iw.setPosition(new google.maps.LatLng(options.position.lat, options.position.lng));
+    if (options.zIndex !== void 0) iw.setZIndex(options.zIndex);
+  }
+  isInfoWindowOpen(handle) {
+    return this.infoWindowReg.get(handle._handleId).getMap() !== null;
+  }
+  // -------------------------------------------------------------------------
+  // Vector overlays
+  // -------------------------------------------------------------------------
+  addPolyline(options) {
+    const polyline = new google.maps.Polyline({
+      map: this.map,
+      path: toGoogleFlatPath(options.path),
+      strokeColor: options.strokeColor,
+      strokeOpacity: options.strokeOpacity,
+      strokeWeight: options.strokeWeight,
+      geodesic: options.geodesic,
+      clickable: options.clickable,
+      zIndex: options.zIndex,
+      visible: options.visible
+    });
+    return makeHandle(this.overlayReg.register(polyline));
+  }
+  removePolyline(handle) {
+    this.overlayReg.get(handle._handleId).setMap(null);
+    this.overlayReg.delete(handle._handleId);
+  }
+  updatePolyline(handle, options) {
+    this.overlayReg.get(handle._handleId).setOptions({
+      strokeColor: options.strokeColor,
+      strokeOpacity: options.strokeOpacity,
+      strokeWeight: options.strokeWeight
+    });
+  }
+  addPolygon(options) {
+    const polygon = new google.maps.Polygon({
+      map: this.map,
+      paths: toGooglePaths(options.paths),
+      strokeColor: options.strokeColor,
+      strokeOpacity: options.strokeOpacity,
+      strokeWeight: options.strokeWeight,
+      fillColor: options.fillColor,
+      fillOpacity: options.fillOpacity,
+      geodesic: options.geodesic,
+      clickable: options.clickable,
+      zIndex: options.zIndex,
+      visible: options.visible
+    });
+    return makeHandle(this.overlayReg.register(polygon));
+  }
+  removePolygon(handle) {
+    this.overlayReg.get(handle._handleId).setMap(null);
+    this.overlayReg.delete(handle._handleId);
+  }
+  updatePolygon(handle, options) {
+    this.overlayReg.get(handle._handleId).setOptions({
+      strokeColor: options.strokeColor,
+      fillColor: options.fillColor,
+      fillOpacity: options.fillOpacity
+    });
+  }
+  addCircle(options) {
+    const circle = new google.maps.Circle({
+      map: this.map,
+      center: new google.maps.LatLng(options.center.lat, options.center.lng),
+      radius: options.radius,
+      strokeColor: options.strokeColor,
+      strokeOpacity: options.strokeOpacity,
+      strokeWeight: options.strokeWeight,
+      fillColor: options.fillColor,
+      fillOpacity: options.fillOpacity,
+      clickable: options.clickable,
+      zIndex: options.zIndex,
+      visible: options.visible
+    });
+    return makeHandle(this.overlayReg.register(circle));
+  }
+  removeCircle(handle) {
+    this.overlayReg.get(handle._handleId).setMap(null);
+    this.overlayReg.delete(handle._handleId);
+  }
+  updateCircle(handle, options) {
+    const circle = this.overlayReg.get(handle._handleId);
+    if (options.center) circle.setCenter(new google.maps.LatLng(options.center.lat, options.center.lng));
+    if (options.radius !== void 0) circle.setRadius(options.radius);
+    circle.setOptions({
+      strokeColor: options.strokeColor,
+      fillColor: options.fillColor,
+      fillOpacity: options.fillOpacity
+    });
+  }
+  addRectangle(options) {
+    const rect = new google.maps.Rectangle({
+      map: this.map,
+      bounds: new google.maps.LatLngBounds(
+        new google.maps.LatLng(options.bounds.sw.lat, options.bounds.sw.lng),
+        new google.maps.LatLng(options.bounds.ne.lat, options.bounds.ne.lng)
+      ),
+      strokeColor: options.strokeColor,
+      strokeOpacity: options.strokeOpacity,
+      strokeWeight: options.strokeWeight,
+      fillColor: options.fillColor,
+      fillOpacity: options.fillOpacity,
+      clickable: options.clickable,
+      zIndex: options.zIndex,
+      visible: options.visible
+    });
+    return makeHandle(this.overlayReg.register(rect));
+  }
+  removeRectangle(handle) {
+    this.overlayReg.get(handle._handleId).setMap(null);
+    this.overlayReg.delete(handle._handleId);
+  }
+  updateRectangle(handle, options) {
+    this.overlayReg.get(handle._handleId).setOptions({
+      strokeColor: options.strokeColor,
+      fillColor: options.fillColor,
+      fillOpacity: options.fillOpacity
+    });
+  }
+  addCustomOverlay(options) {
+    const self = this;
+    const CustomOverlayClass = class extends google.maps.OverlayView {
+      onAdd() {
+        const panes = this.getPanes();
+        if (!panes) return;
+        const pane = options.clickable ? panes.overlayMouseTarget : panes.overlayLayer;
+        pane.appendChild(options.content);
+      }
+      onRemove() {
+        options.content.parentNode?.removeChild(options.content);
+      }
+      draw() {
+        const proj = this.getProjection();
+        const pt = proj.fromLatLngToDivPixel(
+          new google.maps.LatLng(options.position.lat, options.position.lng)
+        );
+        if (pt) {
+          options.content.style.left = `${pt.x}px`;
+          options.content.style.top = `${pt.y}px`;
+          options.content.style.position = "absolute";
+        }
+      }
+    };
+    const overlay = new CustomOverlayClass();
+    overlay.setMap(self.map);
+    return makeHandle(this.overlayReg.register(overlay));
+  }
+  removeCustomOverlay(handle) {
+    this.overlayReg.get(handle._handleId).setMap(null);
+    this.overlayReg.delete(handle._handleId);
+  }
+  addTileLayer(options) {
+    const tileSize = options.tileSize ?? 256;
+    const layer = new google.maps.ImageMapType({
+      getTileUrl: (coord, zoom) => options.getTileUrl({ x: coord.x, y: coord.y }, zoom),
+      tileSize: new google.maps.Size(tileSize, tileSize),
+      minZoom: options.minZoom,
+      maxZoom: options.maxZoom,
+      opacity: options.opacity
+    });
+    if (options.opacity !== void 0) layer.setOpacity(options.opacity);
+    this.map.overlayMapTypes?.push?.(layer);
+    return makeHandle(this.overlayReg.register(layer));
+  }
+  removeTileLayer(handle) {
+    this.overlayReg.delete(handle._handleId);
+  }
+  // -------------------------------------------------------------------------
+  // Projection
+  // -------------------------------------------------------------------------
+  getProjection() {
+    const proj = this.map.getProjection();
+    return {
+      fromLatLngToPoint: (latlng) => {
+        const pt = proj?.fromLatLngToPoint(new google.maps.LatLng(latlng.lat, latlng.lng));
+        return pt ? { x: pt.x, y: pt.y } : { x: 0, y: 0 };
+      },
+      fromPointToLatLng: (point) => {
+        const c = proj?.fromPointToLatLng(new google.maps.Point(point.x, point.y));
+        return c ? { lat: c.lat(), lng: c.lng() } : { lat: 0, lng: 0 };
+      },
+      fromLatLngToDivPixel: (latlng) => {
+        const pt = proj?.fromLatLngToPoint(new google.maps.LatLng(latlng.lat, latlng.lng));
+        return pt ? { x: pt.x, y: pt.y } : { x: 0, y: 0 };
+      }
+    };
+  }
+};
+function resolveApiKey(apiKey) {
+  if (typeof apiKey === "string") return apiKey;
+  if (apiKey.apiKey) return apiKey.apiKey;
+  throw new ConfigurationError("Google Maps requires an apiKey");
+}
+function normalizePaddingForGoogle(padding) {
+  if (padding === void 0) return 0;
+  if (typeof padding === "number") return padding;
+  return {
+    top: padding.top ?? 0,
+    right: padding.right ?? 0,
+    bottom: padding.bottom ?? 0,
+    left: padding.left ?? 0
+  };
+}
+function toGoogleLatLng(latlng) {
+  return new google.maps.LatLng(latlng.lat, latlng.lng);
+}
+function toGoogleFlatPath(path) {
+  if (path.length === 0) return [];
+  if (Array.isArray(path[0])) {
+    return path[0].map(toGoogleLatLng);
+  }
+  return path.map(toGoogleLatLng);
+}
+function toGooglePaths(paths) {
+  if (paths.length === 0) return [];
+  if (Array.isArray(paths[0])) {
+    return paths.map((ring) => ring.map(toGoogleLatLng));
+  }
+  return paths.map(toGoogleLatLng);
+}
+function buildAdvancedMarkerContent(options) {
+  const { icon, label } = options;
+  if (!icon && !label) return void 0;
+  const container = document.createElement("div");
+  container.style.cssText = "display:flex;flex-direction:column;align-items:center;cursor:pointer";
+  if (icon) {
+    const img = document.createElement("img");
+    img.src = typeof icon === "string" ? icon : icon.url;
+    if (typeof icon === "object") {
+      const sz = icon.scaledSize ?? icon.size;
+      if (sz) {
+        img.style.width = `${sz.width}px`;
+        img.style.height = `${sz.height}px`;
+      }
+    }
+    container.appendChild(img);
+  }
+  if (label) {
+    const span = document.createElement("span");
+    span.textContent = label.text;
+    span.style.cssText = [
+      `color:${label.color ?? "#000"}`,
+      `font-size:${label.fontSize ?? "12px"}`,
+      `font-weight:${label.fontWeight ?? "normal"}`,
+      "white-space:nowrap"
+    ].join(";");
+    container.appendChild(span);
+  }
+  return container;
+}
+
+// src/core/KorMap.ts
+var KorMap = class _KorMap {
+  adapter;
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  /**
+   * Async factory. Loads the provider SDK and initializes the map.
+   */
+  static async create(config) {
+    const container = resolveContainer(config.container);
+    const adapter = createAdapter(config.provider);
+    await adapter.init(container, config);
+    return new _KorMap(adapter);
+  }
+  // -------------------------------------------------------------------------
+  // Provider info
+  // -------------------------------------------------------------------------
+  getProvider() {
+    return this.adapter.provider;
+  }
+  supports(feature) {
+    return this.adapter.supports(feature);
+  }
+  /**
+   * The raw underlying map object.
+   * Typed via generic when the provider is known at compile time:
+   *   const map = await KorMap.create<'naver'>({ provider: 'naver', ... });
+   *   map.native  // → naver.maps.Map
+   */
+  get native() {
+    return this.adapter.nativeMap;
+  }
+  // -------------------------------------------------------------------------
+  // Camera / viewport
+  // -------------------------------------------------------------------------
+  setCenter(latlng) {
+    this.adapter.setCenter(latlng);
+  }
+  getCenter() {
+    return this.adapter.getCenter();
+  }
+  setZoom(zoom) {
+    this.adapter.setZoom(zoom);
+  }
+  getZoom() {
+    return this.adapter.getZoom();
+  }
+  getBounds() {
+    return this.adapter.getBounds();
+  }
+  fitBounds(bounds, options) {
+    this.adapter.fitBounds(bounds, options);
+  }
+  panTo(latlng, options) {
+    this.adapter.panTo(latlng, options);
+  }
+  panBy(x, y) {
+    this.adapter.panBy(x, y);
+  }
+  // -------------------------------------------------------------------------
+  // Map type
+  // -------------------------------------------------------------------------
+  setMapType(type) {
+    this.adapter.setMapType(type);
+  }
+  getMapType() {
+    return this.adapter.getMapType();
+  }
+  // -------------------------------------------------------------------------
+  // Events
+  // -------------------------------------------------------------------------
+  on(event, handler) {
+    return this.adapter.on(event, handler);
+  }
+  once(event, handler) {
+    return this.adapter.once(event, handler);
+  }
+  off(event, listener) {
+    this.adapter.off(event, listener);
+  }
+  // -------------------------------------------------------------------------
+  // Lifecycle
+  // -------------------------------------------------------------------------
+  destroy() {
+    this.adapter.destroy();
+  }
+  // -------------------------------------------------------------------------
+  // Internal adapter access (for overlay classes)
+  // -------------------------------------------------------------------------
+  /** @internal */
+  _adapter() {
+    return this.adapter;
+  }
+};
+function resolveContainer(container) {
+  if (typeof container === "string") {
+    const el = /^[#.[[]/.test(container) ? document.querySelector(container) : document.getElementById(container);
+    if (!el) throw new ConfigurationError(`Container element not found: "${container}"`);
+    return el;
+  }
+  return container;
+}
+function createAdapter(provider) {
+  switch (provider) {
+    case "kakao":
+      return new KakaoAdapter();
+    case "naver":
+      return new NaverAdapter();
+    case "google":
+      return new GoogleAdapter();
+    default:
+      throw new ConfigurationError(`Unknown provider: "${String(provider)}"`);
+  }
+}
+
+// src/core/overlays.ts
+var Marker = class {
+  constructor(options) {
+    this.options = options;
+  }
+  handle = null;
+  currentMap = null;
+  setMap(map) {
+    if (this.currentMap && this.handle) {
+      this.currentMap._adapter().removeMarker(this.handle);
+      this.handle = null;
+      this.currentMap = null;
+    }
+    if (map) {
+      this.handle = map._adapter().addMarker(this.options);
+      this.currentMap = map;
+    }
+  }
+  getMap() {
+    return this.currentMap;
+  }
+  setPosition(latlng) {
+    this.options = { ...this.options, position: latlng };
+    if (this.handle && this.currentMap) {
+      this.currentMap._adapter().updateMarker(this.handle, { position: latlng });
+    }
+  }
+  getPosition() {
+    return this.options.position;
+  }
+  setVisible(visible) {
+    this.options = { ...this.options, visible };
+    if (this.handle && this.currentMap) {
+      this.currentMap._adapter().updateMarker(this.handle, { visible });
+    }
+  }
+  setOpacity(opacity) {
+    this.options = { ...this.options, opacity };
+    if (this.handle && this.currentMap) {
+      this.currentMap._adapter().updateMarker(this.handle, { opacity });
+    }
+  }
+  setZIndex(zIndex) {
+    this.options = { ...this.options, zIndex };
+    if (this.handle && this.currentMap) {
+      this.currentMap._adapter().updateMarker(this.handle, { zIndex });
+    }
+  }
+  setDraggable(draggable) {
+    this.options = { ...this.options, draggable };
+    if (this.handle && this.currentMap) {
+      this.currentMap._adapter().updateMarker(this.handle, { draggable });
+    }
+  }
+  setIcon(icon) {
+    this.options = { ...this.options, icon };
+    if (this.handle && this.currentMap) {
+      this.currentMap._adapter().updateMarker(this.handle, { icon });
+    }
+  }
+  setOptions(options) {
+    this.options = { ...this.options, ...options };
+    if (this.handle && this.currentMap) {
+      this.currentMap._adapter().updateMarker(this.handle, options);
+    }
+  }
+  on(event, handler) {
+    if (!this.handle || !this.currentMap) return null;
+    return this.currentMap._adapter().addMarkerEvent(this.handle, event, handler);
+  }
+  off(event, listener) {
+    if (!this.handle || !this.currentMap) return;
+    this.currentMap._adapter().removeMarkerEvent(this.handle, event, listener);
+  }
+};
+var InfoWindow = class {
+  constructor(options) {
+    this.options = options;
+  }
+  handle = null;
+  currentMap = null;
+  open(map, anchor) {
+    if (this.handle && this.currentMap) this.close();
+    const markerHandle = anchor ? anchor.handle : void 0;
+    this.handle = map._adapter().openInfoWindow(this.options, markerHandle ?? void 0);
+    this.currentMap = map;
+  }
+  close() {
+    if (this.handle && this.currentMap) {
+      this.currentMap._adapter().closeInfoWindow(this.handle);
+      this.handle = null;
+      this.currentMap = null;
+    }
+  }
+  setContent(content) {
+    this.options = { ...this.options, content };
+    if (this.handle && this.currentMap) {
+      this.currentMap._adapter().updateInfoWindow(this.handle, { content });
+    }
+  }
+  getContent() {
+    return this.options.content;
+  }
+  setPosition(latlng) {
+    this.options = { ...this.options, position: latlng };
+    if (this.handle && this.currentMap) {
+      this.currentMap._adapter().updateInfoWindow(this.handle, { position: latlng });
+    }
+  }
+  isOpen() {
+    if (!this.handle || !this.currentMap) return false;
+    return this.currentMap._adapter().isInfoWindowOpen(this.handle);
+  }
+};
+var Polyline = class {
+  constructor(options) {
+    this.options = options;
+  }
+  handle = null;
+  currentMap = null;
+  setMap(map) {
+    if (this.currentMap && this.handle) {
+      this.currentMap._adapter().removePolyline(this.handle);
+      this.handle = null;
+      this.currentMap = null;
+    }
+    if (map) {
+      this.handle = map._adapter().addPolyline(this.options);
+      this.currentMap = map;
+    }
+  }
+  setOptions(options) {
+    this.options = { ...this.options, ...options };
+    if (this.handle && this.currentMap) {
+      this.currentMap._adapter().updatePolyline(this.handle, options);
+    }
+  }
+};
+var Polygon = class {
+  constructor(options) {
+    this.options = options;
+  }
+  handle = null;
+  currentMap = null;
+  setMap(map) {
+    if (this.currentMap && this.handle) {
+      this.currentMap._adapter().removePolygon(this.handle);
+      this.handle = null;
+      this.currentMap = null;
+    }
+    if (map) {
+      this.handle = map._adapter().addPolygon(this.options);
+      this.currentMap = map;
+    }
+  }
+  setOptions(options) {
+    this.options = { ...this.options, ...options };
+    if (this.handle && this.currentMap) {
+      this.currentMap._adapter().updatePolygon(this.handle, options);
+    }
+  }
+};
+var Circle = class {
+  constructor(options) {
+    this.options = options;
+  }
+  handle = null;
+  currentMap = null;
+  setMap(map) {
+    if (this.currentMap && this.handle) {
+      this.currentMap._adapter().removeCircle(this.handle);
+      this.handle = null;
+      this.currentMap = null;
+    }
+    if (map) {
+      this.handle = map._adapter().addCircle(this.options);
+      this.currentMap = map;
+    }
+  }
+  setOptions(options) {
+    this.options = { ...this.options, ...options };
+    if (this.handle && this.currentMap) {
+      this.currentMap._adapter().updateCircle(this.handle, options);
+    }
+  }
+};
+var Rectangle = class {
+  constructor(options) {
+    this.options = options;
+  }
+  handle = null;
+  currentMap = null;
+  setMap(map) {
+    if (this.currentMap && this.handle) {
+      this.currentMap._adapter().removeRectangle(this.handle);
+      this.handle = null;
+      this.currentMap = null;
+    }
+    if (map) {
+      this.handle = map._adapter().addRectangle(this.options);
+      this.currentMap = map;
+    }
+  }
+  setOptions(options) {
+    this.options = { ...this.options, ...options };
+    if (this.handle && this.currentMap) {
+      this.currentMap._adapter().updateRectangle(this.handle, options);
+    }
+  }
+};
+var CustomOverlay = class {
+  constructor(options) {
+    this.options = options;
+  }
+  handle = null;
+  currentMap = null;
+  setMap(map) {
+    if (this.currentMap && this.handle) {
+      this.currentMap._adapter().removeCustomOverlay(this.handle);
+      this.handle = null;
+      this.currentMap = null;
+    }
+    if (map) {
+      this.handle = map._adapter().addCustomOverlay(this.options);
+      this.currentMap = map;
+    }
+  }
+  setPosition(latlng) {
+    this.options = { ...this.options, position: latlng };
+  }
+  getPosition() {
+    return this.options.position;
+  }
+};
+var TileLayer = class {
+  constructor(options) {
+    this.options = options;
+  }
+  handle = null;
+  currentMap = null;
+  setMap(map) {
+    if (this.currentMap && this.handle) {
+      this.currentMap._adapter().removeTileLayer(this.handle);
+      this.handle = null;
+      this.currentMap = null;
+    }
+    if (map) {
+      this.handle = map._adapter().addTileLayer(this.options);
+      this.currentMap = map;
+    }
+  }
+};
+
+export { Circle, ConfigurationError, CustomOverlay, InfoWindow, KorMap, KorMapError, Marker, Polygon, Polyline, ProviderLoadError, ProviderNotSupportedError, Rectangle, TileLayer };
+//# sourceMappingURL=chunk-222QLGRB.js.map
+//# sourceMappingURL=chunk-222QLGRB.js.map