@caoguo/maplibre-ai 0.0.2 → 0.0.5

package/dist/index.cjs

@@ -237,19 +237,1293 @@ function toggleMode(style) {
   };
 }
 
+// src/copilot/copilot.ts
+var PLACE_COORDINATES = {
+  \u6B66\u6C49: [114.305, 30.593],
+  \u5149\u8C37: [114.428, 30.507],
+  \u6C49\u53E3: [114.268, 30.586],
+  \u6B66\u660C: [114.316, 30.554],
+  \u5317\u4EAC: [116.407, 39.904],
+  \u4E0A\u6D77: [121.474, 31.23],
+  \u5E7F\u5DDE: [113.264, 23.129],
+  \u6DF1\u5733: [114.058, 22.543],
+  \u6210\u90FD: [104.067, 30.573],
+  \u676D\u5DDE: [120.155, 30.274],
+  \u5357\u4EAC: [118.796, 32.06],
+  \u91CD\u5E86: [106.551, 29.563],
+  \u897F\u5B89: [108.94, 34.341],
+  \u5929\u6D25: [117.2, 39.084]
+};
+var COLOR_NAMES = {
+  \u7EA2: "#ef4444",
+  \u7EA2\u8272: "#ef4444",
+  \u6A59: "#f97316",
+  \u6A59\u8272: "#f97316",
+  \u9EC4: "#f59e0b",
+  \u9EC4\u8272: "#f59e0b",
+  \u7EFF: "#22c55e",
+  \u7EFF\u8272: "#22c55e",
+  \u9752: "#22d3ee",
+  \u84DD\u8272: "#3b82f6",
+  \u84DD: "#3b82f6",
+  \u7D2B: "#8b5cf6",
+  \u7D2B\u8272: "#8b5cf6",
+  \u7C89: "#ec4899",
+  \u7070: "#6b7280",
+  \u9ED1\u8272: "#111827",
+  \u767D\u8272: "#ffffff"
+};
+var INTENT_PATTERNS = [
+  { intent: "popup_interaction", re: /弹窗|信息窗|弹出|popup|点击.*?显示|点击.*?弹出|点击.*?信息/, confidence: 0.92 },
+  { intent: "heatmap", re: /热力|heatmap|热度|密度图|热图/, confidence: 0.9 },
+  { intent: "add_line_polygon", re: /路线|连线|线段|画.{0,2}(线|面)|多边形|折线|面要素|LineString|polygon/, confidence: 0.88 },
+  { intent: "add_marker", re: /标记|marker|点标记|加点|标注|mark/, confidence: 0.86 },
+  { intent: "create_map", re: /地图|初始化|创建|生成|画布|渲染|map/, confidence: 0.8 }
+];
+function classifyIntent(query) {
+  let best = { intent: "unknown", confidence: 0 };
+  for (const p of INTENT_PATTERNS) {
+    const m = query.match(p.re);
+    if (m) {
+      const c = p.confidence * (1 + 0.03 * Math.min(m[0].length / query.length, 1));
+      if (c > best.confidence) best = { intent: p.intent, confidence: Math.min(c, 1) };
+    }
+  }
+  return best;
+}
+function extractParams(query, intent) {
+  const params = {};
+  for (const [name, coord] of Object.entries(PLACE_COORDINATES)) {
+    if (query.includes(name)) {
+      params.place = name;
+      params.center = coord;
+      break;
+    }
+  }
+  const zoomMatch = query.match(/缩放\s*(\d{1,2})|zoom\s*(\d{1,2})|级别\s*(\d{1,2})/i);
+  if (zoomMatch) {
+    const z = parseInt(zoomMatch[1] ?? zoomMatch[2] ?? zoomMatch[3]);
+    if (!Number.isNaN(z) && z >= 0 && z <= 22) params.zoom = z;
+  }
+  if (/暗色|暗黑|深色|dark|夜间/.test(query)) params.style = "caoguo-dark";
+  else if (/亮色|浅色|白色|light|白天/.test(query)) params.style = "caoguo-light";
+  for (const [name, hex] of Object.entries(COLOR_NAMES)) {
+    if (query.includes(name)) {
+      params.color = hex;
+      break;
+    }
+  }
+  const sizeMatch = query.match(/(?:宽度|半径|大小|width|size)\s*(\d+)/i);
+  if (sizeMatch) params.size = parseInt(sizeMatch[1]);
+  const layerMatch = query.match(/(?:图层|layer)\s*["']?([\w-]+)["']?/i);
+  if (layerMatch) params.layerId = layerMatch[1];
+  const textMatch = query.match(/["「『]([^"」』]+)["」』]/);
+  if (textMatch) params.text = textMatch[1];
+  return params;
+}
+function generateCode(intent, p) {
+  const center = p.center ?? [114.305, 30.593];
+  const zoom = p.zoom ?? 12;
+  const style = p.style ?? "caoguo-dark";
+  const color = p.color ?? "#ef4444";
+  const size = p.size ?? 8;
+  const layerId = p.layerId ?? "my-layer";
+  switch (intent) {
+    case "create_map":
+      return [
+        `const map = new CaoguoMap.Map({`,
+        `  container: 'map',`,
+        `  center: [${center[0]}, ${center[1]}],`,
+        `  zoom: ${zoom},`,
+        `  style: '${style}',`,
+        `});`
+      ].join("\n");
+    case "add_marker":
+      return [
+        `map.addSource('marker-src', {`,
+        `  type: 'geojson',`,
+        `  data: { type: 'Feature', geometry: { type: 'Point', coordinates: [${center[0]}, ${center[1]}] }, properties: {} },`,
+        `});`,
+        `map.addLayer({`,
+        `  id: '${layerId}',`,
+        `  type: 'circle',`,
+        `  source: 'marker-src',`,
+        `  paint: { 'circle-radius': ${size}, 'circle-color': '${color}' },`,
+        `});`
+      ].join("\n");
+    case "add_line_polygon":
+      return [
+        `map.addSource('line-src', {`,
+        `  type: 'geojson',`,
+        `  data: { type: 'Feature', geometry: { type: 'LineString', coordinates: [[${center[0]}, ${center[1]}], [${(center[0] + 0.05).toFixed(3)}, ${(center[1] + 0.03).toFixed(3)}]] }, properties: {} },`,
+        `});`,
+        `map.addLayer({`,
+        `  id: '${layerId}',`,
+        `  type: 'line',`,
+        `  source: 'line-src',`,
+        `  paint: { 'line-color': '${color}', 'line-width': ${Math.max(2, size)} },`,
+        `});`
+      ].join("\n");
+    case "heatmap":
+      return [
+        `map.addSource('heat-src', {`,
+        `  type: 'geojson',`,
+        `  data: { type: 'FeatureCollection', features: [] },`,
+        `});`,
+        `map.addLayer({`,
+        `  id: '${layerId}',`,
+        `  type: 'heatmap',`,
+        `  source: 'heat-src',`,
+        `  paint: {`,
+        `    'heatmap-weight': 1,`,
+        `    'heatmap-color': ['interpolate', ['linear'], ['heatmap-density'], 0, 'rgba(33,102,172,0)', 0.5, '${color}', 1, 'rgb(239,68,68)'],`,
+        `    'heatmap-radius': ${Math.max(20, size * 4)},`,
+        `  },`,
+        `});`
+      ].join("\n");
+    case "popup_interaction":
+      return [
+        `map.on('click', '${layerId}', (e) => {`,
+        `  const coords = e.features[0].geometry.coordinates.slice();`,
+        `  new maplibregl.Popup()`,
+        `    .setLngLat(coords)`,
+        `    .setHTML('${p.text ?? "\u8981\u7D20\u4FE1\u606F"}')`,
+        `    .addTo(map.instance);`,
+        `});`
+      ].join("\n");
+    default:
+      return `// \u65E0\u6CD5\u8BC6\u522B\u7684\u610F\u56FE\uFF1A${intent}`;
+  }
+}
+function generateFromQuery(query) {
+  const { intent, confidence } = classifyIntent(query);
+  const params = extractParams(query);
+  const code = generateCode(intent, params);
+  return {
+    intent,
+    params,
+    code,
+    confidence,
+    description: buildDescription(intent, params)
+  };
+}
+function buildDescription(intent, p) {
+  const parts = [];
+  switch (intent) {
+    case "create_map":
+      parts.push("\u521B\u5EFA\u57FA\u7840\u5730\u56FE");
+      break;
+    case "add_marker":
+      parts.push("\u6DFB\u52A0\u70B9\u6807\u8BB0");
+      break;
+    case "add_line_polygon":
+      parts.push("\u6DFB\u52A0\u7EBF/\u9762\u8981\u7D20");
+      break;
+    case "heatmap":
+      parts.push("\u751F\u6210\u70ED\u529B\u56FE");
+      break;
+    case "popup_interaction":
+      parts.push("\u7ED1\u5B9A\u70B9\u51FB\u5F39\u7A97");
+      break;
+    default:
+      parts.push("\u672A\u77E5\u610F\u56FE");
+  }
+  if (p.place) parts.push(`\u5730\u70B9:${p.place}`);
+  if (p.color) parts.push(`\u989C\u8272:${p.color}`);
+  return parts.join(" ");
+}
+var MapCopilot = class {
+  lastIntent = "create_map";
+  lastParams = {};
+  /** 生成代码（支持上下文增量修改） */
+  generate(query) {
+    const { intent, confidence } = classifyIntent(query);
+    const isModification = /改成|改为|换成|变成|调整为|设置成/.test(query);
+    if (isModification && this.lastIntent !== "unknown") {
+      const delta = extractParams(query, this.lastIntent);
+      this.lastParams = { ...this.lastParams, ...delta };
+      const code2 = generateCode(this.lastIntent, this.lastParams);
+      return {
+        intent: this.lastIntent,
+        params: { ...this.lastParams },
+        code: code2,
+        confidence,
+        description: buildDescription(this.lastIntent, this.lastParams)
+      };
+    }
+    this.lastIntent = intent;
+    this.lastParams = extractParams(query);
+    const code = generateCode(intent, this.lastParams);
+    return {
+      intent,
+      params: { ...this.lastParams },
+      code,
+      confidence,
+      description: buildDescription(intent, this.lastParams)
+    };
+  }
+  /** 重置上下文 */
+  reset() {
+    this.lastIntent = "create_map";
+    this.lastParams = {};
+  }
+  /** 获取当前上下文 */
+  get context() {
+    return { intent: this.lastIntent, params: { ...this.lastParams } };
+  }
+};
+
+// src/copilot/llmCopilot.ts
+var SYSTEM_PROMPT = `\u4F60\u662F"\u8349\u679C\u5730\u56FE"(CaoguoMap) \u7684\u5730\u56FE\u4EE3\u7801\u751F\u6210\u52A9\u624B\u3002\u7528\u6237\u7528\u81EA\u7136\u8BED\u8A00\u63CF\u8FF0\u5730\u56FE\u9700\u6C42\uFF0C\u4F60\u751F\u6210\u5BF9\u5E94\u7684 MapLibre GL JS \u4EE3\u7801\u7247\u6BB5\u3002
+
+\u8349\u679C\u5730\u56FE API \u7EA6\u5B9A\uFF1A
+- \u5730\u56FE\u5B9E\u4F8B\uFF1Anew CaoguoMap.Map({ container, center, zoom, style })
+- \u6DFB\u52A0\u70B9\uFF1Amap.addSource + map.addLayer({ type: 'circle' })
+- \u6DFB\u52A0\u7EBF\uFF1Amap.addLayer({ type: 'line' })
+- \u70ED\u529B\u56FE\uFF1Amap.addLayer({ type: 'heatmap' })
+- \u5F39\u7A97\uFF1Amap.on('click', layerId, cb) + new maplibregl.Popup()
+
+\u8981\u6C42\uFF1A
+1. \u53EA\u8FD4\u56DE JSON\uFF0C\u683C\u5F0F\uFF1A{"intent":"create_map|add_marker|add_line_polygon|heatmap|popup_interaction","code":"...","description":"..."}
+2. code \u5FC5\u987B\u662F\u53EF\u76F4\u63A5\u8FD0\u884C\u7684 JavaScript \u4EE3\u7801\u7247\u6BB5\uFF08\u4E0D\u542B import\uFF09\uFF0C\u7981\u6B62\u5305\u542B\u4EFB\u4F55 fetch/\u7F51\u7EDC\u8BF7\u6C42/\u6587\u4EF6\u7CFB\u7EDF/\u5371\u9669\u64CD\u4F5C\u3002
+3. \u82E5\u9700\u6C42\u8D85\u51FA\u5730\u56FE\u4EE3\u7801\u8303\u7574\uFF0C\u8FD4\u56DE {"intent":"unknown","code":"","description":"\u65E0\u6CD5\u8BC6\u522B\u7684\u9700\u6C42"}\u3002
+4. \u4E0D\u8981\u8F93\u51FA JSON \u4EE5\u5916\u7684\u4EFB\u4F55\u6587\u5B57\u3002`;
+var LlmMapCopilot = class {
+  client;
+  enabled;
+  constructor(config) {
+    this.client = config.client;
+    this.enabled = config.enabled ?? true;
+  }
+  /** 生成代码：LLM 优先，失败降级规则引擎 */
+  async generate(query) {
+    if (!this.enabled) {
+      return generateFromQuery(query);
+    }
+    try {
+      return await this.generateWithLlm(query);
+    } catch {
+      return generateFromQuery(query);
+    }
+  }
+  async generateWithLlm(query) {
+    const messages = [
+      { role: "system", content: SYSTEM_PROMPT },
+      { role: "user", content: query }
+    ];
+    const { data } = await this.client.chatJson(messages);
+    const intent = data.intent ?? "unknown";
+    const code = data.code ?? "";
+    if (intent === "unknown" || !code.trim()) {
+      return generateFromQuery(query);
+    }
+    return {
+      intent,
+      params: {},
+      code,
+      confidence: 0.9,
+      description: data.description ?? `LLM \u751F\u6210\uFF08${intent}\uFF09`
+    };
+  }
+};
+
+// src/geoai/addressParser.ts
+var PROVINCES = [
+  "\u5317\u4EAC",
+  "\u4E0A\u6D77",
+  "\u5929\u6D25",
+  "\u91CD\u5E86",
+  "\u6CB3\u5317",
+  "\u5C71\u897F",
+  "\u8FBD\u5B81",
+  "\u5409\u6797",
+  "\u9ED1\u9F99\u6C5F",
+  "\u6C5F\u82CF",
+  "\u6D59\u6C5F",
+  "\u5B89\u5FBD",
+  "\u798F\u5EFA",
+  "\u6C5F\u897F",
+  "\u5C71\u4E1C",
+  "\u6CB3\u5357",
+  "\u6E56\u5317",
+  "\u6E56\u5357",
+  "\u5E7F\u4E1C",
+  "\u6D77\u5357",
+  "\u56DB\u5DDD",
+  "\u8D35\u5DDE",
+  "\u4E91\u5357",
+  "\u9655\u897F",
+  "\u7518\u8083",
+  "\u9752\u6D77",
+  "\u5185\u8499\u53E4",
+  "\u5E7F\u897F",
+  "\u897F\u85CF",
+  "\u5B81\u590F",
+  "\u65B0\u7586",
+  "\u9999\u6E2F",
+  "\u6FB3\u95E8",
+  "\u53F0\u6E7E"
+];
+var CITIES = {
+  \u6E56\u5317: ["\u6B66\u6C49", "\u9EC4\u77F3", "\u8944\u9633", "\u5B9C\u660C", "\u8346\u5DDE", "\u5341\u5830", "\u5B5D\u611F", "\u9EC4\u5188", "\u54B8\u5B81", "\u968F\u5DDE", "\u6069\u65BD", "\u9102\u5DDE", "\u8346\u95E8", "\u4ED9\u6843", "\u5929\u95E8", "\u6F5C\u6C5F"],
+  \u5E7F\u4E1C: ["\u5E7F\u5DDE", "\u6DF1\u5733", "\u73E0\u6D77", "\u4F5B\u5C71", "\u4E1C\u839E", "\u4E2D\u5C71", "\u60E0\u5DDE", "\u6C5F\u95E8", "\u6E5B\u6C5F", "\u8302\u540D", "\u8087\u5E86", "\u6C55\u5934", "\u97F6\u5173"],
+  \u6C5F\u82CF: ["\u5357\u4EAC", "\u82CF\u5DDE", "\u65E0\u9521", "\u5E38\u5DDE", "\u5357\u901A", "\u5F90\u5DDE", "\u626C\u5DDE", "\u9547\u6C5F", "\u6CF0\u5DDE", "\u76D0\u57CE", "\u8FDE\u4E91\u6E2F", "\u6DEE\u5B89", "\u5BBF\u8FC1"],
+  \u6D59\u6C5F: ["\u676D\u5DDE", "\u5B81\u6CE2", "\u6E29\u5DDE", "\u5609\u5174", "\u6E56\u5DDE", "\u7ECD\u5174", "\u91D1\u534E", "\u8862\u5DDE", "\u821F\u5C71", "\u53F0\u5DDE", "\u4E3D\u6C34"],
+  \u56DB\u5DDD: ["\u6210\u90FD", "\u7EF5\u9633", "\u5FB7\u9633", "\u5B9C\u5BBE", "\u6CF8\u5DDE", "\u5357\u5145", "\u8FBE\u5DDE", "\u4E50\u5C71", "\u5185\u6C5F", "\u81EA\u8D21"]
+};
+var FLAT_CITIES = [
+  ...Object.values(CITIES).flat(),
+  "\u5317\u4EAC",
+  "\u4E0A\u6D77",
+  "\u5929\u6D25",
+  "\u91CD\u5E86"
+];
+var WUHAN_DISTRICTS = [
+  "\u6C5F\u5CB8\u533A",
+  "\u6C5F\u6C49\u533A",
+  "\u785A\u53E3\u533A",
+  "\u6C49\u9633\u533A",
+  "\u6B66\u660C\u533A",
+  "\u9752\u5C71\u533A",
+  "\u6D2A\u5C71\u533A",
+  "\u4E1C\u897F\u6E56\u533A",
+  "\u6C49\u5357\u533A",
+  "\u8521\u7538\u533A",
+  "\u6C5F\u590F\u533A",
+  "\u9EC4\u9642\u533A",
+  "\u65B0\u6D32\u533A"
+];
+var POI_DICT = [
+  "\u5149\u8C37",
+  "\u5149\u8C37\u5E7F\u573A",
+  "\u6C49\u53E3\u706B\u8F66\u7AD9",
+  "\u6B66\u660C\u706B\u8F66\u7AD9",
+  "\u6B66\u6C49\u7AD9",
+  "\u5929\u6CB3\u673A\u573A",
+  "\u6B66\u6C49\u5927\u5B66",
+  "\u534E\u4E2D\u79D1\u6280\u5927\u5B66",
+  "\u9EC4\u9E64\u697C",
+  "\u4E1C\u6E56",
+  "\u957F\u6C5F\u5927\u6865",
+  "\u6C5F\u6C49\u8DEF",
+  "\u695A\u6CB3\u6C49\u8857",
+  "\u8857\u9053\u53E3",
+  "\u4E2D\u5357\u8DEF",
+  "\u5F90\u4E1C",
+  "\u738B\u5BB6\u6E7E",
+  "\u949F\u5BB6\u6751",
+  "\u6C49\u6B63\u8857",
+  "\u8F6F\u4EF6\u56ED",
+  "\u91D1\u878D\u6E2F",
+  "\u751F\u7269\u57CE",
+  "\u672A\u6765\u79D1\u6280\u57CE"
+];
+function parseAddress(raw) {
+  const input = (raw ?? "").trim();
+  if (!input) return { raw: input, normalized: "", confidence: 0 };
+  const result = { raw: input, normalized: input, confidence: 0.3 };
+  let matched = 0;
+  for (const p of PROVINCES) {
+    if (input.includes(p)) {
+      result.province = p;
+      matched++;
+      break;
+    }
+  }
+  if (result.province) {
+    const provinceCities = CITIES[result.province] ?? [];
+    for (const c of provinceCities) {
+      if (input.includes(c)) {
+        result.city = c;
+        matched++;
+        break;
+      }
+    }
+    if (!result.city && ["\u5317\u4EAC", "\u4E0A\u6D77", "\u5929\u6D25", "\u91CD\u5E86"].includes(result.province)) {
+      result.city = result.province;
+      matched++;
+    }
+  }
+  if (!result.city) {
+    for (const c of FLAT_CITIES) {
+      if (input.includes(c)) {
+        result.city = c;
+        matched++;
+        break;
+      }
+    }
+  }
+  for (const d of WUHAN_DISTRICTS) {
+    if (input.includes(d)) {
+      result.district = d;
+      matched++;
+      break;
+    }
+  }
+  if (!result.district) {
+    const districtMatch = input.match(/[\u4e00-\u9fa5]{2,4}(区|县)/);
+    if (districtMatch && !districtMatch[0].startsWith("\u6B66\u6C49")) {
+      result.district = districtMatch[0];
+      matched++;
+    }
+  }
+  for (const poi of POI_DICT) {
+    if (input.includes(poi)) {
+      result.poi = poi;
+      matched++;
+      break;
+    }
+  }
+  const streetMatch = input.match(/[\u4e00-\u9fa5]{2,8}(?:路|街|道|大道|大街)/);
+  if (streetMatch) {
+    result.street = streetMatch[0];
+    matched++;
+  }
+  const numMatch = input.match(/(\d+)\s*号/);
+  if (numMatch) {
+    result.number = numMatch[1];
+    matched++;
+  }
+  result.normalized = [
+    result.province,
+    result.city && result.city !== result.province ? result.city : "",
+    result.district,
+    result.poi,
+    result.street,
+    result.number ? `${result.number}\u53F7` : ""
+  ].filter(Boolean).join("");
+  result.confidence = Math.min(0.95, 0.3 + matched * 0.15);
+  return result;
+}
+function isValidAddress(parsed) {
+  return Boolean(parsed.province || parsed.city || parsed.district || parsed.poi);
+}
+
+// src/geoai/headerDetector.ts
+var ADDRESS_KEYS = [
+  "\u5730\u5740",
+  "\u4F4D\u7F6E",
+  "\u5730\u70B9",
+  "\u6240\u5728\u5730",
+  "\u8BE6\u7EC6\u5730\u5740",
+  "\u4F4F\u5740",
+  "\u5730\u7406\u4F4D\u7F6E",
+  "\u8054\u7CFB\u5730\u5740",
+  "address",
+  "addr",
+  "location",
+  "place"
+];
+var NAME_KEYS = ["\u540D\u79F0", "\u540D\u5B57", "\u5355\u4F4D", "\u673A\u6784", "\u7AD9\u70B9", "\u573A\u6240", "name", "title", "label"];
+var CATEGORY_KEYS = ["\u7C7B\u578B", "\u5206\u7C7B", "\u7C7B\u522B", "\u884C\u4E1A", "\u4E1A\u6001", "category", "type", "kind", "class"];
+var LNG_KEYS = ["\u7ECF\u5EA6", "lng", "lon", "longitude", "x\u5750\u6807", "\u7ECF\u5EA6\u5750\u6807", "long", "x"];
+var LAT_KEYS = ["\u7EAC\u5EA6", "lat", "latitude", "y\u5750\u6807", "\u7EAC\u5EA6\u5750\u6807", "y"];
+function normalize(h) {
+  return h.trim().toLowerCase().replace(/[\s_-]+/g, "");
+}
+function matchHeader(headers, keys) {
+  const normalized = headers.map(normalize);
+  for (let i = 0; i < normalized.length; i++) {
+    const h = normalized[i];
+    for (const k of keys) {
+      if (h === normalize(k) || h.includes(normalize(k))) {
+        return i;
+      }
+    }
+  }
+  return -1;
+}
+function detectHeaders(headers) {
+  const addressCol = matchHeader(headers, ADDRESS_KEYS);
+  const nameCol = matchHeader(headers, NAME_KEYS);
+  const categoryCol = matchHeader(headers, CATEGORY_KEYS);
+  const lngCol = matchHeader(headers, LNG_KEYS);
+  const latCol = matchHeader(headers, LAT_KEYS);
+  const detail = {};
+  if (addressCol >= 0) detail.address = headers[addressCol];
+  if (nameCol >= 0) detail.name = headers[nameCol];
+  if (categoryCol >= 0) detail.category = headers[categoryCol];
+  if (lngCol >= 0) detail.lng = headers[lngCol];
+  if (latCol >= 0) detail.lat = headers[latCol];
+  return { addressCol, nameCol, categoryCol, lngCol, latCol, detail };
+}
+
+// src/geoai/crsDetector.ts
+var CHINA_BOUNDS = {
+  lngMin: 73,
+  lngMax: 135,
+  latMin: 18,
+  latMax: 54
+};
+var A = 6378245;
+var EE = 0.006693421622965943;
+function outOfChina(lng, lat) {
+  return lng < CHINA_BOUNDS.lngMin || lng > CHINA_BOUNDS.lngMax || lat < CHINA_BOUNDS.latMin || lat > CHINA_BOUNDS.latMax;
+}
+function transformLat(x, y) {
+  let ret = -100 + 2 * x + 3 * y + 0.2 * y * y + 0.1 * x * y + 0.2 * Math.sqrt(Math.abs(x));
+  ret += (20 * Math.sin(6 * x * Math.PI) + 20 * Math.sin(2 * x * Math.PI)) * 2 / 3;
+  ret += (20 * Math.sin(y * Math.PI) + 40 * Math.sin(y / 3 * Math.PI)) * 2 / 3;
+  ret += (160 * Math.sin(y / 12 * Math.PI) + 320 * Math.sin(y * Math.PI / 30)) * 2 / 3;
+  return ret;
+}
+function transformLng(x, y) {
+  let ret = 300 + x + 2 * y + 0.1 * x * x + 0.1 * x * y + 0.1 * Math.sqrt(Math.abs(x));
+  ret += (20 * Math.sin(6 * x * Math.PI) + 20 * Math.sin(2 * x * Math.PI)) * 2 / 3;
+  ret += (20 * Math.sin(x * Math.PI) + 40 * Math.sin(x / 3 * Math.PI)) * 2 / 3;
+  ret += (150 * Math.sin(x / 12 * Math.PI) + 300 * Math.sin(x / 30 * Math.PI)) * 2 / 3;
+  return ret;
+}
+function wgs84ToGcj02(lng, lat) {
+  if (outOfChina(lng, lat)) return [lng, lat];
+  let dLat = transformLat(lng - 105, lat - 35);
+  let dLng = transformLng(lng - 105, lat - 35);
+  const radLat = lat / 180 * Math.PI;
+  let magic = Math.sin(radLat);
+  magic = 1 - EE * magic * magic;
+  const sqrtMagic = Math.sqrt(magic);
+  dLat = dLat * 180 / (A * (1 - EE) / (magic * sqrtMagic) * Math.PI);
+  dLng = dLng * 180 / (A / sqrtMagic * Math.cos(radLat) * Math.PI);
+  return [lng + dLng, lat + dLat];
+}
+function gcj02ToWgs84(lng, lat) {
+  if (outOfChina(lng, lat)) return [lng, lat];
+  let [wgsLng, wgsLat] = [lng, lat];
+  for (let i = 0; i < 5; i++) {
+    const [gLng, gLat] = wgs84ToGcj02(wgsLng, wgsLat);
+    const dLng = gLng - lng;
+    const dLat = gLat - lat;
+    wgsLng -= dLng;
+    wgsLat -= dLat;
+  }
+  return [wgsLng, wgsLat];
+}
+function isInChina(lng, lat) {
+  return !outOfChina(lng, lat);
+}
+function detectCRS(source, sample = []) {
+  const s = (source ?? "").toLowerCase();
+  if (/(高德|腾讯|amap|qqmap|gcj|火星)/.test(s)) return "gcj02";
+  if (/(天地图|tianditu|cgcs|2000)/.test(s)) return "cgcs2000";
+  if (/(gps|wgs84|84)/.test(s)) return "wgs84";
+  if (sample.length > 0) {
+    let inChinaCount = 0;
+    for (const [lng, lat] of sample) {
+      if (isInChina(lng, lat)) {
+        inChinaCount++;
+      }
+    }
+    if (sample.length > 0 && inChinaCount / sample.length < 0.5) return "wgs84";
+  }
+  return "wgs84";
+}
+
+// src/geoai/geocoder.ts
+var LOCAL_GEO_DB = {
+  // 主要城市
+  \u6B66\u6C49: [114.305, 30.593],
+  \u5317\u4EAC: [116.407, 39.904],
+  \u4E0A\u6D77: [121.474, 31.23],
+  \u5E7F\u5DDE: [113.264, 23.129],
+  \u6DF1\u5733: [114.058, 22.543],
+  \u6210\u90FD: [104.067, 30.573],
+  \u676D\u5DDE: [120.155, 30.274],
+  \u5357\u4EAC: [118.796, 32.06],
+  \u91CD\u5E86: [106.551, 29.563],
+  \u897F\u5B89: [108.94, 34.341],
+  \u5929\u6D25: [117.2, 39.084],
+  // 武汉各区
+  \u6C5F\u5CB8\u533A: [114.31, 30.6],
+  \u6C5F\u6C49\u533A: [114.27, 30.6],
+  \u785A\u53E3\u533A: [114.21, 30.58],
+  \u6C49\u9633\u533A: [114.22, 30.55],
+  \u6B66\u660C\u533A: [114.32, 30.55],
+  \u9752\u5C71\u533A: [114.39, 30.63],
+  \u6D2A\u5C71\u533A: [114.34, 30.5],
+  \u4E1C\u897F\u6E56\u533A: [114.14, 30.62],
+  \u6C49\u5357\u533A: [114.08, 30.31],
+  \u8521\u7538\u533A: [114.03, 30.58],
+  \u6C5F\u590F\u533A: [114.32, 30.35],
+  \u9EC4\u9642\u533A: [114.38, 30.88],
+  \u65B0\u6D32\u533A: [114.8, 30.85],
+  // 常见 POI（口语化地址兜底）
+  \u5149\u8C37: [114.428, 30.507],
+  \u5149\u8C37\u5E7F\u573A: [114.4, 30.507],
+  \u6C49\u53E3\u706B\u8F66\u7AD9: [114.255, 30.618],
+  \u6B66\u660C\u706B\u8F66\u7AD9: [114.317, 30.531],
+  \u6B66\u6C49\u7AD9: [114.424, 30.607],
+  \u5929\u6CB3\u673A\u573A: [114.208, 30.774],
+  \u6B66\u6C49\u5927\u5B66: [114.362, 30.541],
+  \u534E\u4E2D\u79D1\u6280\u5927\u5B66: [114.418, 30.513],
+  \u9EC4\u9E64\u697C: [114.302, 30.544],
+  \u4E1C\u6E56: [114.4, 30.55],
+  \u957F\u6C5F\u5927\u6865: [114.294, 30.55],
+  \u6C5F\u6C49\u8DEF: [114.278, 30.581],
+  \u695A\u6CB3\u6C49\u8857: [114.337, 30.561],
+  \u8857\u9053\u53E3: [114.351, 30.531],
+  \u4E2D\u5357\u8DEF: [114.331, 30.539],
+  \u5F90\u4E1C: [114.348, 30.583],
+  \u738B\u5BB6\u6E7E: [114.204, 30.557],
+  \u949F\u5BB6\u6751: [114.246, 30.549],
+  \u6C49\u6B63\u8857: [114.272, 30.573],
+  \u8F6F\u4EF6\u56ED: [114.4, 30.47],
+  \u91D1\u878D\u6E2F: [114.42, 30.47],
+  \u751F\u7269\u57CE: [114.48, 30.49],
+  \u672A\u6765\u79D1\u6280\u57CE: [114.47, 30.44]
+};
+function geocode(parsed) {
+  if (parsed.poi && LOCAL_GEO_DB[parsed.poi]) {
+    const c = LOCAL_GEO_DB[parsed.poi];
+    return { lng: c[0], lat: c[1], matched: parsed.poi, confidence: 0.95 };
+  }
+  if (parsed.district && LOCAL_GEO_DB[parsed.district]) {
+    const c = LOCAL_GEO_DB[parsed.district];
+    return { lng: c[0], lat: c[1], matched: parsed.district, confidence: 0.8 };
+  }
+  if (parsed.city && LOCAL_GEO_DB[parsed.city]) {
+    const c = LOCAL_GEO_DB[parsed.city];
+    return { lng: c[0], lat: c[1], matched: parsed.city, confidence: 0.6 };
+  }
+  if (parsed.province && LOCAL_GEO_DB[parsed.province]) {
+    const c = LOCAL_GEO_DB[parsed.province];
+    return { lng: c[0], lat: c[1], matched: parsed.province, confidence: 0.4 };
+  }
+  return null;
+}
+function hasLocalGeo(name) {
+  return name in LOCAL_GEO_DB;
+}
+function batchGeocode(rows, parse) {
+  return rows.map((row) => {
+    if (typeof row.lng === "number" && typeof row.lat === "number" && !Number.isNaN(row.lng) && !Number.isNaN(row.lat)) {
+      return { lng: row.lng, lat: row.lat, source: "provided", confidence: 1 };
+    }
+    const parsed = parse(row.address);
+    const geo = geocode(parsed);
+    if (geo) {
+      return { lng: geo.lng, lat: geo.lat, source: "geocoded", matched: geo.matched, confidence: geo.confidence };
+    }
+    return { lng: 0, lat: 0, source: "failed", confidence: 0 };
+  });
+}
+
+// src/geoai/dataImporter.ts
+function importToGeoJSON(headers, rows, opts = {}) {
+  const t0 = typeof performance !== "undefined" ? performance.now() : Date.now();
+  const parse = opts.parse ?? parseAddress;
+  const det = detectHeaders(headers);
+  const { addressCol, nameCol, categoryCol, lngCol, latCol } = det;
+  const samples = [];
+  if (lngCol >= 0 && latCol >= 0) {
+    for (const row of rows.slice(0, 50)) {
+      const lng = Number(row[lngCol]);
+      const lat = Number(row[latCol]);
+      if (!Number.isNaN(lng) && !Number.isNaN(lat)) samples.push([lng, lat]);
+    }
+  }
+  const crs = detectCRS(opts.source, samples);
+  const geocodeInput = rows.map((row) => ({
+    address: String(row[addressCol] ?? ""),
+    lng: lngCol >= 0 ? Number(row[lngCol]) : void 0,
+    lat: latCol >= 0 ? Number(row[latCol]) : void 0
+  }));
+  const coded = batchGeocode(geocodeInput, parse);
+  const features = rows.map((row, i) => {
+    const c = coded[i];
+    let lng = c.lng;
+    let lat = c.lat;
+    if (c.source !== "failed" && crs === "gcj02") {
+      [lng, lat] = gcj02ToWgs84(lng, lat);
+    }
+    const properties = {};
+    if (nameCol >= 0) properties.name = row[nameCol];
+    if (categoryCol >= 0) properties.category = row[categoryCol];
+    if (addressCol >= 0) properties.address = row[addressCol];
+    if (c.matched) properties.matchedPlace = c.matched;
+    const geometry = c.source !== "failed" ? { type: "Point", coordinates: [lng, lat] } : { type: "Point", coordinates: [] };
+    return { type: "Feature", geometry, properties };
+  });
+  const success = coded.filter((c) => c.source !== "failed").length;
+  const durationMs = (typeof performance !== "undefined" ? performance.now() : Date.now()) - t0;
+  return {
+    type: "FeatureCollection",
+    features,
+    stats: {
+      total: rows.length,
+      success,
+      failed: rows.length - success,
+      successRate: rows.length > 0 ? success / rows.length : 0,
+      headers: det,
+      durationMs
+    }
+  };
+}
+
+// src/nlpg/sqlGenerator.ts
+var FIELD_ALIASES = [
+  { field: "material", re: /材质|材料|铸铁|钢管|PE|PVC|球墨|HDPE|铜管/ },
+  { field: "pressure", re: /压力|水压|气压|MPa/ },
+  { field: "diameter", re: /管径|直径|口径|DN/ },
+  { field: "status", re: /状态|运行|停运|故障|检修/ },
+  { field: "install_date", re: /安装日期|投运|建成|敷设/ },
+  { field: "age", re: /年限|使用.{0,2}年|超过.{0,2}年|.{0,2}年以上|年代/ },
+  { field: "voltage", re: /电压|kV|kv|伏/ },
+  { field: "load_rate", re: /负载率|负荷率|利用率|负载|负荷/ },
+  { field: "fault_rate", re: /故障率/ },
+  { field: "flow_rate", re: /流量|流速/ },
+  { field: "water_level", re: /水位/ },
+  { field: "storage_rate", re: /蓄水率|库容/ },
+  { field: "rsrp", re: /RSRP|信号强度|信号/ }
+];
+var TABLE_ALIASES = [
+  { table: "pipelines", re: /管段|管线|管道|管网|燃气管|供水管|排水管|供热管|电力管|通信管/ },
+  { table: "nodes", re: /节点|阀门|泵站|表|井|闸/ },
+  { table: "users", re: /用户|居民|小区|住户|建筑/ },
+  { table: "schools", re: /学校|小学|中学|大学|幼儿园/ },
+  { table: "hospitals", re: /医院|卫生院|诊所/ },
+  { table: "substations", re: /变电站|配变|台区|电站/ },
+  { table: "base_stations", re: /基站|宏站|微站|室分/ },
+  { table: "rivers", re: /河流|水系|河段|支流/ },
+  { table: "reservoirs", re: /水库|大坝/ },
+  { table: "alarms", re: /报警|告警|警报/ },
+  { table: "pois", re: /POI|兴趣点|场所|设施/ }
+];
+var VALUE_DICT = [
+  { field: "material", value: "cast_iron", re: /铸铁/ },
+  { field: "material", value: "ductile_iron", re: /球墨/ },
+  { field: "material", value: "steel", re: /钢(?!筋)/ },
+  { field: "material", value: "pe", re: /PE/ },
+  { field: "material", value: "pvc", re: /PVC/ },
+  { field: "material", value: "hdpe", re: /HDPE/ },
+  { field: "status", value: "normal", re: /正常/ },
+  { field: "status", value: "fault", re: /故障/ },
+  { field: "status", value: "maintenance", re: /检修|维修/ },
+  { field: "status", value: "aging", re: /老化/ }
+];
+function detectOperator(text) {
+  if (/超过|高于|大于|超出|以上|不小于/.test(text)) return text.includes("\u4EE5\u4E0A") || text.includes("\u4E0D\u5C0F\u4E8E") ? ">=" : ">";
+  if (/低于|小于|不到|以下|不足/.test(text)) return text.includes("\u4EE5\u4E0B") ? "<=" : "<";
+  if (/等于|正好|恰好|为\s*\d/.test(text)) return "=";
+  if (/不是|非|不等于/.test(text)) return "!=";
+  if (/包含|含有|含/.test(text)) return "LIKE";
+  return "=";
+}
+function detectTable(text) {
+  for (const t of TABLE_ALIASES) {
+    if (t.re.test(text)) return t.table;
+  }
+  return "pois";
+}
+function detectField(text) {
+  for (const f of FIELD_ALIASES) {
+    if (f.re.test(text)) return f.field;
+  }
+  return null;
+}
+function detectValue(text, field) {
+  for (const v of VALUE_DICT) {
+    if (v.field === field && v.re.test(text)) return v.value;
+  }
+  const numMatch = text.match(/(\d+(?:\.\d+)?)\s*(MPa|mpa|kV|kv|米|m|公里|km|%|％|方|立方米)?/);
+  if (numMatch) {
+    let value = parseFloat(numMatch[1]);
+    const unit = numMatch[2] ?? "";
+    if (/公里|km/.test(unit)) value *= 1e3;
+    if (/%|％/.test(unit)) value /= 100;
+    return value;
+  }
+  const dateMatch = text.match(/(\d{4}-\d{2}-\d{2}|\d{4}年\d{1,2}月)/);
+  if (dateMatch) return dateMatch[1];
+  return null;
+}
+function detectSpatial(text, geometryColumn = "geom") {
+  const nearby = text.match(/(\d+(?:\.\d+)?)\s*(米|m|公里|km|千米)\s*(?:内|以内|范围内|附近|周边)/);
+  if (nearby) {
+    let radius = parseFloat(nearby[1]);
+    if (/公里|km|千米/.test(nearby[2])) radius *= 1e3;
+    return { relation: "dwithin", radius, geometryColumn };
+  }
+  const point = detectReferencePoint(text);
+  if (/缓冲区|缓冲|范围内|区域.{0,2}内/.test(text)) {
+    return { relation: "buffer", point, geometryColumn };
+  }
+  if (/包含|覆盖|涵盖|包围|圈住/.test(text)) {
+    return { relation: "contains", point, geometryColumn };
+  }
+  if (/在.{0,2}内|内部|以内|之中/.test(text)) {
+    return { relation: "within", point, geometryColumn };
+  }
+  if (/相交|叠加|重叠|交叉/.test(text)) {
+    return { relation: "intersects", point, geometryColumn };
+  }
+  return null;
+}
+function detectReferencePoint(text) {
+  const m = text.match(/([1-2]?\d{2,3}(?:\.\d+)?)\s*[,，]\s*(\d{1,3}(?:\.\d+)?)/);
+  if (m) {
+    const lng = parseFloat(m[1]);
+    const lat = parseFloat(m[2]);
+    if (lng >= -180 && lng <= 180 && lat >= -90 && lat <= 90) return [lng, lat];
+  }
+  return void 0;
+}
+function quoteValue(v) {
+  return typeof v === "string" ? `'${v.replace(/'/g, "''")}'` : String(v);
+}
+function buildWhere(conditions, spatial) {
+  const parts = [];
+  for (const c of conditions) {
+    parts.push(`${c.field} ${c.operator} ${quoteValue(c.value)}`);
+  }
+  if (spatial) {
+    const col = spatial.geometryColumn;
+    const refGeom = spatial.referenceColumn ? spatial.referenceColumn : spatial.point ? `ST_Buffer(ST_SetSRID(ST_MakePoint(${spatial.point[0]}, ${spatial.point[1]}), 4326), ${spatial.radius ?? 0})` : null;
+    switch (spatial.relation) {
+      case "dwithin":
+        if (spatial.point && spatial.radius !== void 0) {
+          parts.push(`ST_DWithin(${col}, ST_SetSRID(ST_MakePoint(${spatial.point[0]}, ${spatial.point[1]}), 4326), ${spatial.radius})`);
+        }
+        break;
+      case "buffer":
+        if (refGeom) parts.push(`ST_Intersects(${col}, ${refGeom})`);
+        break;
+      case "within":
+        if (refGeom) parts.push(`ST_Within(${col}, ${refGeom})`);
+        break;
+      case "contains":
+        if (refGeom) parts.push(`ST_Contains(${refGeom}, ${col})`);
+        break;
+      case "intersects":
+        if (refGeom) parts.push(`ST_Intersects(${col}, ${refGeom})`);
+        break;
+    }
+  }
+  return parts.length > 0 ? `WHERE ${parts.join(" AND ")}` : "";
+}
+function generatePostGISQuery(text, opts = {}) {
+  const center = opts.center ?? [114.305, 30.593];
+  const geometryColumn = opts.geometryColumn ?? "geom";
+  const table = detectTable(text);
+  const spatial = detectSpatial(text, geometryColumn);
+  if (spatial && !spatial.point) {
+    spatial.point = center;
+  }
+  if (spatial && spatial.relation !== "dwithin" && spatial.radius === void 0) {
+    spatial.radius = 1e3;
+  }
+  const conditions = [];
+  const field = detectField(text);
+  if (field) {
+    const value = detectValue(text, field);
+    if (value !== null) {
+      conditions.push({ field, operator: detectOperator(text), value });
+    }
+  }
+  let intent;
+  if (spatial && conditions.length > 0) intent = "mixed";
+  else if (spatial) intent = spatial.relation === "dwithin" ? "spatial_nearby" : "spatial_within";
+  else if (conditions.length > 0) intent = "attribute_filter";
+  else intent = "unknown";
+  const where = buildWhere(conditions, spatial);
+  const sql = `SELECT * FROM ${table} ${where}`.trim();
+  let confidence = 0.3;
+  if (conditions.length > 0) confidence += 0.3;
+  if (spatial) confidence += 0.3;
+  if (table !== "pois") confidence += 0.1;
+  confidence = Math.min(0.95, confidence);
+  return { intent, table, conditions, spatial, sql, confidence };
+}
+
+// src/nlpg/sqlValidator.ts
+var DANGEROUS_KEYWORDS = [
+  "DROP",
+  "DELETE",
+  "UPDATE",
+  "INSERT",
+  "ALTER",
+  "TRUNCATE",
+  "GRANT",
+  "REVOKE",
+  "MERGE",
+  "CREATE",
+  "REPLACE",
+  "EXEC",
+  "EXECUTE",
+  "CALL",
+  "COPY",
+  "LOAD",
+  "INTO",
+  "SET",
+  "UNION",
+  "ATTACH",
+  "DETACH",
+  "PRAGMA",
+  "VACUUM",
+  "REINDEX"
+];
+var INJECTION_PATTERNS = [
+  /--/,
+  // SQL 注释
+  /\/\*/,
+  // 块注释
+  /;\s*(DROP|DELETE|UPDATE|INSERT|ALTER|TRUNCATE)/i,
+  // 多语句注入
+  /'\s*OR\s*'/i,
+  // ' OR ' 恒真注入（含 ' OR '1'='1'）
+  /"\s*OR\s*"/i,
+  // " OR " 恒真注入
+  /\bOR\s+\d+\s*=\s*\d+\b/i,
+  // OR 1=1 恒真
+  /\bOR\s+'\w*'\s*=\s*'\w*'/i,
+  // OR 'a'='a' 恒真
+  /UNION\s+SELECT/i
+];
+var DEFAULT_ALLOWED_TABLES = [
+  "pipelines",
+  "nodes",
+  "users",
+  "schools",
+  "hospitals",
+  "substations",
+  "base_stations",
+  "rivers",
+  "reservoirs",
+  "alarms",
+  "pois"
+];
+var ALLOWED_SPATIAL_FUNCTIONS = [
+  "ST_DWithin",
+  "ST_Within",
+  "ST_Intersects",
+  "ST_Contains",
+  "ST_Buffer",
+  "ST_MakePoint",
+  "ST_SetSRID",
+  "ST_Distance",
+  "ST_AsGeoJSON",
+  "ST_Transform"
+];
+function validateSql(sql, allowedTables = DEFAULT_ALLOWED_TABLES) {
+  const issues = [];
+  const upper = sql.toUpperCase().trim();
+  if (!sql.trim()) {
+    issues.push({ severity: "error", rule: "non_empty", message: "SQL \u4E0D\u80FD\u4E3A\u7A7A" });
+    return { valid: false, issues };
+  }
+  if (!upper.startsWith("SELECT")) {
+    issues.push({ severity: "error", rule: "read_only", message: "\u4EC5\u5141\u8BB8 SELECT \u53EA\u8BFB\u67E5\u8BE2" });
+  }
+  for (const kw of DANGEROUS_KEYWORDS) {
+    const re = new RegExp(`\\b${kw}\\b`, "i");
+    if (re.test(sql) && !(kw === "SET" && /ST_SetSRID/i.test(sql))) {
+      issues.push({ severity: "error", rule: "dangerous_keyword", message: `\u68C0\u6D4B\u5230\u5371\u9669\u5173\u952E\u5B57 ${kw}` });
+    }
+  }
+  for (const p of INJECTION_PATTERNS) {
+    if (p.test(sql)) {
+      issues.push({ severity: "error", rule: "injection", message: "\u68C0\u6D4B\u5230 SQL \u6CE8\u5165\u7279\u5F81" });
+    }
+  }
+  const fromMatch = upper.match(/FROM\s+([A-Za-z_][\w]*)/);
+  if (fromMatch) {
+    const table = fromMatch[1].toLowerCase();
+    if (!allowedTables.includes(table)) {
+      issues.push({ severity: "error", rule: "table_whitelist", message: `\u8868 ${table} \u4E0D\u5728\u6388\u6743\u767D\u540D\u5355\u5185` });
+    }
+  }
+  const singleQuotes = (sql.match(/'/g) ?? []).length;
+  if (singleQuotes % 2 !== 0) {
+    issues.push({ severity: "error", rule: "syntax", message: "\u5355\u5F15\u53F7\u672A\u914D\u5BF9" });
+  }
+  const openParen = (sql.match(/\(/g) ?? []).length;
+  const closeParen = (sql.match(/\)/g) ?? []).length;
+  if (openParen !== closeParen) {
+    issues.push({ severity: "error", rule: "syntax", message: "\u62EC\u53F7\u672A\u914D\u5BF9" });
+  }
+  for (const fn of ["ST_"]) {
+    const fnMatch = sql.match(/ST_(\w+)/g) ?? [];
+    for (const m of fnMatch) {
+      if (!ALLOWED_SPATIAL_FUNCTIONS.includes(m)) {
+        issues.push({ severity: "error", rule: "spatial_whitelist", message: `\u7A7A\u95F4\u51FD\u6570 ${m} \u4E0D\u5728\u767D\u540D\u5355\u5185` });
+      }
+    }
+  }
+  return { valid: issues.every((i) => i.severity !== "error"), issues };
+}
+function parameterize(sql) {
+  const params = [];
+  const out = sql.replace(/'([^']*)'/g, (_m, v) => {
+    params.push(v);
+    return `$${params.length}`;
+  });
+  return { sql: out, params };
+}
+
+// src/nlpg/nlpg.ts
+function nlpgQuery(text, opts = {}) {
+  const query = generatePostGISQuery(text, opts);
+  const validation = validateSql(query.sql);
+  const valid = validation.valid;
+  const parameterized = valid ? parameterize(query.sql) : void 0;
+  return { query, valid, validation, parameterized };
+}
+
+// src/nlpg/llmNlpg.ts
+var SYSTEM_PROMPT2 = `\u4F60\u662F"\u8349\u679C\u5730\u56FE"\u7BA1\u7F51\u81EA\u7136\u8BED\u8A00\u67E5\u8BE2\u52A9\u624B\u3002\u7528\u6237\u7528\u4E2D\u6587\u63CF\u8FF0\u6570\u636E\u67E5\u8BE2\u9700\u6C42\uFF0C\u4F60\u751F\u6210 PostGIS SQL\uFF08\u4EC5 SELECT\uFF09\u3002
+
+\u89C4\u5219\uFF1A
+1. \u53EA\u8FD4\u56DE JSON\uFF1A{"sql":"SELECT ...","table":"...","intent":"..."}
+2. \u8868\u540D\u53EA\u80FD\u6765\u81EA\u4EE5\u4E0B\u767D\u540D\u5355\uFF1A${DEFAULT_ALLOWED_TABLES.join(", ")}
+3. \u7A7A\u95F4\u67E5\u8BE2\u53EF\u7528 ST_DWithin / ST_Within / ST_Intersects / ST_Contains / ST_Buffer / ST_MakePoint / ST_SetSRID / ST_Distance / ST_AsGeoJSON / ST_Transform
+4. \u53EA\u751F\u6210 SELECT \u8BED\u53E5\uFF0C\u7981\u6B62 DROP/DELETE/UPDATE/INSERT/ALTER \u7B49\u5199\u64CD\u4F5C
+5. \u5B57\u6BB5\u540D\u4F7F\u7528 snake_case\uFF0C\u5750\u6807\u4F7F\u7528 WGS84\uFF08SRID 4326\uFF09
+6. \u4E0D\u8981\u8F93\u51FA JSON \u4EE5\u5916\u7684\u4EFB\u4F55\u6587\u5B57\u3002`;
+var LlmNlpg = class {
+  client;
+  enabled;
+  allowedTables;
+  constructor(config) {
+    this.client = config.client;
+    this.enabled = config.enabled ?? true;
+    this.allowedTables = config.allowedTables ?? DEFAULT_ALLOWED_TABLES;
+  }
+  /**
+   * 自然语言查询。
+   * LLM 优先，失败或校验不过时降级到规则引擎。
+   */
+  async query(text) {
+    if (this.enabled) {
+      try {
+        const llmResult = await this.queryWithLlm(text);
+        if (llmResult) return llmResult;
+      } catch {
+      }
+    }
+    return this.queryWithRules(text);
+  }
+  async queryWithLlm(text) {
+    const messages = [
+      { role: "system", content: SYSTEM_PROMPT2 },
+      { role: "user", content: text }
+    ];
+    const { data } = await this.client.chatJson(messages);
+    const sql = (data.sql ?? "").trim();
+    if (!sql) return null;
+    const validation = validateSql(sql, this.allowedTables);
+    if (!validation.valid) return null;
+    const query = {
+      intent: "mixed",
+      table: data.table ?? "pois",
+      conditions: [],
+      spatial: null,
+      sql,
+      confidence: 0.9
+    };
+    return { query, valid: true, parameterized: parameterize(sql) };
+  }
+  queryWithRules(text) {
+    const query = generatePostGISQuery(text);
+    const validation = validateSql(query.sql, this.allowedTables);
+    return {
+      query,
+      valid: validation.valid,
+      parameterized: validation.valid ? parameterize(query.sql) : void 0
+    };
+  }
+};
+
+// src/llm/deepseek.ts
+var DEFAULT_BASE_URL = "https://api.deepseek.com";
+var DEFAULT_MODEL = "deepseek-chat";
+function normalizeError(body) {
+  const err = new Error(body || "DeepSeek API \u8BF7\u6C42\u5931\u8D25");
+  err.name = "DeepSeekError";
+  return err;
+}
+var DeepSeekClient = class {
+  config;
+  lastRequestId = 0;
+  constructor(config) {
+    if (!config.apiKey) throw new Error("DeepSeekClient: apiKey \u4E0D\u80FD\u4E3A\u7A7A");
+    this.config = {
+      apiKey: config.apiKey,
+      baseUrl: (config.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, ""),
+      model: config.model ?? DEFAULT_MODEL,
+      temperature: config.temperature ?? 0.3,
+      maxTokens: config.maxTokens ?? 2048,
+      timeoutMs: config.timeoutMs ?? 3e4,
+      retries: config.retries ?? 2,
+      fetchImpl: config.fetchImpl ?? (globalThis.fetch ?? fetch)
+    };
+  }
+  /** 发起一次聊天补全 */
+  async chat(messages, opts = {}) {
+    return this.requestWithRetry(messages, opts);
+  }
+  /** 聊天 + JSON 解析 */
+  async chatJson(messages) {
+    const result = await this.chat(messages, { json: true });
+    const raw = result.content.trim();
+    const cleaned = raw.replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/, "");
+    let data;
+    try {
+      data = JSON.parse(cleaned);
+    } catch (e) {
+      const match = cleaned.match(/\{[\s\S]*\}|\[[\s\S]*\]/);
+      if (match) {
+        data = JSON.parse(match[0]);
+      } else {
+        throw new Error(`DeepSeek \u8FD4\u56DE\u4E86\u975E JSON \u5185\u5BB9: ${raw.slice(0, 200)}`);
+      }
+    }
+    return { data, raw, model: result.model };
+  }
+  async requestWithRetry(messages, opts) {
+    let lastError = null;
+    for (let attempt = 0; attempt <= this.config.retries; attempt++) {
+      try {
+        return await this.requestOnce(messages, opts);
+      } catch (e) {
+        lastError = e;
+        const retryable = !(e instanceof Error) || !e.name.includes("DeepSeek") || this.isRetryable(e);
+        if (!retryable && !this.isRetryable(e)) break;
+        if (attempt < this.config.retries) {
+          await this.sleep(Math.min(1e3 * 2 ** attempt, 8e3));
+        }
+      }
+    }
+    throw lastError ?? new Error("DeepSeek \u8BF7\u6C42\u5931\u8D25");
+  }
+  isRetryable(err) {
+    const msg = err.message ?? "";
+    return /429|500|502|503|504|timeout|network|ECONN|abort|fetch failed/i.test(msg);
+  }
+  async requestOnce(messages, opts) {
+    const { fetchImpl } = this.config;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.config.timeoutMs);
+    const body = {
+      model: this.config.model,
+      messages,
+      temperature: this.config.temperature,
+      max_tokens: this.config.maxTokens,
+      stream: Boolean(opts.onChunk)
+    };
+    if (opts.json) {
+      body.response_format = { type: "json_object" };
+    }
+    try {
+      const res = await fetchImpl(`${this.config.baseUrl}/chat/completions`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.config.apiKey}`
+        },
+        body: JSON.stringify(body),
+        signal: controller.signal
+      });
+      if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        throw normalizeError(`DeepSeek HTTP ${res.status}: ${text}`);
+      }
+      if (opts.onChunk && res.body) {
+        return this.parseStream(res.body, opts.onChunk);
+      }
+      const json = await res.json();
+      const content = json.choices?.[0]?.message?.content ?? "";
+      return {
+        content,
+        model: json.model ?? this.config.model,
+        usage: json.usage ? { promptTokens: json.usage.prompt_tokens, completionTokens: json.usage.completion_tokens, totalTokens: json.usage.total_tokens } : void 0
+      };
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  /** 解析 SSE 流式响应 */
+  async parseStream(body, onChunk) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let content = "";
+    let buffer = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith("data:")) continue;
+        const data = trimmed.slice(5).trim();
+        if (data === "[DONE]") continue;
+        try {
+          const json = JSON.parse(data);
+          const delta = json.choices?.[0]?.delta?.content ?? "";
+          if (delta) {
+            content += delta;
+            onChunk(delta);
+          }
+        } catch {
+        }
+      }
+    }
+    return { content, model: this.config.model };
+  }
+  sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+  }
+};
+function createDeepSeekClient(config) {
+  return new DeepSeekClient(config);
+}
+
 exports.CARRIER_STYLES = CARRIER_STYLES;
+exports.CHINA_BOUNDS = CHINA_BOUNDS;
+exports.COLOR_NAMES = COLOR_NAMES;
+exports.DEFAULT_ALLOWED_TABLES = DEFAULT_ALLOWED_TABLES;
 exports.DIAGNOSIS_RULES = DIAGNOSIS_RULES;
+exports.DeepSeekClient = DeepSeekClient;
 exports.INDUSTRY_TEMPLATES = INDUSTRY_TEMPLATES;
+exports.LOCAL_GEO_DB = LOCAL_GEO_DB;
+exports.LlmMapCopilot = LlmMapCopilot;
+exports.LlmNlpg = LlmNlpg;
+exports.MapCopilot = MapCopilot;
+exports.PLACE_COORDINATES = PLACE_COORDINATES;
 exports.adjustBrightness = adjustBrightness;
 exports.analyzePerformance = analyzePerformance;
 exports.analyzeTiles = analyzeTiles;
+exports.batchGeocode = batchGeocode;
+exports.classifyIntent = classifyIntent;
+exports.createDeepSeekClient = createDeepSeekClient;
+exports.detectCRS = detectCRS;
+exports.detectField = detectField;
+exports.detectHeaders = detectHeaders;
 exports.detectMemoryLeak = detectMemoryLeak;
+exports.detectSpatial = detectSpatial;
+exports.detectTable = detectTable;
+exports.detectValue = detectValue;
 exports.diagnose = diagnose;
 exports.extractDominantColor = extractDominantColor;
+exports.extractParams = extractParams;
+exports.gcj02ToWgs84 = gcj02ToWgs84;
 exports.generateBrandStyle = generateBrandStyle;
 exports.generateCarrierStyle = generateCarrierStyle;
+exports.generateCode = generateCode;
+exports.generateFromQuery = generateFromQuery;
 exports.generateIndustryStyle = generateIndustryStyle;
+exports.generatePostGISQuery = generatePostGISQuery;
+exports.geocode = geocode;
+exports.hasLocalGeo = hasLocalGeo;
+exports.importToGeoJSON = importToGeoJSON;
+exports.isInChina = isInChina;
+exports.isValidAddress = isValidAddress;
+exports.nlpgQuery = nlpgQuery;
+exports.parameterize = parameterize;
+exports.parseAddress = parseAddress;
 exports.suggestOptimizations = suggestOptimizations;
 exports.toggleMode = toggleMode;
+exports.validateSql = validateSql;
+exports.wgs84ToGcj02 = wgs84ToGcj02;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map