@geoscene/ai-components 0.0.0-stage → 5.1.13

package/dist/chunks/adapter.js

@@ -0,0 +1,3148 @@
+/* COPYRIGHT GeoScene - https://js.geoscene.cn/5.1/LICENSE.txt */
+import pe from "@geoscene/core/identity/IdentityManager.js";
+import N from "@geoscene/core/portal/Portal.js";
+import { Annotation as T, messagesStateReducer as be } from "@langchain/langgraph/web";
+import "@geoscene/toolkit/string";
+import { k as Pe, j as H, i as Ae } from "./generateLayerDescriptions.js";
+import "@langchain/core/messages";
+import "@langchain/core/callbacks/dispatch/web";
+import "@langchain/openai";
+import X from "@geoscene/core/config.js";
+import * as Le from "@geoscene/core/core/reactiveUtils.js";
+import "@geoscene/core/layers/FeatureLayer.js";
+import me from "@geoscene/core/request.js";
+import "@langchain/core/prompts";
+import { tool as f } from "@langchain/core/tools";
+import je from "@geoscene/core/Graphic.js";
+import { addressToLocations as Ge } from "@geoscene/core/rest/locator.js";
+import Oe from "@geoscene/core/symbols/PictureMarkerSymbol.js";
+import s, { z as E } from "zod";
+import Me from "@geoscene/core/geometry/Extent.js";
+import Te from "@geoscene/core/geometry/Point.js";
+import { createRenderer as Qe } from "@geoscene/core/smartMapping/renderers/pieChart.js";
+import { getSchemesByTag as _e, getSchemes as We } from "@geoscene/core/smartMapping/symbology/pieChart.js";
+import { getBackgroundColorTheme as he } from "@geoscene/core/views/support/colorUtils.js";
+import { a as R, s as x } from "./index.js";
+import { createAgeRenderer as Ve, createContinuousRenderer as Be } from "@geoscene/core/smartMapping/renderers/color.js";
+import { getSchemesByTag as se } from "@geoscene/core/smartMapping/symbology/color.js";
+import { createContinuousRenderer as Ue } from "@geoscene/core/smartMapping/renderers/univariateColorSize.js";
+import { createRenderer as Ke } from "@geoscene/core/smartMapping/renderers/dotDensity.js";
+import { getSchemesByTag as He } from "@geoscene/core/smartMapping/symbology/dotDensity.js";
+import { createRenderer as Je } from "@geoscene/core/smartMapping/renderers/heatmap.js";
+import { getSchemesByTag as Ye } from "@geoscene/core/smartMapping/symbology/heatmap.js";
+import { createRenderer as Ze } from "@geoscene/core/smartMapping/renderers/predominance.js";
+import { getSchemesByTag as Xe } from "@geoscene/core/smartMapping/symbology/predominance.js";
+import { createRenderer as et } from "@geoscene/core/smartMapping/renderers/relationship.js";
+import { getSchemesByTag as tt } from "@geoscene/core/smartMapping/symbology/relationship.js";
+import { createAgeRenderer as rt, createContinuousRenderer as at } from "@geoscene/core/smartMapping/renderers/size.js";
+import { createRenderer as ot } from "@geoscene/core/smartMapping/renderers/type.js";
+import { getSchemesByTag as nt } from "@geoscene/core/smartMapping/symbology/type.js";
+import { ToolNode as it } from "@langchain/langgraph/prebuilt";
+import st from "@geoscene/core/layers/support/FeatureEffect.js";
+import Se from "@geoscene/core/layers/support/FeatureFilter.js";
+import * as lt from "@geoscene/core/geometry/operators/unionOperator.js";
+import { formatDateOnly as ct, convertDateFormatToIntlOptions as _, formatTimeOnly as ut, formatDate as ye } from "@geoscene/core/intl.js";
+import dt from "@geoscene/core/smartMapping/statistics/summaryStatistics.js";
+import pt from "@geoscene/core/smartMapping/statistics/uniqueValues.js";
+import mt from "@geoscene/core/rest/support/TopFeaturesQuery.js";
+import ht from "@geoscene/core/rest/support/TopFilter.js";
+import yt from "@geoscene/core/WebLinkChart.js";
+import ve from "@geoscene/core/rest/knowledgeGraph/GraphQueryStreaming.js";
+import "@geoscene/core/views/LinkChartView.js";
+import { fetchKnowledgeGraph as fe, executeQueryStreaming as ft, executeSearchStreaming as gt } from "@geoscene/core/rest/knowledgeGraphService.js";
+import wt from "@geoscene/core/rest/knowledgeGraph/GraphSearchStreaming.js";
+import { getBindParametersFromCypherQuery as bt } from "@geoscene/core/applications/KnowledgeStudio/generalSharedKgUtils.js";
+const L = (e, t) => t ?? e, In = T.Root({
+  ...Pe(),
+  // internal to the navigation agent
+  intent: T({
+    reducer: L
+  }),
+  vectorSearchLayerResults: T({
+    reducer: L,
+    default: () => []
+  }),
+  vectorSearchFieldResults: T({
+    reducer: L
+  }),
+  navigationInternalState: T({
+    reducer: L,
+    default: () => ({
+      toolCallMessage: void 0
+    })
+  })
+});
+async function Tt(e, t) {
+  const a = N.getDefault().helperServices, o = a.geocode.find((m) => m.name === "GeoScene World Geocoding Service") ?? a.geocode[0];
+  if (!o)
+    throw new Error("helperServices 中没有地理编码服务。");
+  const n = o.url, l = `${X.assetsPath?.endsWith("/") ? X.assetsPath : `${X.assetsPath}/`}geoscene/images/search/search-symbol-32.png`, c = (await Ge(n, {
+    address: { SingleLine: e },
+    outFields: ["Match_addr"]
+  }))?.[0];
+  if (!c?.extent || !c.location)
+    throw new Error(`未找到以下位置：${e}`);
+  const u = new Oe({
+    url: l,
+    width: 24,
+    height: 24
+  }), d = new je({
+    geometry: c.location,
+    symbol: u
+  });
+  t.graphics.removeAll(), t.graphics.add(d), await t.goTo(c.extent);
+  const p = {
+    address: c.address ?? "",
+    location: c.location ? c.location.toJSON() : null,
+    extent: c.extent ? c.extent.toJSON() : null
+  };
+  return {
+    text: `已缩放到 ${e}.`,
+    sharedStatePatch: { lastResolvedLocation: { value: p } }
+  };
+}
+const St = ["mapView"];
+function C(e) {
+  const r = e?.configurable?.context;
+  if (!r || typeof r != "object")
+    throw new Error("NavigationAgent 缺少上下文");
+  const a = St.filter((o) => !(o in r));
+  if (a.length)
+    throw new Error(`NavigationAgent 缺少上下文：${a.join(", ")}`);
+  return r;
+}
+async function vt({ address: e }, t) {
+  const { mapView: r } = C(t);
+  return await Tt(e, r);
+}
+const xt = s.object({
+  address: s.string().describe("要定位的完整地址或地名。")
+}), Dn = f(vt, {
+  name: "goToAddress",
+  description: "使用 GeoScene 全球地理编码服务解析地址，并将地图缩放到该位置。",
+  schema: xt
+});
+async function Rt(e, t) {
+  const a = t.map.bookmarks;
+  if (!a || a.length === 0)
+    throw new Error("地图中没有书签。");
+  const o = a.find((l) => l.name === e);
+  if (!o)
+    throw new Error(`书签“${e}”不存在。`);
+  const n = o.viewpoint;
+  if (!n)
+    throw new Error(`书签“${e}”没有有效视点。`);
+  return await t.goTo(n), { text: `已定位到书签：${e}` };
+}
+async function $t({ bookmarkName: e }, t) {
+  const { mapView: r } = C(t);
+  return await Promise.resolve(Rt(e, r));
+}
+const Ct = E.object({
+  bookmarkName: E.string().describe("要定位到的书签名称。")
+}), zn = f($t, {
+  name: "goToBookmark",
+  description: "定位到指定名称书签的范围。",
+  schema: Ct
+});
+async function Et(e, t, r) {
+  const a = r.map?.allLayers.find((l) => l.id === e);
+  if (!a)
+    return { text: `错误：未找到图层，ID 为 ${e}，不存在` };
+  const o = t?.trim() ? t : "1=1", n = a.createQuery();
+  n.where = o;
+  try {
+    const { extent: l, count: i } = await a.queryExtent(n);
+    if (i === 0)
+      return { text: `未找到要素，图层为 ${a.title}，匹配条件：${o}`, where: o };
+    if (l)
+      await r.goTo(l);
+    else
+      return { text: `错误：无法确定以下要素的范围：${a.title}`, where: o };
+    const c = {
+      layerId: e,
+      layerTitle: a.title ?? e,
+      where: o,
+      count: i
+    };
+    return {
+      text: `已缩放到 ${i} 个要素，所在图层：${a.title}，匹配条件：${o}`,
+      where: o,
+      sharedStatePatch: { lastNavigatedFeatures: { value: c } }
+    };
+  } catch (l) {
+    return console.error("goToFeatures 执行错误：", l), { text: `错误：${l instanceof Error ? l.message : "未知错误"}`, where: o };
+  }
+}
+async function Ft({ layerId: e, where: t }, r) {
+  const { mapView: a } = C(r);
+  return await Et(e, t, a);
+}
+const Nt = E.object({
+  layerId: E.string().describe("要缩放到的图层 layerId。"),
+  where: E.string().describe(
+    "所选图层 query.where 使用的 GeoScene SQL-92 WHERE 表达式。只能使用该图层字段，返回布尔过滤表达式，例如比较、LIKE、IN、BETWEEN、IS NULL、AND/OR/NOT。不得包含子查询、嵌套 SELECT、JOIN、GROUP BY、HAVING、ORDER BY 或分号。"
+  )
+}), Pn = f(Ft, {
+  name: "goToFeatures",
+  description: "定位到指定 layerId 中符合过滤条件的要素。",
+  schema: Nt
+});
+async function kt(e) {
+  const r = new Me({
+    xmin: -180,
+    ymin: -90,
+    xmax: 180,
+    ymax: 90,
+    spatialReference: { wkid: 4326 }
+  }).expand(0.7);
+  return await e.goTo(r), { text: "已缩放到全球范围" };
+}
+async function qt(e, t) {
+  const { mapView: r } = C(t);
+  return await kt(r);
+}
+const It = E.object({}), An = f(qt, {
+  name: "goToFullExtent",
+  description: "使用 GeoScene 地理编码服务将地图缩放到全球范围。",
+  schema: It
+});
+async function Dt(e) {
+  const r = e.map.initialViewProperties?.viewpoint?.targetGeometry;
+  if (r)
+    await e.goTo(r);
+  else
+    throw new Error("未定义初始范围");
+  return { text: "已返回初始范围" };
+}
+async function zt(e, t) {
+  const { mapView: r } = C(t);
+  return await Dt(r);
+}
+const Pt = s.object({}), Ln = f(zt, {
+  name: "goToHomeExtent",
+  description: "返回 WebMap 初始视图范围",
+  schema: Pt
+});
+async function At(e, t) {
+  await t.when();
+  const r = t.map?.allLayers.find((o) => o.id === e);
+  if (!r)
+    return console.warn(`[goToLayer] 未找到匹配的 FeatureLayer：${e}`), { text: `未找到图层：${e}` };
+  let a;
+  return (r.type === "link-chart" || r.type === "knowledge-graph-sublayer") && t.map?.activeLinkChartLayer ? a = t.map.diagramNodesExtent : a = r.fullExtent, a ? (await t.goTo(a), r.visible = !0, { text: `已缩放到：${r.title ?? ""}` }) : { text: "图层未定义范围，无法缩放到该图层。" };
+}
+async function Lt({ layerId: e }, t) {
+  const { mapView: r } = C(t);
+  return await At(e, r);
+}
+const jt = E.object({
+  layerId: E.string().describe("要定位的图层 ID")
+}), jn = f(Lt, {
+  name: "goToLayer",
+  description: "将地图缩放到最佳匹配图层的完整范围。",
+  schema: jt
+});
+async function Gt(e, t) {
+  return await t.goTo({ scale: e }), { text: `已缩放到：${e}` };
+}
+async function Ot({ scale: e }, t) {
+  const { mapView: r } = C(t);
+  return await Gt(e, r);
+}
+const Mt = s.object({
+  scale: s.number().describe("目标视图的地图比例尺。")
+}), Gn = f(Ot, {
+  name: "goToScale",
+  description: "定位到指定比例尺。",
+  schema: Mt
+});
+async function Qt(e, t, r) {
+  const o = {
+    target: new Te({
+      longitude: e.longitude,
+      latitude: e.latitude,
+      spatialReference: { wkid: 4326 }
+    })
+  };
+  return r?.zoom !== void 0 && (o.zoom = r.zoom), r?.scale !== void 0 && (o.scale = r.scale), await t.goTo(o), { text: `已定位到：${[
+    `(${e.latitude}°, ${e.longitude}°)`,
+    r?.zoom !== void 0 ? `缩放级别 ${r.zoom}` : "",
+    r?.scale !== void 0 ? `比例尺 1:${r.scale}` : ""
+  ].filter(Boolean).join(", ")}` };
+}
+async function _t({
+  center: e,
+  zoom: t,
+  scale: r
+}, a) {
+  const { mapView: o } = C(a);
+  return await Qt(e, o, { zoom: t, scale: r });
+}
+const Wt = s.object({
+  center: s.object({
+    longitude: s.number().describe("目标点的经度，即 x 坐标。"),
+    latitude: s.number().describe("目标点的纬度，即 y 坐标。")
+  }),
+  zoom: s.number().optional().describe("缩放级别，数值越大，地图放得越大。"),
+  scale: s.number().optional().describe("地图比例尺，可替代 zoom；比例尺分母越小，地图放得越大。")
+}), On = f(_t, {
+  name: "goToViewpoint",
+  description: "定位到指定视点，可以组合 scale、center、zoom 等参数。",
+  schema: Wt
+});
+async function Vt(e, t) {
+  return await t.goTo({ zoom: e }), { text: `已缩放到：${e}` };
+}
+async function Bt({ zoom: e }, t) {
+  const { mapView: r } = C(t);
+  return await Vt(e, r);
+}
+const Ut = s.object({
+  zoom: s.number().min(1).max(20).describe("目标视图的缩放级别。")
+}), Mn = f(Bt, {
+  name: "goToZoom",
+  description: "定位到指定缩放级别。如果要求较笼统，例如“放大”，只调整到下一个适当级别；放大时增加级别，缩小时降低级别。",
+  schema: Ut
+}), ge = /* @__PURE__ */ Object.assign({
+  "../agents/geosceneKnowledge/prompts/geoscene_knowledge_current_lc_context.md": () => import("./geoscene_knowledge_current_lc_context.js").then((e) => e.default),
+  "../agents/geosceneKnowledge/prompts/geoscene_knowledge_current_map_context.md": () => import("./geoscene_knowledge_current_map_context.js").then((e) => e.default),
+  "../agents/geosceneKnowledge/prompts/geoscene_knowledge_cypher_query_prompt.md": () => import("./geoscene_knowledge_cypher_query_prompt.js").then((e) => e.default),
+  "../agents/geosceneKnowledge/prompts/geoscene_knowledge_lucene_generation_prompt.md": () => import("./geoscene_knowledge_lucene_generation_prompt.js").then((e) => e.default),
+  "../agents/geosceneKnowledge/prompts/geoscene_knowledge_summarize_result_prompt.md": () => import("./geoscene_knowledge_summarize_result_prompt.js").then((e) => e.default),
+  "../agents/geosceneKnowledge/prompts/geoscene_knowledge_tool_prompt.md": () => import("./geoscene_knowledge_tool_prompt.js").then((e) => e.default),
+  "../agents/dataExploration/prompts/data_explore_filter_prompt.md": () => import("./data_explore_filter_prompt.js").then((e) => e.default),
+  "../agents/dataExploration/prompts/data_explore_query_prompt.md": () => import("./data_explore_query_prompt.js").then((e) => e.default),
+  "../agents/dataExploration/prompts/summarize_query_response_prompt.md": () => import("./summarize_query_response_prompt.js").then((e) => e.default),
+  "../agents/help/prompts/help_prompt.md": () => import("./help_prompt.js").then((e) => e.default),
+  "../agents/layerStyling/prompts/layer_styling_prompt.md": () => import("./layer_styling_prompt.js").then((e) => e.default),
+  "../agents/navigation/prompts/navigation_intent_prompt.md": () => import("./navigation_intent_prompt.js").then((e) => e.default),
+  "../agents/navigation/prompts/navigation_tool_prompt.md": () => import("./navigation_tool_prompt.js").then((e) => e.default)
+});
+async function B(e) {
+  const t = Object.entries(ge).find(([r]) => r.endsWith(`/${e}.md`));
+  if (!t)
+    throw new Error(`未找到提示词：${e}
+可用提示词：
+${Object.keys(ge).join(`
+`)}`);
+  return await t[1]();
+}
+const Kt = (e, t = 300) => {
+  const r = e.replace(/\s+/gu, " ").replace(/[*_`#>\-]/gu, "").trim();
+  return r.length > t ? `${r.slice(0, t)}...` : r;
+}, xe = (e, t) => {
+  const a = e?.configurable?.services?.[t];
+  if (a == null)
+    throw new Error(`${t} 在 config.configurable.services 中不存在`);
+  return a;
+}, Qn = (e, t) => (r, a) => {
+  const o = a?.configurable?.services;
+  for (const n of e)
+    if (!o?.[n])
+      throw new Error(`${t} 需要服务。${n} 可用。`);
+  return r;
+};
+async function Ht(e) {
+  const { fields: t, layer: r, view: a, styleName: o, colorSchemeTags: n } = e;
+  let l;
+  return n ? l = _e({
+    basemapTheme: await he(a),
+    geometryType: r.geometryType,
+    includedTags: n,
+    numColors: Math.min(t.length, 8)
+  })[0] : l = We({
+    basemapTheme: await he(a),
+    geometryType: r.geometryType,
+    numColors: Math.min(t.length, 8)
+  }).primaryScheme, {
+    layer: r,
+    view: a,
+    attributes: t.map((i) => ({
+      field: i,
+      label: r.fields.find((c) => c.name === i)?.alias ?? ""
+    })).slice(0, 8),
+    outlineOptimizationEnabled: !0,
+    sizeOptimizationEnabled: !0,
+    includeSizeVariable: o.includes("Size"),
+    pieChartScheme: l
+  };
+}
+async function Jt(e) {
+  return await Qe(e);
+}
+async function Yt({
+  geosceneMap: e,
+  geosceneMapView: t,
+  layerId: r,
+  fields: a,
+  colorSchemes: o,
+  includeSize: n
+}) {
+  const l = t, i = e?.allLayers.find((d) => d.id === r);
+  if (!i)
+    return `未找到图层，ID：${r}`;
+  const u = {
+    styleName: n ? "chart-size" : "chart",
+    fields: a,
+    layer: i,
+    view: l,
+    colorSchemeTags: o
+  };
+  try {
+    const d = await Ht(u), p = await Jt(d);
+    return i.renderer = p.renderer, i.visible = !0, `已为图层应用图表渲染器：${i.title ?? i.id}，使用字段 ${a.join(", ")}`;
+  } catch (d) {
+    return `应用图表渲染器失败：${d instanceof Error ? d.message : String(d)}`;
+  }
+}
+const Zt = ["mapView"];
+function $(e) {
+  const r = e?.configurable?.context;
+  if (!r || typeof r != "object")
+    throw new Error("LayerStylingAgent 缺少上下文");
+  const a = Zt.filter((o) => !(o in r));
+  if (a.length)
+    throw new Error(`LayerStylingAgent 缺少上下文：${a.join(", ")}`);
+  return r;
+}
+async function Xt({
+  layerId: e,
+  fields: t,
+  colorSchemes: r,
+  includeSize: a
+}, o) {
+  const { mapView: n } = $(o);
+  return await R({ type: "show-legend", data: { layerIds: [e] } }, o), await Yt({
+    geosceneMap: n.map,
+    geosceneMapView: n,
+    layerId: e,
+    fields: t,
+    colorSchemes: r,
+    includeSize: a
+  });
+}
+const er = s.object({
+  layerId: s.string().describe("要应用图表渲染器的图层 ID"),
+  fields: s.array(s.string()).describe("图表使用的多个数值字段"),
+  colorSchemes: s.array(s.string()).optional().describe("可选的配色方案标签"),
+  includeSize: s.boolean().optional().describe("是否按总量改变图表大小（chart-size）")
+}), _n = f(Xt, {
+  name: "chart",
+  description: `标签：图表
+说明：使用饼图表示两个或更多类别各自占总量的比例。
+关键词：饼图、图表、所有类别、构成、比例。
+示例：对每个要素，用饼图显示各年代建造的房屋数量。
+字段：需要2至8个数值字段。
+
+标签：图表和大小
+说明：用饼图表示类别占比，并通过图表大小表示总量或规模。
+关键词：饼图、图表、构成、比例、总计、数量、总和、分级大小、比例大小。
+示例：每个要素按年代显示房屋数量占比，饼图大小随各类别总量变化。
+字段：需要2至8个数值字段。`,
+  schema: er
+});
+function tr(e) {
+  const { fields: t, layer: r, view: a, theme: o, colorSchemeTags: n } = e, l = t[0];
+  let i;
+  return n && (i = se({
+    geometryType: r.geometryType,
+    includedTags: n,
+    theme: o || "high-to-low"
+  })[0]), {
+    layer: r,
+    view: a,
+    startTime: l,
+    endTime: /* @__PURE__ */ new Date(),
+    theme: o,
+    sizeOptimizationEnabled: !0,
+    outlineOptimizationEnabled: !0,
+    colorScheme: i
+  };
+}
+async function rr(e) {
+  return await Ve(e);
+}
+async function ar({
+  geosceneMap: e,
+  geosceneMapView: t,
+  layerId: r,
+  fields: a,
+  colorSchemes: o,
+  theme: n
+}) {
+  const l = t, i = e?.allLayers.find((u) => u.id === r);
+  if (!i)
+    return `未找到图层，ID：${r}`;
+  const c = {
+    styleName: "color-age",
+    fields: a,
+    layer: i,
+    view: l,
+    colorSchemeTags: o,
+    theme: n
+  };
+  try {
+    const u = tr(c), d = await rr(u);
+    return i.renderer = d.renderer, i.visible = !0, `已为图层应用颜色年龄渲染器：${i.title ?? i.id}，使用字段 ${a.join(", ")}`;
+  } catch (u) {
+    return `应用颜色年龄渲染器失败：${u instanceof Error ? u.message : String(u)}`;
+  }
+}
+async function or({
+  layerId: e,
+  fields: t,
+  colorSchemes: r,
+  theme: a
+}, o) {
+  const { mapView: n } = $(o);
+  return await R({ type: "show-legend", data: { layerIds: [e] } }, o), await ar({
+    geosceneMap: n.map,
+    geosceneMapView: n,
+    layerId: e,
+    fields: t,
+    colorSchemes: r,
+    theme: a
+  });
+}
+const nr = s.object({
+  layerId: s.string().describe("要应用颜色年龄渲染器的图层 ID"),
+  fields: s.array(s.string()).describe("颜色年龄渲染器使用的日期字段"),
+  colorSchemes: s.array(s.string()).optional().describe("可选的配色方案标签"),
+  theme: s.enum(["above-and-below", "above", "below", "centered-on", "extremes", "high-to-low"]).optional().describe("可选的色带主题")
+}), Wn = f(or, {
+  name: "color-age",
+  description: `标签：年龄（颜色）
+说明：沿连续色带显示要素年龄，年龄表示开始日期至结束日期的时间长度。
+关键词：自从、年龄、多久、多大。
+示例：根据上报日期显示各要素的年龄。
+字段：至少需要一个日期字段。`,
+  schema: nr
+});
+function ir(e) {
+  const { fields: t, layer: r, view: a, colorSchemeTags: o } = e;
+  let { theme: n } = e, l = t[1];
+  const i = t[0];
+  let c;
+  return o && (c = se({
+    geometryType: r.geometryType,
+    includedTags: o,
+    theme: n || "high-to-low"
+  })[0]), {
+    layer: r,
+    view: a,
+    field: i,
+    normalizationField: l,
+    theme: n,
+    sizeOptimizationEnabled: !0,
+    outlineOptimizationEnabled: !0,
+    colorScheme: c
+  };
+}
+async function sr(e) {
+  return await Be(e);
+}
+async function lr({
+  geosceneMap: e,
+  geosceneMapView: t,
+  layerId: r,
+  fields: a,
+  colorSchemes: o,
+  theme: n
+}) {
+  const l = t, i = e?.allLayers.find((u) => u.id === r);
+  if (!i)
+    return `未找到图层，ID：${r}`;
+  const c = {
+    styleName: "color",
+    fields: a,
+    layer: i,
+    view: l,
+    colorSchemeTags: o,
+    theme: n
+  };
+  try {
+    const u = ir(c), d = await sr(u);
+    return i.renderer = d.renderer, i.visible = !0, `已为图层应用颜色渲染器：${i.title ?? i.id}，使用字段 ${a.join(", ")}`;
+  } catch (u) {
+    return `应用颜色渲染器失败：${u instanceof Error ? u.message : String(u)}`;
+  }
+}
+async function cr({
+  layerId: e,
+  fields: t,
+  colorSchemes: r,
+  theme: a
+}, o) {
+  const { mapView: n } = $(o);
+  return await R({ type: "show-legend", data: { layerIds: [e] } }, o), await lr({
+    geosceneMap: n.map,
+    geosceneMapView: n,
+    layerId: e,
+    fields: t,
+    colorSchemes: r,
+    theme: a
+  });
+}
+const ur = s.object({
+  layerId: s.string().describe("要应用颜色渲染器的图层 ID"),
+  fields: s.array(s.string()).describe("颜色渲染器使用的字段"),
+  colorSchemes: s.array(s.string()).optional().describe("可选的配色方案标签"),
+  theme: s.enum(["above-and-below", "above", "below", "centered-on", "extremes", "high-to-low"]).optional().describe("可选的色带主题")
+}), Vn = f(cr, {
+  name: "color",
+  description: `标签：计数和数量（颜色）
+说明：使用连续色带表示数值或等级数据。
+关键词：分级设色、连续颜色、色相、渐变、饱和度、明度、百分比、比率、指数、增加、减少。
+示例：按人口密度为要素着色。
+字段：需要一个数值字段，可指定第二个数值字段用于归一化第一个字段。`,
+  schema: ur
+});
+function dr(e) {
+  const { fields: t, layer: r, view: a, colorSchemeTags: o, theme: n } = e;
+  let l, i;
+  const c = t[0];
+  return o && (i = se({
+    geometryType: r.geometryType,
+    includedTags: o,
+    theme: n || "high-to-low"
+  })[0]), {
+    layer: r,
+    view: a,
+    field: c,
+    normalizationField: l,
+    theme: n,
+    colorOptions: {
+      colorScheme: i
+    }
+  };
+}
+async function pr(e) {
+  return await Ue(e);
+}
+async function mr({
+  geosceneMap: e,
+  geosceneMapView: t,
+  layerId: r,
+  fields: a,
+  colorSchemes: o,
+  theme: n
+}) {
+  const l = t, i = e?.allLayers.find((u) => u.id === r);
+  if (!i)
+    return `未找到图层，ID：${r}`;
+  const c = {
+    styleName: "color-size-univariate",
+    fields: a,
+    layer: i,
+    view: l,
+    colorSchemeTags: o,
+    theme: n
+  };
+  try {
+    const u = dr(c), d = await pr(u);
+    return i.renderer = d.renderer, i.visible = !0, `已为图层应用颜色与大小渲染器：${i.title ?? i.id}，使用字段 ${a.join(", ")}`;
+  } catch (u) {
+    return `应用颜色与大小渲染器失败：${u instanceof Error ? u.message : String(u)}`;
+  }
+}
+async function hr({
+  layerId: e,
+  fields: t,
+  colorSchemes: r,
+  theme: a
+}, o) {
+  const { mapView: n } = $(o);
+  return await R({ type: "show-legend", data: { layerIds: [e] } }, o), await mr({
+    geosceneMap: n.map,
+    geosceneMapView: n,
+    layerId: e,
+    fields: t,
+    colorSchemes: r,
+    theme: a
+  });
+}
+const yr = s.object({
+  layerId: s.string().describe("要应用颜色与大小渲染器的图层 ID"),
+  fields: s.array(s.string()).describe("颜色与大小渲染器使用的字段"),
+  colorSchemes: s.array(s.string()).optional().describe("可选的配色方案标签"),
+  theme: s.enum(["above-and-below", "above", "below", "centered-on", "extremes", "high-to-low"]).optional().describe("可选的颜色和大小渐变主题")
+}), Bn = f(hr, {
+  name: "color-size-univariate",
+  description: `标签：颜色和大小（univariate）
+说明：根据两个数值属性改变符号大小和颜色。
+关键词：连续颜色、色相、颜色、大小、渐变、饱和度、明度、百分比、比率、指数、数量、增减。
+示例：按拥有住房的人口比例着色，按总人口改变点大小。
+字段：至少需要两个字段，分别控制颜色和大小；每个字段都可另用一个字段归一化。`,
+  schema: yr
+});
+function fr(e) {
+  const { fields: t, layer: r, view: a, colorSchemeTags: o } = e;
+  let n;
+  return o && (n = He({
+    includedTags: o,
+    numColors: Math.min(t.length, 8)
+  })[0]), {
+    layer: r,
+    view: a,
+    legendOptions: {
+      unit: "units"
+    },
+    attributes: t.map((l) => ({
+      field: l,
+      label: r.fields.find((i) => i.name === l)?.alias ?? ""
+    })).slice(0, 8),
+    outlineOptimizationEnabled: !0,
+    dotDensityScheme: n
+  };
+}
+async function gr(e) {
+  return await Ke(e);
+}
+async function wr({
+  geosceneMap: e,
+  geosceneMapView: t,
+  layerId: r,
+  fields: a,
+  colorSchemes: o
+}) {
+  const n = t, l = e?.allLayers.find((c) => c.id === r);
+  if (!l)
+    return `未找到图层，ID：${r}`;
+  const i = {
+    styleName: "dot-density",
+    fields: a,
+    layer: l,
+    view: n,
+    colorSchemeTags: o
+  };
+  try {
+    const c = fr(i), u = await gr(c);
+    return l.renderer = u.renderer, l.visible = !0, `已为图层应用点密度渲染器：${l.title ?? l.id}，使用字段 ${a.join(", ")}`;
+  } catch (c) {
+    return `应用点密度渲染器失败：${c instanceof Error ? c.message : String(c)}`;
+  }
+}
+async function br({
+  layerId: e,
+  fields: t,
+  colorSchemes: r
+}, a) {
+  const { mapView: o } = $(a);
+  return await R({ type: "show-legend", data: { layerIds: [e] } }, a), await wr({
+    geosceneMap: o.map,
+    geosceneMapView: o,
+    layerId: e,
+    fields: t,
+    colorSchemes: r
+  });
+}
+const Tr = s.object({
+  layerId: s.string().describe("要应用点密度渲染器的图层 ID"),
+  fields: s.array(s.string()).describe("点密度渲染器使用的字段，例如人口或计数字段"),
+  colorSchemes: s.array(s.string()).optional().describe("可选的配色方案标签")
+}), Un = f(br, {
+  name: "dot-density",
+  description: `点密度
+使用点密度显示单个属性的分布，或比较多个属性的密度，仅适用于面图层。
+用途：人口分布、区域内多类别对比、空间分布规律。
+示例：按种族或族群显示人口密度；显示不同地区的作物分布；显示人口普查区的人口特征。
+字段：需要2至8个数值字段。
+关键词：密度、多少、总量、数量。`,
+  schema: Tr
+});
+function Sr(e) {
+  const { fields: t, layer: r, view: a, colorSchemeTags: o } = e;
+  let n;
+  const l = t[0];
+  return o && (n = Ye({
+    includedTags: o,
+    basemap: a.map?.basemap || "topo"
+  })[0]), {
+    layer: r,
+    view: a,
+    field: l,
+    heatmapScheme: n
+  };
+}
+async function vr(e) {
+  return await Je(e);
+}
+async function xr({
+  geosceneMap: e,
+  geosceneMapView: t,
+  layerId: r,
+  fields: a,
+  colorSchemes: o
+}) {
+  const n = t, l = e?.allLayers.find((c) => c.id === r);
+  if (!l)
+    return `未找到图层，ID：${r}`;
+  const i = {
+    styleName: "heatmap",
+    fields: a,
+    layer: l,
+    view: n,
+    colorSchemeTags: o
+  };
+  try {
+    const c = Sr(i), u = await vr(c);
+    return l.renderer = u.renderer, l.visible = !0, `已为图层应用热力图渲染器：${l.title ?? l.id}，使用字段 ${a.join(", ")}`;
+  } catch (c) {
+    return `应用热力图渲染器失败：${c instanceof Error ? c.message : String(c)}`;
+  }
+}
+async function Rr({
+  layerId: e,
+  fields: t,
+  colorSchemes: r
+}, a) {
+  const { mapView: o } = $(a);
+  return await R({ type: "show-legend", data: { layerIds: [e] } }, a), await xr({
+    geosceneMap: o.map,
+    geosceneMapView: o,
+    layerId: e,
+    fields: t,
+    colorSchemes: r
+  });
+}
+const $r = s.object({
+  layerId: s.string().describe("要应用热力图渲染器的图层 ID"),
+  fields: s.array(s.string()).describe("热力图渲染器使用的字段，通常表示点密度"),
+  colorSchemes: s.array(s.string()).optional().describe("可选的配色方案标签")
+}), Kn = f(Rr, {
+  name: "heatmap",
+  description: `标签：热力图
+说明：用看起来更热、更亮的颜色表示高密度区域，仅适用于点图层。
+关键词：密度、热力图、热点、规律、聚集。
+示例：创建热力图。
+字段：通常不需要字段，或只需要一个数值字段。`,
+  schema: $r
+});
+function Cr(e) {
+  const { fields: t, layer: r, view: a, styleName: o, colorSchemeTags: n } = e;
+  let l;
+  return n && (l = Xe({
+    geometryType: r.geometryType,
+    includedTags: n,
+    numColors: Math.min(t.length, 10)
+  })[0]), {
+    layer: r,
+    view: a,
+    fields: t.map((i) => ({ name: i })).slice(0, 9),
+    outlineOptimizationEnabled: !0,
+    sizeOptimizationEnabled: !0,
+    includeSizeVariable: o.includes("Size"),
+    predominanceScheme: l
+  };
+}
+async function Er(e) {
+  return await Ze(e);
+}
+async function Fr({
+  geosceneMap: e,
+  geosceneMapView: t,
+  layerId: r,
+  fields: a,
+  colorSchemes: o,
+  includeSize: n
+}) {
+  const l = t, i = e?.allLayers.find((d) => d.id === r);
+  if (!i)
+    return `未找到图层，ID：${r}`;
+  const u = {
+    styleName: n ? "predominance-size" : "predominance",
+    fields: a,
+    layer: i,
+    view: l,
+    colorSchemeTags: o
+  };
+  try {
+    const d = Cr(u), p = await Er(d);
+    return i.renderer = p.renderer, i.visible = !0, `已为图层应用主导类别渲染器：${i.title ?? i.id}，使用字段 ${a.join(", ")}`;
+  } catch (d) {
+    return `应用主导类别渲染器失败：${d instanceof Error ? d.message : String(d)}`;
+  }
+}
+async function Nr({
+  layerId: e,
+  fields: t,
+  colorSchemes: r,
+  includeSize: a
+}, o) {
+  const { mapView: n } = $(o);
+  return await R({ type: "show-legend", data: { layerIds: [e] } }, o), await Fr({
+    geosceneMap: n.map,
+    geosceneMapView: n,
+    layerId: e,
+    fields: t,
+    colorSchemes: r,
+    includeSize: a
+  });
+}
+const kr = s.object({
+  layerId: s.string().describe("要应用主导类别渲染器的图层 ID"),
+  fields: s.array(s.string()).describe("主导类别渲染器使用的相互比较的类别字段"),
+  colorSchemes: s.array(s.string()).optional().describe("可选的配色方案标签"),
+  includeSize: s.boolean().optional().describe("是否同时使用大小表达总量（predominance-size）")
+}), Hn = f(Nr, {
+  name: "predominance",
+  description: `标签：主导类别
+说明：比较具有相同主题和计量单位的属性，显示哪一项最高。
+关键词：主导、胜出、竞争、最多、最常见、最高。
+示例：比较玉米、小麦、棉花面积，显示各地区主要收获作物。
+字段：需要2至10个数值字段。
+
+标签：主导类别和大小
+说明：显示最高类别，同时以符号大小表示所有类别的总量。
+关键词：主导、最多、常见、总量、数量、比例大小、分级大小、总和。
+示例：显示各地区主导作物，并按所有类别总量改变符号大小。
+字段：需要2至10个数值字段。`,
+  schema: kr
+});
+function qr(e) {
+  const { fields: t, layer: r, view: a, colorSchemeTags: o } = e;
+  let n;
+  const l = {
+    field: t[0]
+  }, i = {
+    field: t[1]
+  };
+  return o && (n = tt({
+    geometryType: r.geometryType,
+    includedTags: o
+  })[0]), {
+    layer: r,
+    view: a,
+    field1: l,
+    field2: i,
+    outlineOptimizationEnabled: !0,
+    sizeOptimizationEnabled: !0,
+    relationshipScheme: n
+  };
+}
+async function Ir(e) {
+  return await et(e);
+}
+async function Dr({
+  geosceneMap: e,
+  geosceneMapView: t,
+  layerId: r,
+  fields: a,
+  colorSchemes: o
+}) {
+  const n = t, l = e?.allLayers.find((c) => c.id === r);
+  if (!l)
+    return `未找到图层，ID：${r}`;
+  const i = {
+    styleName: "relationship",
+    fields: a,
+    layer: l,
+    view: n,
+    colorSchemeTags: o
+  };
+  try {
+    const c = qr(i), u = await Ir(c);
+    return l.renderer = u.renderer, l.visible = !0, `已为图层应用关系渲染器：${l.title ?? l.id}，使用字段 ${a.join(", ")}`;
+  } catch (c) {
+    return `应用关系渲染器失败：${c instanceof Error ? c.message : String(c)}`;
+  }
+}
+async function zr({
+  layerId: e,
+  fields: t,
+  colorSchemes: r
+}, a) {
+  const { mapView: o } = $(a);
+  return await R({ type: "show-legend", data: { layerIds: [e] } }, a), await Dr({
+    geosceneMap: o.map,
+    geosceneMapView: o,
+    layerId: e,
+    fields: t,
+    colorSchemes: r
+  });
+}
+const Pr = s.object({
+  layerId: s.string().describe("要应用关系渲染器的图层 ID"),
+  fields: s.array(s.string()).describe("关系渲染器使用的两个字段，用于双变量可视化"),
+  colorSchemes: s.array(s.string()).optional().describe("可选的配色方案标签")
+}), Jn = f(zr, {
+  name: "relationship",
+  description: `标签：关系
+说明：叠加两个色带，表达两个数值属性的关系。
+关键词：关系、相关性、比较、双变量分级设色、双变量颜色。
+示例：显示树木高度与碳储量的关系。
+字段：需要两个数值字段。`,
+  schema: Pr
+});
+function Ar(e) {
+  const { fields: t, layer: r, view: a, theme: o } = e, n = t[0];
+  return {
+    layer: r,
+    view: a,
+    startTime: n,
+    endTime: /* @__PURE__ */ new Date(),
+    theme: o,
+    sizeOptimizationEnabled: !0,
+    outlineOptimizationEnabled: !0
+  };
+}
+async function Lr(e) {
+  return await rt(e);
+}
+async function jr({
+  geosceneMap: e,
+  geosceneMapView: t,
+  layerId: r,
+  fields: a,
+  colorSchemes: o,
+  theme: n
+}) {
+  const l = t, i = e?.allLayers.find((u) => u.id === r);
+  if (!i)
+    return `未找到图层，ID：${r}`;
+  const c = {
+    styleName: "size-age",
+    fields: a,
+    layer: i,
+    view: l,
+    colorSchemeTags: o,
+    theme: n
+  };
+  try {
+    const u = Ar(c), d = await Lr(u);
+    return i.renderer = d.renderer, i.visible = !0, `已为图层应用大小年龄渲染器：${i.title ?? i.id}，使用字段 ${a.join(", ")}`;
+  } catch (u) {
+    return `应用大小年龄渲染器失败：${u instanceof Error ? u.message : String(u)}`;
+  }
+}
+async function Gr({
+  layerId: e,
+  fields: t,
+  colorSchemes: r,
+  theme: a
+}, o) {
+  const { mapView: n } = $(o);
+  return await R({ type: "show-legend", data: { layerIds: [e] } }, o), await jr({
+    geosceneMap: n.map,
+    geosceneMapView: n,
+    layerId: e,
+    fields: t,
+    colorSchemes: r,
+    theme: a
+  });
+}
+const Or = s.object({
+  layerId: s.string().describe("要应用大小年龄渲染器的图层 ID"),
+  fields: s.array(s.string()).describe("大小年龄渲染器使用的日期字段"),
+  colorSchemes: s.array(s.string()).optional().describe("可选的配色方案标签"),
+  theme: s.enum(["above-and-below", "above", "below", "centered-on", "extremes", "high-to-low"]).optional().describe("可选的大小渐变主题")
+}), Yn = f(Gr, {
+  name: "size-age",
+  description: `标签：年龄（大小）
+说明：用连续变化的符号大小表示要素年龄，即开始日期至结束日期的时间长度。
+关键词：自从、年龄、多久、多大。
+示例：让较老要素的符号大于较新要素。
+字段：至少需要一个日期字段。`,
+  schema: Or
+});
+function Mr(e) {
+  const { fields: t, layer: r, view: a } = e;
+  let { theme: o } = e, n = t[1];
+  const l = t[0];
+  return {
+    layer: r,
+    view: a,
+    field: l,
+    normalizationField: n,
+    theme: o,
+    sizeOptimizationEnabled: !0,
+    outlineOptimizationEnabled: !0
+  };
+}
+async function Qr(e) {
+  return await at(e);
+}
+async function _r({
+  geosceneMap: e,
+  geosceneMapView: t,
+  layerId: r,
+  fields: a,
+  colorSchemes: o,
+  theme: n
+}) {
+  const l = t, i = e?.allLayers.find((u) => u.id === r);
+  if (!i)
+    return `未找到图层，ID：${r}`;
+  const c = {
+    styleName: "size",
+    fields: a,
+    layer: i,
+    view: l,
+    colorSchemeTags: o,
+    theme: n
+  };
+  try {
+    const u = Mr(c), d = await Qr(u);
+    return i.renderer = d.renderer, i.visible = !0, `已为图层应用大小渲染器：${i.title ?? i.id}，使用字段 ${a.join(", ")}`;
+  } catch (u) {
+    return `应用大小渲染器失败：${u instanceof Error ? u.message : String(u)}`;
+  }
+}
+async function Wr({
+  layerId: e,
+  fields: t,
+  colorSchemes: r,
+  theme: a
+}, o) {
+  const { mapView: n } = $(o);
+  return await R({ type: "show-legend", data: { layerIds: [e] } }, o), await _r({
+    geosceneMap: n.map,
+    geosceneMapView: n,
+    layerId: e,
+    fields: t,
+    colorSchemes: r,
+    theme: a
+  });
+}
+const Vr = s.object({
+  layerId: s.string().describe("要应用大小渲染器的图层 ID"),
+  fields: s.array(s.string()).describe("大小渲染器使用的数值字段"),
+  colorSchemes: s.array(s.string()).optional().describe("可选的配色方案标签"),
+  theme: s.enum(["above-and-below", "above", "below", "centered-on", "extremes", "high-to-low"]).optional().describe("可选的大小渐变主题")
+}), Zn = f(Wr, {
+  name: "size",
+  description: `标签：计数和数量（大小）
+说明：以连续变化的符号大小表示数值或等级数据。
+关键词：分级大小、比例大小、多少、总量、数量、大小。
+示例：根据总人口改变点的大小。
+字段：需要一个数值字段，可指定第二个数值字段对其归一化。
+
+标签：连续时间线（大小）
+说明：以连续变化的符号大小表示日期。
+关键词：分级大小、比例大小、分级、多少、总量、数量、何时。
+示例：根据工单完成日期改变要素大小。
+字段：需要一个日期字段。`,
+  schema: Vr
+});
+function Br(e) {
+  const { fields: t, layer: r, view: a, colorSchemeTags: o } = e, n = t[0], l = t[1], i = t[2];
+  let c;
+  return o && (c = nt({
+    geometryType: r.geometryType,
+    includedTags: o
+  })[0]), {
+    layer: r,
+    view: a,
+    field: n,
+    field2: l,
+    field3: i,
+    outlineOptimizationEnabled: !0,
+    sizeOptimizationEnabled: !0,
+    typeScheme: c
+  };
+}
+async function Ur(e) {
+  return await ot(e);
+}
+async function Kr({
+  geosceneMap: e,
+  geosceneMapView: t,
+  layerId: r,
+  fields: a,
+  colorSchemes: o,
+  theme: n
+}) {
+  const l = t, i = e?.allLayers.find((u) => u.id === r);
+  if (!i)
+    return `未找到图层，ID：${r}`;
+  const c = {
+    styleName: "type",
+    fields: a,
+    layer: i,
+    view: l,
+    colorSchemeTags: o,
+    theme: n
+  };
+  try {
+    const u = Br(c), d = await Ur(u);
+    return i.renderer = d.renderer, i.visible = !0, `已为图层应用类型渲染器：${i.title ?? i.id}，使用字段 ${a.join(", ")}`;
+  } catch (u) {
+    return `应用类型渲染器失败：${u instanceof Error ? u.message : String(u)}`;
+  }
+}
+async function Hr({
+  layerId: e,
+  fields: t,
+  colorSchemes: r,
+  theme: a
+}, o) {
+  const { mapView: n } = $(o);
+  return await R({ type: "show-legend", data: { layerIds: [e] } }, o), await Kr({
+    geosceneMap: n.map,
+    geosceneMapView: n,
+    layerId: e,
+    fields: t,
+    colorSchemes: r,
+    theme: a
+  });
+}
+const Jr = s.object({
+  layerId: s.string().describe("要应用类型渲染器的图层 ID"),
+  fields: s.array(s.string()).describe("类型渲染器使用的分类字段"),
+  colorSchemes: s.array(s.string()).optional().describe("可选的配色方案标签"),
+  theme: s.enum(["above-and-below", "above", "below", "centered-on", "extremes", "high-to-low"]).optional().describe("可选的配色主题")
+}), Xn = f(Hr, {
+  name: "type",
+  description: `标签：类型（唯一值符号）
+说明：按类别使用不同颜色或形状表示要素，例如树种、道路等级、省份。
+关键词：分类、类别、类型、唯一值、离散、兴趣点、地区、分组。
+示例：按所属地区为要素着色。
+字段：需要一个字符串、数字或日期字段，通常为字符串。`,
+  schema: Jr
+}), ei = T.Root({
+  ...H(),
+  vectorSearchLayerIds: T(),
+  vectorSearchFieldResults: T(),
+  layerFieldInfo: T(),
+  selectedLayerId: T()
+}), ti = T.Root({
+  ...H(),
+  vectorSearchLayerIds: T(),
+  vectorSearchFieldResults: T(),
+  layerFieldInfo: T(),
+  queryResponse: T(),
+  dataExplorationMessages: T({
+    reducer: be,
+    default: () => []
+  })
+}), Yr = ["mapView"];
+function k(e) {
+  const r = e?.configurable?.context;
+  if (!r || typeof r != "object")
+    throw new Error("DataExplorationAgent 缺少上下文");
+  const a = Yr.filter((o) => !(o in r));
+  if (a.length)
+    throw new Error(`DataExplorationAgent 缺少上下文：${a.join(", ")}`);
+  return r;
+}
+const Zr = (e) => {
+  const t = e.map?.allLayers.filter((a) => a.type === "feature");
+  let r = 0;
+  return t?.forEach((a) => {
+    const o = a;
+    o.featureEffect && (o.featureEffect = null, r++);
+  }), r > 0 ? `已清除过滤条件，涉及 ${r} 个图层。视图保持不变。` : "没有需要清除的过滤条件。视图保持不变。";
+}, Xr = async (e, t) => {
+  const { mapView: r } = k(t);
+  return Zr(r);
+}, ea = f(Xr, {
+  name: "clearFilters",
+  description: "清除地图中所有要素效果和过滤条件，保留当前视图。用于“清除过滤”“重置过滤”“移除过滤”“显示所有要素”，或仅移除强调效果而不定位的请求。",
+  schema: s.object({})
+}), ta = async (e) => {
+  e.map?.allLayers.filter((o) => o.type === "feature")?.forEach((o) => {
+    const n = o;
+    n.featureEffect && (n.featureEffect = null);
+  });
+  const a = e.map.initialViewProperties?.viewpoint?.targetGeometry;
+  return a ? (await e.goTo(a), "已清除所有过滤条件并返回初始范围。") : "已清除所有过滤条件，但无法确定初始范围。";
+}, ra = async (e, t) => {
+  const { mapView: r } = k(t);
+  return await ta(r);
+}, aa = f(ra, {
+  name: "resetMap",
+  description: "清除地图中所有要素效果和过滤条件，并返回初始视图范围。用于“重置地图”“重新开始”，或同时要求清除过滤与返回初始视图的请求。",
+  schema: s.object({})
+}), we = 750;
+function U(e) {
+  return "point" in e && e.point !== void 0;
+}
+function j(e) {
+  return "layerId" in e && e.layerId !== void 0;
+}
+const J = async (e, t) => {
+  if (U(e)) {
+    const { point: r } = e;
+    return { geometry: new Te({
+      x: r.x,
+      y: r.y,
+      spatialReference: r.spatialReference ? { wkid: r.spatialReference.wkid } : t.spatialReference
+    }) };
+  }
+  if (j(e)) {
+    const r = t.map?.allLayers.find(
+      (n) => n.id === e.layerId
+    );
+    if (!r)
+      return { error: `未找到几何来源图层，ID：${e.layerId}` };
+    const a = r.title ?? r.id, o = e.where?.trim() || "1=1";
+    try {
+      const n = await r.queryFeatures({
+        where: o,
+        returnGeometry: !0,
+        outSpatialReference: t.spatialReference,
+        num: we + 1
+      });
+      if (!n.features.length)
+        return {
+          error: `几何来源图层“${a}”中没有符合以下 where 条件的要素：${o}`
+        };
+      if (n.features.length > we)
+        return {
+          error: `几何来源图层“${a}”的过滤条件匹配了过多要素（${n.features.length}+），请缩小几何来源图层的过滤范围。`
+        };
+      const l = n.features.map((c) => c.geometry).filter((c) => !!c);
+      if (!l.length)
+        return { error: "匹配的几何来源要素中没有有效几何。" };
+      const i = l.length === 1 ? l[0] : lt.executeMany(l);
+      return i ? (i.spatialReference || (i.spatialReference = t.spatialReference), { geometry: i }) : { error: "合并来源图层几何失败。" };
+    } catch (n) {
+      return { error: `查询几何失败：${String(n)}` };
+    }
+  }
+  return { error: "提供的几何配置无效" };
+}, oa = async (e, t, r, a, o, n) => {
+  const l = e.map?.allLayers.find((c) => c.id === t);
+  if (!l)
+    return { success: !1, error: `图层 '${t}' 不存在。` };
+  const i = l.createQuery();
+  i.where = r ?? "1=1", a && (i.geometry = a, i.spatialRelationship = "intersects", o && (i.distance = o), n && (i.units = n));
+  try {
+    const { extent: c, count: u } = await l.queryExtent(i);
+    return !c || u === 0 ? {
+      success: !1,
+      error: `没有符合过滤条件的要素（where：${i.where}${a ? "，已使用空间过滤" : ""})`
+    } : (await e.goTo(c), { success: !0 });
+  } catch (c) {
+    return {
+      success: !1,
+      error: c instanceof Error ? c.message : String(c)
+    };
+  }
+}, na = async (e, t, r, a, o, n) => {
+  const l = t.map?.allLayers.find(
+    (p) => p.id === e.layerId
+  );
+  if (!l)
+    return `未找到目标图层，ID：${e.layerId}`;
+  let i;
+  if (o) {
+    const p = await J(o, t);
+    if ("error" in p)
+      return p.error;
+    i = p.geometry;
+  }
+  if (l.featureEffect = null, l.featureEffect = new st({
+    filter: new Se({
+      ...e.objectIds?.length ? { objectIds: e.objectIds } : { where: e.where },
+      geometry: i,
+      spatialRelationship: "intersects",
+      distance: o?.distance,
+      units: o?.units
+    }),
+    includedEffect: r,
+    excludedEffect: a
+  }), l.visible = !0, n)
+    return `已应用要素效果到“${l.title ?? e.layerId}”，范围为当前地图视图。`;
+  const c = e.objectIds?.length ? `${l.objectIdField} IN (${e.objectIds.join(",")})` : e.where, u = await oa(
+    t,
+    e.layerId,
+    c,
+    i,
+    o?.distance,
+    o?.units
+  ), d = l.title ?? e.layerId;
+  return u.success ? `已应用要素效果到目标图层“${l.title ?? e.layerId}"${o && "layerId" in o ? `，几何来自图层“${o.layerId}"` : ""}.` : `已应用过滤条件到“${d}”，但没有匹配的要素。${u.error}`;
+}, ia = ["feet", "kilometers", "meters", "miles", "nautical-miles", "us-nautical-miles"], F = s.enum(ia), sa = async ({
+  targetLayer: e,
+  geometryFilter: t,
+  useCurrentExtent: r,
+  includedEffect: a = "drop-shadow(2px, 2px, 2px, gray)",
+  excludedEffect: o = "grayscale(100%) opacity(60%) blur(2px)"
+}, n) => {
+  const { mapView: l } = k(n);
+  return await na(e, l, a, o, t, r);
+}, la = s.object({
+  layerId: s.string().describe("用作空间过滤几何来源的图层 layerId。"),
+  where: s.string().describe("SQL-92 where 子句，用于选择作为过滤几何来源的要素。"),
+  distance: s.number().optional().describe("几何周围的缓冲距离。"),
+  units: F.optional().describe("缓冲距离的单位。")
+}), ca = s.object({
+  point: s.object({
+    x: s.number().describe("导航结果的 X 坐标，即经度"),
+    y: s.number().describe("导航结果的 Y 坐标，即纬度"),
+    spatialReference: s.object({
+      wkid: s.number().describe("空间参考 WKID，例如4326表示 WGS84")
+    }).optional().describe("空间参考，未提供时默认使用地图空间参考。")
+  }).describe("之前导航或地理编码结果中的点坐标"),
+  distance: s.number().optional().describe("点周围的可选缓冲距离。"),
+  units: F.optional().describe("缓冲距离的单位。")
+}), ua = s.object({
+  targetLayer: s.object({
+    layerId: s.string().describe("要设置要素效果的图层 layerId。"),
+    where: s.string().describe("SQL-92 where 子句，用于选择需要强调的要素。"),
+    objectIds: s.array(s.number()).optional().describe(
+      "之前查询结果中的 objectIds 数组。当查询返回 objectIds，例如前 N 项结果时，使用它代替 where。提供此参数时优先于 where。"
+    )
+  }),
+  geometryFilter: s.union([la, ca]).optional().describe("空间查询使用的可选几何过滤参数。"),
+  useCurrentExtent: s.boolean().optional().describe(
+    "之前的查询使用当前地图范围作为空间过滤条件时设为 true，确保效果只作用于当前视图中的要素。默认 false。"
+  ),
+  includedEffect: s.string().default("drop-shadow(2px, 2px, 2px, gray)").describe(
+    "对满足过滤条件的要素应用的效果。有效值包括 bloom、blur、brightness、contrast、drop-shadow、grayscale、hue-rotate、invert、opacity、saturate、sepia。未指定时优先使用默认效果。"
+  ),
+  excludedEffect: s.string().default("grayscale(100%) opacity(60%) blur(2px)").describe(
+    "对不满足过滤条件的要素应用的效果。有效值包括 bloom、blur、brightness、contrast、drop-shadow、grayscale、hue-rotate、invert、opacity、saturate、sepia。未指定时优先使用默认效果。"
+  )
+}), da = f(sa, {
+  name: "setFeatureEffect",
+  description: "根据过滤参数和要素效果，为指定图层中满足条件的要素设置强调效果。未提供效果信息时使用默认效果。",
+  schema: ua
+}), pa = /* @__PURE__ */ new Set([
+  "date",
+  "esrifieldtypedate",
+  "date-only",
+  "dateonly",
+  "esrifieldtypedateonly",
+  "time-only",
+  "timeonly",
+  "esrifieldtypetimeonly",
+  "timestamp-offset",
+  "timestampoffset",
+  "esrifieldtypetimestampoffset"
+]), Re = (e) => {
+  if (!e)
+    return !1;
+  const t = e.toLowerCase();
+  return pa.has(t);
+}, te = (e) => {
+  if (e instanceof Date)
+    return Number.isNaN(e.getTime()) ? null : e;
+  if (typeof e == "number" && Number.isFinite(e)) {
+    const t = new Date(e);
+    return Number.isNaN(t.getTime()) ? null : t;
+  }
+  return null;
+}, ma = (e) => !e || e === "system" ? Intl.DateTimeFormat().resolvedOptions().timeZone : e === "unknown" ? "UTC" : e, ha = (e) => {
+  if (typeof e == "string" && e)
+    return e;
+  const t = te(e);
+  return t ? t.toISOString().slice(0, 10) : null;
+}, ri = () => {
+  const e = (/* @__PURE__ */ new Date()).getTimezoneOffset(), t = e <= 0 ? "+" : "-", r = Math.floor(Math.abs(e) / 60).toString().padStart(2, "0"), a = (Math.abs(e) % 60).toString().padStart(2, "0"), o = `${t}${r}:${a}`;
+  return { userTimezone: Intl.DateTimeFormat().resolvedOptions().timeZone, userTimezoneOffset: o };
+}, ya = (e, t, r) => {
+  const a = t?.toLowerCase();
+  if (a && !Re(a))
+    return e;
+  if (a === "date-only") {
+    const n = ha(e);
+    return n ? ct(n, _("short-date")) : e;
+  }
+  if (a === "time-only") {
+    if (typeof e == "string" && e)
+      return ut(e, _("long-time"));
+    const n = te(e);
+    return n ? ye(n, {
+      ..._("long-time"),
+      timeZone: "UTC"
+    }) : e;
+  }
+  const o = te(e);
+  return o ? ye(o, {
+    ..._("short-date-short-time"),
+    timeZone: ma(r)
+  }) : e;
+}, $e = (e, t, r) => {
+  if (e && typeof e != "function") {
+    const a = "getField" in r && r.getField?.(e), o = a && "getFieldDomain" in r && r.getFieldDomain ? r.getFieldDomain(a.name) : null;
+    if (o?.type === "coded-value") {
+      const l = o.codedValues.find((i) => i.code === t);
+      return l ? l.name : null;
+    }
+  }
+  return null;
+}, fa = (e) => !e || e === "system" ? Intl.DateTimeFormat().resolvedOptions().timeZone : e === "unknown" ? "UTC" : e, ga = (e) => {
+  if (e instanceof Date)
+    return Number.isNaN(e.getTime()) ? null : e;
+  if (typeof e == "number" && Number.isFinite(e)) {
+    const t = new Date(e);
+    return Number.isNaN(t.getTime()) ? null : t;
+  }
+  if (typeof e == "string" && e) {
+    const t = new Date(e);
+    return Number.isNaN(t.getTime()) ? null : t;
+  }
+  return null;
+}, wa = (e, t) => {
+  if (typeof e != "number")
+    return e;
+  const r = {};
+  t.minimumFractionDigits !== void 0 && (r.minimumFractionDigits = t.minimumFractionDigits), t.maximumFractionDigits !== void 0 && (r.maximumFractionDigits = t.maximumFractionDigits), t.useGrouping === "always" ? r.useGrouping = !0 : t.useGrouping === "never" && (r.useGrouping = !1);
+  try {
+    return new Intl.NumberFormat(void 0, r).format(e);
+  } catch {
+    return e;
+  }
+}, ba = (e, t, r) => {
+  const a = ga(e);
+  if (!a)
+    return e;
+  const o = {};
+  t.dateStyle ? o.dateStyle = t.dateStyle : (t.year && (o.year = t.year), t.month && (o.month = t.month)), t.timeStyle && (o.timeStyle = t.timeStyle), t.timeStyle && t.hour12 === "always" ? o.hour12 = !0 : t.timeStyle && t.hour12 === "never" && (o.hour12 = !1), o.timeZone = fa(r);
+  try {
+    return new Intl.DateTimeFormat(void 0, o).format(a);
+  } catch {
+    return e;
+  }
+}, Ce = (e, t) => e.getFieldAlias?.(t) ?? e.fieldsIndex?.get(t)?.alias ?? e.fieldsIndex?.get(t)?.name ?? t, Ee = (e, t, r, a, o) => {
+  if (r == null)
+    return r;
+  const l = e.getFieldConfiguration?.(t)?.fieldFormat;
+  return l?.type === "number" ? wa(r, l) : l?.type === "date-time" ? !a || Re(a) ? ba(r, l, o) : r : ya(r, a, o);
+}, Ta = (e, t, r, a) => {
+  const o = e.fieldsIndex?.get(t), n = $e(t, r, e) ?? r;
+  return Ee(e, t, n, o?.type, a);
+}, Sa = (e, t) => Ce(e, t), Fe = (e, t, r) => {
+  const a = e.objectIdField, o = t.features.map(
+    (l) => l.attributes[a]
+  ), n = t.features.map((l) => {
+    const i = l.attributes, c = {};
+    return e.fields.forEach((u) => {
+      if (!Object.hasOwn(i, u.name))
+        return;
+      const d = i[u.name];
+      if (u.name === a) {
+        c[u.name] = d;
+        return;
+      }
+      const p = $e(u.name, d, e) ?? d, m = Ce(e, u.name);
+      c[m] = Ee(e, u.name, p, u.type, r);
+    }), c;
+  });
+  return { objectIds: o, attributes: n };
+}, va = (e, t, r) => {
+  const a = e.createQuery();
+  return a.outFields = [t], a.where = r || "1=1", a.num = 1, a;
+}, xa = async (e, t, r, a) => {
+  const o = a.map?.allLayers.find((m) => m.id === e), n = va(o, t, r.where), i = (await o.queryFeatures(n)).features[0], c = i ? i.attributes[t] : null, u = Ta(o, t, c, a.timeZone), d = Sa(o, t);
+  return {
+    tool: "getAttribute",
+    layerName: o.title ?? e,
+    summary: `${d} = ${u}`,
+    details: {
+      fieldName: t,
+      fieldAlias: d !== t ? d : void 0,
+      value: u,
+      where: r.where
+    }
+  };
+};
+async function Ra({ layerId: e, fieldName: t, query: r }, a) {
+  const { mapView: o } = k(a), n = await xa(e, t, r, o);
+  return JSON.stringify(n, null, 2);
+}
+const $a = s.object({
+  layerId: s.string().describe("要读取属性值的字段所属图层 layerId。"),
+  fieldName: s.string().describe("要读取值的字段或属性名称。"),
+  query: s.object({
+    where: s.string().describe("用于选择要读取属性值的要素的 SQL-92 where 子句。")
+  })
+}), Ca = f(Ra, {
+  name: "getAttribute",
+  description: "返回指定要素的一个属性值。",
+  schema: $a
+}), le = (e, t, r) => {
+  if (!(r ? e.hasAllFeaturesInView : e.hasAllFeatures))
+    return !1;
+  const o = new Set((e.availableFields ?? []).map((n) => n.toLowerCase()));
+  return o.has("*") ? !0 : t.every((n) => o.has(n.toLowerCase()));
+};
+function K(e, t) {
+  let r = e ?? "";
+  return t != null && t && (r = r ? `(${r}) AND (${t})` : t), r || null;
+}
+const Ea = async (e) => {
+  const { targetLayer: t, fieldName: r, statisticType: a, mapView: o, layersAndFieldsRegistry: n, geometryFilter: l } = e, i = o.map?.allLayers.find((S) => S.id === t.layerId);
+  if (!i)
+    throw new Error(`图层 '${t.layerId}' 不存在。`);
+  const c = await o.whenLayerView(i), d = n.get(t.layerId)?.fieldRegistry.get(r), p = d?.alias;
+  if (!d)
+    throw new Error(`字段 '${r}' 不存在。`);
+  let m, w;
+  if (l) {
+    const S = await J(l, o);
+    if ("error" in S)
+      throw new Error(S.error);
+    if (!S.geometry)
+      throw j(l) ? new Error(`没有符合以下条件的要素：${l.where}`) : new Error("创建几何失败");
+    if (j(l)) {
+      const Q = o.map?.allLayers.find((A) => A.id === l.layerId);
+      m = {
+        geometryLayerName: Q?.title ?? Q?.id,
+        geometryLayerId: l.layerId,
+        geometryWhere: l.where,
+        distance: l.distance,
+        units: l.units,
+        applied: !0
+      };
+    } else U(l) && (m = {
+      point: l.point,
+      distance: l.distance,
+      units: l.units,
+      applied: !0
+    });
+    w = new Se({
+      geometry: S.geometry,
+      distance: l.distance,
+      units: l.units,
+      spatialRelationship: "intersects"
+    });
+  }
+  const h = le(c, [r], !1);
+  let y = null, g = null;
+  const b = 10;
+  if (d.type !== "geometry" && d.type !== "oid" && d.type !== "global-id")
+    try {
+      const S = {
+        layer: i,
+        useFeaturesInView: h,
+        view: h ? o : void 0,
+        field: r,
+        sqlWhere: K(i.definitionExpression, t.where),
+        ...w && { filter: w },
+        outStatisticTypes: { include: [a] }
+      };
+      y = await dt(S);
+      const Q = ["string", "small-integer", "integer"], A = d.domain?.type === "coded-value" ? d.domain : null;
+      (Q.includes(d.type) || A) && (g = (await pt({
+        layer: i,
+        useFeaturesInView: h,
+        view: h ? o : void 0,
+        field: r,
+        sqlWhere: K(i.definitionExpression, t.where),
+        ...w && { filter: w }
+      })).uniqueValueInfos.sort((I, ze) => ze.count - I.count).slice(0, b)), g && d.domain?.type === "coded-value" && (g = g.map((I) => ({
+        ...I,
+        value: A ? A.getName(I.value) ?? I.value : I.value
+      })));
+    } catch (S) {
+      console.error("统计错误：", S);
+    }
+  return {
+    tool: "getStatistics",
+    layerName: i.title ?? t.layerId,
+    summary: `${a} = ${typeof y?.[a] == "number" ? y[a] : "N/A"}`,
+    details: {
+      fieldName: r,
+      fieldAlias: p,
+      statisticType: a,
+      statistic: y?.[a] ?? null,
+      summaryStatistics: y,
+      uniqueValues: g,
+      where: t.where,
+      spatialFilterInfo: m
+    }
+  };
+};
+async function Fa({
+  targetLayer: e,
+  fieldName: t,
+  statisticType: r,
+  geometryFilter: a
+}, o) {
+  const n = xe(o, "layersAndFieldsRegistry"), { mapView: l } = k(o), i = await Ea({
+    targetLayer: e,
+    fieldName: t,
+    statisticType: r,
+    mapView: l,
+    layersAndFieldsRegistry: n,
+    geometryFilter: a
+  });
+  return JSON.stringify(i, null, 2);
+}
+const Na = s.object({
+  layerId: s.string().describe("用作空间过滤几何来源的图层 layerId。"),
+  where: s.string().describe("SQL-92 where 子句，用于选择作为过滤几何来源的要素。"),
+  distance: s.number().optional().describe("几何周围的缓冲距离。"),
+  units: F.optional().describe("缓冲距离的单位。")
+}), ka = s.object({
+  point: s.object({
+    x: s.number().describe("导航结果的 X 坐标，即经度"),
+    y: s.number().describe("导航结果的 Y 坐标，即纬度"),
+    spatialReference: s.object({
+      wkid: s.number().describe("空间参考 WKID，例如4326表示 WGS84")
+    }).optional().describe("空间参考，未提供时默认使用地图空间参考。")
+  }).describe("之前导航或地理编码结果中的点坐标"),
+  distance: s.number().optional().describe("点周围的可选缓冲距离。"),
+  units: F.optional().describe("缓冲距离的单位。")
+}), qa = s.object({
+  targetLayer: s.object({
+    layerId: s.string().describe("要读取属性值的字段所属图层 layerId。"),
+    where: s.string().describe("用于选择要读取属性值的要素的 SQL-92 where 子句。")
+  }),
+  geometryFilter: s.union([Na, ka]).optional().describe(
+    "空间查询的几何过滤条件。使用 point 和导航结果的 x/y 坐标查找该点位置的要素（点落入面）；使用 layerId/where 按其他图层的要素进行空间过滤。"
+  ),
+  fieldName: s.string().describe("要统计的字段名称，严禁使用 OBJECTID，应选择其他字段。"),
+  statisticType: s.enum(["avg", "max", "median", "min", "stddev", "sum", "variance", "nullcount", "count"]).describe("要计算的统计类型。")
+}), Ia = f(Fa, {
+  name: "getStatistics",
+  description: `对匹配要素的某个数值字段计算单项聚合统计，例如 max、min、avg、sum、median、stddev、variance；对分类字段还返回频数分析。
+
+适用：
+- 某字段的平均值、最大值、最小值、总和。
+- 某字段最常见或出现最多的值。
+- 需要对多个要素进行数学聚合的问题。
+
+不适用：
+- 有多少要素匹配条件：使用 queryFeatures，它返回 totalCount。
+- 显示、列出或查找要素：使用 queryFeatures。
+- 对符合条件的要素简单计数：使用 queryFeatures。
+
+仅在答案需要对字段值聚合计算时调用，不能只为计数或列出要素而调用。`,
+  schema: qa
+}), Da = (e) => e.flatMap((t) => t.split(",")).map((t) => t.trim()).map((t) => t.split(/\s+/u)[0]?.replace(/^"|"$/gu, "")).filter((t) => !!t), za = async (e, t, r, a, o) => {
+  const n = r.map?.allLayers.find((m) => m.id === e.layerId), l = await r.whenLayerView(n), i = n.title ?? e.layerId;
+  let c;
+  if (a) {
+    const m = await J(a, r);
+    if ("error" in m)
+      return {
+        tool: "getTopFeatures",
+        layerName: i,
+        summary: "查找几何失败",
+        details: { error: m.error }
+      };
+    if (!m.geometry)
+      return {
+        tool: "getTopFeatures",
+        layerName: i,
+        summary: "没有符合几何过滤条件的要素",
+        details: {
+          error: `没有符合以下条件的要素：${"where" in a ? a.where : "未知条件"}`
+        }
+      };
+    c = m.geometry;
+  } else o && (c = r.extent.clone());
+  const u = t.groupByFields && t.groupByFields.length > 0, d = n.objectIdField, p = e.outFields.includes("*") ? ["*"] : [.../* @__PURE__ */ new Set([...e.outFields, d])];
+  try {
+    let m;
+    if (u) {
+      const y = new mt({
+        where: e.where || "1=1",
+        outFields: p,
+        orderByFields: e.orderByFields,
+        geometry: c,
+        spatialRelationship: c ? "intersects" : void 0,
+        distance: a?.distance,
+        units: a?.units,
+        topFilter: new ht({
+          topCount: t.topCount,
+          groupByFields: t.groupByFields,
+          orderByFields: t.orderByFields
+        })
+      });
+      m = await n.queryTopFeatures(y);
+    } else {
+      const y = n.createQuery();
+      y.where = K(n.definitionExpression, e.where || "1=1"), y.outFields = p.length ? p : ["*"], y.orderByFields = t.orderByFields, y.returnGeometry = !1, y.num = t.topCount, c && (y.geometry = c, y.spatialRelationship = "intersects"), a?.distance && (y.distance = a.distance), a?.units && (y.units = a.units), y.outSpatialReference = r.spatialReference;
+      const g = [
+        .../* @__PURE__ */ new Set([...e.outFields, ...Da(t.orderByFields)])
+      ], b = le(l, g, o ?? !1);
+      try {
+        m = b ? await l.queryFeatures(y) : await n.queryFeatures(y);
+      } catch (v) {
+        console.warn("客户端查询失败，改为服务端查询：", v), m = await n.queryFeatures(y);
+      }
+    }
+    const w = m.features.map((y) => y.attributes[d]), { attributes: h } = Fe(n, m, r.timeZone);
+    return {
+      tool: "getTopFeatures",
+      layerName: i,
+      summary: `已提取前 ${t.topCount} 个要素`,
+      details: {
+        topCount: t.topCount,
+        attributes: h,
+        objectIds: w,
+        objectIdField: d,
+        where: e.where,
+        orderByFields: t.orderByFields,
+        ...u && { groupByFields: t.groupByFields }
+      }
+    };
+  } catch (m) {
+    return {
+      tool: "getTopFeatures",
+      layerName: i,
+      summary: "查询失败",
+      details: { error: m instanceof Error ? m.message : String(m) }
+    };
+  }
+}, Pa = async ({
+  targetLayer: e,
+  topFilter: t,
+  geometryFilter: r,
+  useCurrentExtent: a
+}, o) => {
+  const { mapView: n } = k(o), l = await za(e, t, n, r, a);
+  return JSON.stringify(l, null, 2);
+}, Aa = s.object({
+  layerId: s.string().describe("用作空间过滤几何来源的图层 layerId。"),
+  where: s.string().describe("SQL-92 where 子句，用于选择作为过滤几何来源的要素。"),
+  distance: s.number().optional().describe("几何周围的缓冲距离。"),
+  units: F.optional().describe("缓冲距离的单位。")
+}), La = s.object({
+  point: s.object({
+    x: s.number().describe("导航结果的 X 坐标，即经度"),
+    y: s.number().describe("导航结果的 Y 坐标，即纬度"),
+    spatialReference: s.object({
+      wkid: s.number().describe("空间参考 WKID，例如4326表示 WGS84")
+    }).optional().describe("空间参考，未提供时默认使用地图空间参考。")
+  }).describe("之前导航或地理编码结果中的点坐标"),
+  distance: s.number().optional().describe("点周围的可选缓冲距离。"),
+  units: F.optional().describe("缓冲距离的单位。")
+}), ja = s.object({
+  targetLayer: s.object({
+    layerId: s.string().describe("要读取属性值的字段所属图层 layerId。"),
+    where: s.string().describe("用于选择要读取属性值的要素的 SQL-92 where 子句。"),
+    orderByFields: s.array(s.string().describe("查询结果的排序字段及排序方向。")),
+    outFields: s.array(
+      s.string().describe(
+        "向用户展示的输出字段，应包含名称或 ID 等要素标识，以及用户需要的值。不确定时选择全部字段（\"*\"）。"
+      ).default("*")
+    )
+  }),
+  geometryFilter: s.union([Aa, La]).optional().describe(
+    "空间查询的几何过滤条件。使用 point 和导航结果的 x/y 坐标查找该点位置的要素（点落入面）；使用 layerId/where 按其他图层的要素进行空间过滤。"
+  ),
+  topFilter: s.object({
+    topCount: s.number().describe("每组返回的前几条要素数量。"),
+    orderByFields: s.array(
+      s.string().describe("用于排名的字段及 ASC/DESC，必须使用已有字段名，不能使用聚合函数。")
+    ),
+    groupByFields: s.array(s.string().describe("结果分组字段，每组返回前 N 个要素。"))
+  }).required(),
+  useCurrentExtent: s.boolean().optional().describe(
+    "仅当用户明确询问“我的视图内”“我的地图上”“我正在看的”要素时设为 true，默认 false，查询整个图层。"
+  )
+}), Ga = f(Pa, {
+  name: "getTopFeatures",
+  description: "按已有字段值排序，返回前 N 个要素。适用于基于人口、数值、日期、深度等已有字段的“最高”“最低”“前 N 个”问题。orderByFields 必须使用真实字段名及 ASC/DESC。不要使用 COUNT()、SUM()、AVG() 等聚合函数，聚合应使用 getStatistics。",
+  schema: ja
+}), ee = 25, Oa = (e) => e.flatMap((t) => t.split(",")).map((t) => t.trim()).map((t) => t.split(/\s+/u)[0]?.replace(/^"|"$/gu, "")).filter((t) => !!t), Ma = async (e, t, r, a) => {
+  const o = t.map?.allLayers.find((g) => g.id === e.layerId), n = await t.whenLayerView(o), l = o.title ?? e.layerId;
+  let i;
+  if (r) {
+    const g = await J(r, t);
+    if ("error" in g) {
+      const b = { error: g.error };
+      if (j(r)) {
+        const v = t.map?.allLayers.find((S) => S.id === r.layerId);
+        b.geometryLayerName = v?.title ?? v?.id, b.geometryLayerId = r.layerId, b.geometryWhere = r.where;
+      } else U(r) && (b.point = r.point);
+      return {
+        tool: "queryFeatures",
+        layerName: l,
+        summary: "查找几何失败",
+        details: b
+      };
+    }
+    if (!g.geometry) {
+      const b = {};
+      if (j(r)) {
+        const v = t.map?.allLayers.find((S) => S.id === r.layerId);
+        b.error = `没有符合以下条件的要素：${r.where}`, b.geometryLayerName = v?.title ?? v?.id, b.geometryLayerId = r.layerId, b.geometryWhere = r.where;
+      } else U(r) && (b.error = "创建点几何失败", b.point = r.point);
+      return {
+        tool: "queryFeatures",
+        layerName: l,
+        summary: "没有符合几何过滤条件的要素",
+        details: b
+      };
+    }
+    i = g.geometry;
+  } else a && (i = t.extent.clone());
+  const c = [
+    .../* @__PURE__ */ new Set([...e.outFields, ...Oa(e.orderByFields)])
+  ], u = le(n, c, a ?? !1), d = o.objectIdField, p = o.createQuery();
+  p.where = K(o.definitionExpression, e.where || "1=1"), p.outFields = e.outFields.includes("*") ? ["*"] : [.../* @__PURE__ */ new Set([...e.outFields, d])], p.orderByFields = e.orderByFields, i && (p.geometry = i, p.spatialRelationship = "intersects"), r?.distance && (p.distance = r.distance), r?.units && (p.units = r.units), p.outSpatialReference = t.spatialReference;
+  let m, w;
+  try {
+    m = u ? await n.queryFeatureCount(p) : await o.queryFeatureCount(p), m > 0 && m <= ee && (w = u ? await n.queryFeatures(p) : await o.queryFeatures(p));
+  } catch (g) {
+    console.warn("客户端查询失败，改为服务端查询：", g), m = await o.queryFeatureCount(p), m > 0 && m <= ee && (w = await o.queryFeatures(p));
+  }
+  const { objectIds: h, attributes: y } = w ? Fe(o, w, t.timeZone) : { objectIds: void 0, attributes: void 0 };
+  return {
+    tool: "queryFeatures",
+    layerName: l,
+    summary: `${m} 个要素`,
+    details: {
+      totalCount: m,
+      where: e.where,
+      orderByFields: e.orderByFields,
+      outFields: e.outFields,
+      ...h && { objectIds: h, objectIdField: d },
+      ...y && { attributes: y },
+      ...m > ee && {
+        note: `${m} 个要素。`
+      }
+    }
+  };
+};
+async function Qa({
+  targetLayer: e,
+  geometryFilter: t,
+  useCurrentExtent: r
+}, a) {
+  const { mapView: o } = k(a), n = await Ma(e, o, t, r);
+  return JSON.stringify(n, null, 2);
+}
+const _a = s.object({
+  layerId: s.string().describe("用作空间过滤几何来源的图层 layerId。"),
+  where: s.string().describe("SQL-92 where 子句，用于选择作为过滤几何来源的要素。"),
+  distance: s.number().optional().describe("几何周围的缓冲距离。"),
+  units: F.optional().describe("缓冲距离的单位。")
+}), Wa = s.object({
+  point: s.object({
+    x: s.number().describe("导航结果的 X 坐标，即经度"),
+    y: s.number().describe("导航结果的 Y 坐标，即纬度"),
+    spatialReference: s.object({
+      wkid: s.number().describe("空间参考 WKID，例如4326表示 WGS84")
+    }).optional().describe("空间参考，未提供时默认使用地图空间参考。")
+  }).describe("之前导航或地理编码结果中的点坐标"),
+  distance: s.number().optional().describe("点周围的可选缓冲距离。"),
+  units: F.optional().describe("缓冲距离的单位。")
+}), Va = s.object({
+  targetLayer: s.object({
+    layerId: s.string().describe("要读取属性值的字段所属图层 layerId。"),
+    where: s.string().describe(
+      "SQL-92 where 子句。重要：使用 geometryFilter.point 进行点落入面查询时，设为 '1=1'，返回与点相交的全部要素；只有用户在空间查询之外明确要求属性过滤时，才添加属性条件。"
+    ),
+    orderByFields: s.array(s.string().describe("查询结果的排序字段及排序方向。")),
+    outFields: s.array(
+      s.string().describe(
+        "向用户展示的输出字段，应包含名称或 ID 等要素标识，以及用户需要的值。不确定时选择全部字段（\"*\"）。"
+      ).default("*")
+    )
+  }),
+  geometryFilter: s.union([_a, Wa]).optional().describe(
+    "空间查询的几何过滤条件。使用 point 和导航结果的 x/y 坐标查找该点位置的要素（点落入面）；使用 layerId/where 按其他图层的要素进行空间过滤。"
+  ),
+  useCurrentExtent: s.boolean().optional().describe(
+    "仅当用户明确询问当前视图中的要素，或指代之前通过当前范围识别的要素，例如“这些”“那些”“它们”“同一批”时设为 true。默认 false，查询整个图层。"
+  )
+}), Ba = f(Qa, {
+  name: "queryFeatures",
+  description: `查询图层要素。返回匹配总数；不超过25个时，还返回各要素属性。
+
+适用：
+- 显示、列出满足条件的要素。
+- 有多少 X 满足 Y：按条件计数。
+- 哪些要素、查找要素：识别具体要素。
+- 空间查询：查找其他要素附近、内部或相交的要素。
+- 任何需要查看或统计匹配要素数量的问题。
+
+这是多数查询的默认工具，不确定时使用它。`,
+  schema: Va
+}), Ua = [Ca, Ia, Ga, Ba], ai = [da, aa, ea], Ka = new it(Ua, { handleToolErrors: !1 });
+async function oi(e, t) {
+  const { messages: r } = await Ka.invoke({ messages: e.dataExplorationMessages }, t), a = [], o = [];
+  for (const n of r) {
+    const l = n.content;
+    let i;
+    typeof l != "string" && (i = {
+      tool: n.name ?? "unknown",
+      layerName: "unknown",
+      summary: "查询失败",
+      details: { error: "跳过非字符串工具输出：", raw: l }
+    });
+    try {
+      typeof l == "string" ? i = JSON.parse(l) : i = {
+        tool: n.name ?? "unknown",
+        layerName: "unknown",
+        summary: "查询失败",
+        details: { error: "工具输出类型无效", raw: l }
+      };
+    } catch {
+      i = {
+        tool: n.name ?? "unknown",
+        layerName: "unknown",
+        summary: "查询失败",
+        details: { error: l }
+      };
+    }
+    a.push(i), i.details && typeof i.details == "object" && "error" in i.details ? o.push(`- ${i.tool}：错误——${String(i.details.error)}`) : o.push(`- ${i.layerName}: ${i.summary}`);
+  }
+  return await x({ text: `图层查询工具执行完成：${o.join(", ")}` }, t), {
+    ...e,
+    dataExplorationMessages: [...e.dataExplorationMessages, ...r],
+    queryResponse: a,
+    status: "success",
+    summary: o.length > 0 ? Kt(o.join(`
+`)) : "查询已执行。"
+  };
+}
+const ni = T.Root({
+  ...H(),
+  // internal to the help agent
+  helpInternalState: T({
+    reducer: L,
+    default: () => ({
+      toolCallMessage: void 0
+    })
+  })
+}), Ha = (e, t) => {
+  const r = Array.from(e.values()).find(
+    ({ layerItem: n }) => n.title?.toLowerCase().includes(t.toLowerCase())
+  );
+  if (!r) {
+    const n = Array.from(e.values()).map((l) => l.layerItem.title).join(", ");
+    return `未找到匹配图层“${t}”。可用图层：${n}`;
+  }
+  const a = Array.from(r.fieldRegistry.values()), o = a.map((n) => `- **${n.alias || n.name}** (\`${n.name}\`, ${n.type})${n.description ? `: ${n.description}` : ""}`).join(`
+`);
+  return `**${r.layerItem.title}** 包含 ${a.length} 个字段：
+
+${o}`;
+}, Ja = async ({ layerTitle: e }, t) => {
+  const r = xe(t, "layersAndFieldsRegistry");
+  return Ha(r, e);
+}, ii = f(Ja, {
+  name: "listLayerFields",
+  description: "按图层标题列出全部字段。仅当用户明确要求查看指定图层的字段、列或属性时使用。一般帮助、能力介绍或列出图层时不得调用。",
+  schema: s.object({
+    layerTitle: s.string().describe("要列出字段的图层标题或部分标题。")
+  })
+}), si = T.Root({
+  ...H(),
+  intent: T({
+    reducer: (e, t) => t
+  }),
+  geosceneKnowledgeMessages: T({
+    reducer: be,
+    default: () => []
+  }),
+  geosceneKnowledgeToolResult: T({
+    reducer: (e, t) => t,
+    default: () => null
+  })
+});
+function ce(e) {
+  const t = e.map?.allLayers.filter((r) => r.type === "knowledge-graph");
+  if (!t || t?.length !== 1)
+    throw new Error("知识 Agent 当前仅支持恰好包含一个知识图谱图层的地图。");
+}
+function q(e) {
+  return !!e?.map && !("activeLinkChartLayer" in e.map);
+}
+async function Y(e) {
+  !e || q(e) || !e.map?.diagramNodesExtent || await e.goTo(e.map.diagramNodesExtent);
+}
+function O(e) {
+  const r = e?.configurable?.context;
+  if (!r || typeof r != "object")
+    throw new Error("GeosceneKnowledgeAgent 缺少上下文");
+  if (!("view" in r))
+    throw new Error("缺少视图上下文");
+  const a = r.view;
+  return a.map && !("activeLinkChartLayer" in a.map) && ce(a), {
+    view: a
+  };
+}
+function li(e) {
+  const r = e?.configurable?.context;
+  if (Ne(e) === "knowledgeGraph")
+    return "knowledgeGraph";
+  const o = r.view;
+  return q(o) ? (ce(o), "map") : "linkChart";
+}
+async function M(e) {
+  const r = e?.configurable?.context;
+  if (Ne(e) === "knowledgeGraph")
+    return r;
+  {
+    const o = r.view.map;
+    if (o && "activeLinkChartLayer" in o) {
+      const n = o.knowledgeGraph?.url;
+      if (!n)
+        throw new Error("链接图缺少知识图谱 URL。");
+      return {
+        knowledgeGraph: await fe(n)
+      };
+    } else {
+      ce(r.view);
+      const l = (r.view.map?.allLayers.find(
+        (c) => c.type === "knowledge-graph"
+      )).url;
+      if (!l)
+        throw new Error("地图缺少知识图谱 URL。");
+      return {
+        knowledgeGraph: await fe(l)
+      };
+    }
+  }
+}
+function Ne(e) {
+  const r = e?.configurable?.context;
+  if (!r || typeof r != "object")
+    throw new Error("GeosceneKnowledgeAgent 缺少上下文");
+  if ("knowledgeGraph" in r && "view" in r)
+    throw new Error("知识图谱上下文只能包含 view 或 knowledgeGraph 其中之一，不能同时提供。");
+  if ("knowledgeGraph" in r)
+    return "knowledgeGraph";
+  if ("view" in r)
+    return "view";
+  throw new Error("GeosceneKnowledgeAgent 上下文必须包含 view 或 knowledgeGraph。");
+}
+class Ya {
+  constructor(t) {
+    this.dataModel = t, this.kind = "GraphQueryGenerationRequest", this.explainQuery = !0, this.schemaInformation = ue.fromDataModel(t);
+  }
+}
+class ue {
+  constructor() {
+    this.schemaType = "GeosceneGraphSchema", this.entityTypes = [], this.relationshipTypes = [], this.identifierInfo = {
+      mappingInfo: {
+        identifierMapsTo: "UniformPropertyIdentifier",
+        identifierPropertyName: "globalid"
+      }
+    };
+  }
+  static fromDataModel(t) {
+    const r = new ue();
+    for (const a of t.entityTypes)
+      r.entityTypes.push(G.fromEntityType(a));
+    for (const a of t.relationshipTypes)
+      r.relationshipTypes.push(Za.fromRelationshipType(a));
+    return r.identifierInfo = {
+      mappingInfo: {
+        identifierMapsTo: Xa(
+          t.identifierInfo.identifierMappingInfo.identifierInfoType
+        ),
+        identifierPropertyName: t.identifierInfo.identifierMappingInfo.uniformPropertyIdentifier.identifierPropertyName
+      }
+    }, r.spatialReference = JSON.parse(JSON.stringify(t.spatialReference)), r;
+  }
+  // Generates a short summary of the types in the data model for LLM consumption.
+  static getDataModelTypesSummary(t) {
+    const r = t.entityTypes.map((o) => o.name).join(", "), a = t.relationshipTypes.map((o) => o.name).join(", ");
+    return `实体类型：${r}。
+关系类型：${a}.`;
+  }
+}
+class G {
+  constructor() {
+    this.name = "", this.properties = [];
+  }
+  static fromEntityType(t) {
+    const r = new G();
+    r.name = t.name, r.alias = t.alias ? t.alias : void 0, r.role = eo(t.role);
+    for (const a of t.properties) {
+      const o = {
+        name: a.name,
+        alias: a.alias ? a.alias : void 0,
+        fieldType: a.fieldType,
+        role: to(a.role),
+        geometryDef: a.fieldType === "esriFieldTypeGeometry" ? {
+          geometryType: a.geometryType ?? "esriGeometryAny",
+          hasM: a.hasM ? a.hasM : void 0,
+          hasZ: a.hasZ ? a.hasZ : void 0
+        } : void 0
+      };
+      r.properties.push(o);
+    }
+    return r;
+  }
+}
+class Za extends G {
+  constructor() {
+    super(...arguments), this.observedEndPoints = [];
+  }
+  static fromRelationshipType(t) {
+    const r = G.fromEntityType(t);
+    r.observedEndPoints = [];
+    for (const a of t.endPoints)
+      r.observedEndPoints.push({
+        originEntityType: a.originEntityType,
+        destinationEntityType: a.destinationEntityType
+      });
+    return r;
+  }
+}
+const Xa = (e) => {
+  switch (e) {
+    case "esriIdentifierInfoTypeUNSPECIFIED":
+      return "UNSPECIFIED";
+    case "esriIdentifierInfoTypeDatabaseNative":
+      return "DatabaseNative";
+    case "esriIdentifierInfoTypeUniformProperty":
+      return "UniformPropertyIdentifier";
+    default:
+      return e;
+  }
+}, eo = (e) => {
+  switch (e) {
+    case "Regular":
+      return "esriGraphNamedObjectRegular";
+    case "Provenance":
+      return "esriGraphNamedObjectProvenance";
+    case "Document":
+      return "esriGraphNamedObjectDocument";
+    default:
+      return e;
+  }
+};
+function to(e) {
+  switch (e) {
+    case "esriGraphPropertyRegular":
+      return "Regular";
+    case "esriGraphPropertyDocumentName":
+      return "Document_Name";
+    case "esriGraphPropertyDocumentTitle":
+      return "Document_Title";
+    case "esriGraphPropertyDocumentUrl":
+      return "Document_Url";
+    case "esriGraphPropertyDocumentText":
+      return "Document_Text";
+    case "esriGraphPropertyDocumentKeywords":
+      return "Document_Keywords";
+    case "esriGraphPropertyDocumentContentType":
+      return "Document_ContentType";
+    case "esriGraphPropertyDocumentMetadata":
+      return "Document_Metadata";
+    case "esriGraphPropertyDocumentFileExtension":
+      return "Document_FileExtension";
+    case "esriGraphPropertyProvenanceInstanceId":
+      return "Provenance_InstanceId";
+    case "esriGraphPropertyProvenanceSourceType":
+      return "Provenance_SourceType";
+    case "esriGraphPropertyProvenanceSourceName":
+      return "Provenance_SourceName";
+    case "esriGraphPropertyProvenanceSource":
+      return "Provenance_Source";
+    case "esriGraphPropertyProvenanceComment":
+      return "Provenance_Comment";
+    case "esriGraphPropertyProvenanceTypeName":
+      return "Provenance_TypeName";
+    case "esriGraphPropertyProvenancePropertyName":
+      return "Provenance_PropertyName";
+    default:
+      return "Regular";
+  }
+}
+function Z(e) {
+  return e?.signal;
+}
+async function ro(e, t) {
+  const r = await B("geoscene_knowledge_cypher_query_prompt");
+  return t ? `${e} ${r}
+
+上次生成的 Cypher 查询执行失败。请阅读下方信息，生成避免该错误的新查询。
+
+尝试次数：${t.attemptCount}
+执行错误：${t.executionError}
+失败的查询：
+${t.failedGraphQuery}` : `${e} ${r}`;
+}
+async function ao(e, t, r, a) {
+  const { graphQuery: o, explanation: n } = await de(e, t, r, a);
+  return { graphQuery: o, explanation: n };
+}
+async function de(e, t, r, a, o) {
+  const n = {
+    message: await ro(e, o),
+    context: new Ya(t)
+  }, l = Z(a);
+  await x({ text: "正在根据用户提示生成 Cypher 查询……" }, a);
+  const i = await me(`${r}/chat`, {
+    method: "post",
+    body: JSON.stringify(n),
+    headers: {
+      "Content-Type": "application/json",
+      token: pe.findCredential(N.getDefault().url)?.token ?? ""
+    },
+    signal: l
+  });
+  if (i.httpStatus !== 200)
+    throw new Error(`图谱查询服务返回错误：${i.httpStatus}`, {
+      cause: i.data
+    });
+  let c = !1;
+  const u = Date.now();
+  let d = i.data.sequenceNumber, p = "", m = "", w = 1;
+  for (; !c; ) {
+    await new Promise((y) => setTimeout(y, 1e3)), await x(
+      { text: `正在定期查询 GeoScene AI 服务的任务状态${"...".substring(0, w)}` },
+      a
+    ), w = w % 3 + 1;
+    const h = await me(`${r}/chat`, {
+      method: "post",
+      body: JSON.stringify({
+        conversationId: i.data.conversationId,
+        inquiryId: i.data.inquiryId,
+        ackSequenceNumber: d
+      }),
+      headers: {
+        "Content-Type": "application/json",
+        token: pe.findCredential(N.getDefault().url)?.token ?? ""
+      },
+      signal: l
+    });
+    if (h.httpStatus !== 200)
+      throw new Error(`轮询图谱查询服务时返回错误：${h.httpStatus}`, {
+        cause: h.data
+      });
+    if (h.data.context?.kind) {
+      if (h.data.context.kind !== "GraphQueryGenerationResponse")
+        throw new Error(`图谱查询服务轮询响应异常，消息：${h.data.message}`, {
+          cause: h.data
+        });
+      p = h.data.context.graphQuery, m = h.data.message || "", c = !0;
+    } else if (!h.data.hasMore)
+      c = !0;
+    else if (Date.now() - u > 6e4)
+      throw new Error("图谱查询服务轮询超过1分钟，已超时。");
+    d = h.data.sequenceNumber;
+  }
+  return { graphQuery: p, explanation: m };
+}
+function oo(e, t) {
+  D(e, (r) => {
+    t.set(`${r.typeName}__${r.id}`, {
+      id: r.id,
+      typeName: r.typeName
+    });
+  });
+}
+function D(e, t) {
+  if (!(!e || typeof e != "object")) {
+    if (io(e))
+      for (const r of e.path)
+        D(r, t);
+    else if (no(e))
+      t(e);
+    else if (Array.isArray(e))
+      for (const r of e)
+        D(r, t);
+    else if (so(e))
+      for (const r of Object.values(e.properties ?? {}))
+        D(r, t);
+  }
+}
+function no(e) {
+  return !e || typeof e != "object" || Array.isArray(e) ? !1 : "id" in e && "typeName" in e;
+}
+function io(e) {
+  return !e || typeof e != "object" || Array.isArray(e) ? !1 : e && "path" in e && Array.isArray(e.path);
+}
+function so(e) {
+  return !e || typeof e != "object" || Array.isArray(e) || "id" in e ? !1 : "properties" in e && typeof e.properties == "object";
+}
+function lo(e, t) {
+  const r = [], a = [], o = [
+    [t.dataModel.entityTypes, r],
+    [t.dataModel.relationshipTypes, a]
+  ];
+  for (const [n, l] of o)
+    for (const i of n) {
+      const c = e.getMemberIdsByType(i.name);
+      l.push(...c);
+    }
+  return { entityIds: r, relationshipIds: a };
+}
+function co(e, t) {
+  const r = { entityIds: new Array(), relationshipIds: new Array() }, a = [], n = e?.allLayers.find((c) => c.type === "knowledge-graph")?.inclusionModeDefinition;
+  if (!n)
+    return { allNamedTypesFullyDynamic: !0, bindParameters: r, nonDynamicTypes: a };
+  const l = [
+    [t.dataModel.entityTypes, r.entityIds],
+    [t.dataModel.relationshipTypes, r.relationshipIds]
+  ];
+  let i = !0;
+  for (const [c, u] of l)
+    for (const d of c) {
+      const p = n.namedTypeDefinitions.get(d.name);
+      if (!p) {
+        i = !1, a.push(d.name);
+        continue;
+      }
+      if (!p.useAllData) {
+        i = !1, a.push(d.name);
+        for (const [m] of p.members || [])
+          u.push(m);
+      }
+    }
+  return { allNamedTypesFullyDynamic: i, bindParameters: r, nonDynamicTypes: a };
+}
+const z = 3;
+function ke(e, t = 100) {
+  const r = {};
+  for (const a of Object.entries(e.properties ?? {})) {
+    const [o, n] = a;
+    typeof n == "string" && n.length > t ? r[o] = `${n.slice(0, t)}……（已截断，原始长度：${n.length})` : r[o] = n;
+  }
+  return e.properties = r, e;
+}
+function P(e) {
+  return typeof e != "object" || e === null ? String(e) : "details" in e && typeof e.details == "object" && e.details !== null && "errorMessage" in e.details && typeof e.details.errorMessage == "string" ? e.details.errorMessage : "message" in e && typeof e.message == "string" ? e.message : String(e);
+}
+const uo = async ({
+  kg: e,
+  queryParams: t,
+  targetStructure: r,
+  targetStructureReducer: a,
+  requestOptions: o,
+  queryRowLimit: n,
+  queryTimeoutMs: l
+}) => {
+  let i = null, c = r;
+  const u = new AbortController(), d = o?.signal, p = () => {
+    u.abort(d?.reason);
+  };
+  d && (d.aborted ? u.abort(d.reason) : d.addEventListener("abort", p, { once: !0 }));
+  try {
+    const m = await ft(e, t, o);
+    i = m.resultHeader;
+    const w = m.resultRowsStream.getReader();
+    let h = 0;
+    const y = Date.now(), g = !1;
+    for (; ; ) {
+      const { done: b, value: v } = await w.read();
+      if (b)
+        break;
+      if (!g && l && Date.now() - y > l)
+        return u.abort(), { type: "timeout" };
+      for (const S of v) {
+        if (h++, n && h > n)
+          return u.abort(), { type: "success", rowLimitReached: !0, resultHeader: i, processedResult: c };
+        c = a(c, S);
+      }
+    }
+  } catch (m) {
+    return u.signal.aborted ? { type: "aborted" } : { type: "error", errorMessage: P(m), error: m };
+  } finally {
+    d?.removeEventListener("abort", p);
+  }
+  return { type: "success", rowLimitReached: !1, resultHeader: i, processedResult: c };
+};
+async function qe({
+  prompt: e,
+  bindParameters: t,
+  kg: r,
+  graphQueryServiceUrl: a,
+  targetStructure: o,
+  targetStructureReducer: n,
+  requestOptions: l,
+  queryRowLimit: i,
+  queryTimeoutMs: c,
+  config: u
+}) {
+  let d;
+  for (let p = 1; p <= z; p++) {
+    let m;
+    try {
+      m = await de(e, r.dataModel, a, u, d);
+    } catch (g) {
+      return {
+        type: "generation-error",
+        errorMessage: P(g),
+        error: g
+      };
+    }
+    await x(
+      {
+        text: `正在尝试执行查询：${m.graphQuery.substring(0, 500)}${m.graphQuery.length > 500 ? "..." : ""}`
+      },
+      u
+    );
+    const w = await po(m.graphQuery, t), h = await uo({
+      kg: r,
+      queryParams: new ve({
+        openCypherQuery: m.graphQuery,
+        bindParameters: w
+      }),
+      targetStructure: o,
+      targetStructureReducer: n,
+      requestOptions: l,
+      queryRowLimit: i,
+      queryTimeoutMs: c
+    }), y = h.type === "aborted" ? "查询执行已中止。" : h.type === "timeout" ? "查询执行已超时。" : h.type === "error" ? `查询失败，错误：${h.errorMessage}` : "";
+    if (h.type === "success")
+      return {
+        type: "success",
+        graphQuery: m.graphQuery,
+        explanation: m.explanation,
+        rowLimitReached: h.rowLimitReached,
+        resultHeader: h.resultHeader,
+        processedResult: h.processedResult
+      };
+    if (h.type === "aborted")
+      return {
+        type: "aborted",
+        errorMessage: y,
+        graphQuery: m.graphQuery,
+        explanation: m.explanation
+      };
+    if (p >= z)
+      return h.type === "timeout" ? {
+        type: "timeout",
+        errorMessage: y,
+        graphQuery: m.graphQuery,
+        explanation: m.explanation
+      } : {
+        type: "execution-error",
+        errorMessage: y,
+        error: h.error,
+        graphQuery: m.graphQuery,
+        explanation: m.explanation
+      };
+    d = {
+      failedGraphQuery: m.graphQuery,
+      executionError: y,
+      attemptCount: p
+    }, await x(
+      { text: `第 ${p} 次尝试失败，错误：${y}。正在重试……` },
+      u
+    );
+  }
+  throw new Error(
+    `生成的 Cypher 查询在多次尝试后仍执行失败，尝试次数：${z}。`
+  );
+}
+const po = async (e, t) => {
+  if (!t)
+    return {};
+  const { bindParameters: r, parseErrors: a } = await bt(e);
+  if (a)
+    return t;
+  const o = {};
+  for (const n of r)
+    n in t && (o[n] = t[n]);
+  return o;
+}, mo = async ({
+  kg: e,
+  searchQuery: t,
+  typeCategoryFilter: r,
+  namedTypesFilter: a,
+  searchResultLimit: o,
+  requestOptions: n
+}) => {
+  const l = [];
+  let i = [r];
+  r === "both" && !e.serviceDefinition.serviceCapabilities.searchCapabilities.searchTypeFilterCapabilities.includes("esriTypeBoth") && (i = ["entity", "relationship"]);
+  const c = o ?? 1 / 0;
+  try {
+    for (const u of i) {
+      const d = c - l.length;
+      if (d <= 0)
+        break;
+      const w = (await gt(
+        e,
+        new wt({
+          searchQuery: t,
+          typeCategoryFilter: u,
+          namedTypesFilter: a ?? void 0,
+          num: d
+        }),
+        n
+      )).resultRowsStream.getReader();
+      let h = !1;
+      for (; !h; ) {
+        const { done: y, value: g } = await w.read();
+        if (y) {
+          h = !0;
+          break;
+        }
+        for (const b of g)
+          for (const v of b)
+            l.push(v);
+      }
+    }
+  } catch (u) {
+    const d = P(u);
+    return n?.signal?.aborted ? {
+      type: "aborted",
+      errorMessage: d,
+      error: u
+    } : { type: "error", errorMessage: d, error: u };
+  }
+  return {
+    type: "success",
+    results: l
+  };
+}, Ie = "重要：生成的 Cypher 查询只能返回完整实体和关系。";
+async function De({
+  prompt: e,
+  view: t,
+  knowledgeGraph: r,
+  includeReturnEntityAndRelationshipContext: a = !1
+}) {
+  const o = [e];
+  if (a && o.push(Ie), !q(t)) {
+    const d = await B("geoscene_knowledge_current_lc_context"), p = lo(t.map, r);
+    return o.push(d), {
+      enhancedPrompt: o.join(`
+
+`),
+      bindParameters: p,
+      allNamedTypesFullyDynamic: !1
+    };
+  }
+  const n = t.map, { allNamedTypesFullyDynamic: l, bindParameters: i, nonDynamicTypes: c } = co(
+    n,
+    r
+  );
+  if (l)
+    return {
+      enhancedPrompt: o.join(`
+
+`),
+      bindParameters: i,
+      allNamedTypesFullyDynamic: !0
+    };
+  const u = (await B("geoscene_knowledge_current_map_context")).replaceAll(
+    "{nonDynamicTypes}",
+    JSON.stringify(c)
+  );
+  return o.push(u), {
+    enhancedPrompt: o.join(`
+
+`),
+    bindParameters: i,
+    allNamedTypesFullyDynamic: l
+  };
+}
+async function ho(e, t, r, a, o, n) {
+  const { view: l } = o, i = await qe({
+    prompt: e,
+    bindParameters: t,
+    kg: r,
+    graphQueryServiceUrl: a,
+    targetStructure: /* @__PURE__ */ new Map(),
+    targetStructureReducer: (m, w) => {
+      for (const h of w)
+        oo(h, m);
+      return m;
+    },
+    requestOptions: {
+      signal: Z(n),
+      timeout: n?.timeout
+    },
+    config: n
+  });
+  if (i.type !== "success") {
+    const m = i.type === "generation-error" ? i.errorMessage : `${i.errorMessage}，Cypher 查询：${i.graphQuery}`;
+    throw new Error(`添加记录到链接图失败。${m}`);
+  }
+  const { graphQuery: c, explanation: u, processedResult: d } = i, p = Array.from(d.values());
+  return await x(
+    {
+      text: `查询结果已解析为 ${p.length} 个唯一的关系和实体，正在添加到链接图……`
+    },
+    n
+  ), !q(l) && l?.map ? (await l.map.addRecords(p), await Y(l), { generatedQuery: c, explanation: u, addedIdTypePairs: p }) : (await l?.map?.allLayers.find(
+    (w) => w.type === "knowledge-graph"
+  )?.addRecords(p), { generatedQuery: c, explanation: u, addedIdTypePairs: p });
+}
+const W = "addRecords", yo = s.object({
+  prompt: s.string().describe(
+    "用于生成 Cypher 查询的用户问题及必要上下文，查询结果将添加到链接图。"
+  )
+}), fo = async ({ prompt: e }, t) => {
+  const { knowledgeGraph: r } = await M(t), a = O(t), { view: o } = a, l = N.getDefault().helperServices, {
+    enhancedPrompt: i,
+    bindParameters: c,
+    allNamedTypesFullyDynamic: u
+  } = await De({
+    prompt: e,
+    view: o,
+    knowledgeGraph: r,
+    includeReturnEntityAndRelationshipContext: !0
+  });
+  if (u)
+    return {
+      toolName: W,
+      status: "success",
+      summary: "知识图谱的全部数据已包含在地图中，因此没有新增记录。",
+      details: {
+        generatedQuery: "N/A",
+        explanation: "知识图谱的所有命名类型都是完全动态的，全部数据已在地图中，因此没有新增记录。",
+        addedIdTypePairs: []
+      }
+    };
+  try {
+    const { generatedQuery: d, explanation: p, addedIdTypePairs: m } = await ho(
+      i,
+      c,
+      r,
+      `${l.aiAssistantServices.url}${l.aiAssistantServices.graphQueryAssistant}`,
+      a,
+      t
+    );
+    return {
+      toolName: W,
+      status: "success",
+      summary: `记录添加成功。使用的 Cypher 查询：${d}
+
+新增记录数量：${m.length}`,
+      details: {
+        generatedQuery: d,
+        explanation: p,
+        addedIdTypePairs: m
+      }
+    };
+  } catch (d) {
+    const p = P(d);
+    return {
+      toolName: W,
+      status: "error",
+      errorMessage: `添加记录到链接图失败。${p}`,
+      error: d
+    };
+  }
+}, ci = f(fo, {
+  name: W,
+  description: `根据知识图谱查询结果，将实体或关系添加到当前链接图。用户必须明确要求添加到当前链接图；“添加到新链接图”不适用。
+示例：将供应商和其生产零件加入链接图；查询公司 X 的竞争者并添加；添加公司 X 和 Y 的关系；展开所有公司；展开公司 X 拥有的建筑；连接公司 X 和 Y；连接图中的所有建筑。`,
+  schema: yo
+});
+async function go(e, t) {
+  return await t.map?.applyLayout(e), await Y(t), { appliedLayout: e };
+}
+const re = "applyLayout", wo = s.object({
+  layout: s.enum([
+    "organic-standard",
+    "organic-community",
+    "basic-grid",
+    "hierarchical-bottom-to-top",
+    "radial-root-centric",
+    "tree-left-to-right",
+    "geographic-organic-standard",
+    "chronological-mono-timeline",
+    "chronological-multi-timeline"
+  ]).describe(
+    "链接图布局模式，必须为以下值之一：organic-standard、organic-community、basic-grid、hierarchical-bottom-to-top、radial-root-centric、tree-left-to-right、geographic-organic-standard、chronological-mono-timeline、chronological-multi-timeline"
+  )
+}), bo = async ({ layout: e }, t) => {
+  const { view: r } = O(t);
+  if (q(r))
+    return {
+      toolName: re,
+      status: "error",
+      errorMessage: "applyLayout 工具只能用于 LinkChartView。",
+      error: new Error()
+    };
+  {
+    const { appliedLayout: a } = await go(e, r);
+    return {
+      toolName: re,
+      status: "success",
+      summary: `已应用布局：${a}.`,
+      details: {
+        appliedLayout: a
+      }
+    };
+  }
+}, ui = f(bo, {
+  name: re,
+  description: "为链接图应用图布局",
+  schema: wo
+});
+async function To(e, t) {
+  return t.map?.changeNonspatialDataDisplay(e), await Y(t), { appliedNonspatialDataDisplayMode: e };
+}
+const ae = "changeNonspatialVisibility", So = s.object({
+  setting: s.enum(["hidden", "visible"]).describe("非空间数据可见性设置")
+}), vo = async ({ setting: e }, t) => {
+  const { view: r } = O(t);
+  if (q(r))
+    return {
+      toolName: ae,
+      status: "error",
+      errorMessage: "changeNonspatialVisibility 工具只能用于 LinkChartView。",
+      error: new Error()
+    };
+  {
+    const { appliedNonspatialDataDisplayMode: a } = await To(e, r);
+    return {
+      toolName: ae,
+      status: "success",
+      summary: `已设置非空间数据可见性：${a}.`,
+      details: {
+        appliedNonspatialDataDisplayMode: a
+      }
+    };
+  }
+}, di = f(vo, {
+  name: ae,
+  description: "切换链接图中的非空间数据可见性，只能为 'hidden' 或 'visible'。",
+  schema: So
+});
+async function xo(e, t, r, a, o) {
+  let n, l = "";
+  for (let i = 1; i <= z; i++) {
+    const { graphQuery: c, explanation: u } = await de(
+      e,
+      t.dataModel,
+      r,
+      o,
+      n
+    );
+    try {
+      await x({ text: `正在使用生成的查询创建链接图：${c}` }, o);
+      const d = await yt.fromCypherQuery(
+        t,
+        new ve({
+          openCypherQuery: c
+        })
+      );
+      await x({ text: "链接图创建成功，正在加载……" }, o), await d.load();
+      const p = a.map;
+      return a.map = d, await a.when(), await Le.whenOnce(() => !a.updating), d.entityCount === 0 && d.relationshipCount === 0 ? (a.map === d && (a.map = p), d.destroy(), {
+        type: "error",
+        errorMessage: `查询没有返回结果。用于创建链接图的 Cypher 查询：
+${c}
+
+说明：${u}`
+      }) : (await Y(a), {
+        type: "success",
+        graphQuery: c,
+        explanation: u
+      });
+    } catch (d) {
+      const p = P(d);
+      if (i >= z) {
+        l = p;
+        break;
+      }
+      n = {
+        failedGraphQuery: c,
+        executionError: p,
+        attemptCount: i
+      }, await x(
+        { text: `第 ${i} 次创建链接图失败，错误：${p}。正在重试……` },
+        o
+      );
+    }
+  }
+  return {
+    type: "error",
+    errorMessage: `创建链接图失败，尝试次数：${z}。最后错误：${l}`
+  };
+}
+const V = "createLinkChart", Ro = s.object({
+  prompt: s.string().describe(
+    "用于生成链接图查询的用户问题及必要上下文。只包含生成 Cypher 所需的信息，不要建议实体类型、关系类型或属性。除非用户明确要求，否则不要添加结果数量限制或格式指令。重点描述用户希望看到的数据，而不是生成方法。"
+  )
+}), $o = async ({ prompt: e }, t) => {
+  const { knowledgeGraph: r } = await M(t), { view: a } = O(t);
+  if (q(a))
+    return {
+      toolName: V,
+      status: "error",
+      errorMessage: "createLinkChart 工具只能用于 LinkChartView。",
+      error: new Error()
+    };
+  {
+    const n = N.getDefault().helperServices, l = await xo(
+      `${e}
+
+${Ie}`,
+      r,
+      `${n.aiAssistantServices.url}${n.aiAssistantServices.graphQueryAssistant}`,
+      a,
+      t
+    );
+    if (l.type === "error")
+      return {
+        toolName: V,
+        status: "error",
+        errorMessage: l.errorMessage,
+        error: new Error()
+      };
+    const { graphQuery: i, explanation: c } = l;
+    return {
+      toolName: V,
+      status: "success",
+      summary: `链接图创建成功。用于创建链接图的 Cypher 查询：
+${i}
+
+说明：${c}`,
+      details: {
+        generatedQuery: i,
+        explanation: c
+      }
+    };
+  }
+}, pi = f($o, {
+  name: V,
+  description: "根据知识图谱数据查询创建新链接图。用户必须明确要求创建新链接图，例如“创建新链接图”或“添加到新链接图”。",
+  schema: Ro
+}), oe = "queryGraphData", Co = s.object({
+  prompt: s.string().describe(
+    "用户对知识图谱的提问，将生成并执行 Cypher 查询。仅当用户提示或之前步骤提供了实体类型、关系类型或属性时才能包含，不要自行建议。除非用户明确要求，不要增加数量限制、返回内容、查询编写方法或结果格式指令。"
+  )
+}), Eo = async ({ prompt: e }, t) => {
+  const { knowledgeGraph: r } = await M(t), o = N.getDefault().helperServices;
+  let n = e, l = null, i = null;
+  try {
+    ({ view: i } = O(t));
+  } catch {
+  }
+  i && ({ enhancedPrompt: n, bindParameters: l } = await De({
+    prompt: e,
+    view: i,
+    knowledgeGraph: r,
+    includeReturnEntityAndRelationshipContext: !1
+  }));
+  const c = await qe({
+    prompt: n,
+    bindParameters: l,
+    kg: r,
+    graphQueryServiceUrl: `${o.aiAssistantServices.url}${o.aiAssistantServices.graphQueryAssistant}`,
+    targetStructure: new Array(),
+    targetStructureReducer: (g, b) => (g.push(b), g),
+    requestOptions: {
+      signal: Z(t),
+      timeout: t?.timeout
+    },
+    config: t
+  });
+  if (c.type !== "success") {
+    const g = c.type === "generation-error" ? c.errorMessage : `${c.errorMessage}，Cypher 查询：${c.graphQuery}`;
+    return {
+      toolName: oe,
+      status: "error",
+      errorMessage: `查询知识图谱失败。${g}`,
+      error: "error" in c ? c.error : null
+    };
+  }
+  const { graphQuery: u, explanation: d, processedResult: p, resultHeader: m } = c, w = m.headerKeys;
+  for (const g of p)
+    for (const b of g)
+      D(
+        b,
+        (v) => ke(v)
+      );
+  const h = 50, y = p.slice(0, h).map((g) => JSON.stringify(g));
+  return {
+    toolName: oe,
+    status: "success",
+    summary: `为回答问题，对知识图谱执行了以下 Cypher 查询：
+
+\`\`\`cypher
+${u}
+\`\`\`
+
+查询结果：
+${y.length} 条结果。
+
+列标题：${w.join(", ")}
+
+${y.length > h ? `显示前 ${h} 条结果：
+
+` : `结果：
+
+`}${y.join(`
+`)}
+`,
+    details: {
+      generatedQuery: u,
+      explanation: d,
+      resultHeader: m,
+      queryResults: p
+    }
+  };
+}, mi = f(Eo, {
+  name: oe,
+  description: "使用 Cypher 查询探索知识图谱数据。根据用户问题生成并执行查询，在聊天面板展示结果，不修改已有链接图。适用于可通过 Cypher 回答的整体数据探索问题，例如“按零件总成本排名前5的供应商”或“各部门员工有多少”。",
+  schema: Co
+}), ne = "generateCypher", Fo = s.object({
+  prompt: s.string().describe("需要转换为 Cypher 查询的用户知识图谱问题。")
+}), No = async ({ prompt: e }, t) => {
+  const { knowledgeGraph: r } = await M(t), o = N.getDefault().helperServices;
+  try {
+    const { graphQuery: n, explanation: l } = await ao(
+      e,
+      r.dataModel,
+      `${o.aiAssistantServices.url}${o.aiAssistantServices.graphQueryAssistant}`,
+      t
+    );
+    return {
+      toolName: ne,
+      status: "success",
+      summary: `生成的图谱查询：
+${n}
+
+说明：${l}`,
+      details: {
+        generatedQuery: n,
+        explanation: l
+      }
+    };
+  } catch (n) {
+    const l = P(n);
+    return {
+      toolName: ne,
+      status: "error",
+      errorMessage: `生成 Cypher 查询失败。${l}`,
+      error: n
+    };
+  }
+}, hi = f(No, {
+  name: ne,
+  description: "根据用户提示生成 Open Cypher 查询，对知识服务和图数据库的数据按条件过滤并遍历指定关系。查询必须语法正确并尽量优化性能。",
+  schema: Fo
+}), ko = (e) => {
+  const t = e.dataModel, r = /* @__PURE__ */ new Map();
+  for (const i of t.searchIndexes)
+    if (i.supportedCategory !== "esriTypeMetaEntityProvenance")
+      for (const [c, u] of i.searchProperties.entries()) {
+        const d = r.get(c) ?? /* @__PURE__ */ new Set();
+        u.propertyNames.forEach((p) => d.add(p)), r.set(c, d);
+      }
+  const a = t.entityTypes.filter((i) => r.has(i.name)), o = t.relationshipTypes.filter((i) => r.has(i.name)), n = `实体类型：
+${a.map(({ name: i }) => `${i}: [${Array.from(r.get(i) ?? []).join(", ")}]`).join(`
+`)}`, l = `关系类型：
+${o.map(({ name: i }) => `${i}: [${Array.from(r.get(i) ?? []).join(", ")}]`).join(`
+`)}`;
+  return `${n}
+
+${l}`;
+};
+async function qo(e, t, r) {
+  const a = await B("geoscene_knowledge_lucene_generation_prompt"), o = {
+    inquiry: e,
+    dataModelForSearch: ko(t)
+  }, n = s.enum(["entity", "relationship", "both"]).describe("搜索的图谱元素类别：entity、relationship 或 both"), l = s.number().int().positive().nullable().describe(
+    "最多返回的搜索结果数量。用户未指定时默认10，明确要求不限或全部时设为 null。"
+  ), i = s.array(
+    s.enum(
+      t.dataModel.entityTypes.map((d) => d.name).concat(t.dataModel.relationshipTypes.map((d) => d.name))
+    )
+  ).min(1), c = s.object({
+    query: s.string().describe("发送给知识图谱搜索 API 的 Lucene 查询字符串"),
+    typeFilters: i.nullable().describe(
+      "用于限制搜索范围的实体或关系类型列表，可为 null。设为 null 时搜索全部具有已索引属性的命名类型。"
+    ),
+    typeCategoryFilter: n,
+    resultLimit: l
+  });
+  return await Ae({
+    promptText: a,
+    inputVariables: o,
+    schema: c,
+    config: r
+  });
+}
+const ie = "searchGraphData", Io = s.object({
+  prompt: s.string().describe(
+    "用户对知识图谱的提问，将据此生成并执行 Lucene 搜索以返回相关结果。"
+  )
+}), Do = async ({ prompt: e }, t) => {
+  const { knowledgeGraph: r } = await M(t);
+  await x({ text: "正在根据用户问题生成搜索查询" }, t);
+  const a = await qo(e, r, t);
+  await x({ text: "正在执行生成的图谱搜索查询" }, t);
+  const o = await mo({
+    kg: r,
+    searchQuery: a.query,
+    typeCategoryFilter: a.typeCategoryFilter,
+    namedTypesFilter: a.typeFilters,
+    searchResultLimit: a.resultLimit,
+    requestOptions: {
+      signal: Z(t),
+      timeout: t?.timeout
+    }
+  });
+  if (o.type !== "success")
+    return {
+      toolName: ie,
+      status: "error",
+      errorMessage: o.errorMessage,
+      error: "error" in o ? o.error : null
+    };
+  for (const i of o.results)
+    D(
+      i,
+      (c) => ke(c)
+    );
+  const n = 10, l = o.results.slice(0, n);
+  return {
+    toolName: ie,
+    status: "success",
+    summary: `为回答问题，生成并执行了以下 Lucene 查询：
+    查询：${a.query}
+    类别过滤：${a.typeCategoryFilter}
+    命名类型过滤：${a.typeFilters ? a.typeFilters.join(", ") : "无"}
+    结果数量上限：${a.resultLimit ?? "不限数量"}
+
+    搜索结果：${o.results.length} 条结果。
+
+${o.results.length > n ? `显示前 ${n} 条结果：
+
+` : ""}${l.map((i) => JSON.stringify(i)).join(`
+`)}`,
+    details: {
+      generatedSearchQuery: a,
+      searchResults: o.results
+    }
+  };
+}, yi = f(Do, {
+  name: ie,
+  description: `使用 Lucene 语法，对知识图谱实体和关系的已索引字符串属性进行文本搜索。适用于可通过属性文本搜索回答的问题，例如模糊匹配。如果需要查找相连记录、路径或聚合数据，使用 queryGraphData。
+示例：查找 Bradley；查找 John Smith；查找姓 Smith 的所有人；查找提到“delayed parts shipment”的记录；查找 Researcher 撰写的报告；查找前5份 summary 提到 Sacramento 附近 flood zoning、organization 为 City of Sacramento Utilities、tags 含 stormwater 的报告；搜索所有 John Smith 并显示 globalid。`,
+  schema: Io
+});
+export {
+  Wn as A,
+  Vn as B,
+  Bn as C,
+  Un as D,
+  Kn as E,
+  Hn as F,
+  ue as G,
+  ni as H,
+  Jn as I,
+  Yn as J,
+  Zn as K,
+  Xn as L,
+  ei as M,
+  In as N,
+  ri as O,
+  ai as P,
+  Ua as Q,
+  k as R,
+  ti as S,
+  oi as T,
+  ui as a,
+  hi as b,
+  di as c,
+  pi as d,
+  ci as e,
+  xe as f,
+  B as g,
+  li as h,
+  M as i,
+  si as j,
+  Dn as k,
+  ii as l,
+  zn as m,
+  Pn as n,
+  An as o,
+  Ln as p,
+  mi as q,
+  Qn as r,
+  yi as s,
+  Kt as t,
+  jn as u,
+  Gn as v,
+  On as w,
+  Mn as x,
+  C as y,
+  _n as z
+};