@agrotools1/at-components 0.3.5 → 0.3.6

package/dist/QueryEngine-238072cd.js

@@ -0,0 +1,896 @@
+import { n as Oe, a as O, h as j, j as z, y as X, P as Ee, x as re, g as M, b as je, c as Ze, S as ce, v as G, t as Be, I as he, d as ke } from "./timeSupport-97c324f3.js";
+import { t as Le, e as Ue } from "./OptimizedGeometry-3b808152.js";
+import { W as v, dh as de, bW as se, bX as ie, a5 as Ve, da as $e, dr as ae, G as Q, X as fe, dp as K, il as He, ie as me, i8 as Je, im as We, bz as J, a6 as Ye, l as ye, x as Xe, io as A, dS as pe, c7 as ge, bJ as Ke, ip as et, cK as tt, cN as st, cw as ee, cQ as it, cI as at, ae as rt, ao as xe, aj as nt, aK as lt, aG as ot, cL as ut, cS as ct } from "./index-4ead5b97.js";
+import { h as ht, r as dt } from "./MemCache-cfd09d4d.js";
+import { o as ft } from "./featureConversionUtils-90914512.js";
+import { e as _e } from "./LRUCache-7a6c25d0.js";
+import { x as mt } from "./WhereClause-51a4f26b.js";
+import { t as yt } from "./QueryEngineCapabilities-0d8477a2.js";
+import { m as Fe } from "./quantizationUtils-2be4bff3.js";
+import { w as pt } from "./utils-514bee8e.js";
+import { c as te, B as gt, f as xt, d as we, p as Ie, C as _t, k as Ft, $ as wt, E as It, P as St, U as Tt, T as Rt, v as bt } from "./utils-7d755f59.js";
+import { Z as vt } from "./FieldsIndex-cddb2b35.js";
+import { C as Se } from "./Scheduler-202e661b.js";
+const is = { getObjectId: (l) => l.objectId, getAttributes: (l) => l.attributes, getAttribute: (l, e) => l.attributes[e], cloneWithGeometry: (l, e) => new Le(e, l.attributes, null, l.objectId), getGeometry: (l) => l.geometry, getCentroid: (l, e) => (l.centroid == null && (l.centroid = Oe(new Ue(), l.geometry, e.hasZ, e.hasM)), l.centroid) };
+class At {
+  constructor(e, t) {
+    this._cache = new _e(e), this._invalidCache = new _e(t);
+  }
+  get(e, t) {
+    const s = `${t.uid}:${e}`, i = this._cache.get(s);
+    if (i)
+      return i;
+    if (this._invalidCache.get(s) != null)
+      return null;
+    try {
+      const a = mt.create(e, t);
+      return this._cache.put(s, a), a;
+    } catch (a) {
+      return this._invalidCache.put(s, a), null;
+    }
+  }
+  getError(e, t) {
+    const s = `${t.uid}:${e}`;
+    return this._invalidCache.get(s) ?? null;
+  }
+}
+const Qe = new At(50, 500), Z = "unsupported-query", Ce = " as ", ze = /* @__PURE__ */ new Set(["esriFieldTypeOID", "esriFieldTypeSmallInteger", "esriFieldTypeBigInteger", "esriFieldTypeInteger", "esriFieldTypeSingle", "esriFieldTypeDouble", "esriFieldTypeLong"]), qe = /* @__PURE__ */ new Set(["esriFieldTypeDate", "esriFieldTypeDateOnly", "esriFieldTypeTimeOnly", "esriFieldTypeTimestampOffset"]), Et = /* @__PURE__ */ new Set(["esriFieldTypeString", "esriFieldTypeGUID", "esriFieldTypeGlobalID", ...ze, ...qe]);
+function ne(l, e, t = {}) {
+  const s = q(e, l);
+  if (!s) {
+    const a = Qe.getError(e, l);
+    throw new v(Z, "invalid SQL expression", { expression: e, error: a });
+  }
+  const i = t.expressionName || "expression";
+  if (t.validateStandardized && !s.isStandardized)
+    throw new v(Z, `${i} is not standard`, { expression: e });
+  if (t.validateAggregate && !s.isAggregate)
+    throw new v(Z, `${i} does not contain a valid aggregate function`, { expression: e });
+  return s.fieldNames;
+}
+function Vt(l, e, t, s) {
+  if (!t)
+    return !0;
+  const i = "where clause";
+  return C(l, e, ne(l, t, { validateStandardized: !0, expressionName: i }), { expressionName: i, query: s }), !0;
+}
+function $t(l, e, t, s, i) {
+  if (!t)
+    return !0;
+  const a = "having clause", r = ne(l, t, { validateAggregate: !0, expressionName: a });
+  C(l, e, r, { expressionName: a, query: i });
+  const n = q(t, l);
+  if (!(n == null ? void 0 : n.getExpressions().every((u) => {
+    var f;
+    const { aggregateType: c, field: h } = u, m = (f = l.get(h)) == null ? void 0 : f.name;
+    return s.some((y) => {
+      var S;
+      const { onStatisticField: d, statisticType: F } = y;
+      return ((S = l.get(d)) == null ? void 0 : S.name) === m && F.toLowerCase().trim() === c;
+    });
+  })))
+    throw new v(Z, "expressions in having clause should also exist in outStatistics", { having: t });
+  return !0;
+}
+function q(l, e) {
+  return l ? Qe.get(l, e) : null;
+}
+function De(l) {
+  return /\((.*?)\)/.test(l) ? l : l.split(Ce)[0];
+}
+function Qt(l) {
+  return l.split(Ce)[1];
+}
+function C(l, e, t, s = {}) {
+  const i = /* @__PURE__ */ new Map();
+  if (Ct(i, l, e, s.allowedFieldTypes ?? Et, t), i.size) {
+    const a = s.expressionName ?? "expression";
+    throw new v(Z, `${a} contains invalid or missing fields`, { errors: Array.from(i.values()), query: s.query });
+  }
+}
+function Ct(l, e, t, s, i) {
+  const a = i.includes("*") ? [...t, ...i.filter((r) => r !== "*")] : i;
+  for (const r of a)
+    if (e.get(r))
+      Te(l, e, t, s, r);
+    else
+      try {
+        const n = ne(e, De(r), { validateStandardized: !0 });
+        for (const o of n)
+          Te(l, e, t, s, o);
+      } catch (n) {
+        l.set(r, { type: "expression-error", expression: r, error: n });
+      }
+}
+function Te(l, e, t, s, i) {
+  const a = e.get(i);
+  a ? t.has(a.name) ? s !== "all" && (s == null ? void 0 : s.has(a.type)) === !1 && l.set(i, { type: "invalid-type", fieldName: a.name, fieldType: de.fromJSON(a.type), allowedFieldTypes: Array.from(s, (r) => de.fromJSON(r)) }) : l.set(i, { type: "missing-field", fieldName: a.name }) : l.set(i, { type: "invalid-field", fieldName: i });
+}
+let H = class {
+  constructor(e, t, s) {
+    this._fieldDataCache = /* @__PURE__ */ new Map(), this._returnDistinctMap = /* @__PURE__ */ new Map(), this.returnDistinctValues = e.returnDistinctValues ?? !1, this.fieldsIndex = s, this.featureAdapter = t;
+    const i = e.outFields;
+    if (i && !i.includes("*")) {
+      this.outFields = i;
+      let a = 0;
+      for (const r of i) {
+        const n = De(r), o = this.fieldsIndex.get(n), u = o ? null : q(n, s), c = o ? o.name : Qt(r) || "FIELD_EXP_" + a++;
+        this._fieldDataCache.set(r, { alias: c, clause: u });
+      }
+    }
+  }
+  countDistinctValues(e) {
+    return this.returnDistinctValues ? (e.forEach((t) => this.getAttributes(t)), this._returnDistinctMap.size) : e.length;
+  }
+  getAttributes(e) {
+    const t = this._processAttributesForOutFields(e);
+    return this._processAttributesForDistinctValues(t);
+  }
+  getFieldValue(e, t, s) {
+    var r;
+    const i = s ? s.name : t;
+    let a = null;
+    return this._fieldDataCache.has(i) ? a = (r = this._fieldDataCache.get(i)) == null ? void 0 : r.clause : s || (a = q(t, this.fieldsIndex), this._fieldDataCache.set(i, { alias: i, clause: a })), s ? this.featureAdapter.getAttribute(e, i) : a == null ? void 0 : a.calculateValue(e, this.featureAdapter);
+  }
+  getDataValues(e, t, s = !0) {
+    const i = t.normalizationType, a = t.normalizationTotal, r = this.fieldsIndex.get(t.field), n = se(r) || ie(r), o = Ve(r);
+    return e.map((u) => {
+      let c = t.field && this.getFieldValue(u, t.field, this.fieldsIndex.get(t.field));
+      if (t.field2 ? (c = `${te(c)}${t.fieldDelimiter}${te(this.getFieldValue(u, t.field2, this.fieldsIndex.get(t.field2)))}`, t.field3 && (c = `${c}${t.fieldDelimiter}${te(this.getFieldValue(u, t.field3, this.fieldsIndex.get(t.field3)))}`)) : typeof c == "string" && s && (n ? c = c ? new Date(c).getTime() : null : o && (c = c ? pt(c) : null)), i && Number.isFinite(c)) {
+        const h = i === "field" && t.normalizationField ? this.getFieldValue(u, t.normalizationField, this.fieldsIndex.get(t.normalizationField)) : null;
+        c = gt(c, i, h, a);
+      }
+      return c;
+    });
+  }
+  async getExpressionValues(e, t, s, i, a) {
+    const { arcadeUtils: r } = await $e(), n = r.hasGeometryOperations(t);
+    n && await r.enableGeometryOperations();
+    const o = r.createFunction(t), u = r.getViewInfo(s), c = { fields: this.fieldsIndex.fields };
+    return e.map((h) => {
+      const m = { attributes: this.featureAdapter.getAttributes(h), layer: c, geometry: n ? { ...O(i.geometryType, i.hasZ, i.hasM, this.featureAdapter.getGeometry(h)), spatialReference: s == null ? void 0 : s.spatialReference } : null }, f = r.createExecContext(m, u, a);
+      return r.executeFunction(o, f);
+    });
+  }
+  validateItem(e, t) {
+    var s, i;
+    return this._fieldDataCache.has(t) || this._fieldDataCache.set(t, { alias: t, clause: q(t, this.fieldsIndex) }), ((i = (s = this._fieldDataCache.get(t)) == null ? void 0 : s.clause) == null ? void 0 : i.testFeature(e, this.featureAdapter)) ?? !1;
+  }
+  validateItems(e, t) {
+    var s, i;
+    return this._fieldDataCache.has(t) || this._fieldDataCache.set(t, { alias: t, clause: q(t, this.fieldsIndex) }), ((i = (s = this._fieldDataCache.get(t)) == null ? void 0 : s.clause) == null ? void 0 : i.testSet(e, this.featureAdapter)) ?? !1;
+  }
+  _processAttributesForOutFields(e) {
+    const t = this.outFields;
+    if (!(t != null && t.length))
+      return this.featureAdapter.getAttributes(e);
+    const s = {};
+    for (const i of t) {
+      const { alias: a, clause: r } = this._fieldDataCache.get(i);
+      s[a] = r ? r.calculateValue(e, this.featureAdapter) : this.featureAdapter.getAttribute(e, a);
+    }
+    return s;
+  }
+  _processAttributesForDistinctValues(e) {
+    if (e == null || !this.returnDistinctValues)
+      return e;
+    const t = this.outFields, s = [];
+    if (t)
+      for (const r of t) {
+        const { alias: n } = this._fieldDataCache.get(r);
+        s.push(e[n]);
+      }
+    else
+      for (const r in e)
+        s.push(e[r]);
+    const i = `${(t || ["*"]).join(",")}=${s.join(",")}`;
+    let a = this._returnDistinctMap.get(i) || 0;
+    return this._returnDistinctMap.set(i, ++a), a > 1 ? null : e;
+  }
+};
+function Re(l, e, t) {
+  return { objectId: l, target: e, distance: t, type: "vertex" };
+}
+function zt(l, e, t, s, i, a = !1) {
+  return { objectId: l, target: e, distance: t, type: "edge", start: s, end: i, draped: a };
+}
+class b {
+  constructor(e, t, s) {
+    this.items = e, this.query = t, this.geometryType = s.geometryType, this.hasM = s.hasM, this.hasZ = s.hasZ, this.fieldsIndex = s.fieldsIndex, this.objectIdField = s.objectIdField, this.spatialReference = s.spatialReference, this.featureAdapter = s.featureAdapter;
+  }
+  get size() {
+    return this.items.length;
+  }
+  createQueryResponseForCount() {
+    const e = new H(this.query, this.featureAdapter, this.fieldsIndex);
+    if (!this.query.outStatistics)
+      return e.countDistinctValues(this.items);
+    const { groupByFieldsForStatistics: t, having: s, outStatistics: i } = this.query;
+    if (!(t == null ? void 0 : t.length))
+      return 1;
+    const r = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Set();
+    for (const u of i) {
+      const { statisticType: c } = u, h = c !== "exceedslimit" ? u.onStatisticField : void 0;
+      if (!n.has(h)) {
+        const f = [];
+        for (const y of t) {
+          const d = this._getAttributeValues(e, y, r);
+          f.push(d);
+        }
+        n.set(h, this._calculateUniqueValues(f, e.returnDistinctValues));
+      }
+      const m = n.get(h);
+      for (const f in m) {
+        const { data: y, items: d } = m[f], F = y.join(",");
+        s && !e.validateItems(d, s) || o.add(F);
+      }
+    }
+    return o.size;
+  }
+  async createQueryResponse() {
+    let e;
+    if (this.query.outStatistics ? e = this.query.outStatistics.some((t) => t.statisticType === "exceedslimit") ? this._createExceedsLimitQueryResponse(this.query) : await this._createStatisticsQueryResponse(this.query) : e = this._createFeatureQueryResponse(this.query), this.query.returnQueryGeometry) {
+      const t = this.query.geometry;
+      ae(this.query.outSR) && !Q(t.spatialReference, this.query.outSR) ? e.queryGeometry = j({ spatialReference: this.query.outSR, ...z(t, t.spatialReference, this.query.outSR) }) : e.queryGeometry = j({ spatialReference: this.query.outSR, ...t });
+    }
+    return e;
+  }
+  createSnappingResponse(e, t) {
+    const s = this.featureAdapter, i = be(this.hasZ, this.hasM), { point: a, mode: r } = e, n = typeof e.distance == "number" ? e.distance : e.distance.x, o = typeof e.distance == "number" ? e.distance : e.distance.y, u = { candidates: [] }, c = this.geometryType === "esriGeometryPolygon", h = this._getPointCreator(r, this.spatialReference, t), m = new ve(null, 0), f = new ve(null, 0), y = { x: 0, y: 0, z: 0 };
+    for (const d of this.items) {
+      const F = s.getGeometry(d);
+      if (F == null)
+        continue;
+      const { coords: _, lengths: S } = F;
+      if (m.coords = _, f.coords = _, e.returnEdge) {
+        let T = 0;
+        for (let p = 0; p < S.length; p++) {
+          const g = S[p];
+          for (let w = 0; w < g; w++, T += i) {
+            const x = m;
+            if (x.coordsIndex = T, w !== g - 1) {
+              const I = f;
+              I.coordsIndex = T + i;
+              const R = y;
+              qt(y, a, x, I);
+              const E = (a.x - R.x) / n, B = (a.y - R.y) / o, k = E * E + B * B;
+              k <= 1 && u.candidates.push(zt(s.getObjectId(d), h(R), Math.sqrt(k), h(x), h(I)));
+            }
+          }
+        }
+      }
+      if (e.vertexMode !== "none") {
+        const T = c ? _.length - i : _.length;
+        if (e.vertexMode === "all")
+          for (let p = 0; p < T; p += i) {
+            const g = m;
+            g.coordsIndex = p;
+            const w = (a.x - g.x) / n, x = (a.y - g.y) / o, I = w * w + x * x;
+            I <= 1 && u.candidates.push(Re(s.getObjectId(d), h(g), Math.sqrt(I)));
+          }
+        else if (e.vertexMode === "ends") {
+          const p = [0];
+          c || p.push(_.length - i);
+          for (const g of p) {
+            const w = m;
+            w.coordsIndex = g;
+            const x = (a.x - w.x) / n, I = (a.y - w.y) / o, R = x * x + I * I;
+            R <= 1 && u.candidates.push(Re(s.getObjectId(d), h(w), Math.sqrt(R)));
+          }
+        }
+      }
+    }
+    return u.candidates.sort((d, F) => d.distance - F.distance), u;
+  }
+  _getPointCreator(e, t, s) {
+    const i = s == null || Q(t, s) ? (n) => n : (n) => z(n, t, s), { hasZ: a } = this, r = 0;
+    return e === "3d" ? a ? ({ x: n, y: o, z: u }) => i({ x: n, y: o, z: u }) : ({ x: n, y: o }) => i({ x: n, y: o, z: r }) : ({ x: n, y: o }) => i({ x: n, y: o });
+  }
+  async createSummaryStatisticsResponse(e) {
+    const { field: t, valueExpression: s, normalizationField: i, normalizationType: a, normalizationTotal: r, minValue: n, maxValue: o, scale: u, timeZone: c } = e, h = this.fieldsIndex.get(t), m = fe(h) || se(h) || ie(h), f = await this._getDataValues({ field: t, valueExpression: s, normalizationField: i, normalizationType: a, normalizationTotal: r, scale: u, timeZone: c }), y = xt({ normalizationType: a, normalizationField: i, minValue: n, maxValue: o }), d = { value: 0.5, fieldType: h == null ? void 0 : h.type }, F = K(h) ? we({ values: f, supportsNullCount: y, percentileParams: d }) : Ie({ values: f, minValue: n, maxValue: o, useSampleStdDev: !a, supportsNullCount: y, percentileParams: d });
+    return _t(F, m);
+  }
+  async createUniqueValuesResponse(e) {
+    const { field: t, valueExpression: s, domains: i, returnAllCodedValues: a, scale: r, timeZone: n } = e, o = await this._getDataValues({ field: t, field2: e.field2, field3: e.field3, fieldDelimiter: e.fieldDelimiter, valueExpression: s, scale: r, timeZone: n }, !1), u = Ft(o);
+    return wt(u, i, a, e.fieldDelimiter);
+  }
+  async createClassBreaksResponse(e) {
+    const { field: t, valueExpression: s, normalizationField: i, normalizationType: a, normalizationTotal: r, classificationMethod: n, standardDeviationInterval: o, minValue: u, maxValue: c, numClasses: h, scale: m, timeZone: f } = e, y = await this._getDataValues({ field: t, valueExpression: s, normalizationField: i, normalizationType: a, normalizationTotal: r, scale: m, timeZone: f }), d = It(y, { field: t, normalizationField: i, normalizationType: a, normalizationTotal: r, classificationMethod: n, standardDeviationInterval: o, minValue: u, maxValue: c, numClasses: h });
+    return St(d, n);
+  }
+  async createHistogramResponse(e) {
+    const { field: t, valueExpression: s, normalizationField: i, normalizationType: a, normalizationTotal: r, classificationMethod: n, standardDeviationInterval: o, minValue: u, maxValue: c, numBins: h, scale: m, timeZone: f } = e, y = await this._getDataValues({ field: t, valueExpression: s, normalizationField: i, normalizationType: a, normalizationTotal: r, scale: m, timeZone: f });
+    return Tt(y, { field: t, normalizationField: i, normalizationType: a, normalizationTotal: r, classificationMethod: n, standardDeviationInterval: o, minValue: u, maxValue: c, numBins: h });
+  }
+  _sortFeatures(e, t, s) {
+    if (e.length > 1 && (t != null && t.length))
+      for (const i of t.reverse()) {
+        const a = i.split(" "), r = a[0], n = this.fieldsIndex.get(r), o = !!a[1] && a[1].toLowerCase() === "desc", u = Rt(n == null ? void 0 : n.type, o);
+        e.sort((c, h) => {
+          const m = s(c, r, n), f = s(h, r, n);
+          return u(m, f);
+        });
+      }
+  }
+  _createFeatureQueryResponse(e) {
+    const t = this.items, { geometryType: s, hasM: i, hasZ: a, objectIdField: r, spatialReference: n } = this, { outFields: o, outSR: u, quantizationParameters: c, resultRecordCount: h, resultOffset: m, returnZ: f, returnM: y } = e, d = h != null && t.length > (m || 0) + h, F = o && (o.includes("*") ? [...this.fieldsIndex.fields] : o.map((_) => this.fieldsIndex.get(_)));
+    return { exceededTransferLimit: d, features: this._createFeatures(e, t), fields: F, geometryType: s, hasM: i && y, hasZ: a && f, objectIdFieldName: r, spatialReference: j(u || n), transform: c && Fe(c) || null };
+  }
+  _createFeatures(e, t) {
+    const s = new H(e, this.featureAdapter, this.fieldsIndex), { hasM: i, hasZ: a } = this, { orderByFields: r, quantizationParameters: n, returnGeometry: o, returnCentroid: u, maxAllowableOffset: c, resultOffset: h, resultRecordCount: m, returnZ: f = !1, returnM: y = !1 } = e, d = a && f, F = i && y;
+    let _ = [], S = 0;
+    const T = [...t];
+    if (this._sortFeatures(T, r, (g, w, x) => s.getFieldValue(g, w, x)), this.geometryType && (o || u)) {
+      const g = Fe(n) ?? void 0, w = this.geometryType === "esriGeometryPolygon" || this.geometryType === "esriGeometryPolyline";
+      if (o && !u)
+        for (const x of T) {
+          const I = this.featureAdapter.getGeometry(x), R = { attributes: s.getAttributes(x), geometry: O(this.geometryType, this.hasZ, this.hasM, I, c, g, d, F) };
+          w && I && !R.geometry && (R.centroid = X(this, this.featureAdapter.getCentroid(x, this), g)), _[S++] = R;
+        }
+      else if (!o && u)
+        for (const x of T)
+          _[S++] = { attributes: s.getAttributes(x), centroid: X(this, this.featureAdapter.getCentroid(x, this), g) };
+      else
+        for (const x of T)
+          _[S++] = { attributes: s.getAttributes(x), centroid: X(this, this.featureAdapter.getCentroid(x, this), g), geometry: O(this.geometryType, this.hasZ, this.hasM, this.featureAdapter.getGeometry(x), c, g, d, F) };
+    } else
+      for (const g of T) {
+        const w = s.getAttributes(g);
+        w && (_[S++] = { attributes: w });
+      }
+    const p = h || 0;
+    if (m != null) {
+      const g = p + m;
+      _ = _.slice(p, Math.min(_.length, g));
+    }
+    return _;
+  }
+  _createExceedsLimitQueryResponse(e) {
+    let t = !1, s = Number.POSITIVE_INFINITY, i = Number.POSITIVE_INFINITY, a = Number.POSITIVE_INFINITY;
+    for (const r of e.outStatistics ?? [])
+      if (r.statisticType === "exceedslimit") {
+        s = r.maxPointCount != null ? r.maxPointCount : Number.POSITIVE_INFINITY, i = r.maxRecordCount != null ? r.maxRecordCount : Number.POSITIVE_INFINITY, a = r.maxVertexCount != null ? r.maxVertexCount : Number.POSITIVE_INFINITY;
+        break;
+      }
+    if (this.geometryType === "esriGeometryPoint")
+      t = this.items.length > s;
+    else if (this.items.length > i)
+      t = !0;
+    else {
+      const r = be(this.hasZ, this.hasM), n = this.featureAdapter;
+      t = this.items.reduce((o, u) => {
+        const c = n.getGeometry(u);
+        return o + (c != null && c.coords.length || 0);
+      }, 0) / r > a;
+    }
+    return { fields: [{ name: "exceedslimit", type: "esriFieldTypeInteger", alias: "exceedslimit", sqlType: "sqlTypeInteger", domain: null, defaultValue: null }], features: [{ attributes: { exceedslimit: Number(t) } }] };
+  }
+  async _createStatisticsQueryResponse(e) {
+    var T;
+    const t = { attributes: {} }, s = [], i = /* @__PURE__ */ new Map(), a = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map(), o = new H(e, this.featureAdapter, this.fieldsIndex), u = e.outStatistics, { groupByFieldsForStatistics: c, having: h, orderByFields: m, resultRecordCount: f } = e, y = c == null ? void 0 : c.length, d = !!y, F = d ? c[0] : null, _ = d && !this.fieldsIndex.get(F);
+    for (const p of u ?? []) {
+      const { outStatisticFieldName: g, statisticType: w } = p, x = p, I = w !== "exceedslimit" ? p.onStatisticField : void 0, R = w === "percentile_disc" || w === "percentile_cont", E = w === "EnvelopeAggregate" || w === "CentroidAggregate" || w === "ConvexHullAggregate", B = d && y === 1 && (I === F || _) && w === "count";
+      if (d) {
+        if (!r.has(I)) {
+          const L = [];
+          for (const Y of c) {
+            const U = this._getAttributeValues(o, Y, i);
+            L.push(U);
+          }
+          r.set(I, this._calculateUniqueValues(L, !E && o.returnDistinctValues));
+        }
+        const V = r.get(I);
+        if (!V)
+          continue;
+        const W = Object.keys(V);
+        for (const L of W) {
+          const { count: Y, data: U, items: le, itemPositions: Ne } = V[L], oe = U.join(",");
+          if (!h || o.validateItems(le, h)) {
+            const D = n.get(oe) || { attributes: {} };
+            if (E) {
+              D.aggregateGeometries || (D.aggregateGeometries = {});
+              const { aggregateGeometries: $, outStatisticFieldName: P } = await this._getAggregateGeometry(x, le);
+              D.aggregateGeometries[P] = $;
+            } else {
+              let $ = null;
+              if (B)
+                $ = Y;
+              else {
+                const P = this._getAttributeValues(o, I, i), ue = Ne.map((Ge) => P[Ge]);
+                $ = R && "statisticParameters" in x ? this._getPercentileValue(x, ue) : this._getStatisticValue(x, ue, null, o.returnDistinctValues);
+              }
+              D.attributes[g] = $;
+            }
+            let Pe = 0;
+            c.forEach(($, P) => D.attributes[this.fieldsIndex.get($) ? $ : "EXPR_" + ++Pe] = U[P]), n.set(oe, D);
+          }
+        }
+      } else if (E) {
+        t.aggregateGeometries || (t.aggregateGeometries = {});
+        const { aggregateGeometries: V, outStatisticFieldName: W } = await this._getAggregateGeometry(x, this.items);
+        t.aggregateGeometries[W] = V;
+      } else {
+        const V = this._getAttributeValues(o, I, i);
+        t.attributes[g] = R && "statisticParameters" in x ? this._getPercentileValue(x, V) : this._getStatisticValue(x, V, a, o.returnDistinctValues);
+      }
+      const k = w !== "min" && w !== "max" || !K(this.fieldsIndex.get(I)) && !this._isAnyDateField(I) ? null : (T = this.fieldsIndex.get(I)) == null ? void 0 : T.type;
+      s.push({ name: g, alias: g, type: k || "esriFieldTypeDouble" });
+    }
+    const S = d ? Array.from(n.values()) : [t];
+    return this._sortFeatures(S, m, (p, g) => p.attributes[g]), f && (S.length = Math.min(f, S.length)), { fields: s, features: S };
+  }
+  _isAnyDateField(e) {
+    const t = this.fieldsIndex.get(e);
+    return fe(t) || se(t) || ie(t) || Ve(t);
+  }
+  async _getAggregateGeometry(e, t) {
+    const { convexHull: s, union: i } = await import("./geometryEngineJSON-7d93793c.js"), { statisticType: a, outStatisticFieldName: r } = e, { featureAdapter: n, spatialReference: o, geometryType: u, hasZ: c, hasM: h } = this, m = t.map((d) => O(u, c, h, n.getGeometry(d))), f = s(o, m, !0)[0], y = { aggregateGeometries: null, outStatisticFieldName: null };
+    if (a === "EnvelopeAggregate") {
+      const d = f ? He(f) : me(i(o, m));
+      y.aggregateGeometries = { ...d, spatialReference: o }, y.outStatisticFieldName = r || "extent";
+    } else if (a === "CentroidAggregate") {
+      const d = f ? Je(f) : We(me(i(o, m)));
+      y.aggregateGeometries = { x: d[0], y: d[1], spatialReference: o }, y.outStatisticFieldName = r || "centroid";
+    } else
+      a === "ConvexHullAggregate" && (y.aggregateGeometries = f, y.outStatisticFieldName = r || "convexHull");
+    return y;
+  }
+  _getStatisticValue(e, t, s, i) {
+    const { onStatisticField: a, statisticType: r } = e;
+    let n = null;
+    return n = s != null && s.has(a) ? s.get(a) : K(this.fieldsIndex.get(a)) || this._isAnyDateField(a) ? we({ values: t, returnDistinct: i }) : Ie({ values: i ? [...new Set(t)] : t, minValue: null, maxValue: null, useSampleStdDev: !0 }), s && s.set(a, n), n[r === "var" ? "variance" : r];
+  }
+  _getPercentileValue(e, t) {
+    const { onStatisticField: s, statisticParameters: i, statisticType: a } = e, { value: r, orderBy: n } = i, o = this.fieldsIndex.get(s);
+    return bt(t, { value: r, orderBy: n, fieldType: o == null ? void 0 : o.type, isDiscrete: a === "percentile_disc" });
+  }
+  _getAttributeValues(e, t, s) {
+    if (s.has(t))
+      return s.get(t);
+    const i = this.fieldsIndex.get(t), a = this.items.map((r) => e.getFieldValue(r, t, i));
+    return s.set(t, a), a;
+  }
+  _calculateUniqueValues(e, t) {
+    const s = {}, i = this.items, a = i.length;
+    for (let r = 0; r < a; r++) {
+      const n = i[r], o = [];
+      for (const c of e)
+        o.push(c[r]);
+      const u = o.join(",");
+      s[u] == null ? s[u] = { count: 1, data: o, items: [n], itemPositions: [r] } : (t || s[u].count++, s[u].items.push(n), s[u].itemPositions.push(r));
+    }
+    return s;
+  }
+  async _getDataValues(e, t = !0) {
+    const s = new H(this.query, this.featureAdapter, this.fieldsIndex), { valueExpression: i, scale: a, timeZone: r } = e;
+    return i ? s.getExpressionValues(this.items, i, { viewingMode: "map", scale: a, spatialReference: this.query.outSR || this.spatialReference }, { geometryType: this.geometryType, hasZ: this.hasZ, hasM: this.hasM }, r) : s.getDataValues(this.items, J(e), t);
+  }
+}
+function qt(l, e, t, s) {
+  const i = s.x - t.x, a = s.y - t.y, r = i * i + a * a, n = (e.x - t.x) * i + (e.y - t.y) * a, o = Math.min(1, Math.max(0, n / r));
+  l.x = t.x + i * o, l.y = t.y + a * o;
+}
+function be(l, e) {
+  return l ? e ? 4 : 3 : e ? 3 : 2;
+}
+class ve {
+  constructor(e, t) {
+    this.coords = e, this.coordsIndex = t;
+  }
+  get x() {
+    return this.coords[this.coordsIndex];
+  }
+  get y() {
+    return this.coords[this.coordsIndex + 1];
+  }
+  get z() {
+    return this.coords[this.coordsIndex + 2];
+  }
+}
+const N = "unsupported-query";
+async function Ae(l, { fieldsIndex: e, geometryType: t, spatialReference: s, availableFields: i }) {
+  if ((l.distance ?? 0) < 0 || l.geometryPrecision != null || l.multipatchOption && l.multipatchOption !== "xyFootprint" || l.pixelSize || l.relationParam || l.text)
+    throw new v(N, "Unsupported query options", { query: l });
+  return Me(e, i, l), Mt(e, i, l), Promise.all([Ee(l, t, s), re(s, l.outSR)]).then(() => l);
+}
+function Me(l, e, t) {
+  const { outFields: s, orderByFields: i, returnDistinctValues: a, outStatistics: r } = t, n = r ? r.map((o) => o.outStatisticFieldName && o.outStatisticFieldName.toLowerCase()).filter(Boolean) : [];
+  if (i && i.length > 0) {
+    const o = " asc", u = " desc", c = i.map((h) => {
+      const m = h.toLowerCase();
+      return m.includes(o) ? m.split(o)[0] : m.includes(u) ? m.split(u)[0] : h;
+    }).filter((h) => !n.includes(h));
+    C(l, e, c, { expressionName: "orderByFields", query: t });
+  }
+  if (s && s.length > 0)
+    C(l, e, s, { expressionName: "outFields", query: t, allowedFieldTypes: "all" });
+  else if (a)
+    throw new v(N, "outFields should be specified for returnDistinctValues", { query: t });
+  Vt(l, e, t.where, t);
+}
+const Dt = /* @__PURE__ */ new Set([...ze, ...qe]);
+function Mt(l, e, t) {
+  const { outStatistics: s, groupByFieldsForStatistics: i, having: a } = t, r = i == null ? void 0 : i.length, n = s == null ? void 0 : s.length;
+  if (a) {
+    if (!r || !n)
+      throw new v(N, "outStatistics and groupByFieldsForStatistics should be specified with having", { query: t });
+    $t(l, e, a, s, t);
+  }
+  if (n) {
+    if (!Gt(s))
+      return;
+    const o = s.map((u) => u.onStatisticField).filter(Boolean);
+    C(l, e, o, { expressionName: "onStatisticFields", query: t }), r && C(l, e, i, { expressionName: "groupByFieldsForStatistics", query: t });
+    for (const u of s) {
+      const { onStatisticField: c, statisticType: h } = u;
+      if ((h === "percentile_disc" || h === "percentile_cont") && "statisticParameters" in u) {
+        const { statisticParameters: m } = u;
+        if (!m)
+          throw new v(N, "statisticParameters should be set for percentile type", { definition: u, query: t });
+      } else
+        l.get(c) && h !== "count" && h !== "min" && h !== "max" && C(l, e, [c], { expressionName: `outStatistics with '${h}' statistic type`, allowedFieldTypes: Dt, query: t });
+    }
+  }
+}
+async function Nt(l, e, { fieldsIndex: t, geometryType: s, spatialReference: i, availableFields: a }) {
+  if ((l.distance ?? 0) < 0 || l.geometryPrecision != null || l.multipatchOption || l.pixelSize || l.relationParam || l.text || l.outStatistics || l.groupByFieldsForStatistics || l.having || l.orderByFields)
+    throw new v(N, "Unsupported query options", { query: l });
+  return Me(t, a, l), Promise.all([Pt(t, a, e, l), Ee(l, s, i), re(i, l.outSR)]).then(() => l);
+}
+async function Pt(l, e, t, s) {
+  let i = [];
+  if (t.valueExpression) {
+    const { arcadeUtils: a } = await $e();
+    i = a.extractFieldNames(t.valueExpression);
+  }
+  if (t.field && i.push(t.field), t.field2 && i.push(t.field2), t.field3 && i.push(t.field3), t.normalizationField && i.push(t.normalizationField), !i.length && !t.valueExpression)
+    throw new v(N, "field or valueExpression is required", { params: t });
+  C(l, e, i, { expressionName: "statistics", query: s });
+}
+function Gt(l) {
+  return l != null && l.every((e) => e.statisticType !== "exceedslimit");
+}
+const Ot = "unsupported-query", jt = new ht(2e6);
+let Zt = 0;
+class rs {
+  constructor(e) {
+    this._geometryQueryCache = null, this._changeHandle = null, this.capabilities = { query: yt }, this.geometryType = e.geometryType, this.hasM = !!e.hasM, this.hasZ = !!e.hasZ, this.objectIdField = e.objectIdField, this.spatialReference = e.spatialReference, this.definitionExpression = e.definitionExpression, this.featureStore = e.featureStore, this.aggregateAdapter = e.aggregateAdapter, this._changeHandle = this.featureStore.events.on("changed", () => this.clearCache()), this.timeInfo = e.timeInfo, e.cacheSpatialQueries && (this._geometryQueryCache = new dt(Zt++ + "$$", jt)), this.fieldsIndex = Ye(e.fieldsIndex) ? e.fieldsIndex : vt.fromJSON(e.fieldsIndex), !e.availableFields || e.availableFields.length === 1 && e.availableFields[0] === "*" ? this.availableFields = new Set(this.fieldsIndex.fields.map((t) => t.name)) : this.availableFields = new Set(e.availableFields.map((t) => {
+      var s;
+      return (s = this.fieldsIndex.get(t)) == null ? void 0 : s.name;
+    }).filter((t) => t != null)), e.scheduler && e.priority && (this._frameTask = e.scheduler.registerTask(e.priority));
+  }
+  destroy() {
+    this._frameTask = ye(this._frameTask), this.clearCache(), Xe(this._geometryQueryCache), this._changeHandle = ye(this._changeHandle);
+  }
+  get featureAdapter() {
+    return this.featureStore.featureAdapter;
+  }
+  clearCache() {
+    var e;
+    (e = this._geometryQueryCache) == null || e.clear(), this._allFeaturesPromise = null, this._timeExtentPromise = null, this._fullExtentPromise = null;
+  }
+  async executeQuery(e, t) {
+    const s = A(t);
+    try {
+      return (await this._executeQuery(e, {}, s)).createQueryResponse();
+    } catch (i) {
+      if (i !== M)
+        throw i;
+      return new b([], e, this).createQueryResponse();
+    }
+  }
+  async executeQueryForCount(e = {}, t) {
+    const s = A(t);
+    try {
+      return (await this._executeQuery(e, { returnGeometry: !1, returnCentroid: !1, outSR: null }, s)).createQueryResponseForCount();
+    } catch (i) {
+      if (i !== M)
+        throw i;
+      return 0;
+    }
+  }
+  async executeQueryForExtent(e, t) {
+    const s = A(t), i = e.outSR;
+    try {
+      const a = await this._executeQuery(e, { returnGeometry: !0, returnCentroid: !1, outSR: null }, s), r = a.size;
+      return r ? { count: r, extent: await this._getBounds(a.items, a.spatialReference, i || this.spatialReference) } : { count: 0, extent: null };
+    } catch (a) {
+      if (a === M)
+        return { count: 0, extent: null };
+      throw a;
+    }
+  }
+  async executeQueryForIds(e, t) {
+    return this.executeQueryForIdSet(e, t).then((s) => Array.from(s));
+  }
+  async executeQueryForIdSet(e, t) {
+    const s = A(t);
+    try {
+      const i = await this._executeQuery(e, { returnGeometry: !0, returnCentroid: !1, outSR: null }, s), a = i.items, r = /* @__PURE__ */ new Set();
+      return await this._reschedule(() => {
+        for (const n of a)
+          r.add(i.featureAdapter.getObjectId(n));
+      }, s), r;
+    } catch (i) {
+      if (i === M)
+        return /* @__PURE__ */ new Set();
+      throw i;
+    }
+  }
+  async executeQueryForSnapping(e, t) {
+    const s = A(t), { point: i, distance: a, returnEdge: r, vertexMode: n } = e;
+    if (!r && n === "none")
+      return { candidates: [] };
+    let o = J(e.query);
+    o = await this._schedule(() => je(o, this.definitionExpression, this.spatialReference), s), o = await this._reschedule(() => Ae(o, { availableFields: this.availableFields, fieldsIndex: this.fieldsIndex, geometryType: this.geometryType, spatialReference: this.spatialReference }), s);
+    const u = !Q(i.spatialReference, this.spatialReference);
+    u && await re(i.spatialReference, this.spatialReference);
+    const c = typeof a == "number" ? a : a.x, h = typeof a == "number" ? a : a.y, m = { xmin: i.x - c, xmax: i.x + c, ymin: i.y - h, ymax: i.y + h, spatialReference: i.spatialReference }, f = u ? z(m, this.spatialReference) : m;
+    if (!f)
+      return { candidates: [] };
+    const y = (await pe(ge(i), null, { signal: s }))[0], d = (await pe(ge(f), null, { signal: s }))[0];
+    if (y == null || d == null)
+      return { candidates: [] };
+    const F = new b(await this._reschedule(() => this._searchFeatures(this._getQueryBBoxes(d.toJSON())), s), o, this);
+    await this._reschedule(() => this._executeObjectIdsQuery(F), s), await this._reschedule(() => this._executeTimeQuery(F), s), await this._reschedule(() => this._executeAttributesQuery(F), s), await this._reschedule(() => this._executeGeometryQueryForSnapping(F, s), s);
+    const _ = y.toJSON(), S = u ? z(_, this.spatialReference) : _, T = u ? Math.max(f.xmax - f.xmin, f.ymax - f.ymin) / 2 : a;
+    return F.createSnappingResponse({ ...e, point: S, distance: T }, i.spatialReference);
+  }
+  async executeQueryForLatestObservations(e, t) {
+    var i;
+    const s = A(t);
+    if (!((i = this.timeInfo) != null && i.trackIdField))
+      throw new v(Ot, "Missing timeInfo or timeInfo.trackIdField", { query: e, timeInfo: this.timeInfo });
+    try {
+      const a = await this._executeQuery(e, {}, s);
+      return await this._reschedule(() => this._filterLatest(a), s), a.createQueryResponse();
+    } catch (a) {
+      if (a !== M)
+        throw a;
+      return new b([], e, this).createQueryResponse();
+    }
+  }
+  async executeQueryForSummaryStatistics(e = {}, t, s) {
+    const i = A(s), { field: a, normalizationField: r, valueExpression: n } = t;
+    return (await this._executeQueryForStatistics(e, { field: a, normalizationField: r, valueExpression: n }, i)).createSummaryStatisticsResponse(t);
+  }
+  async executeQueryForUniqueValues(e = {}, t, s) {
+    const i = A(s), { field: a, field2: r, field3: n, valueExpression: o } = t;
+    return (await this._executeQueryForStatistics(e, { field: a, field2: r, field3: n, valueExpression: o }, i)).createUniqueValuesResponse(t);
+  }
+  async executeQueryForClassBreaks(e = {}, t, s) {
+    const i = A(s), { field: a, normalizationField: r, valueExpression: n } = t;
+    return (await this._executeQueryForStatistics(e, { field: a, normalizationField: r, valueExpression: n }, i)).createClassBreaksResponse(t);
+  }
+  async executeQueryForHistogram(e = {}, t, s) {
+    const i = A(s), { field: a, normalizationField: r, valueExpression: n } = t;
+    return (await this._executeQueryForStatistics(e, { field: a, normalizationField: r, valueExpression: n }, i)).createHistogramResponse(t);
+  }
+  async fetchRecomputedExtents(e) {
+    const t = A(e);
+    this._timeExtentPromise || (this._timeExtentPromise = Ze(this.timeInfo, this.featureStore));
+    const [s, i] = await Promise.all([this._getFullExtent(), this._timeExtentPromise]);
+    return Ke(t), { fullExtent: s, timeExtent: i };
+  }
+  async _getBounds(e, t, s) {
+    const i = et(tt(), ut);
+    await this.featureStore.forEachBounds(e, (n) => st(i, n));
+    const a = { xmin: i[0], ymin: i[1], xmax: i[3], ymax: i[4], spatialReference: j(this.spatialReference) };
+    this.hasZ && isFinite(i[2]) && isFinite(i[5]) && (a.zmin = i[2], a.zmax = i[5]);
+    const r = z(a, t, s);
+    if (r.spatialReference = j(s), r.xmax - r.xmin == 0) {
+      const n = ee(r.spatialReference);
+      r.xmin -= n, r.xmax += n;
+    }
+    if (r.ymax - r.ymin == 0) {
+      const n = ee(r.spatialReference);
+      r.ymin -= n, r.ymax += n;
+    }
+    if (this.hasZ && r.zmin != null && r.zmax != null && r.zmax - r.zmin == 0) {
+      const n = ee(r.spatialReference);
+      r.zmin -= n, r.zmax += n;
+    }
+    return r;
+  }
+  _getFullExtent() {
+    return this._fullExtentPromise || (this._fullExtentPromise = "getFullExtent" in this.featureStore && this.featureStore.getFullExtent ? Promise.resolve(this.featureStore.getFullExtent(this.spatialReference)) : this._getAllFeatures().then((e) => this._getBounds(e, this.spatialReference, this.spatialReference))), this._fullExtentPromise;
+  }
+  async _schedule(e, t) {
+    return this._frameTask != null ? this._frameTask.schedule(e, t) : e(Se);
+  }
+  async _reschedule(e, t) {
+    return this._frameTask != null ? this._frameTask.reschedule(e, t) : e(Se);
+  }
+  async _getAllFeaturesQueryEngineResult(e) {
+    return new b(await this._getAllFeatures(), e, this);
+  }
+  async _getAllFeatures() {
+    if (this._allFeaturesPromise == null) {
+      const s = [];
+      this._allFeaturesPromise = (async () => {
+        await this.featureStore.forEach((i) => s.push(i));
+      })().then(() => s);
+    }
+    const e = this._allFeaturesPromise, t = await e;
+    return e === this._allFeaturesPromise ? t.slice() : this._getAllFeatures();
+  }
+  async _executeQuery(e, t, s) {
+    e = J(e), e = await this._schedule(() => ce(e, this.definitionExpression, this.spatialReference), s), e = await this._reschedule(() => Ae(e, { availableFields: this.availableFields, fieldsIndex: this.fieldsIndex, geometryType: this.geometryType, spatialReference: this.spatialReference }), s), e = { ...e, ...t };
+    const i = await this._reschedule(() => this._executeSceneFilterQuery(e, s), s), a = await this._reschedule(() => this._executeGeometryQuery(e, i, s), s);
+    return await this._reschedule(() => this._executeAggregateIdsQuery(a), s), await this._reschedule(() => this._executeObjectIdsQuery(a), s), await this._reschedule(() => this._executeTimeQuery(a), s), await this._reschedule(() => this._executeAttributesQuery(a), s), a;
+  }
+  async _executeSceneFilterQuery(e, t) {
+    if (e.sceneFilter == null)
+      return null;
+    const { outSR: s, returnGeometry: i, returnCentroid: a } = e, r = this.featureStore.featureSpatialReference, n = e.sceneFilter.geometry, o = r == null || Q(r, n.spatialReference) ? n : z(n, r);
+    if (!o)
+      return null;
+    const u = i || a, c = ae(s) && !Q(this.spatialReference, s) && u ? async (d) => this._project(d, s) : (d) => d, h = this.featureAdapter, m = await this._reschedule(() => this._searchFeatures(this._getQueryBBoxes(o)), t);
+    if (e.sceneFilter.spatialRelationship === "disjoint") {
+      if (!m.length)
+        return null;
+      const d = /* @__PURE__ */ new Set();
+      for (const S of m)
+        d.add(h.getObjectId(S));
+      const F = await this._reschedule(() => this._getAllFeatures(), t), _ = await this._reschedule(async () => {
+        const S = await G("esriSpatialRelDisjoint", o, this.geometryType, this.hasZ, this.hasM), T = (g) => !d.has(h.getObjectId(g)) || S(h.getGeometry(g)), p = await this._runSpatialFilter(F, T, t);
+        return new b(p, e, this);
+      }, t);
+      return c(_);
+    }
+    if (!m.length)
+      return new b([], e, this);
+    if (this._canExecuteSinglePass(o, e))
+      return c(new b(m, e, this));
+    const f = await G("esriSpatialRelContains", o, this.geometryType, this.hasZ, this.hasM), y = await this._runSpatialFilter(m, (d) => f(h.getGeometry(d)), t);
+    return c(new b(y, e, this));
+  }
+  async _executeGeometryQuery(e, t, s) {
+    if (t != null && t.items.length === 0)
+      return t;
+    e = t != null ? t.query : e;
+    const { geometry: i, outSR: a, spatialRel: r, returnGeometry: n, returnCentroid: o } = e, u = this.featureStore.featureSpatialReference, c = !i || u == null || Q(u, i.spatialReference) ? i : z(i, u), h = n || o, m = ae(a) && !Q(this.spatialReference, a), f = this._geometryQueryCache && t == null ? JSON.stringify(m && h ? { originalFilterGeometry: i, spatialRelationship: r, outSpatialReference: a } : { originalFilterGeometry: i, spatialRelationship: r }) : null, y = f ? this._geometryQueryCache.get(f) : null;
+    if (y != null)
+      return new b(y, e, this);
+    const d = async (p) => (m && h && await this._project(p, a), f && this._geometryQueryCache.put(f, p.items, p.items.length + 1), p);
+    if (!c)
+      return d(t ?? await this._getAllFeaturesQueryEngineResult(e));
+    const F = this.featureAdapter;
+    let _ = await this._reschedule(() => this._searchFeatures(this._getQueryBBoxes(i)), s);
+    if (r === "esriSpatialRelDisjoint") {
+      if (!_.length)
+        return d(t ?? await this._getAllFeaturesQueryEngineResult(e));
+      const p = /* @__PURE__ */ new Set();
+      for (const x of _)
+        p.add(F.getObjectId(x));
+      const g = t != null ? t.items : await this._reschedule(() => this._getAllFeatures(), s), w = await this._reschedule(async () => {
+        const x = await G(r, c, this.geometryType, this.hasZ, this.hasM), I = (E) => !p.has(F.getObjectId(E)) || x(F.getGeometry(E)), R = await this._runSpatialFilter(g, I, s);
+        return new b(R, e, this);
+      }, s);
+      return d(w);
+    }
+    if (t != null) {
+      const p = new ct();
+      _ = _.filter((g) => it(t.items, g, t.items.length, p) >= 0);
+    }
+    if (!_.length) {
+      const p = new b([], e, this);
+      return f && this._geometryQueryCache.put(f, p.items, 1), p;
+    }
+    if (this._canExecuteSinglePass(c, e))
+      return d(new b(_, e, this));
+    const S = await G(r, c, this.geometryType, this.hasZ, this.hasM), T = await this._runSpatialFilter(_, (p) => S(F.getGeometry(p)), s);
+    return d(new b(T, e, this));
+  }
+  async _executeGeometryQueryForSnapping(e, t) {
+    var n;
+    const { query: s } = e, { spatialRel: i } = s;
+    if (!((n = e == null ? void 0 : e.items) != null && n.length) || !s.geometry || !i)
+      return;
+    const a = await G(i, s.geometry, this.geometryType, this.hasZ, this.hasM), r = await this._runSpatialFilter(e.items, (o) => a(o.geometry), t);
+    e.items = r;
+  }
+  _executeAggregateIdsQuery(e) {
+    var i;
+    if (e.items.length === 0 || !((i = e.query.aggregateIds) != null && i.length) || this.aggregateAdapter == null)
+      return;
+    const t = /* @__PURE__ */ new Set();
+    for (const a of e.query.aggregateIds)
+      this.aggregateAdapter.getFeatureObjectIds(a).forEach((r) => t.add(r));
+    const s = this.featureAdapter.getObjectId;
+    e.items = e.items.filter((a) => t.has(s(a)));
+  }
+  _executeObjectIdsQuery(e) {
+    var i;
+    if (e.items.length === 0 || !((i = e.query.objectIds) != null && i.length))
+      return;
+    const t = new Set(e.query.objectIds), s = this.featureAdapter.getObjectId;
+    e.items = e.items.filter((a) => t.has(s(a)));
+  }
+  _executeTimeQuery(e) {
+    if (e.items.length === 0)
+      return;
+    const t = Be(this.timeInfo, e.query.timeExtent, this.featureAdapter);
+    t != null && (e.items = e.items.filter(t));
+  }
+  _executeAttributesQuery(e) {
+    if (e.items.length === 0)
+      return;
+    const t = q(e.query.where, this.fieldsIndex);
+    if (t) {
+      if (!t.isStandardized)
+        throw new TypeError("Where clause is not standardized");
+      e.items = e.items.filter((s) => t.testFeature(s, this.featureAdapter));
+    }
+  }
+  async _runSpatialFilter(e, t, s) {
+    if (!t)
+      return e;
+    if (this._frameTask == null)
+      return e.filter((n) => t(n));
+    let i = 0;
+    const a = new Array(), r = async (n) => {
+      for (; i < e.length; ) {
+        const o = e[i++];
+        t(o) && (a.push(o), n.madeProgress()), n.done && await this._reschedule((u) => r(u), s);
+      }
+    };
+    return this._reschedule((n) => r(n), s).then(() => a);
+  }
+  _filterLatest(e) {
+    const { trackIdField: t, startTimeField: s, endTimeField: i } = this.timeInfo, a = i || s, r = /* @__PURE__ */ new Map(), n = this.featureAdapter.getAttribute;
+    for (const o of e.items) {
+      const u = n(o, t), c = n(o, a), h = r.get(u);
+      (!h || c > n(h, a)) && r.set(u, o);
+    }
+    e.items = Array.from(r.values());
+  }
+  _canExecuteSinglePass(e, t) {
+    const { spatialRel: s } = t;
+    return he(e) && (s === "esriSpatialRelEnvelopeIntersects" || this.geometryType === "esriGeometryPoint" && (s === "esriSpatialRelIntersects" || s === "esriSpatialRelContains"));
+  }
+  async _project(e, t) {
+    if (!t || Q(this.spatialReference, t))
+      return e;
+    const s = this.featureAdapter;
+    let i;
+    try {
+      const r = await this._getFullExtent();
+      i = at(this.spatialReference, t, r);
+    } catch {
+    }
+    const a = await ke(e.items.map((r) => O(this.geometryType, this.hasZ, this.hasM, s.getGeometry(r))), this.spatialReference, t, i);
+    return e.items = a.map((r, n) => s.cloneWithGeometry(e.items[n], ft(r, this.hasZ, this.hasM))), e;
+  }
+  _getQueryBBoxes(e) {
+    if (he(e)) {
+      if (rt(e))
+        return [xe(Math.min(e.xmin, e.xmax), Math.min(e.ymin, e.ymax), Math.max(e.xmin, e.xmax), Math.max(e.ymin, e.ymax))];
+      if (nt(e))
+        return e.rings.map((t) => xe(Math.min(t[0][0], t[2][0]), Math.min(t[0][1], t[2][1]), Math.max(t[0][0], t[2][0]), Math.max(t[0][1], t[2][1])));
+    }
+    return [lt(ot(), e)];
+  }
+  async _searchFeatures(e) {
+    const t = /* @__PURE__ */ new Set();
+    await Promise.all(e.map((i) => this.featureStore.forEachInBounds(i, (a) => t.add(a))));
+    const s = Array.from(t.values());
+    return t.clear(), s;
+  }
+  async _executeQueryForStatistics(e, t, s) {
+    e = J(e);
+    try {
+      e = await this._schedule(() => ce(e, this.definitionExpression, this.spatialReference), s), e = await this._reschedule(() => Nt(e, t, { availableFields: this.availableFields, fieldsIndex: this.fieldsIndex, geometryType: this.geometryType, spatialReference: this.spatialReference }), s);
+      const i = await this._reschedule(() => this._executeSceneFilterQuery(e, s), s), a = await this._reschedule(() => this._executeGeometryQuery(e, i, s), s);
+      return await this._reschedule(() => this._executeAggregateIdsQuery(a), s), await this._reschedule(() => this._executeObjectIdsQuery(a), s), await this._reschedule(() => this._executeTimeQuery(a), s), await this._reschedule(() => this._executeAttributesQuery(a), s), a;
+    } catch (i) {
+      if (i !== M)
+        throw i;
+      return new b([], e, this);
+    }
+  }
+}
+export {
+  rs as $,
+  is as o
+};