@agrotools1/at-components 0.2.1 → 0.2.3

package/dist/FeaturePipelineWorker-d4301d2a.js

@@ -0,0 +1,3633 @@
+import { n as we, j7 as ht, dc as xe, cK as ke, bR as V, cw as Ht, cx as Jt, ia as Kt, eQ as ut, aO as y, fc as Fe, x as dt, bJ as Y, by as ct, ci as es, bw as ts, e as G, y as K, c as lt, S as _t, o as pe, W as D, ap as ss, s as rs, kG as is, gU as se, gW as ns, hN as pt, b as as, fm as gt, U as os, he as hs, dO as Te, cs as us, bh as ds, kH as cs, cZ as De, h as Le } from "./index-01c737ed.js";
+import { a as x } from "./definitions-a00a3a6c.js";
+import { m as ft, p as he, d as ze, s as Ue } from "./diffUtils-e71a6152.js";
+import { n as Ge, i as A, r as ls, M as Ce, p as Me, d as yt, f as $e, g as _s, a as ps, b as gs, h as fs, j as ys } from "./AttributeStore-b90878e3.js";
+import { o as ms } from "./tileUtils-3e0c8c1d.js";
+import { S as bs, R as Is, A as vs } from "./geohashUtils-2bc76440.js";
+import { g as Ss, e as ws, c as mt, N as xs, n as bt, p as ks, b as Fs, w as Ts, a as X, K as Cs, O as Ms, r as $s, f as It } from "./featureConversionUtils-650d7601.js";
+import { s as H, t as B, e as T } from "./OptimizedGeometry-3b808152.js";
+import { x as Os, j as We } from "./timeSupport-3f529cdb.js";
+import { o as qs, $ as vt } from "./QueryEngine-10c97624.js";
+import { Z as St } from "./FieldsIndex-75cca4d0.js";
+import { d as As, c as Ne, S as Rs } from "./query-b6e1fd14.js";
+import { m as wt } from "./quantizationUtils-0a8f74c6.js";
+import { $ as Be } from "./ogcFeatureUtils-46ac1c44.js";
+import { n as Es } from "./pbf-5dd791f5.js";
+import { b as Ps, h as js } from "./pbfQueryUtils-a6ca7e23.js";
+import { t as Ve } from "./CircularArray-b2bc1dfd.js";
+import { createConnection as Ds } from "./createConnection-f974a00a.js";
+import { d as Ls } from "./UpdateTracking2D-e9adad8f.js";
+import "vue";
+import "./LabelMetric-e2728bbf.js";
+import "./enums-2c166c09.js";
+import "./enums-fa8f05ab.js";
+import "./Texture-22a8cca5.js";
+import "./Program-ba2f18b2.js";
+import "./BufferObject-cbd0168e.js";
+import "./VertexElementDescriptor-d7c718c2.js";
+import "./labelUtils-a3634e8f.js";
+import "./TimeOnly-9ee66ca6.js";
+import "./UnknownTimeZone-220952b5.js";
+import "./highlightReasons-de432106.js";
+import "./OptimizedFeatureSet-54e095c4.js";
+import "./json-5febf88a.js";
+import "./MemCache-a9232ec2.js";
+import "./LRUCache-27e8c401.js";
+import "./WhereClause-7a28b740.js";
+import "./QueryEngineCapabilities-0d8477a2.js";
+import "./utils-d252c575.js";
+import "./heatmapUtils-56758920.js";
+import "./vec42-36edeb73.js";
+import "./vec4f64-043e974c.js";
+import "./utils-3a10b10c.js";
+import "./utils-5432e258.js";
+import "./ClassBreaksDefinition-07ba0c64.js";
+import "./Scheduler-eacc84bb.js";
+import "./RenderState-b244097f.js";
+import "./queryZScale-c5733d0a.js";
+import "./geojson-603231df.js";
+import "./date-1c28c6a5.js";
+import "./clientSideDefaults-5c1f97c9.js";
+import "./defaultsJSON-ba17aa15.js";
+import "./sourceUtils-01d115c6.js";
+import "./TurboLine-6ab04aef.js";
+import "./earcut-6fa1a128.js";
+import "./GeometryUtils-fa897cbd.js";
+import "./utils-7a88ec6a.js";
+import "./Rect-894f011c.js";
+import "./defaults-2bfa4a36.js";
+import "./BindType-5e76c8e1.js";
+import "./Util-002f5109.js";
+import "./constants-5bd557fe.js";
+let zs = class {
+  constructor(e) {
+    this._client = e, this.layerView = this._client.createInvokeProxy("", { ignoreConnectionErrors: !0 }), this.container = this._client.createInvokeProxy("container", { ignoreConnectionErrors: !0 }), this.eventLog = this._client.createInvokeProxy("eventLog", { ignoreConnectionErrors: !0 });
+  }
+};
+const re = 1, Oe = 2, ie = 4, qe = 8, Ae = 16, ne = 32, Re = 64, ae = 128;
+function ue(u) {
+  switch (u) {
+    case re:
+    case qe:
+    case ne:
+      return -1;
+    case Oe:
+    case Re:
+      return 0;
+    case ie:
+    case Ae:
+    case ae:
+      return 1;
+  }
+}
+function de(u) {
+  switch (u) {
+    case re:
+    case Oe:
+    case ie:
+      return -1;
+    case qe:
+    case Ae:
+      return 0;
+    case ne:
+    case Re:
+    case ae:
+      return 1;
+  }
+}
+const Ye = re | qe | ne, Xe = ie | Ae | ae, Qe = re | Oe | ie, Ze = ne | Re | ae;
+let Us = class {
+  constructor(e, t, s, r = 0) {
+    this.tileKey = e, this._bufferingEnabled = t, this._sizeHint = r, this._meshes = { self: new Ge(this.id, this._sizeHint), neighbors: new Array() }, this._currentRecordOverlaps = 0, this._currentEntityOverlaps = 0, this._copyBufferedDataIntoSelf = s && this._bufferingEnabled && e.level === 0;
+  }
+  get id() {
+    return this.tileKey.id;
+  }
+  vertexCount() {
+    return this._meshes.self.vertexCount();
+  }
+  indexCount() {
+    return this._meshes.self.indexCount();
+  }
+  indexEnsureSize(e) {
+    this._meshes.self.indexEnsureSize(e);
+  }
+  entityStart(e, t = e) {
+    this._currentEntityOverlaps = 0, this._meshes.self.entityStart(e, t);
+  }
+  entityRecordCount() {
+    return this._meshes.self.entityRecordCount();
+  }
+  entityEnd() {
+    if (this._meshes.self.entityEnd(), this._bufferingEnabled) {
+      if (this._copyBufferedDataIntoSelf)
+        return;
+      for (let e = 0; e < 8; e++) {
+        const t = 1 << e;
+        this._currentEntityOverlaps & t && this._meshes.neighbors[e].entityEnd();
+      }
+    }
+  }
+  recordStart(e, t, s) {
+    this._currentRecordOverlaps = 0, this._meshes.self.recordStart(e, t, s);
+  }
+  recordEnd(e = 0) {
+    const t = this._meshes.self.recordEnd(this._currentRecordOverlaps);
+    return t && this._currentRecordOverlaps !== 0 ? (this._copyIntoNeighbors(), this._currentEntityOverlaps |= this._currentRecordOverlaps, !0) : t;
+  }
+  recordBounds(e, t, s, r) {
+    this._bufferingEnabled && this._addOverlap(e, t, s, r);
+  }
+  recordCount() {
+    return this._meshes.self.recordCount();
+  }
+  metricStart(e) {
+    this._meshes.self.metricStart(e);
+  }
+  metricBoxWrite(e) {
+    this._meshes.self.metricBoxWrite(e);
+  }
+  metricEnd() {
+    this._meshes.self.metricEnd();
+  }
+  vertexWrite(e) {
+    this._meshes.self.vertexWrite(e);
+  }
+  vertexWriteF32(e) {
+    this._meshes.self.vertexWriteF32(e);
+  }
+  vertexWriteRegion(e) {
+    this._meshes.self.vertexWriteRegion(e);
+  }
+  indexWrite(e) {
+    this._meshes.self.indexWrite(e);
+  }
+  serialize(e) {
+    const t = { message: [], transferList: [] }, s = this._meshes.self.serialize();
+    return t.message.push({ tileId: this.tileKey.id, ...s.message }), t.transferList.push(...s.transferList), this._meshes.neighbors.forEach((r, i) => {
+      const n = r.serialize(), a = 1 << i, o = ue(a), h = de(a), c = ms(new we(this.tileKey), o, h, e);
+      t.message.push({ tileId: c.id, ...n.message }), t.transferList.push(...n.transferList);
+    }), t;
+  }
+  _addOverlap(e, t, s, r) {
+    const i = Math.min(x / 2, s), n = Math.min(x / 2, r), a = 255 ^ ((e < 0 + i ? Xe : e >= x - i ? Ye : Xe | Ye) | (t < 0 + n ? Ze : t >= x - n ? Qe : Ze | Qe));
+    this._currentRecordOverlaps |= a;
+  }
+  _copyIntoNeighbors() {
+    for (let e = 0; e < 8; e++) {
+      const t = 1 << e;
+      if (this._currentRecordOverlaps & t) {
+        if (this._copyBufferedDataIntoSelf) {
+          const n = -ue(t) * x, a = -de(t) * x;
+          this._meshes.self.copyLast(n, a);
+          continue;
+        }
+        if (!this._meshes.neighbors[e]) {
+          const n = Math.floor(this._sizeHint / 16);
+          this._meshes.neighbors[e] = new Ge(t, n);
+        }
+        const s = this._meshes.neighbors[e], r = -ue(t) * x, i = -de(t) * x;
+        s.copyLastFrom(this._meshes.self, r, i);
+      }
+    }
+  }
+}, Gs = class {
+}, L = class xt {
+  constructor() {
+    this._defaultResult = null, this._backgroundFillResult = null;
+  }
+  static async from(e, t, s, r) {
+    const i = new xt();
+    return i.setDefault(await A(e, t, s.meshes, r)), i;
+  }
+  size() {
+    return 1;
+  }
+  getDefault() {
+    return this._defaultResult;
+  }
+  setDefault(e) {
+    this._defaultResult = e;
+  }
+  getBackgroundFill() {
+    return this._backgroundFillResult;
+  }
+  setBackgroundFill(e) {
+    this._backgroundFillResult = e;
+  }
+  match(e, t) {
+    const s = this.doMatch(e, t) || this.getDefault();
+    if (s && s.length > 0) {
+      const r = this.getBackgroundFill();
+      if (r)
+        return [...r, ...s];
+    }
+    return s;
+  }
+  getSortKey(e, t) {
+    return 0;
+  }
+  doMatch(e, t) {
+    return null;
+  }
+  async fetchResources(e, t) {
+  }
+}, Ws = class kt extends L {
+  static async fromDictionaryRenderer(e, t, s) {
+    return new kt(e, t, s);
+  }
+  constructor(e, t, s) {
+    super(), this._storage = e, this._schema = t, this._viewParams = s, this._hashToGroup = /* @__PURE__ */ new Map();
+  }
+  get fieldMap() {
+    return this._schema.fieldMap;
+  }
+  async fetchResources(e, t) {
+    const s = t.getCursor(), r = [];
+    for (; s.next(); )
+      r.push(this._updateMeshWriterGroup(e, s));
+    await Promise.all(r);
+  }
+  match(e, t) {
+    const s = e.getAttributeHash();
+    return this._hashToGroup.get(s);
+  }
+  async _updateMeshWriterGroup(e, t) {
+    const s = t.readLegacyFeatureForDisplay(), r = t.getAttributeHash();
+    if (this._hashToGroup.has(r))
+      return;
+    this._hashToGroup.set(r, null);
+    const i = await e.fetchDictionaryResourceImmediate({ type: "dictionary-request", feature: s });
+    if (!i)
+      return;
+    const n = await A(this._storage, e, i.meshes, this._viewParams);
+    this._hashToGroup.set(r, n);
+  }
+}, Ns = class Ft extends L {
+  constructor(e, t) {
+    super(), this._intervals = [], this._isMaxInclusive = t, this._field = e;
+  }
+  static async fromIntervalSchema(e, t, s, r) {
+    const i = await e.createComputedField(s), n = new Ft(i, s.isMaxInclusive);
+    await Promise.all(s.intervals.map(async (h) => {
+      const c = await A(e, t, h.meshes, r);
+      n.add(h, c);
+    }));
+    const a = await A(e, t, s.defaultSymbol, r);
+    n.setDefault(a);
+    const o = await A(e, t, s.backgroundFill, r);
+    return n.setBackgroundFill(o), n;
+  }
+  add(e, t) {
+    this._intervals.push({ interval: e, result: t }), this._intervals.sort((s, r) => s.interval.min - r.interval.min);
+  }
+  size() {
+    return super.size() + this._intervals.length;
+  }
+  doMatch(e, t) {
+    var r;
+    const s = (r = this._field) == null ? void 0 : r.read(e, t);
+    if (s == null || isNaN(s) || s === 1 / 0 || s === -1 / 0)
+      return null;
+    for (let i = 0; i < this._intervals.length; i++) {
+      const { interval: n, result: a } = this._intervals[i], o = s >= n.min, h = this._isMaxInclusive ? s <= n.max : s < n.max;
+      if (o && h)
+        return a;
+    }
+    return null;
+  }
+}, Bs = class Tt extends L {
+  static async fromLabelSchema(e, t, s, r) {
+    const i = s.classes.map(async (a) => {
+      const o = await A(e, t, a.meshes, r);
+      return { minScale: a.minScale, maxScale: a.maxScale, meshes: o, expression: null, where: await e.createWhereClause(a.where) };
+    }), n = await Promise.all(i);
+    return new Tt(n);
+  }
+  constructor(e) {
+    super(), this._labels = e;
+  }
+  match(e, t) {
+    if (!this._labels.length)
+      return null;
+    const s = this._getLabels(t.$view.scale), r = [];
+    for (const i of s)
+      i.where && !i.where(e) || r.push(...i.meshes);
+    return r;
+  }
+  _getLabels(e) {
+    return this._labels.filter((t) => this._validForTileScale(t, e));
+  }
+  _validForTileScale(e, t) {
+    const s = t - t / 4, r = t + t / 2;
+    return (!e.minScale || e.minScale >= s) && (!e.maxScale || e.maxScale <= r);
+  }
+}, Vs = class Ct extends L {
+  constructor(e, t) {
+    super(), this._defaultSymbolSortKey = 0, this._nullResult = null, this._resultsMap = /* @__PURE__ */ new Map(), this._fields = [], this._fields = e, this._separator = t || "";
+  }
+  static async fromMatcherSchema(e, t, s, r) {
+    const i = s.expression ? [e.createComputedField({ expression: s.expression })] : [s.field ? e.createComputedField({ field: s.field }) : null, s.field2 ? e.createComputedField({ field: s.field2 }) : null, s.field3 ? e.createComputedField({ field: s.field3 }) : null], n = (await Promise.all(i)).filter((c) => !!c), a = new Ct(n, s.fieldDelimiter), o = await A(e, t, s.defaultSymbol, r);
+    a.setDefault(o);
+    const h = await A(e, t, s.backgroundFill, r);
+    return a.setBackgroundFill(h), await Promise.all(s.map.map(async (c, d) => {
+      const l = await A(e, t, c.symbol, r);
+      c.value === "<Null>" ? a.setNullResult(l) : a.add(c.value, l, d + 1);
+    })), a;
+  }
+  setNullResult(e) {
+    this._nullResult = e;
+  }
+  getSortKey(e, t) {
+    const s = this._getValueFromFields(e, t);
+    if (s == null || s === "" || s === "<Null>")
+      return 0;
+    const r = this._resultsMap.get(s.toString());
+    return r ? r.sortKey : this._defaultSymbolSortKey;
+  }
+  add(e, t, s) {
+    this._resultsMap.set(e.toString(), { meshWriters: t, sortKey: s }), this._defaultSymbolSortKey = Math.max(this._defaultSymbolSortKey, s + 1);
+  }
+  size() {
+    return super.size() + this._resultsMap.size;
+  }
+  doMatch(e, t) {
+    var i;
+    const s = this._getValueFromFields(e, t);
+    if (this._nullResult !== null && (s == null || s === "" || s === "<Null>"))
+      return this._nullResult;
+    if (s == null)
+      return null;
+    const r = s.toString();
+    return (i = this._resultsMap.get(r)) == null ? void 0 : i.meshWriters;
+  }
+  _getValueFromFields(e, t) {
+    const s = [];
+    for (const r of this._fields) {
+      const i = r.read(e, t);
+      i == null || i === "" ? s.push("<Null>") : s.push(i);
+    }
+    return s.join(this._separator);
+  }
+};
+async function Q(u, e, t, s) {
+  switch (t.type) {
+    case "simple":
+    case "heatmap":
+    case "dot-density":
+    case "pie-chart":
+      return L.from(u, e, t, s);
+    case "interval":
+      return Ns.fromIntervalSchema(u, e, t, s);
+    case "dictionary":
+      return Ws.fromDictionaryRenderer(u, t, s);
+    case "label":
+      return Bs.fromLabelSchema(u, e, t, s);
+    case "map":
+      return Vs.fromMatcherSchema(u, e, t, s);
+    case "subtype":
+      return Ys.fromSubtypes(u, e, t, s);
+    case "cluster":
+      return Xs.fromClusterSchema(u, e, t, s);
+    default:
+      throw new Error("Impl");
+  }
+}
+let Ys = class Mt extends L {
+  constructor(e, t) {
+    super(), this._subMatchers = e, this._subtypeField = t;
+  }
+  static async fromSubtypes(e, t, s, r) {
+    const i = /* @__PURE__ */ new Map(), n = [];
+    for (const a in s.renderers) {
+      const o = parseInt(a, 10), h = Q(e, t, s.renderers[a], r).then((c) => i.set(o, c));
+      n.push(h);
+    }
+    return await Promise.all(n), new Mt(i, s.subtypeField);
+  }
+  match(e, t) {
+    const s = e.readAttribute(this._subtypeField), r = this._subMatchers.get(s);
+    return r ? r.match(e, t) : null;
+  }
+}, Xs = class $t extends L {
+  static async fromClusterSchema(e, t, s, r) {
+    const [i, n] = await Promise.all([Q(e, t, s.feature, r), Q(e, t, s.cluster, r)]);
+    return new $t(i, n);
+  }
+  constructor(e, t) {
+    super(), this._featureMatcher = e, this._clusterMatcher = t;
+  }
+  match(e, t) {
+    return e.readAttribute("cluster_count") === 1 ? this._featureMatcher.match(e, t) : this._clusterMatcher.match(e, t);
+  }
+}, Qs = class Ot extends Gs {
+  static async create(e, t, s, r) {
+    const i = await Q(e, t, s.symbology, r), n = s.labels ? await Q(e, t, s.labels, r) : null;
+    return new Ot(i, n);
+  }
+  constructor(e, t) {
+    super(), this._symbology = e, this._labels = t;
+  }
+  destroy() {
+  }
+  async enqueueMatcherRequests(e, t) {
+    var s;
+    await Promise.all([this._symbology.fetchResources(e, t), (s = this._labels) == null ? void 0 : s.fetchResources(e, t)]);
+  }
+  enqueueWriterRequests(e, t, s) {
+    const r = this._symbology.match(t, s);
+    if (r) {
+      for (const i of r)
+        i.enqueueRequest(e, t, s);
+      if (this._labels) {
+        const i = this._labels.match(t, s);
+        if (!i)
+          return;
+        for (const n of i)
+          n.enqueueRequest(e, t, s);
+      }
+    }
+  }
+  write(e, t, s, r, i) {
+    const n = this._symbology.match(s, r);
+    if (n) {
+      for (const a of n)
+        a.write(e, t, s, r, i);
+      if (e.entityRecordCount() >= 1 && this._labels) {
+        const a = this._labels.match(s, r);
+        if (!a)
+          return;
+        for (const o of a)
+          o.setReferences(n), o.write(e, t, s, r, i);
+      }
+    }
+  }
+  getSortKey(e, t) {
+    return this._symbology.getSortKey(e, t);
+  }
+}, Zs = class {
+  constructor(e) {
+    this._outstandingMessages = [], this._queue = new ht({ concurrency: e.concurrency, process: (t) => e.process(t) });
+  }
+  async push(e) {
+    if (e.end)
+      return await Promise.all(this._outstandingMessages), await this._queue.push(e), void (this._outstandingMessages = []);
+    const t = this._queue.push(e);
+    return this._outstandingMessages.push(t), t;
+  }
+}, qt = class ge {
+  static async create(e, t) {
+    var r;
+    if (t.statisticType === "count") {
+      const i = new ls(1);
+      return new ge(t.name, t.alias, t.type, t.statisticType, i);
+    }
+    const s = await e.createComputedField({ expression: (r = t.onStatisticExpression) == null ? void 0 : r.expression, field: t.onStatisticField });
+    return new ge(t.name, t.alias, t.type, t.statisticType, s);
+  }
+  constructor(e, t, s, r, i) {
+    this.name = e, this.alias = t, this.type = s, this.statisticType = r, this.computed = i;
+  }
+}, Ee = class {
+  constructor(e) {
+    this.subscription = e, this.handledChunks = /* @__PURE__ */ new Set();
+  }
+  destroy() {
+  }
+}, At = class {
+  constructor(e, t) {
+    this._source = e, this._attributeStore = t, this._sendStates = /* @__PURE__ */ new Map();
+  }
+  destroy() {
+  }
+  get enablePixelBuffering() {
+    return !0;
+  }
+  onSubscribe(e) {
+    const t = this.createState(e);
+    this._sendStates.set(e.key.id, t), this.updateChunks();
+  }
+  onUnsubscribe(e) {
+    var t;
+    (t = this._sendStates.get(e.key.id)) == null || t.destroy(), this._sendStates.delete(e.key.id);
+  }
+  invalidate() {
+    const e = Array.from(this._sendStates.values());
+    this._sendStates.clear();
+    for (const t of e)
+      t.destroy(), this.onSubscribe(t.subscription);
+  }
+  invalidateAttributeData() {
+  }
+  getFeatureObjectIdsForAggregate(e) {
+    throw new Error("InternalError: AggregateId lookup not supported");
+  }
+  getDisplayIds(e) {
+    return this.displayMap(e, (t) => t, (t) => t);
+  }
+  getDisplayAndObjectIds(e) {
+    return this.displayMap(e, (t) => t, (t, s, r) => [t, r]);
+  }
+  afterUpdateChunks() {
+  }
+}, Rt = class extends At {
+  constructor(e, t, s, r) {
+    super(e, t), this.spatialReference = s, this.aggregateFields = r, this.events = new xe(), this.featureAdapter = qs;
+  }
+  get aggregateQueryEngine() {
+    return this._aggregateQueryEngine || (this._aggregateQueryEngine = new vt({ featureStore: this, fieldsIndex: this._metadata.fieldsIndex, geometryType: this._metadata.geometryType, objectIdField: this._metadata.objectIdField, spatialReference: this.spatialReference })), this._aggregateQueryEngine;
+  }
+  removeChunks(e) {
+  }
+  forEach(e) {
+    return this.forEachAggregateWorldSpace(e);
+  }
+  forEachInBounds(e, t) {
+  }
+  forEachBounds(e, t) {
+    const s = ke();
+    for (const r of e) {
+      const i = Ss(s, r.geometry, !1, !1);
+      i && t(i);
+    }
+  }
+}, Pe = class {
+  constructor(e, t, s, r, i) {
+    this.subscription = e, this.reader = t, this.clear = s, this.end = r, this.debugInfo = i, this.type = "append";
+  }
+  get id() {
+    return this.subscription.tile.id;
+  }
+  createMessage(e, t, s) {
+    return { type: "append", clear: this.clear, id: this.id, append: e, end: this.end, debugInfo: this.debugInfo, subscriptionVesrion: this.subscription.version, version: t, attributeEpoch: s };
+  }
+}, fe = class {
+  constructor(e, t, s, r, i) {
+    this.subscription = e, this.reader = t, this.remove = s, this.end = r, this.debugInfo = i, this.type = "update";
+  }
+  get id() {
+    return this.subscription.tile.id;
+  }
+  createMessage(e, t, s) {
+    return { type: "update", id: this.id, modify: e, debugInfo: this.debugInfo, remove: this.remove, version: t, subscriptionVesrion: this.subscription.version, end: this.end, attributeEpoch: s };
+  }
+}, M = class j extends Ce {
+  static fromFeatures(e, t) {
+    const { objectIdField: s, geometryType: r } = t, i = ws([], e, r, !1, !1, s);
+    for (let n = 0; n < i.length; n++)
+      i[n].displayId = e[n].displayId;
+    return j.fromOptimizedFeatures(i, t);
+  }
+  static fromFeatureSet(e, t) {
+    const s = mt(e, t.objectIdField);
+    return j.fromOptimizedFeatureSet(s, t);
+  }
+  static fromOptimizedFeatureSet(e, t) {
+    const s = j.fromOptimizedFeatures(e.features, t);
+    return s._exceededTransferLimit = e.exceededTransferLimit, s._transform = e.transform, s._fieldsIndex = new St(e.fields), s;
+  }
+  static fromOptimizedFeatures(e, t, s) {
+    const r = new j(e, t);
+    return r._fieldsIndex = t.fieldsIndex, r._transform = s, r;
+  }
+  static empty(e) {
+    return new j([], e);
+  }
+  constructor(e, t) {
+    super(t), this._exceededTransferLimit = !1, this._featureIndex = -1, this._fieldsIndex = null, this._geometryType = t.geometryType, this._features = e;
+  }
+  get fields() {
+    return this._fieldsIndex;
+  }
+  get geometryType() {
+    return this._geometryType;
+  }
+  get hasFeatures() {
+    return !!this._features.length;
+  }
+  get hasNext() {
+    return this._featureIndex + 1 < this._features.length;
+  }
+  get exceededTransferLimit() {
+    return this._exceededTransferLimit;
+  }
+  get hasZ() {
+    return !1;
+  }
+  get hasM() {
+    return !1;
+  }
+  get _current() {
+    return this._features[this._featureIndex];
+  }
+  removeIds(e) {
+    const t = new Set(e);
+    this._features = this._features.filter((s) => !(s.objectId != null && t.has(s.objectId)));
+  }
+  getSize() {
+    return this._features.length;
+  }
+  getCursor() {
+    return this.copy();
+  }
+  getInTransform() {
+    return this._transform;
+  }
+  getAttributeHash() {
+    let e = "";
+    for (const t in this._current.attributes)
+      e += this._current.attributes[t];
+    return e;
+  }
+  getIndex() {
+    return this._featureIndex;
+  }
+  setIndex(e) {
+    this._featureIndex = e;
+  }
+  getObjectId() {
+    var e;
+    return (e = this._current) == null ? void 0 : e.objectId;
+  }
+  getDisplayId() {
+    return this._current.displayId;
+  }
+  setDisplayId(e) {
+    this._current.displayId = e;
+  }
+  copy() {
+    const e = new j(this._features, this.metadata);
+    return this.copyInto(e), e;
+  }
+  next() {
+    for (; ++this._featureIndex < this._features.length && !this._getExists(); )
+      ;
+    return this._featureIndex < this._features.length;
+  }
+  readGeometryArea() {
+    return H(this._current) ? xs(this._current.geometry, 2) : 0;
+  }
+  _readX() {
+    return H(this._current) ? this._current.geometry.coords[0] : 0;
+  }
+  _readY() {
+    return H(this._current) ? this._current.geometry.coords[1] : 0;
+  }
+  _readGeometry() {
+    return H(this._current) ? this._current.geometry ?? null : null;
+  }
+  _readServerCentroid() {
+    return this._current.centroid;
+  }
+  _readAttribute(e, t) {
+    var i;
+    if (!this._fieldsIndex) {
+      const n = this._current.attributes[e];
+      if (n !== void 0)
+        return n;
+      const a = e.toLowerCase();
+      for (const o in this._current.attributes)
+        if (o.toLowerCase() === a)
+          return this._current.attributes[o];
+      return;
+    }
+    const s = this._fieldsIndex.get(e);
+    if (!s)
+      return;
+    let r = this._current.attributes[s.name];
+    return r == null ? r : (((i = this.fields.get(e)) == null ? void 0 : i.type) === "esriFieldTypeTimestampOffset" && (r = this.parseTimestampOffset(r)), t && this.fields.isDateField(e) ? new Date(r) : r);
+  }
+  _readAttributes() {
+    return this._current.attributes;
+  }
+  copyInto(e) {
+    super.copyInto(e), e._featureIndex = this._featureIndex, e._transform = this._transform, e._fieldsIndex = this._fieldsIndex;
+  }
+}, Hs = class extends Ee {
+  constructor(e, t) {
+    super(e), this.bins = /* @__PURE__ */ new Map(), this.done = !1, this._store = t;
+  }
+  reset() {
+    this.destroy(), this.bins.clear(), this.done = !1, this.handledChunks.clear();
+  }
+  destroy() {
+    var t;
+    const e = this.subscription.tile.key.level;
+    for (const s of this.bins.values()) {
+      const r = (t = s.cachedFeature) == null ? void 0 : t.objectId;
+      r != null && this._store.releaseDisplayIdForObjectId(`${r}.${e}`);
+    }
+  }
+  *featuresWorldSpace() {
+    for (const e of this.bins.values()) {
+      const t = e.cachedFeature;
+      if (t) {
+        const s = t.clone();
+        s.geometry && ks(s.geometry, s.geometry, !1, !1, this.subscription.tile.transform), yield s;
+      }
+    }
+  }
+  getGeohashBounds(e, t) {
+    const s = this.subscription.tile;
+    return bs(s.extent, s.resolution, t, e);
+  }
+}, Js = class Et extends Rt {
+  static async create(e, t, s, r, i) {
+    const n = new Me({ spatialReference: t }), a = e.fixedBinLevel, o = await Promise.all(e.fields.map(async (c) => qt.create(n, c))), h = e.featureFilter ? await yt.create({ geometryType: s.metadata.geometryType, hasM: !1, hasZ: !1, timeInfo: s.metadata.timeInfo, fieldsIndex: s.metadata.fieldsIndex, spatialReference: t, filterJSON: e.featureFilter }) : null;
+    return await Os(t, V.WGS84), new Et({ fields: o, geohashLevel: a, spatialReference: t, featureFilter: h, timeZone: i }, e.fields, s, r);
+  }
+  constructor(e, t, s, r) {
+    super(s, r, e.spatialReference, e.fields), this._indexOptions = e, this._metadata = new $e({ geometryType: "esriGeometryPolygon", objectIdField: "aggregateId", fields: t, globalIdField: null, spatialReference: s.metadata.spatialReference, subtypeField: null, subtypes: null, timeInfo: null, timeReferenceUnknownClient: null, typeIdField: null, types: null });
+  }
+  createState(e) {
+    return new Hs(e, this._attributeStore);
+  }
+  async *applyOverride(e) {
+    for (const t of this._sendStates.values())
+      t.reset(), yield new Pe(t.subscription, M.empty(this._source.metadata), !0, !1, {});
+  }
+  displayMap(e, t, s) {
+    const r = new Map(e.map((n) => [t(n), n])), i = [];
+    for (const n of this._sendStates.values())
+      for (const a of n.featuresWorldSpace()) {
+        const { objectId: o, displayId: h } = a, c = r.get(o);
+        if (c != null) {
+          const d = s(h, c, o);
+          i.push(d), r.delete(o);
+        }
+      }
+    return i;
+  }
+  getDisplayFeatures(e) {
+    const t = new Set(e), s = /* @__PURE__ */ new Set(), r = [];
+    for (const i of this._sendStates.values())
+      for (const n of i.featuresWorldSpace())
+        t.has(n.displayId) && !s.has(n.objectId) && (n.geometry && r.push({ ...bt(n, this._metadata.geometryType, !1, !1), displayId: n.displayId }), s.add(n.objectId));
+    return { features: [], aggregates: r };
+  }
+  getFeatureObjectIdsForAggregate(e) {
+    for (const t of this._sendStates.values())
+      for (const s of t.bins.values())
+        if (s.id === e)
+          return Array.from(s.objectIds);
+    return [];
+  }
+  async *updateChunks() {
+    if (this._source.chunks().length)
+      for (const e of this._sendStates.values())
+        yield* this._update(e, this._source);
+  }
+  forEachAggregateWorldSpace(e) {
+    for (const t of this._sendStates.values())
+      for (const s of t.featuresWorldSpace())
+        e(s);
+  }
+  async *_update(e, t) {
+    const { handledChunks: s, subscription: r, bins: i } = e, { spatialReference: n, geohashLevel: a } = this._indexOptions, o = r.tile;
+    if (e.done)
+      return;
+    for (const p of t.chunks()) {
+      if (s.has(p.chunkId))
+        continue;
+      s.add(p.chunkId);
+      const I = p.queryInfo;
+      if ("tileId" in I) {
+        const b = new we(I.tileId);
+        if (b.level !== o.level || b.world !== o.key.world)
+          continue;
+      }
+      const f = p.getGeohashIndex(this._indexOptions), k = e.getGeohashBounds(n, a);
+      k != null && f.putBins(i, k);
+    }
+    const h = [], c = r.tile.transform, d = r.tile.key.level;
+    for (const p of i.values()) {
+      if (p.cachedFeature)
+        p.cachedFeature.attributes = p.getAttributes();
+      else {
+        const I = p.getGeometry(this.spatialReference, c), f = new B(I, p.getAttributes(), null);
+        I || (f.centroid = p.getGeometryCentroid(this.spatialReference, c)), f.objectId = p.id, f.displayId = this._attributeStore.createDisplayIdForObjectId(`${f.objectId}.${d}`), p.cachedFeature = f;
+      }
+      h.push(p.cachedFeature);
+    }
+    this.events.emit("changed"), e.done = !t.updateTracking.updating;
+    const l = M.fromOptimizedFeatures(h, this._metadata, c), g = l.getCursor(), _ = e.subscription.tile.createArcadeEvaluationOptions(this._indexOptions.timeZone);
+    for (; g.next(); )
+      this._attributeStore.setAttributeData(g.getDisplayId(), g, _);
+    yield new fe(e.subscription, l, [], e.done, {});
+  }
+};
+const He = Math.PI / 180;
+let Pt = class ye {
+  static create(e) {
+    return new ye(e.map((t) => Ks(t)));
+  }
+  constructor(e) {
+    this._statistics = e;
+  }
+  values() {
+    return this._statistics.values();
+  }
+  insert(e, t) {
+    for (const s of this._statistics)
+      s.insert(e, t);
+  }
+  merge(e) {
+    for (let t = 0; t < this._statistics.length; t++) {
+      const s = this._statistics[t], r = e._statistics[t];
+      if (s.field.name !== r.field.name)
+        throw new Error("InternalError: Tried to merge incompatible statistics");
+      s.merge(r);
+    }
+  }
+  clone() {
+    return new ye(this._statistics.map((e) => e.clone()));
+  }
+};
+function Ks(u) {
+  switch (u.statisticType) {
+    case "min":
+      return new er(u);
+    case "max":
+      return new tr(u);
+    case "avg":
+      return new rr(u);
+    case "avg_angle":
+      return new ir(u);
+    case "sum":
+    case "count":
+      return new sr(u);
+    case "mode":
+      return new nr(u);
+  }
+}
+let W = class {
+  constructor(e) {
+    this.field = e;
+  }
+  insert(e, t) {
+    if (!this.field.computed)
+      return;
+    const s = this.field.computed.read(e, t);
+    _s(s) || this._insertValue(s);
+  }
+}, er = class jt extends W {
+  constructor() {
+    super(...arguments), this.type = "min", this.value = Number.MAX_VALUE;
+  }
+  _insertValue(e) {
+    this.value = Math.min(this.value, e);
+  }
+  merge(e) {
+    this.value = Math.min(this.value, e.value);
+  }
+  clone() {
+    const e = new jt(this.field);
+    return e.value = this.value, e;
+  }
+}, tr = class Dt extends W {
+  constructor() {
+    super(...arguments), this.type = "max", this.value = Number.MIN_VALUE;
+  }
+  _insertValue(e) {
+    this.value = Math.max(this.value, e);
+  }
+  merge(e) {
+    this.value = Math.max(this.value, e.value);
+  }
+  clone() {
+    const e = new Dt(this.field);
+    return e.value = this.value, e;
+  }
+}, sr = class Lt extends W {
+  constructor() {
+    super(...arguments), this.type = "sum", this.value = 0;
+  }
+  _insertValue(e) {
+    this.value += e;
+  }
+  merge(e) {
+    this.value += e.value;
+  }
+  clone() {
+    const e = new Lt(this.field);
+    return e.value = this.value, e;
+  }
+}, rr = class zt extends W {
+  constructor() {
+    super(...arguments), this.type = "avg", this._total = 0, this._count = 0;
+  }
+  get value() {
+    return this._total / this._count;
+  }
+  _insertValue(e) {
+    this._total += e, this._count += 1;
+  }
+  merge(e) {
+    this._total += e._total, this._count += e._count;
+  }
+  clone() {
+    const e = new zt(this.field);
+    return e._total = this._total, e._count = this._count, e;
+  }
+}, ir = class Ut extends W {
+  constructor() {
+    super(...arguments), this.type = "avg_angle", this._x = 0, this._y = 0, this._count = 0;
+  }
+  get value() {
+    const e = this._x / this._count, t = this._y / this._count, s = 180 / Math.PI;
+    return Math.atan2(t, e) * s;
+  }
+  _insertValue(e) {
+    this._x = this._x + Math.cos(e * He), this._y = this._y + Math.sin(e * He), this._count += 1;
+  }
+  merge(e) {
+    this._x += e._x, this._y += e._y, this._count += e._count;
+  }
+  clone() {
+    const e = new Ut(this.field);
+    return e._x = this._x, e._y = this._y, e._count = this._count, e;
+  }
+}, nr = class Gt extends W {
+  constructor() {
+    super(...arguments), this._frequencies = /* @__PURE__ */ new Map();
+  }
+  get value() {
+    let e, t = 0;
+    for (const [s, r] of this._frequencies.entries())
+      r > t && (t = r, e = s);
+    return e;
+  }
+  _insertValue(e) {
+    const t = this._frequencies.get(e);
+    t != null ? this._frequencies.set(e, t + 1) : this._frequencies.set(e, 1);
+  }
+  merge(e) {
+    for (const [t, s] of e._frequencies.entries()) {
+      const r = this._frequencies.get(t);
+      r != null ? this._frequencies.set(t, r + s) : this._frequencies.set(t, s);
+    }
+  }
+  clone() {
+    const e = new Gt(this.field);
+    return e._frequencies = new Map(this._frequencies), e;
+  }
+}, me = class ee {
+  static createId(e, t) {
+    return `${e}.${t}`;
+  }
+  static create(e, t, s, r) {
+    return new ee(e, t, Pt.create(s), r);
+  }
+  constructor(e, t, s, r) {
+    this.gridX = e, this.gridY = t, this._statistics = s, this._worldUnitsPerCell = r, this._count = 0, this._xWorldTotal = 0, this._yWorldTotal = 0, this._objectIds = /* @__PURE__ */ new Set();
+  }
+  get id() {
+    return ee.createId(this.gridX, this.gridY);
+  }
+  get count() {
+    return this._count;
+  }
+  get statistics() {
+    return this._statistics;
+  }
+  get objectIds() {
+    return this._objectIds;
+  }
+  get firstObjectId() {
+    return this._objectIds.values().next().value;
+  }
+  get centroidXWorld() {
+    return this._xWorldTotal / this._count;
+  }
+  get centroidYWorld() {
+    return this._yWorldTotal / this._count;
+  }
+  clone() {
+    const e = new ee(this.gridX, this.gridY, this._statistics.clone(), this._worldUnitsPerCell);
+    return e._count = this._count, e._xWorldTotal = this._xWorldTotal, e._yWorldTotal = this._yWorldTotal, e._firstFeatureAttributes = this._firstFeatureAttributes, e._objectIds = new Set(this._objectIds), e;
+  }
+  insert(e, t, s, r) {
+    this._count === 0 ? this._firstFeatureAttributes = e.readAttributes() : this._firstFeatureAttributes = null, this._count += 1, this._xWorldTotal += s, this._yWorldTotal += r, this._statistics.insert(e, t), this._objectIds.add(e.getObjectId());
+  }
+  merge(e) {
+    if (e._count !== 0) {
+      this._count += e._count, this._firstFeatureAttributes = e._firstFeatureAttributes, this._xWorldTotal += e._xWorldTotal, this._yWorldTotal += e._yWorldTotal, this._statistics.merge(e._statistics);
+      for (const t of e._objectIds.values())
+        this._objectIds.add(t);
+    }
+  }
+  getCentroidX(e) {
+    return e == null ? this.centroidXWorld : Fs(e, this.centroidXWorld);
+  }
+  getCentroidY(e) {
+    return e == null ? this.centroidYWorld : Ts(e, this.centroidYWorld);
+  }
+  getCentroid(e) {
+    const t = new T([], [this.centroidXWorld, this.centroidYWorld]);
+    if (e != null) {
+      const s = new T();
+      return X(s, t, !1, !1, "esriGeometryPoint", e);
+    }
+    return t;
+  }
+  getGeometricCentroid(e) {
+    const t = this.gridX * this._worldUnitsPerCell + 0.5 * this._worldUnitsPerCell, s = this.gridY * this._worldUnitsPerCell + 0.5 * this._worldUnitsPerCell, r = new T([], [t, s]);
+    if (e != null) {
+      const i = new T();
+      return X(i, r, !1, !1, "esriGeometryPoint", e);
+    }
+    return r;
+  }
+  getAttributes() {
+    const e = { aggregateId: this.id };
+    for (const t of this._statistics.values())
+      e[t.field.name] = t.value;
+    return this._firstFeatureAttributes != null ? { ...e, ...this._firstFeatureAttributes } : e;
+  }
+};
+const ar = 96;
+function be(u, e) {
+  return Ht(u) * Jt * ar / e;
+}
+let or = class {
+  constructor(e) {
+    this._options = e, this._cells = /* @__PURE__ */ new Map(), this._pixelsPerMapUnit = be(e.spatialReference, e.scale);
+  }
+  insert(e, t) {
+    const s = e.getCursor(), r = { $view: { scale: this._options.scale, timeZone: this._options.timeZone } };
+    for (; s.next(); )
+      this._insertFeature(s, r, t);
+  }
+  putCellsInBounds(e, t) {
+    const [s, r, i, n] = t, a = Math.floor(s * this._pixelsPerMapUnit / this._options.cellSize), o = Math.floor(r * this._pixelsPerMapUnit / this._options.cellSize), h = Math.ceil(i * this._pixelsPerMapUnit / this._options.cellSize), c = Math.ceil(n * this._pixelsPerMapUnit / this._options.cellSize);
+    for (let d = o; d <= c; d++)
+      for (let l = a; l <= h; l++) {
+        const g = `${l}.${d}`, _ = this._cells.get(g);
+        if (!_)
+          continue;
+        const m = e.get(_.id);
+        m ? _ && !e.has(_.id) && m.merge(_) : e.set(_.id, _.clone());
+      }
+  }
+  putCells(e) {
+    for (const t of this._cells.values()) {
+      const s = e.get(t.id);
+      s ? s.merge(t) : e.set(t.id, t.clone());
+    }
+  }
+  _insertFeature(e, t, s) {
+    const { featureFilter: r } = this._options;
+    if (r !== null && !r.check(e))
+      return;
+    let i = 0, n = 0;
+    if (e.geometryType === "esriGeometryPoint")
+      i = e.readXWorldSpace(), n = e.readYWorldSpace();
+    else {
+      if (s) {
+        const l = e.readCentroidForDisplay();
+        if (l == null)
+          return;
+        const [g, _] = l.coords;
+        if (g < 0 || g > x || _ < 0 || _ > x)
+          return;
+      }
+      const d = e.readCentroidWorldSpace();
+      if (d == null)
+        return;
+      i = d.coords[0], n = d.coords[1];
+    }
+    const a = i * this._pixelsPerMapUnit, o = n * this._pixelsPerMapUnit, h = Math.floor(a / this._options.cellSize), c = Math.floor(o / this._options.cellSize);
+    this._getCellOrCreate(h, c).insert(e, t, i, n);
+  }
+  _getCellOrCreate(e, t) {
+    const s = me.createId(e, t);
+    let r = this._cells.get(s);
+    if (!r) {
+      const i = 1 * this._options.cellSize / this._pixelsPerMapUnit;
+      r = me.create(e, t, this._options.fields, i), this._cells.set(s, r);
+    }
+    return r;
+  }
+}, hr = class {
+  constructor(e, t) {
+    this.inner = e, this.displayId = t;
+  }
+};
+const J = 128;
+let ur = class extends Ee {
+  constructor(e) {
+    super(e), this.didSend = !1, this.done = !1;
+  }
+}, dr = class {
+  constructor(e, t, s, r, i) {
+    this._level = e, this._scale = t, this._indexOptions = s, this._clusterRadius = r, this._store = i, this._cells = /* @__PURE__ */ new Map(), this._handledChunks = /* @__PURE__ */ new Set(), this._statistics = /* @__PURE__ */ new Map(), this._clusters = /* @__PURE__ */ new Map();
+  }
+  destroy() {
+    this._clearClusters();
+  }
+  _clearClusters() {
+    for (const e of this._clusters.values())
+      this._store.releaseDisplayIdForObjectId(e.inner.id);
+    this._clusters.clear();
+  }
+  *aggregatesWorldSpace() {
+    for (const e of this._clusters.values()) {
+      const t = e.inner.getCentroid(null), s = new B(t, e.inner.getAttributes(), null);
+      s.objectId = e.inner.id, s.displayId = e.displayId, yield s;
+    }
+  }
+  clusters() {
+    return this._clusters.values();
+  }
+  updateChunks(e, t) {
+    let s = !1;
+    for (const a of e) {
+      const o = a.queryInfo;
+      "tileId" in o && new we(o.tileId).level !== this._level || this._handledChunks.has(a.normalizedChunkId) || (this._handledChunks.add(a.normalizedChunkId), s = !0, a.getGridIndex({ ...this._indexOptions, scale: this._scale }).putCells(this._cells));
+    }
+    const r = { xMin: 1 / 0, yMin: 1 / 0, xMax: -1 / 0, yMax: -1 / 0 }, i = be(this._indexOptions.spatialReference, this._scale), n = this._indexOptions.cellSize;
+    for (const { subscription: a } of t) {
+      const o = a.tile.bounds, h = Math.floor(o[0] * i / n), c = Math.floor(o[1] * i / n), d = Math.ceil(o[2] * i / n), l = Math.ceil(o[3] * i / n);
+      r.xMin = Math.min(r.xMin, h), r.yMin = Math.min(r.yMin, c), r.xMax = Math.max(r.xMax, d), r.yMax = Math.max(r.yMax, l);
+    }
+    return this._lastCellBounds != null && r.xMin === this._lastCellBounds.xMin && r.yMin === this._lastCellBounds.yMin && r.yMin === this._lastCellBounds.yMin && r.yMax === this._lastCellBounds.yMax || (s = !0, this._lastCellBounds = r), s && this._clusterCells(r), s;
+  }
+  async updateStatistics(e) {
+    let t = !1;
+    for (const s of this._clusters.values())
+      s.inner.count > 1 && (t = this._updateAggregateStatistics(this._statistics, s.inner) || t);
+    if (t) {
+      const s = Array.from(this._statistics.entries()).map(([r, i]) => ({ fieldName: r, minValue: i.minValue, maxValue: i.maxValue }));
+      await e.container.updateStatistics(this._level, s);
+    }
+  }
+  createAggregateFeatures(e, t) {
+    const s = e.subscription, r = [], i = s.tile.transform;
+    for (const n of this._clusters.values()) {
+      let a = n.inner.getCentroidX(i);
+      const o = n.inner.getCentroidY(i), h = s.tile.lod, c = h.wrap ? h.worldSize[0] : null, d = n.inner.count === 1 ? n.inner.firstObjectId : n.inner.id, l = n.displayId;
+      if (c != null)
+        if (c === 1) {
+          const g = new T([], [a, o]), _ = new B(g, n.inner.getAttributes(), null);
+          _.geometry.coords[0] -= x, _.objectId = d, _.displayId = l, r.push(_);
+          const m = new T([], [a, o]), p = new B(m, n.inner.getAttributes(), null);
+          p.geometry.coords[0] += x, p.objectId = d, p.displayId = l, r.push(p);
+        } else
+          a > x + x / 2 ? a -= c * x : a < -x / 2 && (a += c * x);
+      if (a < x + J && a >= -J && o < x + J && o >= -J) {
+        const g = new T([], [a, o]), _ = new B(g, n.inner.getAttributes(), null);
+        _.objectId = d, _.displayId = l, r.push(_);
+      }
+    }
+    return M.fromOptimizedFeatures(r, t, s.tile.transform);
+  }
+  _clusterCells(e) {
+    let t = Array.from(this._cells.values());
+    t = t.sort((a, o) => o.count - a.count);
+    const s = [];
+    for (const a of this._clusters.values())
+      s.push(a.inner.id);
+    this._clusters.clear();
+    const r = this._clusterRadius * (1 / be(this._indexOptions.spatialReference, this._scale)), i = 1 + this._clusterRadius / this._indexOptions.cellSize, n = /* @__PURE__ */ new Set();
+    for (const a of t) {
+      if (n.has(a.id) || a.gridX < e.xMin || a.gridX > e.xMax || a.gridY < e.yMin || a.gridY > e.yMax)
+        continue;
+      const o = this._store.createDisplayIdForObjectId(a.id), h = new hr(a.clone(), o);
+      n.add(a.id), this._clusters.set(a.id, h);
+      const c = a.centroidXWorld, d = a.centroidYWorld;
+      for (let l = a.gridY - i; l <= a.gridY + i; l++)
+        for (let g = a.gridX - i; g <= a.gridX + i; g++) {
+          if (l === a.gridY && g === a.gridX)
+            continue;
+          const _ = this._cells.get(me.createId(g, l));
+          if (!_ || n.has(_.id))
+            continue;
+          const m = Math.abs(_.centroidXWorld - c), p = Math.abs(_.centroidYWorld - d);
+          m < r && p < r && (h.inner.merge(_), n.add(_.id));
+        }
+    }
+    for (const a of s)
+      this._store.releaseDisplayIdForObjectId(a);
+  }
+  _updateAggregateStatistics(e, t) {
+    let s = !1;
+    for (const r of t.statistics.values()) {
+      if (r.field.type === "esriFieldTypeString")
+        continue;
+      const i = r.value, n = r.field, a = e.get(n.name);
+      if (a) {
+        const { minValue: o, maxValue: h } = a, c = Math.min(a.minValue, i), d = Math.max(a.maxValue, i);
+        o === c && h === d || (a.minValue = c, a.maxValue = d, s = !0);
+      } else
+        e.set(n.name, { minValue: i, maxValue: i }), s = !0;
+    }
+    return s;
+  }
+};
+class je extends Rt {
+  static async create(e, t, s, r, i, n) {
+    const a = new Me({ spatialReference: s }), o = { fields: await Promise.all(t.fields.map(async (h) => qt.create(a, h))), spatialReference: s, featureFilter: t.featureFilter ? await yt.create({ geometryType: r.metadata.geometryType, hasM: !1, hasZ: !1, timeInfo: r.metadata.timeInfo, fieldsIndex: r.metadata.fieldsIndex, spatialReference: s, filterJSON: t.featureFilter }) : null, cellSize: t.clusterRadius / 4, timeZone: n };
+    return new je(e, t.clusterRadius, o, t.fields, r, i);
+  }
+  constructor(e, t, s, r, i, n) {
+    super(i, n, s.spatialReference, s.fields), this._connection = e, this._clusterRadius = t, this._indexOptions = s, this._cellsPerScale = /* @__PURE__ */ new Map(), this._metadata = new $e({ geometryType: "esriGeometryPoint", objectIdField: "aggregateId", fields: [...r, ...this._source.metadata.fieldsIndex.fields, { name: "aggregateId", alias: "aggregateId", type: "esriFieldTypeOID" }], globalIdField: null, spatialReference: i.metadata.spatialReference, subtypeField: null, subtypes: null, timeInfo: null, timeReferenceUnknownClient: null, typeIdField: null, types: null });
+  }
+  get enablePixelBuffering() {
+    return !1;
+  }
+  invalidate() {
+    super.invalidate();
+    for (const e of this._cellsPerScale.values())
+      e.destroy();
+    this._cellsPerScale.clear();
+  }
+  onSubscribe(e) {
+    super.onSubscribe(e), this._requiredLevel = e.tile.level, this._requiredScale = e.tile.scale;
+  }
+  createState(e) {
+    return new ur(e);
+  }
+  async *applyOverride(e) {
+    for (const t of this._cellsPerScale.values())
+      t.destroy();
+    this._cellsPerScale.clear();
+    for (const t of this._sendStates.values())
+      t.done = !1;
+  }
+  displayMap(e, t, s) {
+    const r = new Map(e.map((a) => [t(a), a])), i = [], n = this._getClusterState(this._requiredLevel, this._requiredScale);
+    for (const a of n.clusters()) {
+      const o = r.get(a.inner.id);
+      if (o == null) {
+        if (a.inner.count === 1) {
+          const h = r.get(a.inner.firstObjectId);
+          if (h != null) {
+            const c = s(a.displayId, h, a.inner.firstObjectId);
+            i.push(c), r.delete(a.inner.firstObjectId);
+          }
+        }
+      } else {
+        const h = s(a.displayId, o, a.inner.id);
+        i.push(h), r.delete(a.inner.id);
+      }
+    }
+    return i;
+  }
+  getDisplayFeatures(e) {
+    const t = new Set(e), s = /* @__PURE__ */ new Set(), r = [], i = [], n = this._getClusterState(this._requiredLevel, this._requiredScale);
+    for (const a of n.aggregatesWorldSpace())
+      if (t.has(a.displayId) && !s.has(a.displayId)) {
+        const o = bt(a, this._metadata.geometryType, !1, !1);
+        if (s.add(a.displayId), o.attributes.cluster_count === 1) {
+          r.push({ ...o, displayId: a.displayId });
+          continue;
+        }
+        i.push({ ...o, displayId: a.displayId });
+      }
+    return { features: r, aggregates: i };
+  }
+  getFeatureObjectIdsForAggregate(e) {
+    const t = this._getClusterState(this._requiredLevel, this._requiredScale);
+    for (const s of t.clusters())
+      if (s.inner.id === e)
+        return Array.from(s.inner.objectIds);
+    return [];
+  }
+  async *updateChunks() {
+    const e = this._source.chunks();
+    if (!e.length)
+      return;
+    const t = this._getClusterState(this._requiredLevel, this._requiredScale), s = Array.from(this._sendStates.values()).filter((n) => n.subscription.tile.level === this._requiredLevel);
+    if (t.updateChunks(e, s) || !this._source.updateTracking.updating)
+      for (const n of s)
+        n.subscription.tile.level === this._requiredLevel && (n.didSend = !1, n.done = !1);
+    const r = Array.from(this._sendStates.values()).filter((n) => n.done).map((n) => n.subscription.tile.key), i = new Set(r);
+    for (const n of this._sendStates.values())
+      this._source.updateTracking.updating && (r.some((a) => a.containsChild(n.subscription.tile.key)) || n.subscription.tile.key.getChildKeys().every((a) => i.has(a))) || n.didSend || n.subscription.tile.level !== this._requiredLevel || (n.didSend = !0, yield* this._update(n, t, this._source));
+    await t.updateStatistics(this._connection);
+  }
+  forEachAggregateWorldSpace(e) {
+    if (this._requiredLevel == null || this._requiredScale == null)
+      return;
+    const t = this._getClusterState(this._requiredLevel, this._requiredScale);
+    for (const s of t.aggregatesWorldSpace())
+      e(s);
+  }
+  _getClusterState(e, t) {
+    if (e == null || t == null)
+      throw new Error("InternalError: Level and scale must be defined");
+    let s = this._cellsPerScale.get(t);
+    return s || (s = new dr(e, t, this._indexOptions, this._clusterRadius, this._attributeStore), this._cellsPerScale.set(t, s)), s;
+  }
+  async *_update(e, t, s) {
+    if (e.done)
+      return;
+    const r = t.createAggregateFeatures(e, this._metadata);
+    this.events.emit("changed"), e.done = !s.updateTracking.updating;
+    const i = r.getCursor(), n = e.subscription.tile.createArcadeEvaluationOptions(this._indexOptions.timeZone);
+    for (; i.next(); )
+      this._attributeStore.setAttributeData(i.getDisplayId(), i, n);
+    yield new Pe(e.subscription, r, !0, e.done, {});
+  }
+}
+let cr = class Wt {
+  static fromReader(e) {
+    const t = [], s = e.copy(), r = ke();
+    for (; s.next(); )
+      s.getBounds(r) && t.push(s.getIndex());
+    const i = Kt(9, (n) => (s.setIndex(n), { minX: s.getBoundsXMin(), minY: s.getBoundsYMin(), maxX: s.getBoundsXMax(), maxY: s.getBoundsYMax() }));
+    return i.load(t), new Wt(i);
+  }
+  constructor(e) {
+    this._index = e;
+  }
+  search(e) {
+    const t = { minX: e[0], minY: e[1], maxX: e[2], maxY: e[3] };
+    return this._index.search(t);
+  }
+}, Je = class Ie {
+  static create(e, t, s, r) {
+    const i = Pt.create(e), n = new Array(32);
+    for (let a = 0; a < n.length; a++)
+      n[a] = null;
+    return new Ie(i, t, s, r, n);
+  }
+  constructor(e, t, s, r, i) {
+    this._statistics = e, this.xNode = t, this.yNode = s, this.depth = r, this.children = i, this._objectIds = /* @__PURE__ */ new Set(), this._count = 0, this._xWorldTotal = 0, this._yWorldTotal = 0, this._xGeohashTotal = 0, this._yGeohashTotal = 0, this.next = null;
+  }
+  get id() {
+    return `${this.xNode}.${this.yNode}`;
+  }
+  get objectIds() {
+    return this._objectIds;
+  }
+  clone() {
+    const e = new Ie(this._statistics.clone(), this.xNode, this.yNode, this.depth, this.children);
+    return e._count = this._count, e._xWorldTotal = this._xWorldTotal, e._yWorldTotal = this._yWorldTotal, e._xGeohashTotal = this._xGeohashTotal, e._yGeohashTotal = this._yGeohashTotal, e.next = this.next, e.cachedFeature = this.cachedFeature, e._objectIds = new Set(this._objectIds), e;
+  }
+  insert(e, t, s, r, i, n) {
+    this._count += 1, this._xWorldTotal += t, this._yWorldTotal += s, this._xGeohashTotal += r, this._yGeohashTotal += i, this._statistics.insert(e, n), this._objectIds.add(e.getObjectId());
+  }
+  merge(e) {
+    if (e._count !== 0) {
+      this._count += e._count, this._xWorldTotal += e._xWorldTotal, this._yWorldTotal += e._yWorldTotal, this._xGeohashTotal += e._xWorldTotal, this._yGeohashTotal += e._yWorldTotal, this._statistics.merge(e._statistics);
+      for (const t of e._objectIds.values())
+        this._objectIds.add(t);
+    }
+  }
+  getGeometry(e, t) {
+    const s = this._getLngLatBounds(), [r, i, n, a] = s, o = We({ rings: [[[r, i], [r, a], [n, a], [n, i], [r, i]]] }, V.WGS84, e), h = Cs(new T(), o, !1, !1);
+    return t != null ? X(new T(), h, !1, !1, "esriGeometryPolygon", t, !1, !1) : h;
+  }
+  getGeometryCentroid(e, t) {
+    const s = this._getLngLatBounds(), [r, i, n, a] = s, o = We({ x: (r + n) / 2, y: (i + a) / 2 }, V.WGS84, e), h = Ms(new T(), o);
+    return t != null ? X(new T(), h, !1, !1, "esriGeometryPoint", t, !1, !1) : h;
+  }
+  getAttributes() {
+    const e = { aggregateId: this.id };
+    for (const t of this._statistics.values())
+      e[t.field.name] = t.value;
+    return e.aggregateCount = this._count, e;
+  }
+  _getLngLatBounds() {
+    const e = this.depth, t = Math.ceil(e / 2), s = Math.floor(e / 2), r = 30 - (3 * t + 2 * s), i = 30 - (2 * t + 3 * s), n = this.xNode << r, a = this.yNode << i;
+    return Is({ geohashX: n, geohashY: a }, this.depth);
+  }
+}, lr = class {
+  constructor(e) {
+    this._fields = e, this._root = Je.create(this._fields, 0, 0, 0);
+  }
+  destroy() {
+  }
+  insert(e, t, s, r, i, n, a) {
+    let o = this._root, h = 0, c = 0, d = 0;
+    for (; o !== null; ) {
+      if (o.insert(e, t, s, r, i, a), h >= n)
+        return;
+      const l = Math.ceil((h + 1) / 2), g = Math.floor((h + 1) / 2), _ = 1 - h % 2, m = 30 - (3 * l + 2 * g), p = 30 - (2 * l + 3 * g), I = (r & 7 * _ + 3 * (1 - _) << m) >> m, f = (i & 3 * _ + 7 * (1 - _) << p) >> p, k = I + f * (8 * _ + 4 * (1 - _));
+      c = c << 3 * _ + 2 * (1 - _) | I, d = d << 2 * _ + 3 * (1 - _) | f, o.children[k] == null && (o.children[k] = Je.create(this._fields, c, d, h + 1)), h += 1, o = o.children[k];
+    }
+  }
+  putBins(e, t) {
+    for (const s of this.getNodes(t)) {
+      const r = e.get(s.id);
+      r ? r.merge(s) : e.set(s.id, s.clone());
+    }
+  }
+  getNodes(e) {
+    const t = [], { geohashBounds: s, level: r } = e;
+    let i = this._root;
+    for (; i !== null; ) {
+      const n = i.depth, a = i.xNode, o = i.yNode;
+      if (n >= r) {
+        t.push(i), i = i.next;
+        continue;
+      }
+      const h = Math.ceil((n + 1) / 2), c = Math.floor((n + 1) / 2), d = 1 - n % 2, l = 30 - (3 * h + 2 * c), g = 30 - (2 * h + 3 * c), _ = ~((1 << l) - 1), m = ~((1 << g) - 1), p = (s.xLL & _) >> l, I = (s.yLL & m) >> g, f = (s.xTR & _) >> l, k = (s.yTR & m) >> g, b = a << 3 * d + 2 * (1 - d), v = o << 2 * d + 3 * (1 - d), S = b + 8 * d + 4 * (1 - d), w = v + 4 * d + 8 * (1 - d), $ = Math.max(b, p), F = Math.max(v, I), O = Math.min(S, f), R = Math.min(w, k);
+      let C = null, q = null;
+      for (let E = F; E <= R; E++)
+        for (let P = $; P <= O; P++) {
+          const Zt = P - b + (E - v) * (8 * d + 4 * (1 - d)), N = i.children[Zt];
+          N && (C || (C = N, C.next = i.next), q && (q.next = N), q = N, N.next = i.next);
+        }
+      i = C || i.next;
+    }
+    return t;
+  }
+}, _r = class {
+  constructor(e) {
+    this._options = e, this._tree = new lr(e.fields);
+  }
+  insert(e, t) {
+    const s = e.getCursor(), r = { $view: { scale: 0, timeZone: this._options.timeZone } };
+    for (; s.next(); )
+      this._insertFeature(s, r, t);
+  }
+  putBins(e, t) {
+    this._tree.putBins(e, t);
+  }
+  _insertFeature(e, t, s) {
+    const { featureFilter: r, geohashLevel: i, spatialReference: n } = this._options;
+    if (r !== null && !r.check(e))
+      return;
+    let a = 0, o = 0;
+    if (e.geometryType === "esriGeometryPoint")
+      a = e.readXWorldSpace(), o = e.readYWorldSpace();
+    else {
+      if (s) {
+        const d = e.readCentroidForDisplay();
+        if (d == null)
+          return;
+        const [l, g] = d.coords;
+        if (l < 0 || l > x || g < 0 || g > x)
+          return;
+      }
+      const c = e.readCentroidWorldSpace();
+      if (c == null)
+        return;
+      a = c.coords[0], o = c.coords[1];
+    }
+    const h = vs(a, o, i, n);
+    h && this._tree.insert(e, a, o, h[0], h[1], i, t);
+  }
+}, pr = class ve extends Ce {
+  static from(e, t) {
+    return new ve(e.copy(), t);
+  }
+  constructor(e, t) {
+    super(e.metadata), this._currentIndex = -1, this._displayTranslationX = 0, this._displayTranslationY = 0, this._displayScaleX = 1, this._displayScaleY = 1, this._reader = e, this._indices = t, this._isPoint = e.geometryType === "esriGeometryPoint";
+  }
+  setTransformForDisplay(e) {
+    const t = this._reader.getInTransform();
+    if (t == null) {
+      const [d, l] = e.scale, [g, _] = e.translate;
+      return this._displayTranslationX = -g / d, this._displayScaleX = 1 / d, this._displayTranslationY = _ / l, this._displayScaleY = 1 / -l, void (this._displayTransform = e);
+    }
+    const [s, r] = t.scale, [i, n] = t.translate, [a, o] = e.scale, [h, c] = e.translate;
+    if (this._displayScaleX = s / a, this._displayTranslationX = (i - h) / a, this._displayScaleY = r / o, this._displayTranslationY = (-n + c) / o, !this._isPoint && t)
+      throw new Error("InternalError: Relative transformations not supported for non-point features");
+    this._displayTransform = e;
+  }
+  getInTransform() {
+    return this._reader.getInTransform();
+  }
+  get fields() {
+    return this._reader.fields;
+  }
+  get hasNext() {
+    return this._currentIndex + 1 < this._indices.length;
+  }
+  getSize() {
+    return this._indices.length;
+  }
+  getCursor() {
+    return this.copy();
+  }
+  copy() {
+    const e = new ve(this._reader.copy(), this._indices);
+    return e._currentIndex = this._currentIndex, e._displayTransform = this._displayTransform, e._displayTranslationX = this._displayTranslationX, e._displayTranslationY = this._displayTranslationY, e._displayScaleX = this._displayScaleX, e._displayScaleY = this._displayScaleY, e;
+  }
+  get contextTimeZone() {
+    return this._reader.contextTimeZone;
+  }
+  set contextTimeZone(e) {
+    this._reader.contextTimeZone = e;
+  }
+  _nextIndex() {
+    return ++this._currentIndex < this._indices.length && (this._reader.setIndex(this._indices[this._currentIndex]), !0);
+  }
+  next() {
+    for (; this._nextIndex() && !this._reader._getExists(); )
+      ;
+    return this._currentIndex < this._indices.length;
+  }
+  readXForDisplay() {
+    return this._reader.readXForDisplay() * this._displayScaleX + this._displayTranslationX;
+  }
+  readYForDisplay() {
+    return this._reader.readYForDisplay() * this._displayScaleY + this._displayTranslationY;
+  }
+  readGeometryForDisplay() {
+    const e = this._reader.readGeometryForDisplay();
+    if (!this._displayTransform)
+      return e;
+    const t = new T();
+    return X(t, e, this.hasZ, this.hasM, this.geometryType, this._displayTransform), t.deltaDecode();
+  }
+  readCentroidForDisplay() {
+    var t;
+    const e = (t = this._reader.readCentroidForDisplay()) == null ? void 0 : t.clone();
+    if (e) {
+      const [s, r] = e.coords;
+      e.coords[0] = s * this._displayScaleX + this._displayTranslationX, e.coords[1] = r * this._displayScaleY + this._displayTranslationY;
+    }
+    return e;
+  }
+  get geometryType() {
+    return this._reader.geometryType;
+  }
+  get hasFeatures() {
+    return this._reader.hasFeatures;
+  }
+  get exceededTransferLimit() {
+    return this._reader.exceededTransferLimit;
+  }
+  get hasZ() {
+    return this._reader.hasZ;
+  }
+  get hasM() {
+    return this._reader.hasM;
+  }
+  readAttribute(e, t = !1) {
+    return this._reader.readAttribute(e, t);
+  }
+  readAttributes() {
+    return this._reader.readAttributes();
+  }
+  joinAttributes(e) {
+    return this._reader.joinAttributes(e);
+  }
+  getBounds(e) {
+    return this._reader.getBounds(e);
+  }
+  getAttributeHash() {
+    return this._reader.getAttributeHash();
+  }
+  getObjectId() {
+    return this._reader.getObjectId();
+  }
+  getDisplayId() {
+    return this._reader.getDisplayId();
+  }
+  setDisplayId(e) {
+    return this._reader.setDisplayId(e);
+  }
+  setIndex(e) {
+    return this._reader.setIndex(e);
+  }
+  getIndex() {
+    return this._reader.getIndex();
+  }
+  readXWorldSpace() {
+    return this._reader.readXWorldSpace();
+  }
+  readYWorldSpace() {
+    return this._reader.readYWorldSpace();
+  }
+  _readX() {
+    return this._reader.readXForDisplay();
+  }
+  _readY() {
+    return this._reader.readYForDisplay();
+  }
+  _readServerCentroid() {
+    return this._reader._readServerCentroid();
+  }
+  readLegacyFeatureForDisplay() {
+    const e = this.readCentroidForDisplay();
+    return { attributes: this.readAttributes(), geometry: this.readLegacyGeometryForDisplay(), centroid: (e && { x: e.coords[0], y: e.coords[1] }) ?? null };
+  }
+  readLegacyGeometryForDisplay() {
+    const e = this.readGeometryForDisplay();
+    return $s(e, this.geometryType, !1, !1);
+  }
+  readGeometryArea() {
+    return this._reader.readGeometryArea();
+  }
+  readGeometryWorldSpace() {
+    return this._reader.readGeometryWorldSpace();
+  }
+  _readGeometry() {
+    return this._reader._readGeometry();
+  }
+  _readAttribute(e, t) {
+    throw new Error("Error: Should not be called. Underlying _reader should be used instead");
+  }
+  _readAttributes() {
+    throw new Error("Error: Should not be called. Underlying _reader should be used instead");
+  }
+  readArcadeFeature() {
+    return this._reader.readArcadeFeature();
+  }
+  geometry() {
+    return this._reader.geometry();
+  }
+  field(e) {
+    return this.readAttribute(e, !0);
+  }
+  hasField(e) {
+    return this._reader.hasField(e);
+  }
+  setField(e, t) {
+    return this._reader.setField(e, t);
+  }
+  keys() {
+    return this._reader.keys();
+  }
+  castToText(e = !1) {
+    return this._reader.castToText(e);
+  }
+}, Z = class {
+  size() {
+    return this.reader.getSize();
+  }
+  get fields() {
+    return this.reader.fields;
+  }
+  invalidate() {
+    this._geohashIndex = null, this._geohashIndexHash = null, this._spatialIndex = null, this._gridIndex = null, this._gridIndexHash = null;
+  }
+  queryFeaturesInBounds(e) {
+    const t = this._getSpatialIndex().search(e);
+    return pr.from(this.reader, t);
+  }
+  getGeohashIndex(e) {
+    const t = JSON.stringify(e);
+    return t !== this._geohashIndexHash && (this._geohashIndexHash = t, this._geohashIndex = new _r(e), this._geohashIndex.insert(this.reader, this.isTiled)), this._geohashIndex;
+  }
+  getGridIndex(e) {
+    const t = JSON.stringify(e);
+    return t !== this._gridIndexHash && (this._gridIndexHash = t, this._gridIndex = new or(e), this._gridIndex.insert(this.reader, this.isTiled)), this._gridIndex;
+  }
+  _getSpatialIndex() {
+    return this._spatialIndex || (this._spatialIndex = cr.fromReader(this.reader)), this._spatialIndex;
+  }
+}, Nt = class extends Z {
+  constructor(e) {
+    super(), this.metadata = e, this.chunkId = "override", this.normalizedChunkId = "override", this.removed = /* @__PURE__ */ new Set(), this.overridenIds = /* @__PURE__ */ new Set(), this._features = [];
+  }
+  get reader() {
+    return M.fromOptimizedFeatures(this._features, this.metadata);
+  }
+  get queryInfo() {
+    return {};
+  }
+  get first() {
+    return !1;
+  }
+  get end() {
+    return !1;
+  }
+  get isTiled() {
+    return !1;
+  }
+  applyOverrides(e) {
+    super.invalidate();
+    const { reader: t, removed: s } = e, r = [], i = /* @__PURE__ */ new Set(), n = t.getCursor(), a = new Set(s);
+    for (this.overridenIds.clear(); n.next(); ) {
+      const o = n.readOptimizedFeatureWorldSpace(), h = o.objectId;
+      r.push(o), i.add(h), this.overridenIds.add(h), this.removed.delete(h);
+    }
+    for (const o of this._features) {
+      const h = o.objectId;
+      a.has(h) || i.has(h) || (r.push(o), this.overridenIds.add(h));
+    }
+    this._features = r;
+    for (const o of i.values())
+      this.removed.delete(o);
+    for (const o of s)
+      this.removed.add(o), this.overridenIds.add(o);
+  }
+  getTileReader(e) {
+    if (!this._features.length)
+      return null;
+    const t = this.queryFeaturesInBounds(e.bounds);
+    return t.setTransformForDisplay(e.transform), t;
+  }
+}, gr = class extends Ee {
+}, fr = class extends At {
+  constructor(e, t, s) {
+    super(e, t), this._timeZone = s, this.handledChunks = /* @__PURE__ */ new Set(), this.handledChunksForIdCreation = /* @__PURE__ */ new Set(), this.handledChunksForAttributeData = /* @__PURE__ */ new Set(), this._streamLayerDeferredObjectIdsToRemove = [];
+  }
+  destroy() {
+    super.destroy();
+    for (const e of this._source.chunks())
+      this._cleanupChunkIds(e);
+  }
+  invalidateAttributeData() {
+    this.handledChunksForAttributeData.clear();
+  }
+  onSubscribe(e) {
+    super.onSubscribe(e), this._evalOptions = e.tile.createArcadeEvaluationOptions(this._timeZone);
+  }
+  createState(e) {
+    return new gr(e);
+  }
+  get aggregateQueryEngine() {
+    return null;
+  }
+  displayMap(e, t, s) {
+    const r = new Map(e.map((n) => [t(n), n])), i = [];
+    for (const n of this._source.chunks()) {
+      const a = n.reader.getCursor();
+      for (; a.next(); ) {
+        const o = a.getObjectId(), h = a.getDisplayId(), c = r.get(o);
+        if (c != null) {
+          const d = s(h, c, o);
+          i.push(d), r.delete(o);
+        }
+      }
+    }
+    return i;
+  }
+  getDisplayFeatures(e) {
+    const t = new Set(e), s = /* @__PURE__ */ new Set(), r = [];
+    for (const i of this._source.chunks()) {
+      const n = i.reader.getCursor();
+      for (; n.next(); ) {
+        const a = n.getObjectId(), o = n.getDisplayId();
+        t.has(o) && !s.has(a) && (r.push({ ...n.readLegacyFeatureWorldSpace(), displayId: o }), s.add(a));
+      }
+    }
+    return { features: r, aggregates: [] };
+  }
+  async *applyOverride(e) {
+    const t = [], s = e.reader.getCursor();
+    for (; s.next(); ) {
+      const a = s.getObjectId();
+      t.push(a);
+      const o = this._attributeStore.createDisplayIdForObjectId(a);
+      s.setDisplayId(o), this._attributeStore.setAttributeData(o, s, this._evalOptions);
+    }
+    const r = this.getDisplayIds(t), i = this.getDisplayIds(e.removed), n = new Nt(this._source.metadata);
+    n.applyOverrides(e), this.handledChunks.add(n.chunkId), this.handledChunksForAttributeData.add(n.chunkId), this.handledChunksForIdCreation.add(n.chunkId);
+    for (const a of this._sendStates.values())
+      a.handledChunks.add(n.chunkId), yield new fe(a.subscription, null, r, !1, n.queryInfo);
+    for (const a of this._sendStates.values()) {
+      const o = n.getTileReader(a.subscription.tile);
+      yield new fe(a.subscription, o, i, !1, n.queryInfo);
+    }
+    for (const a of e.removed)
+      this._attributeStore.releaseDisplayIdForObjectId(a);
+  }
+  async *updateChunks() {
+    if (this._source.chunks().length) {
+      await this._updateAttributeData();
+      for (const e of this._sendStates.values())
+        yield* this._update(e);
+    }
+  }
+  removeChunks(e) {
+    for (const t of e)
+      this.handledChunks.delete(t.chunkId), this.handledChunksForAttributeData.delete(t.chunkId), this._cleanupChunkIds(t);
+  }
+  afterUpdateChunks() {
+    for (const e of this._streamLayerDeferredObjectIdsToRemove)
+      this._attributeStore.releaseDisplayIdForObjectId(e);
+    this._streamLayerDeferredObjectIdsToRemove = [];
+  }
+  _cleanupChunkIds(e) {
+    if (this.handledChunksForIdCreation.has(e.chunkId)) {
+      const t = e.reader.getCursor();
+      for (; t.next(); ) {
+        const s = t.getObjectId();
+        this._source.isStream ? this._streamLayerDeferredObjectIdsToRemove.push(s) : this._attributeStore.releaseDisplayIdForObjectId(s);
+      }
+      this.handledChunksForIdCreation.delete(e.chunkId);
+    }
+  }
+  async _updateAttributeData() {
+    for (const e of this._source.chunks()) {
+      const { chunkId: t, reader: s } = e;
+      if (!this.handledChunksForIdCreation.has(t)) {
+        this.handledChunksForIdCreation.add(t);
+        const r = s.getCursor();
+        for (; r.next(); ) {
+          const i = this._attributeStore.createDisplayIdForObjectId(r.getObjectId());
+          r.setDisplayId(i);
+        }
+      }
+    }
+    for (const e of this._source.chunks())
+      if (!this.handledChunksForAttributeData.has(e.chunkId)) {
+        this.handledChunksForAttributeData.add(e.chunkId);
+        const t = e.reader.getCursor();
+        for (; t.next(); ) {
+          const s = t.getDisplayId();
+          this._attributeStore.setAttributeData(s, t, this._evalOptions);
+        }
+      }
+  }
+  *_update(e) {
+    const { subscription: t, handledChunks: s } = e;
+    for (const r of this._source.chunks()) {
+      const { chunkId: i } = r;
+      if (s.has(i))
+        continue;
+      s.add(i);
+      const n = r.getTileReader(t.tile);
+      n && (yield new Pe(e.subscription, n, !1, r.end, r.queryInfo));
+    }
+  }
+}, yr = class {
+  constructor(e, t) {
+    this._connection = e, this._source = t, this._version = 1, this._proxy = new ps({ fetch: (s, r) => this._connection.layerView.fetch(s, r), fetchDictionary: (s, r) => this._connection.layerView.fetchDictionary(s, r) }), this._attributeStore = new gs({ isLocal: !1, update: (s) => ut(this._connection.container.updateAttributeView(s)) });
+  }
+  destroy() {
+    var e;
+    this._proxy.destory(), (e = this._strategy) == null || e.destroy(), this._attributeStore.destroy();
+  }
+  get aggregateQueryEngine() {
+    var e;
+    return (e = this._strategy) == null ? void 0 : e.aggregateQueryEngine;
+  }
+  getDisplayFeatures(e) {
+    return this._strategy ? this._strategy.getDisplayFeatures(e) : { features: [], aggregates: [] };
+  }
+  getFeatureObjectIdsForAggregate(e) {
+    return this._strategy ? this._strategy.getFeatureObjectIdsForAggregate(e) : [];
+  }
+  onSubscribe(e) {
+    var t;
+    (t = this._strategy) == null || t.onSubscribe(e);
+  }
+  onUnsubscribe(e) {
+    var t;
+    (t = this._strategy) == null || t.onUnsubscribe(e);
+  }
+  async update(e, t, s, r, i) {
+    var c;
+    const n = e.processor, a = ft(this._schema, n);
+    if (!a && !r)
+      return;
+    y("esri-2d-update-debug") && console.debug(`Version[${this._version}] SymbolProcessor.update`, { changes: a, schema: n }), this._schema = n;
+    const o = V.fromJSON(e.source.mutable.dataFilter.outSpatialReference), h = new Me({ fields: this._source.metadata.fieldsIndex, spatialReference: o });
+    return await this._attributeStore.update(n.storage, h, this._source.metadata, o, t), (c = this._strategy) == null || c.invalidateAttributeData(), r || he(a, "mesh") ? (he(a, "mesh.strategy") && await this._updateStrategy(n.mesh.strategy, o, i, n.mesh.timeZone), this._updateSortKey(h, "sortKey" in n.mesh ? n.mesh.sortKey : null), (he(a, "mesh.factory") || n.mesh.factory.symbology.type === "dictionary") && (this._factory = await Qs.create(h, this._proxy, n.mesh.factory, s)), this._invalidate(), this._version = t, this._connection.container.updateRenderState(this._version)) : void 0;
+  }
+  async applyOverride(e) {
+    if (!this._strategy)
+      return;
+    const t = this._strategy.applyOverride(e);
+    for await (const s of t)
+      try {
+        await this._process(s);
+      } catch {
+      }
+    this._source.applyOverride(e);
+  }
+  async updateChunks() {
+    var e;
+    await this._doUpdateChunks(), (e = this._strategy) == null || e.afterUpdateChunks();
+  }
+  async removeChunks(e) {
+    var t;
+    (t = this._strategy) == null || t.removeChunks(e), this._attributeStore.incrementDisplayIdGeneration();
+  }
+  updateHighlight({ highlights: e }) {
+    if (!this._strategy)
+      return void this._attributeStore.setHighlight(e.map(({ objectId: s, highlightFlags: r }) => ({ objectId: s, highlightFlags: r, displayId: -1 })), e);
+    const t = this._strategy.displayMap(e, ({ objectId: s }) => s, (s, { highlightFlags: r }, i) => ({ objectId: i, displayId: s, highlightFlags: r }));
+    this._attributeStore.setHighlight(t, e);
+  }
+  async _doUpdateChunks() {
+    if (!this._strategy)
+      return;
+    const e = this._strategy.updateChunks(), t = [], s = /* @__PURE__ */ new Map();
+    for await (const r of e) {
+      let i = s.get(r.id);
+      i == null && (i = new Zs({ concurrency: 16, process: (a) => this._process(a) }), s.set(r.id, i));
+      const n = i.push(r).catch((a) => Fe(a));
+      t.push(n);
+    }
+    try {
+      await Promise.all(t);
+    } catch {
+    }
+    y("esri-2d-update-debug") && console.log("SendUpdates"), await this._attributeStore.sendUpdates(), y("esri-2d-update-debug") && console.log("SendUpdates.await");
+  }
+  async _updateStrategy(e, t, s, r) {
+    var i;
+    switch ((i = this._strategy) == null || i.destroy(), e.type) {
+      case "feature":
+        this._strategy = new fr(this._source, this._attributeStore, r);
+        break;
+      case "binning":
+        this._strategy = await Js.create(e, t, this._source, this._attributeStore, r);
+        break;
+      case "cluster":
+        this._strategy = await je.create(this._connection, e, t, this._source, this._attributeStore, r);
+    }
+    for (const n of s)
+      this._strategy.onSubscribe(n);
+  }
+  async _updateSortKey(e, t) {
+    var s;
+    if (this._sortInfo = dt((s = this._sortInfo) == null ? void 0 : s.computed), t != null) {
+      const r = t.byRenderer ? null : await e.createComputedField(t);
+      this._sortInfo = { ...t, computed: r };
+    }
+  }
+  _invalidate() {
+    this._strategy && this._strategy.invalidate();
+  }
+  async _process(e) {
+    const t = e.subscription;
+    if (y("esri-2d-update-debug")) {
+      const o = t.tile;
+      console.debug(`Version[${this._version}] Tile[${o.key.id}, end=${e.end}] Processor._process`);
+    }
+    await this._fetchResources(e), Y(t.signal);
+    const s = await this._write(e, t.tile.createArcadeEvaluationOptions(this._schema.mesh.timeZone)), r = t.tile.tileInfoView.tileInfo.isWrappable, { message: i, transferList: n } = s.serialize(r), a = e.createMessage(i, this._version, this._attributeStore.epoch);
+    if (Y(t.signal), this._connection.container.onMessage(a, { signal: t.signal, transferList: n }), this._attributeStore.sendUpdates(), y("esri-2d-update-debug")) {
+      const o = t.tile;
+      console.debug(`Version[${this._version}] Tile[${o.key.id}, end=${e.end}] Processor._process.await`);
+    }
+  }
+  async _fetchResources(e) {
+    await this._fetchMatcherResources(e), await this._fetchWriterResources(e);
+  }
+  async _fetchMatcherResources(e) {
+    if (e.reader)
+      return this._factory.enqueueMatcherRequests(this._proxy, e.reader);
+  }
+  async _fetchWriterResources(e) {
+    if (!e.reader)
+      return;
+    const t = e.reader.getCursor(), s = e.subscription.tile.createArcadeEvaluationOptions(this._schema.mesh.timeZone);
+    for (; t.next(); )
+      this._factory.enqueueWriterRequests(this._proxy, t, s);
+    await this._proxy.fetchEnqueuedResources();
+  }
+  async _write(e, t) {
+    var h;
+    const s = e.subscription.tile, r = (h = e.reader) == null ? void 0 : h.getCursor(), i = (r == null ? void 0 : r.getSize()) ?? 0, n = s.tileInfoView.tileInfo.isWrappable, a = new Us(s.key, this._strategy.enablePixelBuffering, n, i);
+    if (!r)
+      return a;
+    const o = s.createArcadeEvaluationOptions(this._schema.mesh.timeZone);
+    for (; r.next(); ) {
+      const c = this._getSortKeyValue(r, t);
+      a.entityStart(r.getDisplayId(), c), this._factory.write(a, this._proxy, r, o, s.level), a.entityEnd();
+    }
+    return a;
+  }
+  _getSortKeyValue(e, t) {
+    if (!this._sortInfo)
+      return 0;
+    const { computed: s, order: r, byRenderer: i } = this._sortInfo, n = i ? this._factory.getSortKey(e, t) : s == null ? void 0 : s.read(e, t);
+    return n == null || isNaN(n) ? 0 : n * (r === "asc" ? -1 : 1);
+  }
+}, mr = class Bt {
+  static from(e) {
+    let t = 0, s = 0, r = 0;
+    return e.forEach((i) => {
+      const n = i._readGeometry();
+      n && (s += n.isPoint ? 1 : n.lengths.reduce((a, o) => a + o, 0), r += n.isPoint ? 1 : n.lengths.length, t += 1);
+    }), new Bt(t, s, r);
+  }
+  constructor(e, t, s) {
+    this.featureCount = e, this.vertexCount = t, this.ringCount = s;
+  }
+  toJSON() {
+    return { featureCount: this.featureCount, ringCount: this.featureCount, vertexCount: this.featureCount };
+  }
+};
+const ce = 4;
+function br(u, e) {
+  const { service: t } = u, s = t.orderByFields ?? e.objectIdField + " ASC", r = t.source, i = { returnCentroid: !(r !== null && typeof r == "object" && "path" in r && es(r.path)) && e.geometryType === "esriGeometryPolygon", returnGeometry: !0, timeReferenceUnknownClient: e.timeReferenceUnknownClient ?? void 0, outSpatialReference: V.fromJSON(u.mutable.dataFilter.outSpatialReference), orderByFields: [s], where: u.mutable.dataFilter.definitionExpression ?? "1=1", outFields: u.mutable.availableFields };
+  if (u.type === "feature") {
+    const { gdbVersion: n, historicMoment: a, timeExtent: o } = u.mutable.dataFilter;
+    return { ...i, gdbVersion: n, historicMoment: a ? new Date(a) : null, timeExtent: o ? ts.fromJSON(o) : null, outFields: u.mutable.availableFields };
+  }
+  return i;
+}
+let Ir = class Vt {
+  static fromSchema(e, t) {
+    return new Vt(br(e, t), e.mutable.dataFilter.customParameters, t.geometryType, e.service.queryMetadata.capabilities);
+  }
+  constructor(e, t, s, r) {
+    this._queryParams = e, this._customParameters = t, this._geometryType = s, this._capabilities = r;
+  }
+  get pageSize() {
+    if (this._capabilities == null)
+      throw new Error("InternalError: Service does not support paged queries");
+    const { query: e } = this._capabilities, t = e.supportsMaxRecordCountFactor ? ce : null, s = (e.maxRecordCount ?? 8e3) * (t ?? 1);
+    return Math.min(8e3, s);
+  }
+  updateFields(e) {
+    this._queryParams.outFields = e;
+  }
+  createPatchFieldsQuery(e, t) {
+    const s = e.clone();
+    if (this._queryParams.outFields[0] === "*") {
+      if ((s.outFields ?? [])[0] === "*")
+        return null;
+      s.outFields = this._queryParams.outFields;
+    } else {
+      const r = new Set(this._queryParams.outFields), i = [];
+      for (const n of r)
+        t.hasField(n) || i.push(n);
+      if (i.length === 0)
+        return null;
+      s.outFields = i;
+    }
+    return s.returnGeometry = !1, s.returnCentroid = !1, s.quantizationParameters = null, s.cacheHint = !0, { inner: s, customParameters: this._customParameters };
+  }
+  createQuery(e = {}) {
+    if (!this._queryParams)
+      throw new Error("InternalError: queryInfo should be defined");
+    return { inner: new ct({ ...this._queryParams, ...e }), customParameters: this._customParameters };
+  }
+  createTileQuery(e, t) {
+    if (this._capabilities == null)
+      throw new Error("InternalError: Service does not support tile queries");
+    const s = this.createQuery(t), r = s.inner;
+    return r.quantizationParameters = t.quantizationParameters ?? e.getQuantizationParameters(), r.resultType = "tile", r.geometry = e.extent, this._capabilities.query.supportsQuantization ? this._geometryType === "esriGeometryPolyline" && (r.maxAllowableOffset = e.resolution * y("feature-polyline-generalization-factor")) : this._geometryType !== "esriGeometryPolyline" && this._geometryType !== "esriGeometryPolygon" || (r.maxAllowableOffset = e.resolution, this._geometryType === "esriGeometryPolyline" && (r.maxAllowableOffset *= y("feature-polyline-generalization-factor"))), r.defaultSpatialReferenceEnabled = this._capabilities.query.supportsDefaultSpatialReference, r.compactGeometryEnabled = this._capabilities.query.supportsCompactGeometry, this._capabilities.query.supportsMaxRecordCountFactor && (r.maxRecordCountFactor = ce), s;
+  }
+  createPagedTileQuery(e, t) {
+    const s = this.pageSize;
+    return this.createTileQuery(e, { start: s * t, num: s, returnExceededLimitFeatures: !0 });
+  }
+  createPagedQuery(e) {
+    const t = this.pageSize;
+    return this.createQuery({ start: t * e, num: t, returnExceededLimitFeatures: !0, maxRecordCountFactor: ce });
+  }
+};
+const vr = 2500;
+let te = class extends _t {
+  constructor(e) {
+    super(), this._connection = e, this._enabledEventTypes = /* @__PURE__ */ new Set(), this._updateInfo = { websocket: 0, client: 0 }, this._lastTime = performance.now(), this.addHandles([pe(() => {
+      var t;
+      return ((t = this._strategy) == null ? void 0 : t.connectionStatus) ?? "disconnected";
+    }, (t) => {
+      this._layerView.setProperty({ propertyName: "pipelineConnectionStatus", value: t });
+    }, { initial: !0 }), pe(() => {
+      var t;
+      return ((t = this._strategy) == null ? void 0 : t.errorString) || null;
+    }, (t) => this._layerView.setProperty({ propertyName: "pipelineErrorString", value: t }), { initial: !0 })]);
+  }
+  destroy() {
+    this._strategy = null, this.removeAllHandles();
+  }
+  get _layerView() {
+    return this._connection.layerView;
+  }
+  set strategy(e) {
+    this._strategy == null && this._resetUpdateInfo(performance.now());
+    const t = "event-handles";
+    this.removeHandles(t), e != null && this.addHandles([e.events.on("data-received", (s) => this._onFeature(s)), e.events.on("message-received", (s) => this._onWebSocketMessage(s)), e.events.on("features-updated", (s) => this._onUpdate(s)), e.events.on("tick", () => this._onTick())], t), this._strategy = e;
+  }
+  updateCustomParameters(e) {
+    var t;
+    e != null && ((t = this._strategy) == null || t.updateCustomParameters(e));
+  }
+  sendMessageToSocket(e) {
+    var t;
+    (t = this._strategy) == null || t.sendMessageToSocket(e);
+  }
+  sendMessageToClient(e) {
+    var t;
+    (t = this._strategy) == null || t.sendMessageToClient(e);
+  }
+  enableEvent(e, t) {
+    t ? this._enabledEventTypes.add(e) : this._enabledEventTypes.delete(e);
+  }
+  disconnect() {
+    var e;
+    (e = this._strategy) == null || e.disconnect();
+  }
+  connect() {
+    var e;
+    (e = this._strategy) == null || e.connect();
+  }
+  clear() {
+    var e;
+    (e = this._strategy) == null || e.clear();
+  }
+  _onWebSocketMessage(e) {
+    this._enabledEventTypes.has("message-received") && this._layerView.emitEvent({ name: "message-received", event: e });
+  }
+  _onFeature(e) {
+    this._updateInfo.websocket++, this._enabledEventTypes.has("data-received") && this._layerView.emitEvent({ name: "data-received", event: { attributes: e.attributes, centroid: e.centroid, geometry: e.geometry } });
+  }
+  _onUpdate(e) {
+    this._updateInfo.client += e;
+  }
+  _onTick() {
+    const e = performance.now(), t = e - this._lastTime;
+    if (t > vr) {
+      const s = Math.round(this._updateInfo.client / (t / 1e3)), r = Math.round(this._updateInfo.websocket / (t / 1e3));
+      this._resetUpdateInfo(e), this._layerView.emitEvent({ name: "update-rate", event: { client: s, websocket: r } });
+    }
+  }
+  _resetUpdateInfo(e) {
+    this._lastTime = e, this._updateInfo.client = 0, this._updateInfo.websocket = 0;
+  }
+};
+G([K()], te.prototype, "_strategy", void 0), te = G([lt("esri.views.2d.layers.features.sources.StreamMessenger")], te);
+let Yt = class {
+  constructor(e) {
+    this._store = e, this._controller = new AbortController();
+  }
+  destroy() {
+    this._controller.abort();
+  }
+  get _options() {
+    return { signal: this._controller.signal };
+  }
+  async queryOverride(e) {
+    throw new Error("InternalError: LoadStrategy does not support fetching");
+  }
+};
+const le = 268435455;
+let Sr = class {
+  constructor() {
+    this.hasFeatures = !1, this.exceededTransferLimit = !1, this.fieldCount = 0, this.featureCount = 0, this.objectIdFieldIndex = 0, this.vertexCount = 0, this.offsets = { attributes: new Array(), geometry: new Array() }, this.centroid = new Array();
+  }
+};
+function wr(u, e, t = !1) {
+  var $;
+  const h = u.asUnsafe(), c = h.pos(), d = new Sr();
+  let l = 0, g = 0;
+  const _ = 1, m = 2, p = 4, I = 3;
+  let f = null, k = null, b = null, v = !1;
+  const S = [];
+  for (; h.next(); )
+    switch (h.tag()) {
+      case 1:
+        f = h.getString();
+        break;
+      case 3:
+        k = h.getString();
+        break;
+      case 12:
+        b = h.processMessage(js);
+        break;
+      case 9:
+        if (d.exceededTransferLimit = h.getBool(), d.exceededTransferLimit) {
+          d.offsets.geometry = t ? new Float64Array(8e3) : new Int32Array(8e3), d.centroid = t ? new Float64Array(16e3) : new Int32Array(16e3);
+          for (let F = 0; F < d.centroid.length; F++)
+            d.centroid[F] = le;
+        }
+        break;
+      case 13: {
+        const F = h.processMessage(Ps);
+        F.index = l++, S.push(F);
+        break;
+      }
+      case 15: {
+        const F = h.getLength(), O = h.pos() + F;
+        if (!d.exceededTransferLimit) {
+          const C = d.offsets.geometry, q = d.centroid;
+          C.push(0), q.push(le), q.push(le);
+        }
+        !v && d.exceededTransferLimit && (v = !0, d.offsets.attributes = t ? new Float64Array(8e3 * l) : new Uint32Array(8e3 * l));
+        let R = g * l;
+        for (; h.pos() < O && h.next(); )
+          switch (h.tag()) {
+            case _: {
+              v ? d.offsets.attributes[R++] = h.pos() : d.offsets.attributes.push(h.pos());
+              const C = h.getLength();
+              h.skipLen(C);
+              break;
+            }
+            case m:
+              if (e) {
+                const C = h.getLength(), q = h.pos() + C;
+                for (; h.pos() < q && h.next(); )
+                  switch (h.tag()) {
+                    case I: {
+                      h.getUInt32();
+                      const E = h.getSInt64(), P = h.getSInt64();
+                      d.centroid[2 * g] = E, d.centroid[2 * g + 1] = P;
+                      break;
+                    }
+                    default:
+                      h.skip();
+                  }
+              } else {
+                d.offsets.geometry[g] = h.pos();
+                const C = h.getLength();
+                d.vertexCount += C, h.skipLen(C);
+              }
+              break;
+            case p: {
+              const C = h.getLength(), q = h.pos() + C;
+              for (; h.pos() < q && h.next(); )
+                switch (h.tag()) {
+                  case I: {
+                    h.getUInt32();
+                    const E = h.getSInt64(), P = h.getSInt64();
+                    d.centroid[2 * g] = E, d.centroid[2 * g + 1] = P;
+                    break;
+                  }
+                  default:
+                    h.skip();
+                }
+              break;
+            }
+            default:
+              h.skip();
+          }
+        g++, d.hasFeatures = !0;
+        break;
+      }
+      default:
+        h.skip();
+    }
+  const w = f || k;
+  if (!w)
+    throw new D("FeatureSet has no objectId or globalId field name");
+  return d.fields = new St(S), d.featureCount = g, d.fieldCount = l, d.objectIdFieldIndex = ($ = d.fields.get(w)) == null ? void 0 : $.index, d.transform = b, d.displayIds = new Uint32Array(d.featureCount), d.groupIds = new Uint16Array(d.featureCount), h.move(c), d;
+}
+const xr = !0, Ke = 268435455, et = 128, tt = 128e3, z = { small: { delta: new Int32Array(et), decoded: new Int32Array(et) }, large: { delta: new Int32Array(tt), decoded: new Int32Array(tt) } };
+function st(u) {
+  return u <= z.small.delta.length ? z.small : (u <= z.large.delta.length || (z.large.delta = new Int32Array(Math.round(1.25 * u)), z.large.decoded = new Int32Array(Math.round(1.25 * u))), z.large);
+}
+function kr(u) {
+  try {
+    const t = new Es(new Uint8Array(u), new DataView(u));
+    for (; t.next(); ) {
+      if (t.tag() === 2)
+        return Fr(t.getMessage());
+      t.skip();
+    }
+  } catch (e) {
+    const t = new D("query:parsing-pbf", "Error while parsing FeatureSet PBF payload", { error: e });
+    rs.getLogger("esri.view.2d.layers.features.support.FeatureSetReaderPBF").error(t);
+  }
+  return null;
+}
+function Fr(u) {
+  for (; u.next(); ) {
+    if (u.tag() === 1)
+      return u.getMessage();
+    u.skip();
+  }
+  return null;
+}
+function Tr(u) {
+  const c = u.getLength(), d = u.pos() + c;
+  for (; u.pos() < d && u.next(); )
+    switch (u.tag()) {
+      case 1:
+        return u.getString();
+      case 2:
+        return u.getFloat();
+      case 3:
+        return u.getDouble();
+      case 4:
+        return u.getSInt32();
+      case 5:
+        return u.getUInt32();
+      case 6:
+        return u.getInt64();
+      case 7:
+        return u.getUInt64();
+      case 8:
+        return u.getSInt64();
+      case 9:
+        return u.getBool();
+      default:
+        return u.skip(), null;
+    }
+  return null;
+}
+function Cr(u, e, t, s, r, i) {
+  return 0.5 * Math.abs(u * s + t * i + r * e - u * i - t * e - r * s);
+}
+function _e(u, e, t, s) {
+  return u * s - t * e === 0 && u * t + e * s > 0;
+}
+let Mr = class Se extends Ce {
+  static fromBuffer(e, t, s = !1) {
+    const r = t.geometryType, i = kr(e), n = wr(i, r === "esriGeometryPoint", s);
+    return new Se(i, n, t);
+  }
+  constructor(e, t, s) {
+    super(s), this._hasNext = !1, this._isPoints = !1, this._featureIndex = -1, this._featureOffset = 0, this._cache = { area: 0, unquantGeometry: void 0, geometry: void 0, centroid: void 0, legacyFeature: void 0, optFeature: void 0 }, this._parseCaches = new Array(), this._geometryType = s.geometryType, this._reader = e, this._header = t, this._hasNext = t.hasFeatures, this._isPoints = s.geometryType === "esriGeometryPoint";
+  }
+  get _size() {
+    return this._header.featureCount;
+  }
+  get fields() {
+    return this._header.fields;
+  }
+  get geometryType() {
+    return this._geometryType;
+  }
+  get hasZ() {
+    return !1;
+  }
+  get hasM() {
+    return !1;
+  }
+  get hasFeatures() {
+    return this._header.hasFeatures;
+  }
+  get hasNext() {
+    return this._hasNext;
+  }
+  get exceededTransferLimit() {
+    return this._header.exceededTransferLimit;
+  }
+  getSize() {
+    return this._size;
+  }
+  getInTransform() {
+    return this._header.transform;
+  }
+  getCursor() {
+    return this.copy();
+  }
+  getIndex() {
+    return this._featureIndex;
+  }
+  setIndex(e) {
+    this._cache.area = 0, this._cache.unquantGeometry = void 0, this._cache.geometry = void 0, this._cache.centroid = void 0, this._cache.legacyFeature = void 0, this._cache.optFeature = void 0, this._featureIndex = e;
+  }
+  getAttributeHash() {
+    let e = "";
+    for (const t of this._header.fields.fields)
+      e += this._readAttributeAtIndex(t.index) + ".";
+    return e;
+  }
+  getObjectId() {
+    return this._readAttributeAtIndex(this._header.objectIdFieldIndex);
+  }
+  getDisplayId() {
+    return this._header.displayIds[this._featureIndex];
+  }
+  setDisplayId(e) {
+    this._header.displayIds[this._featureIndex] = e;
+  }
+  readGeometryArea() {
+    return this._cache.area || this._readGeometry(!0), this._cache.area;
+  }
+  copy() {
+    const e = this._reader.clone(), t = new Se(e, this._header, this.metadata);
+    return this.copyInto(t), t;
+  }
+  next() {
+    for (this._cache.area = 0, this._cache.unquantGeometry = void 0, this._cache.geometry = void 0, this._cache.centroid = void 0, this._cache.legacyFeature = void 0, this._cache.optFeature = void 0; ++this._featureIndex < this._size && !this._getExists(); )
+      ;
+    return this._featureIndex < this._size;
+  }
+  _readX() {
+    return this._header.centroid[2 * this._featureIndex];
+  }
+  _readY() {
+    return this._header.centroid[2 * this._featureIndex + 1];
+  }
+  _readServerCentroid() {
+    const e = this._header.centroid[2 * this._featureIndex], t = this._header.centroid[2 * this._featureIndex + 1];
+    return e === Ke ? null : new T([], [e, t]);
+  }
+  _readGeometry(e = !1) {
+    if (this._cache.geometry === void 0) {
+      let t = null;
+      if (this._isPoints) {
+        if (this._header.centroid[2 * this._featureIndex] === Ke)
+          return null;
+        const s = this._header.centroid[2 * this._featureIndex], r = this._header.centroid[2 * this._featureIndex + 1];
+        t = new T([], [s, r]);
+      } else {
+        const s = this._header.offsets.geometry[this._featureIndex], r = this._reader;
+        if (s === 0)
+          return null;
+        r.move(s);
+        try {
+          t = e ? this._parseGeometryForDisplay(r) : this._parseGeometry(r);
+        } catch (i) {
+          return console.error("Failed to parse geometry!", i), null;
+        }
+      }
+      return (t == null ? void 0 : t.coords.length) === 0 && (t = null), this._cache.geometry = t, t;
+    }
+    return this._cache.geometry;
+  }
+  _readAttribute(e, t) {
+    var n;
+    const s = this._header.fields.get(e);
+    if (s == null)
+      return;
+    let r = this._readAttributeAtIndex(s.index);
+    ((n = this.fields.get(e)) == null ? void 0 : n.type) === "esriFieldTypeTimestampOffset" && (r = this.parseTimestampOffset(r));
+    const i = this._header.fields.isDateField(s.name);
+    return t ? r == null ? r : i ? new Date(r) : r : r;
+  }
+  _readAttributes() {
+    const e = {};
+    for (const t of this._header.fields.fields)
+      e[t.name] = this._readAttributeAtIndex(t.index);
+    return e;
+  }
+  copyInto(e) {
+    super.copyInto(e), e._featureIndex = this._featureIndex, e._featureOffset = this._featureOffset, e._hasNext = this._hasNext, e._parseCaches = this._parseCaches;
+  }
+  _readAttributeAtIndex(e) {
+    let t = this._parseCaches[e];
+    if (t || (t = new fs(this.getSize()), this._parseCaches[e] = t), t.has(this._featureIndex))
+      return t.get(this._featureIndex);
+    const s = this._header.offsets.attributes[this._featureIndex * this._header.fieldCount + e], r = this._reader;
+    r.move(s);
+    const i = Tr(r);
+    return t.set(this._featureIndex, i), i;
+  }
+  _readGeometryDeltaDecoded(e = !1) {
+    if (this._cache.unquantGeometry === void 0) {
+      const t = this._readGeometry(e);
+      if (!t)
+        return this._cache.unquantGeometry = void 0, null;
+      if (!this.getInTransform())
+        return this._cache.unquantGeometry = t, t;
+      const s = st(t.coords.length).decoded, r = t.clone(s), i = r.coords;
+      let n = 0;
+      for (const a of r.lengths) {
+        for (let o = 1; o < a; o++) {
+          const h = 2 * (n + o), c = 2 * (n + o - 1);
+          i[h] += i[c], i[h + 1] += i[c + 1];
+        }
+        n += a;
+      }
+      return this._cache.unquantGeometry = r, r;
+    }
+    return this._cache.unquantGeometry;
+  }
+  _parseGeometry(e) {
+    const r = e.asUnsafe(), i = r.getLength(), n = r.pos() + i, a = [], o = [];
+    for (; r.pos() < n && r.next(); )
+      switch (r.tag()) {
+        case 2: {
+          const h = r.getUInt32(), c = r.pos() + h;
+          for (; r.pos() < c; )
+            o.push(r.getUInt32());
+          break;
+        }
+        case 3: {
+          const h = r.getUInt32(), c = r.pos() + h;
+          for (a.push(r.getSInt64()), a.push(r.getSInt64()), this.hasZ && r.getSInt64(), this.hasM && r.getSInt64(); r.pos() < c; )
+            a.push(r.getSInt64()), a.push(r.getSInt64()), this.hasZ && r.getSInt64(), this.hasM && r.getSInt64();
+          break;
+        }
+        default:
+          r.skip();
+      }
+    return new T(o, a);
+  }
+  _parseGeometryForDisplay(e) {
+    const r = e.asUnsafe(), i = r.getLength(), n = r.pos() + i, a = [], o = [];
+    let h = 0, c = 0, d = null, l = 0;
+    const g = this.geometryType === "esriGeometryPolygon";
+    for (; r.pos() < n && r.next(); )
+      switch (r.tag()) {
+        case 2: {
+          const _ = r.getUInt32(), m = r.pos() + _;
+          for (; r.pos() < m; ) {
+            const p = r.getUInt32();
+            a.push(p), h += p;
+          }
+          d = st(2 * h).delta;
+          break;
+        }
+        case 3: {
+          r.getUInt32();
+          const _ = 2 + (this.hasZ ? 1 : 0) + (this.hasM ? 1 : 0);
+          ss(d);
+          for (const m of a)
+            if (c + _ * m > d.length)
+              for (let p = 0; p < m; p++)
+                r.getSInt32(), r.getSInt32(), this.hasZ && r.getSInt32(), this.hasM && r.getSInt32();
+            else if (g && xr) {
+              const p = this.getAreaSimplificationThreshold(m, this._header.vertexCount);
+              let I = 2, f = 1;
+              const k = !1;
+              let b = r.getSInt32(), v = r.getSInt32();
+              d[c++] = b, d[c++] = v, this.hasZ && r.getSInt32(), this.hasM && r.getSInt32();
+              let S = r.getSInt32(), w = r.getSInt32();
+              for (this.hasZ && r.getSInt32(), this.hasM && r.getSInt32(); I < m; ) {
+                let $ = r.getSInt32(), F = r.getSInt32();
+                this.hasZ && r.getSInt32(), this.hasM && r.getSInt32();
+                const O = b + S, R = v + w;
+                Cr(b, v, O, R, O + $, R + F) >= p ? (l += -0.5 * (O - b) * (R + v), f > 1 && _e(d[c - 2], d[c - 1], S, w) ? (d[c - 2] += S, d[c - 1] += w) : (d[c++] = S, d[c++] = w, f++), b = O, v = R) : ($ += S, F += w), S = $, w = F, I++;
+              }
+              f < 3 || k ? c -= 2 * f : (l += -0.5 * (b + S - b) * (v + w + v), _e(d[c - 2], d[c - 1], S, w) ? (d[c - 2] += S, d[c - 1] += w, o.push(f)) : (d[c++] = S, d[c++] = w, o.push(++f)));
+            } else {
+              let p = 0, I = r.getSInt32(), f = r.getSInt32();
+              this.hasZ && r.getSInt32(), this.hasM && r.getSInt32(), d[c++] = I, d[c++] = f, p += 1;
+              for (let k = 1; k < m; k++) {
+                const b = r.getSInt32(), v = r.getSInt32(), S = I + b, w = f + v;
+                l += -0.5 * (S - I) * (w + f), this.hasZ && r.getSInt32(), this.hasM && r.getSInt32(), k > 2 && _e(d[c - 2], d[c - 1], b, v) ? (d[c - 2] += b, d[c - 1] += v) : (d[c++] = b, d[c++] = v, p += 1), I = S, f = w;
+              }
+              o.push(p);
+            }
+          break;
+        }
+        default:
+          r.skip();
+      }
+    return this._cache.area = l, o.length ? new T(o, d) : null;
+  }
+};
+class oe {
+  constructor(e, t) {
+    this.service = e, this._metadata = t;
+  }
+  destroy() {
+  }
+}
+function $r(u, e) {
+  switch (u.type) {
+    case "memory":
+      return new qr(u, e);
+    case "ogc":
+      return new Er(u, e);
+    case "feature-service":
+      return u.queryMetadata.capabilities.query.supportsFormatPBF && y("featurelayer-pbf") ? new Ar(u, e) : new Rr(u, e);
+  }
+}
+async function Or(u) {
+  const e = new is();
+  return await e.open(u, {}), e;
+}
+class qr extends oe {
+  constructor(e, t) {
+    super(e, t), this._portsOpen = Or(e.source).then((s) => this.client = s);
+  }
+  destroy() {
+    this.client.close(), this.client = null;
+  }
+  async executeQuery(e, t) {
+    await this._portsOpen;
+    const s = await this.client.invoke("queryFeatures", e.toJSON(), t);
+    return M.fromFeatureSet(s, this._metadata);
+  }
+}
+class Ar extends oe {
+  async executeQuery(e, t) {
+    const { data: s } = await As(this.service.source, e, t), r = !e.quantizationParameters;
+    return Mr.fromBuffer(s, this._metadata, r);
+  }
+}
+class Rr extends oe {
+  async executeQuery(e, t) {
+    var a;
+    const { source: s, queryMetadata: r } = this.service, i = r.capabilities;
+    if (e.quantizationParameters != null && !i.query.supportsQuantization) {
+      const o = e.clone(), h = wt(o.quantizationParameters);
+      o.quantizationParameters = null;
+      const { data: c } = await Ne(s, o, this._metadata.spatialReference, t), d = mt(c, this._metadata.objectIdField);
+      return It(h, d), M.fromOptimizedFeatureSet(d, this._metadata);
+    }
+    const { data: n } = await Ne(s, e, this._metadata.spatialReference, t);
+    return this._metadata.geometryType === "esriGeometryPoint" && (n.features = (a = n.features) == null ? void 0 : a.filter((o) => {
+      if (o.geometry != null) {
+        const h = o.geometry;
+        return Number.isFinite(h.x) && Number.isFinite(h.y);
+      }
+      return !0;
+    })), M.fromFeatureSet(n, this._metadata);
+  }
+}
+let Er = class extends oe {
+  async executeQuery(e, t) {
+    const { capabilities: s } = this.service.queryMetadata;
+    if (e.quantizationParameters && !s.query.supportsQuantization) {
+      const i = e.clone(), n = wt(i.quantizationParameters);
+      i.quantizationParameters = null;
+      const a = await Be(this.service.source, e, t);
+      return It(n, a), M.fromOptimizedFeatureSet(a, this._metadata);
+    }
+    const r = await Be(this.service.source, e, t);
+    return M.fromOptimizedFeatureSet(r, this._metadata);
+  }
+}, Xt = class extends Yt {
+  constructor(e, t, s, r, i) {
+    super(s), this._serviceInfo = e, this._queryInfo = t, this._metadata = r, this._eventLog = i, this._queue = new ht({ concurrency: 16, process: async (n) => {
+      var o;
+      const a = { signal: (o = n.options) == null ? void 0 : o.signal, query: n.query.customParameters };
+      return this._adapter.executeQuery(n.query.inner, a);
+    } }), this._adapter = $r(e, r);
+  }
+  async updateFields(e) {
+    this._queryInfo.updateFields(e);
+    const t = Array.from(this._store.chunks()).map(async (r) => {
+      const i = ct.fromJSON(r.queryInfo.queryJSON);
+      if (i)
+        try {
+          return await this._tryUpdateFields(r.reader, i), null;
+        } catch (n) {
+          return n;
+        }
+    }), s = (await Promise.all(t)).filter((r) => r);
+    if (s.length)
+      throw new D("featurelayer-query", "Encountered errors when downloading fields", { errors: s });
+  }
+  async queryOverride({ edits: e }) {
+    const t = [], s = [];
+    for (const n of e.removed)
+      n.objectId != null && n.objectId !== -1 ? t.push(n.objectId) : s.push(n.globalId);
+    s.length && t.push(...this._mapGlobalIdsToObjectIds(s));
+    const r = e.addOrModified.map(({ objectId: n }) => n);
+    let i;
+    if (r.length) {
+      const n = this._queryInfo.createQuery({ objectIds: r });
+      i = await this._fetch(n);
+    } else
+      i = M.empty(this._metadata);
+    return { reader: i, removed: t };
+  }
+  _mapGlobalIdsToObjectIds(e) {
+    const t = new Set(e), s = this._metadata.globalIdField;
+    if (s == null)
+      throw new Error("InternalError: Recieved an edit with globalIds, but not supported by the service");
+    const r = [];
+    return this._store.forEachUnsafe((i) => {
+      const n = i.readAttribute(s);
+      t.has(n) && r.push(i.getObjectId());
+    }), r;
+  }
+  async _fetch(e, t) {
+    const s = await this._enqueue(e, t);
+    return await this._tryUpdateFields(s, e.inner), s;
+  }
+  async _tryUpdateFields(e, t) {
+    const s = this._queryInfo.createPatchFieldsQuery(t, e);
+    if (!s)
+      return;
+    const r = await this._enqueue(s, this._options);
+    e.joinAttributes(r);
+  }
+  async _enqueue(e, t) {
+    return this._eventLog.onEvent({ type: "fetchStart" }), this._queue.push({ query: e, options: t }).finally(() => {
+      this._eventLog.onEvent({ type: "fetchEnd", done: this._queue.length === 0 });
+    });
+  }
+}, Qt = class extends Xt {
+  constructor() {
+    super(...arguments), this._chunksById = /* @__PURE__ */ new Map();
+  }
+  unload(e) {
+    this._removeChunks(e.tile);
+  }
+  _addChunk(e) {
+    const t = e.tile.id;
+    this._chunksById.has(t) || this._chunksById.set(t, []);
+    const s = e.size();
+    (s || e.first || e.end) && (y("esri-2d-update-debug") && console.debug(`Chunk[${e.chunkId}] ATileLoadStrategy.addChunk [count=${s}]`), this._chunksById.get(t).push(e), this._store.insert(e));
+  }
+  _removeChunks(e) {
+    const t = this._chunksById.get(e.key.id) ?? [];
+    for (const s of t)
+      y("esri-2d-update-debug") && console.debug(`Tile[${e.key.id}] Chunk[${s.chunkId}] ATileLoadStrategy.removeChunk`), this._store.remove(s);
+    this._chunksById.delete(e.key.id);
+  }
+}, rt = class extends Z {
+  constructor(e, t, s, r, i, n) {
+    var a, o;
+    super(), this._reader = e, this._queryJSON = t, this._tile = s, this._sourceTile = r, this._sourceTileDepth = i, this._end = n, this.chunkId = `${this._tile.key.id}.${(a = this._sourceTile) == null ? void 0 : a.key.id}${this._end ? "e" : ""}`, this.normalizedChunkId = `${this._tile.key.normalizedId}.${(o = this._sourceTile) == null ? void 0 : o.key.normalizedId}${this._end ? "e" : ""}`;
+  }
+  get queryInfo() {
+    var e;
+    return { type: "drill-down-tile", chunkId: this.chunkId, tileId: this._tile.key.id, queryJSON: this._queryJSON, sourceTileDepth: this._sourceTileDepth, sourceTileId: (e = this._sourceTile) == null ? void 0 : e.key.id, size: this.size(), end: this.end };
+  }
+  get first() {
+    return this._sourceTileDepth === 0;
+  }
+  get reader() {
+    return this._reader;
+  }
+  get end() {
+    return this._end;
+  }
+  get tile() {
+    return this._tile;
+  }
+  get isTiled() {
+    return !0;
+  }
+  getTileReader(e) {
+    return this._tile.key.id === e.key.id ? this.reader : null;
+  }
+}, Pr = class {
+  constructor(e, t) {
+    this.subscription = e, this._tileIdToResult = /* @__PURE__ */ new Map(), this._controller = new AbortController(), se(e.options, () => this._controller.abort()), se(t, () => this._controller.abort());
+  }
+  get(e) {
+    return this._tileIdToResult.get(e);
+  }
+  set(e, t) {
+    this._tileIdToResult.set(e, t);
+  }
+  get options() {
+    return { signal: this._controller.signal };
+  }
+}, jr = class extends Qt {
+  constructor() {
+    super(...arguments), this._loadStates = /* @__PURE__ */ new Map();
+  }
+  get about() {
+    return { willQueryAllFeatures: !1, willQueryFullResolutionGeometry: !1 };
+  }
+  async load(e) {
+    this._loadStates.has(e.key.id) || this._loadStates.set(e.key.id, new Pr(e, this._options));
+    const t = this._loadStates.get(e.key.id);
+    let s;
+    try {
+      for await (const i of this._fetchChunkInfos(t, e.tile, 0)) {
+        const { queryJSON: n, reader: a, sourceTile: o, sourceTileDepth: h, tile: c } = i, d = new rt(a, n, c, o, h, !1);
+        Y(e.options), this._addChunk(d);
+      }
+    } catch (i) {
+      s = i;
+    }
+    const r = new rt(M.empty(this._metadata), null, e.tile, null, -1, !0);
+    if (this._addChunk(r), s)
+      throw s;
+  }
+  unload(e) {
+    super.unload(e), this._loadStates.delete(e.key.id);
+  }
+  async *_fetchChunkInfos(e, t, s) {
+    let r = e.get(t.id);
+    const i = !!r;
+    if (r || (r = await this._fetchChunkInfo(e, t, s), e.set(t.id, r)), r.reader.exceededTransferLimit && s < y("featurelayer-query-max-depth"))
+      for (const n of t.createChildTiles())
+        yield* this._fetchChunkInfos(e, n, s + 1);
+    else
+      i || (yield r);
+  }
+  async _fetchChunkInfo(e, t, s) {
+    const r = e.subscription.tile.getQuantizationParameters(), i = this._queryInfo.createTileQuery(t, { returnExceededLimitFeatures: !1, quantizationParameters: r });
+    return { reader: await this._fetch(i, e.subscription.options), queryJSON: i.inner.toJSON(), tile: e.subscription.tile, sourceTile: t, sourceTileDepth: s };
+  }
+}, it = class extends Z {
+  constructor(e, t, s, r, i) {
+    super(), this._reader = e, this._queryJSON = t, this._tile = s, this._page = r, this._end = i, this.chunkId = `${this._tile.key.id}.${this._page}${this.end ? "e" : ""}`, this.normalizedChunkId = `${this._tile.key.normalizedId}.${this._page}${this.end ? "e" : ""}`;
+  }
+  get queryInfo() {
+    return { type: "paged-tile", chunkId: this.chunkId, tileId: this._tile.key.id, queryJSON: this._queryJSON, page: this._page, size: this.size(), end: this.end };
+  }
+  get reader() {
+    return this._reader;
+  }
+  get first() {
+    return this._page === 0;
+  }
+  get end() {
+    return this._end;
+  }
+  get page() {
+    return this._page;
+  }
+  get tile() {
+    return this._tile;
+  }
+  get isTiled() {
+    return !0;
+  }
+  getTileReader(e) {
+    return this._tile.key.id === e.key.id ? this.reader : null;
+  }
+}, Dr = class {
+  constructor(e, t) {
+    this.subscription = e, this._pages = /* @__PURE__ */ new Set(), this._controller = new AbortController(), this._done = !1, se(e.options, () => this._controller.abort()), se(t, () => this._controller.abort());
+  }
+  resetAbortController() {
+    this._controller = new AbortController();
+  }
+  get pageStart() {
+    let e = -1;
+    for (const t of this._pages.values())
+      e = Math.max(e, t);
+    return e + 1;
+  }
+  get done() {
+    return this._done;
+  }
+  get options() {
+    return { signal: this._controller.signal };
+  }
+  add(e, t) {
+    this._pages.add(e), this._done = this._done || t;
+  }
+}, Lr = class extends Qt {
+  constructor() {
+    super(...arguments), this._loadStates = /* @__PURE__ */ new Map();
+  }
+  get about() {
+    return { willQueryAllFeatures: !1, willQueryFullResolutionGeometry: !1 };
+  }
+  async load(e) {
+    this._loadStates.has(e.key.id) || this._loadStates.set(e.key.id, new Dr(e, this._options));
+    const t = this._loadStates.get(e.key.id);
+    let s;
+    t.resetAbortController();
+    try {
+      await this._fetchPages(t);
+    } catch (i) {
+      s = i;
+    }
+    const r = new it(M.empty(this._metadata), null, e.tile, -1, !0);
+    if (ns(t.options) || this._addChunk(r), s)
+      throw s;
+  }
+  unload(e) {
+    super.unload(e), this._loadStates.delete(e.key.id);
+  }
+  async _fetchPages(e) {
+    let r = 0, i = e.pageStart, n = 1;
+    for (; r < 20 && !e.done; ) {
+      const a = [];
+      for (let h = 0; h < n; h++)
+        a.push(this._fetchChunk(e, i++));
+      const o = await Promise.all(a);
+      for (const h of o)
+        (h.size() !== 0 || h.first) && (e.add(h.page, !h.reader.exceededTransferLimit), Y(e.options), this._addChunk(h));
+      r++, n = Math.min(n + 1, 4);
+    }
+  }
+  async _fetchChunk(e, t) {
+    const s = e.subscription.tile, r = this._queryInfo.createPagedTileQuery(s, t), i = await this._fetch(r, e.options);
+    return new it(i, r.inner.toJSON(), s, t, !1);
+  }
+}, nt = class extends Z {
+  constructor(e, t, s, r) {
+    super(), this._reader = e, this._queryJSON = t, this._page = s, this._end = r, this.chunkId = `${this._page}${this.end ? "e" : ""}`, this.normalizedChunkId = this.chunkId;
+  }
+  get reader() {
+    return this._reader;
+  }
+  get first() {
+    return this._page === 0;
+  }
+  get end() {
+    return this._end;
+  }
+  get queryInfo() {
+    return { type: "snapshot", chunkId: this.chunkId, queryJSON: this._queryJSON, page: this._page, size: this.size(), end: this.end };
+  }
+  get isTiled() {
+    return !1;
+  }
+  getTileReader(e) {
+    const t = this.queryFeaturesInBounds(e.bounds);
+    return t.setTransformForDisplay(e.transform), t;
+  }
+};
+class zr extends Xt {
+  constructor(e, t, s, r, i, n) {
+    super(e, t, s, i, n), this._random = new pt(1e3), this._featureCount = r;
+  }
+  get about() {
+    return { willQueryAllFeatures: !0, willQueryFullResolutionGeometry: !0 };
+  }
+  load(e) {
+    return this._promise == null && (this._promise = this._downloadPages(this._featureCount)), this._promise;
+  }
+  unload(e) {
+  }
+  async _downloadPages(e) {
+    const t = Math.ceil(e / this._queryInfo.pageSize), s = Array.from({ length: t }, (a, o) => o).sort((a, o) => this._random.getInt() - this._random.getInt()), r = await Promise.all(s.map((a) => this._downloadPage(a))), i = new nt(M.empty(this._metadata), null, -1, !0);
+    this._store.insert(i);
+    const n = r.filter((a) => a);
+    if (n.length)
+      throw new D("featurelayer-query", "Encountered errors when downloading data", { errors: n });
+  }
+  async _downloadPage(e) {
+    try {
+      const t = this._queryInfo.createPagedQuery(e), s = await this._fetch(t, this._options), r = new nt(s, t.inner.toJSON(), e, !1);
+      return Y(this._options), this._store.insert(r), null;
+    } catch (t) {
+      return t;
+    }
+  }
+}
+const Ur = "__esri_stream_id__", at = "__esri_timestamp__", ot = 1e3;
+class Gr {
+  constructor(e, t, s, r, i = 128) {
+    this._trackIdToObservations = /* @__PURE__ */ new Map(), this._idCounter = 0, this._lastPurge = performance.now(), this._addOrUpdated = /* @__PURE__ */ new Map(), this._removed = [], this._maxAge = 0, this._timeInfo = s, this._purgeOptions = r, this.store = e, this.objectIdField = t, this.purgeInterval = i, this._useGeneratedIds = this.objectIdField === Ur;
+  }
+  removeById(e) {
+    this._removed.push(e);
+  }
+  removeByTrackId(e) {
+    const t = this._trackIdToObservations.get(e);
+    if (t)
+      for (const s of t.entries)
+        this._removed.push(s);
+  }
+  add(e) {
+    var n;
+    if (this._useGeneratedIds) {
+      const a = this._nextId();
+      e.attributes[this.objectIdField] = a, e.objectId = a;
+    } else
+      e.objectId = e.attributes[this.objectIdField];
+    const t = e.objectId;
+    if (this._addOrUpdated.set(t, e), this._maxAge = Math.max(this._maxAge, e.attributes[this._timeInfo.startTimeField]), !this._timeInfo.trackIdField)
+      return this._trackIdLessObservations == null && (this._trackIdLessObservations = new Ve(1e5)), void this._trackIdLessObservations.enqueue(t);
+    const s = e.attributes[this._timeInfo.trackIdField];
+    if (!this._trackIdToObservations.has(s)) {
+      const a = ((n = this._purgeOptions) == null ? void 0 : n.maxObservations) != null ? this._purgeOptions.maxObservations : ot, o = as(a, 0, ot);
+      this._trackIdToObservations.set(s, new Ve(o));
+    }
+    const r = this._trackIdToObservations.get(s), i = r == null ? void 0 : r.enqueue(t);
+    i != null && (this._addOrUpdated.has(i) ? this._addOrUpdated.delete(i) : this._removed.push(i));
+  }
+  checkForUpdates() {
+    const e = this._getToAdd(), t = this._getToRemove(), s = performance.now();
+    s - this._lastPurge >= this.purgeInterval && (this._purge(s), this._lastPurge = s);
+    const r = [];
+    if (t != null)
+      for (const n of t) {
+        const a = this.store.removeById(n);
+        a != null && r.push(a);
+      }
+    const i = [];
+    if (e != null) {
+      const n = new Set(t ?? []);
+      for (const a of e)
+        n.has(a.objectId) || (a.attributes[at] = s, this.store.add(a), i.push(a));
+    }
+    return !(!i.length && !(r != null && r.length)) && (this.store.update(i, r), !0);
+  }
+  _getToAdd() {
+    if (!this._addOrUpdated.size)
+      return null;
+    const e = new Array(this._addOrUpdated.size);
+    let t = 0;
+    return this._addOrUpdated.forEach((s) => e[t++] = s), this._addOrUpdated.clear(), e;
+  }
+  _getToRemove() {
+    const e = this._removed;
+    return this._removed.length ? (this._removed = [], e) : null;
+  }
+  _nextId() {
+    const e = this._idCounter;
+    return this._idCounter = (this._idCounter + 1) % 4294967294 + 1, e;
+  }
+  _purge(e) {
+    const t = this._purgeOptions;
+    t != null && (this._purgeSomeByDisplayCount(t), this._purgeByAge(t), this._purgeByAgeReceived(e, t), this._purgeTracks());
+  }
+  _purgeSomeByDisplayCount(e) {
+    if (!e.displayCount)
+      return;
+    let t = this.store.size;
+    if (t > e.displayCount) {
+      if (this._timeInfo.trackIdField) {
+        for (const s of this._trackIdToObservations.values())
+          if (t > e.displayCount && s.size) {
+            const r = s.dequeue();
+            this._removed.push(r), t--;
+          }
+      }
+      if (this._trackIdLessObservations != null) {
+        let s = t - e.displayCount;
+        for (; s-- > 0; ) {
+          const r = this._trackIdLessObservations.dequeue();
+          r != null && this._removed.push(r);
+        }
+      }
+    }
+  }
+  _purgeByAge(e) {
+    var i;
+    const t = (i = this._timeInfo) == null ? void 0 : i.startTimeField;
+    if (!e.age || !t)
+      return;
+    const s = 60 * e.age * 1e3, r = this._maxAge - s;
+    this.store.forEach((n) => {
+      n.attributes[t] < r && this._removed.push(n.objectId);
+    });
+  }
+  _purgeByAgeReceived(e, t) {
+    if (!t.ageReceived)
+      return;
+    const s = e - 60 * t.ageReceived * 1e3;
+    this.store.forEach((r) => {
+      r.attributes[at] < s && this._removed.push(r.objectId);
+    });
+  }
+  _purgeTracks() {
+    this._trackIdToObservations.forEach((e, t) => {
+      e.size === 0 && this._trackIdToObservations.delete(t);
+    });
+  }
+}
+let U = class extends _t {
+  constructor(u) {
+    super(u);
+  }
+  get connectionStatus() {
+    var u;
+    return (u = this.connection) == null ? void 0 : u.connectionStatus;
+  }
+  get errorString() {
+    var u;
+    return (u = this.connection) == null ? void 0 : u.errorString;
+  }
+};
+G([K()], U.prototype, "connection", void 0), G([K()], U.prototype, "connectionStatus", null), G([K()], U.prototype, "errorString", null), U = G([lt("esri.views.2d.layers.features.sources.StreamConnectionState")], U);
+class Wr {
+  constructor(e, t) {
+    this._metadata = e, this._onUpdate = t, this._objectIdToFeature = /* @__PURE__ */ new Map();
+  }
+  get size() {
+    return this._objectIdToFeature.size;
+  }
+  get reader() {
+    return M.fromFeatures([...this._objectIdToFeature.values()], this._metadata);
+  }
+  add(e) {
+    this._objectIdToFeature.set(e.objectId, e);
+  }
+  forEach(e) {
+    this._objectIdToFeature.forEach(e);
+  }
+  removeById(e) {
+    const t = this._objectIdToFeature.get(e);
+    return t ? (this._objectIdToFeature.delete(e), t) : null;
+  }
+  clear() {
+    this._objectIdToFeature = /* @__PURE__ */ new Map();
+  }
+  update(e, t) {
+    this._onUpdate((e == null ? void 0 : e.length) ?? 0);
+  }
+}
+let Nr = class extends Z {
+  constructor(e) {
+    super(), this._reader = e, this.chunkId = "stream-chunk", this.normalizedChunkId = "stream-chunk";
+  }
+  get reader() {
+    return this._reader;
+  }
+  get first() {
+    return !0;
+  }
+  get end() {
+    return !0;
+  }
+  get queryInfo() {
+    return { type: "stream", chunkId: this.chunkId, size: this.size(), end: this.end };
+  }
+  get isTiled() {
+    return !1;
+  }
+  getTileReader(e) {
+    const t = this.queryFeaturesInBounds(e.bounds);
+    return t.setTransformForDisplay(e.transform), t;
+  }
+};
+class Br extends Yt {
+  constructor(e, t, s, r, i) {
+    super(s), this._service = e, this._dataFilter = t, this._streamOptions = r, this._metadata = i, this._connectionState = new U(), this._forceRefresh = !1, this.events = new xe();
+    const { objectIdField: n, timeInfo: a } = this._metadata, { purgeOptions: o } = t;
+    this._stagingStore = new Wr(this._metadata, (h) => this.events.emit("features-updated", h)), this._manager = new Gr(this._stagingStore, n, a, o), this.connect();
+  }
+  destroy() {
+    super.destroy(), this.disconnect();
+  }
+  get about() {
+    return { willQueryAllFeatures: !1, willQueryFullResolutionGeometry: !1 };
+  }
+  get connectionStatus() {
+    return this._connectionState.connectionStatus;
+  }
+  get errorString() {
+    var e;
+    return (e = this._connectionState) == null ? void 0 : e.errorString;
+  }
+  async refresh() {
+    const e = this._chunk != null;
+    this._manager.checkForUpdates() || !e || this._forceRefresh ? (this._chunk && this._store.remove(this._chunk), this._forceRefresh = !1, this._chunk = new Nr(this._stagingStore.reader), this._store.insert(this._chunk), this.events.emit("tick")) : this.events.emit("tick");
+  }
+  async updateFields(e) {
+    throw new Error("Updating available fields not supported for StreamLayer");
+  }
+  async load(e) {
+  }
+  unload(e) {
+  }
+  disconnect() {
+    var e;
+    this._connection = dt(this._connection), this._connectionState.connection = null, (e = this._handlesGroup) == null || e.remove();
+  }
+  connect() {
+    if (this._connection != null)
+      return;
+    const { geometryType: e, spatialReference: t } = this._metadata, { maxReconnectionAttempts: s, maxReconnectionInterval: r, geometryDefinition: i, definitionExpression: n, customParameters: a } = this._dataFilter;
+    this._connection = Ds(this._service.source, t, this._streamOptions.outSR, e, n, i, s, r, a), this._handlesGroup = gt([this._connection.on("data-received", (o) => this._onFeature(o)), this._connection.on("message-received", (o) => this._onWebSocketMessage(o))]), this._connectionState.connection = this._connection;
+  }
+  clear() {
+    this._manager.checkForUpdates(), this._stagingStore.clear(), this._forceRefresh = !0;
+  }
+  updateCustomParameters(e) {
+    var t;
+    (t = this._connection) == null || t.updateCustomParameters(e);
+  }
+  sendMessageToSocket(e) {
+    var t;
+    (t = this._connection) == null || t.sendMessageToSocket(e);
+  }
+  sendMessageToClient(e) {
+    var t;
+    (t = this._connection) == null || t.sendMessageToClient(e);
+  }
+  _onWebSocketMessage(e) {
+    if ("type" in e)
+      switch (e.type) {
+        case "delete":
+          if (e.objectIds)
+            for (const t of e.objectIds)
+              this._manager.removeById(t);
+          if (e.trackIds)
+            for (const t of e.trackIds)
+              this._manager.removeByTrackId(t);
+          break;
+        case "clear":
+          this.clear();
+      }
+    this.events.emit("message-received", e);
+  }
+  _onFeature(e) {
+    try {
+      this._manager.add(e), this.events.emit("data-received", e);
+    } catch {
+    }
+  }
+}
+class Vr {
+  constructor(e) {
+    this._onChange = e, this._chunks = /* @__PURE__ */ new Map(), this._chunksToRemove = [], this.events = new xe(), this.featureAdapter = new ys();
+  }
+  destroy() {
+    this.clear();
+  }
+  clear() {
+    for (const e of this._chunks.values())
+      this._chunksToRemove.push(e);
+    this._chunks.clear(), this._overrideChunk != null && this._chunksToRemove.push(this._overrideChunk), this._overrideChunk = null;
+  }
+  *chunks() {
+    this._overrideChunk && (yield this._overrideChunk), yield* this._chunks.values();
+  }
+  insert(e) {
+    var t;
+    y("esri-2d-update-debug") && console.debug(`Chunk[${e.chunkId}] SourceChunkStore.insert`), (t = this._overrideChunk) != null && t.overridenIds.size && e.reader.removeIds(this._overrideChunk.overridenIds), this._chunks.set(e.chunkId, e), this.events.emit("changed"), this._onChange();
+  }
+  remove(e) {
+    y("esri-2d-update-debug") && console.debug(`Chunk[${e.chunkId}] SourceChunkStore.remove`), this._chunks.delete(e.chunkId), this._chunksToRemove.push(e);
+  }
+  cleanupRemovedChunks() {
+    const e = this._chunksToRemove;
+    return this._chunksToRemove = [], e;
+  }
+  applyOverrides(e, t) {
+    this._overrideChunk == null && (this._overrideChunk = new Nt(t)), this._overrideChunk.applyOverrides(e);
+    for (const s of this._chunks.values())
+      s.reader.removeIds(this._overrideChunk.overridenIds), s.invalidate();
+  }
+  forEach(e) {
+    const t = /* @__PURE__ */ new Set();
+    for (const s of this.chunks()) {
+      const r = s.reader.getCursor();
+      for (; r.next(); ) {
+        const i = r.getObjectId();
+        t.has(i) || (e(r.copy()), t.add(i));
+      }
+    }
+  }
+  forEachUnsafe(e) {
+    const t = /* @__PURE__ */ new Set();
+    for (const s of this.chunks()) {
+      const r = s.reader.getCursor();
+      for (; r.next(); ) {
+        const i = r.getObjectId();
+        t.has(i) || (e(r), t.add(i));
+      }
+    }
+  }
+  forEachInBounds(e, t) {
+    const s = /* @__PURE__ */ new Set();
+    for (const r of this.chunks()) {
+      const i = r.queryFeaturesInBounds(e);
+      for (; i.next(); ) {
+        const n = i.getObjectId();
+        s.has(n) || (t(i.copy()), s.add(n));
+      }
+    }
+  }
+  forEachBounds(e, t) {
+    const s = ke();
+    for (const r of e)
+      r.getBounds(s) && t(s);
+  }
+}
+class Yr {
+  constructor(e, t, s, r) {
+    this._aggregateAdapter = e, this._subscriptions = t, this._onChange = s, this._connection = r, this._updateTracking = new Ls({ debugName: "FeatureSource" }), this._didInvalidateData = !1, this._store = new Vr(this._onChange);
+  }
+  destroy() {
+    var e, t;
+    (e = this._strategy) == null || e.destroy(), this._store.destroy(), (t = this._streamMessenger) == null || t.destroy();
+  }
+  get _eventLog() {
+    return this._connection.eventLog;
+  }
+  get metadata() {
+    if (!this._metadata)
+      throw new Error("InternalError: Metadata not defined. Was update called?");
+    return this._metadata;
+  }
+  get service() {
+    return this._schema.service;
+  }
+  get store() {
+    return this._store;
+  }
+  get streamMessenger() {
+    return this._streamMessenger == null && this._initStreamMessenger(), this._streamMessenger;
+  }
+  get statistics() {
+    return mr.from(this._store);
+  }
+  get updateTracking() {
+    return this._updateTracking;
+  }
+  get queryEngine() {
+    if (!this._queryEngine) {
+      if (!this._schema)
+        return null;
+      const { dataFilter: e } = this._schema.mutable, t = this._schema.mutable.availableFields, s = this._metadata;
+      this._queryEngine = new vt({ featureStore: this._store, fieldsIndex: s.fieldsIndex, geometryType: s.geometryType, objectIdField: s.objectIdField, hasM: !1, hasZ: !1, spatialReference: e.outSpatialReference, cacheSpatialQueries: !0, aggregateAdapter: this._aggregateAdapter, timeInfo: s.timeInfo, definitionExpression: e.definitionExpression, availableFields: t });
+    }
+    return this._queryEngine;
+  }
+  get isStream() {
+    return this._schema.type === "stream";
+  }
+  chunks() {
+    return Array.from(this._store.chunks());
+  }
+  cleanupRemovedChunks() {
+    return this._store.cleanupRemovedChunks();
+  }
+  onSubscribe(e) {
+    var s;
+    this._eventLog.onEvent({ type: "subscribe", tile: e.tile.id });
+    const t = (s = this._strategy) == null ? void 0 : s.load(e);
+    t && (t.then(() => this._eventLog.onEvent({ type: "loaded", tile: e.tile.id })).catch((r) => this._eventLog.onEvent({ type: "error", tile: e.tile.id, error: r })), this._updateTracking.addPromise(t));
+  }
+  onResume(e) {
+    var t;
+    this._updateTracking.addPromise(ut((t = this._strategy) == null ? void 0 : t.load(e)));
+  }
+  onUnsubscribe(e) {
+    var t;
+    this._eventLog.onEvent({ type: "unsubscribe", tile: e.tile.id }), (t = this._strategy) == null || t.unload(e);
+  }
+  getOverride(e) {
+    return this._updateTracking.addPromise(this._doGetOverride(e));
+  }
+  applyOverride(e) {
+    this._didInvalidateData = !0, this._store.applyOverrides(e, this.metadata);
+  }
+  async update(e, t) {
+    var i, n, a;
+    const s = e.source, r = ft((i = this._schema) == null ? void 0 : i.mutable, s.mutable);
+    if (!r)
+      return !1;
+    if (y("esri-2d-update-debug") && console.debug(`Version[${t}] FeatureSource.update`, { changes: r }), this._schema = s, this._metadata = new $e(this._schema.service.metadata), (n = this._queryEngine) == null || n.destroy(), this._queryEngine = null, this._schema.type === "feature" && this._schema.service.queryMetadata.lastEditDate != null && (this._lastEditDate = this._schema.service.queryMetadata.lastEditDate), this._streamMessenger == null && this._schema.type === "stream" && this._initStreamMessenger(), ze(r, "sourceRefreshVersion") && ((a = this._strategy) == null ? void 0 : a.refresh))
+      return await this._strategy.refresh(), !0;
+    if (s.type === "feature" && ze(r, "availableFields")) {
+      if (await this._queryLastEditDateChanged() || this._didInvalidateData)
+        this._didInvalidateData = !1, await this._updateStrategy(t);
+      else {
+        this._eventLog.onEvent({ type: "updateFieldsStart" });
+        try {
+          await this._strategy.updateFields(s.mutable.availableFields), this._eventLog.onEvent({ type: "updateFieldsEnd" });
+        } catch (o) {
+          this._eventLog.onEvent({ type: "updateFieldsError", error: o });
+        }
+      }
+      return !1;
+    }
+    return !(!Ue(r, "dataFilter") && !Ue(r, "sourceRefreshVersion")) && (await this._updateStrategy(t), !0);
+  }
+  _initStreamMessenger() {
+    this._streamMessenger == null && (this._streamMessenger = new te(this._connection));
+  }
+  async _doGetOverride(e) {
+    return this._strategy.queryOverride(e);
+  }
+  async _queryLastEditDateChanged() {
+    if (this._lastEditDate == null)
+      return !1;
+    const e = this._schema.service.source, t = { ...e.query, f: "json" }, s = (await os(e.path, { query: t, responseType: "json" })).data.editingInfo.lastEditDate;
+    return s !== this._lastEditDate && (this._lastEditDate = s, !0);
+  }
+  async _createStrategy() {
+    const e = this.service, t = "isSourceHosted" in e && e.isSourceHosted, s = Array.isArray(e.source), r = e.source && "collection" in e.source, i = t || s || r;
+    if (this._schema.type === "stream") {
+      const o = new Br(this._schema.service, this._schema.mutable.dataFilter, this._store, { outSR: this._schema.mutable.dataFilter.outSpatialReference }, this.metadata);
+      return this._streamMessenger.strategy = o, o;
+    }
+    const n = Ir.fromSchema(this._schema, this._metadata), a = await this._supportSnapshotMode(this._schema, n);
+    return a ? new zr(this._schema.service, n, this._store, a.featureCount, this.metadata, this._eventLog) : i ? new Lr(this._schema.service, n, this._store, this.metadata, this._eventLog) : new jr(this._schema.service, n, this._store, this.metadata, this._eventLog);
+  }
+  async _updateStrategy(e) {
+    var n;
+    const t = await this._createStrategy();
+    this._eventLog.onEvent({ type: "updateStrategyStart", about: t.about });
+    const s = !!this._strategy;
+    this._store.clear(), (n = this._strategy) == null || n.destroy(), this._strategy = t, y("esri-2d-update-debug") && console.debug(`Version[${e}] FeatureSource.updateStrategy`, { strategy: t });
+    const r = Array.from(this._subscriptions.values());
+    if (!r.length)
+      return void this._eventLog.onEvent({ type: "updateStrategyEnd" });
+    const i = Promise.all(r.map((a) => this._strategy.load(a).then(() => this._eventLog.onEvent({ type: "loaded", tile: a.tile.id })).catch((o) => this._eventLog.onEvent({ type: "error", tile: a.tile.id, error: o }))));
+    this._updateTracking.addPromise(i);
+    try {
+      s && await i;
+    } catch (a) {
+      Fe(a);
+    }
+    this._eventLog.onEvent({ type: "updateStrategyEnd" }), y("esri-2d-update-debug") && console.debug(`Version[${e}] FeatureSource.updateStrategyEnd`, { strategy: t });
+  }
+  async _supportSnapshotMode(e, t) {
+    const { queryMetadata: s } = e.service, r = s.snapshotInfo;
+    if (!r || !r.supportsSnapshotMinThreshold || !r.snapshotCountThresholds)
+      return null;
+    const i = e.service.source, n = t.createQuery();
+    n.inner.orderByFields = [], n.inner.returnGeometry = !1;
+    const a = (await Rs(i, n.inner, { query: n.customParameters })).data.count, { min: o, max: h } = r.snapshotCountThresholds;
+    return a <= o || r.supportsSnapshotMaxThreshold && a < h ? { featureCount: a } : null;
+  }
+}
+class Xr {
+  constructor(e, t) {
+    this._handles = new hs(), this._abortController = new AbortController(), this._resolver = Te(), this._isDone = !1, this._aborted = !1, this.tile = e, this._version = t, this._handles.add([]);
+  }
+  destroy() {
+    this.pause(), this._handles.destroy();
+  }
+  get key() {
+    return this.tile.key;
+  }
+  get version() {
+    return this._version;
+  }
+  set version(e) {
+    this._version = e;
+  }
+  get signal() {
+    return this._abortController.signal;
+  }
+  get options() {
+    return { signal: this._abortController.signal };
+  }
+  get done() {
+    return this._resolver.promise;
+  }
+  get isDone() {
+    return this._isDone;
+  }
+  resolve() {
+    this._isDone = !0, this._resolver.resolve();
+  }
+  get paused() {
+    return this._aborted;
+  }
+  resume() {
+    this._abortController = new AbortController(), this._aborted = !1;
+  }
+  pause() {
+    this._aborted || (this._aborted = !0, this._abortController.abort());
+  }
+}
+class Qr {
+  constructor(e) {
+    this.edit = e, this.resolver = Te();
+  }
+}
+class Zr {
+  constructor(e, t) {
+    this.schema = e, this.version = t, this.resolver = Te();
+  }
+}
+class Un {
+  constructor() {
+    this._aggregateAdapter = { getFeatureObjectIds: (e) => this._processor.getFeatureObjectIdsForAggregate(e) }, this._subscriptions = /* @__PURE__ */ new Map(), this._updateRequested = !1, this._updateSubscriptionRequests = [], this._updateHighlightRequests = [];
+  }
+  destroy() {
+    this._subscriptions.clear(), this._processor.destroy(), this._source.destroy(), this._handles.remove(), this._editState = null, this._tileInfoView = null;
+  }
+  onDetach() {
+    this.destroy(), this._initialize(this._connection);
+  }
+  _initialize(e) {
+    this._source = new Yr(this._aggregateAdapter, this._subscriptions, () => this._requestUpdate(), e), this._processor = new yr(e, this._source), this._handles = gt([pe(() => this._source.updateTracking.updating, () => {
+      this._requestUpdate(), this._connection.layerView.setUpdating({ data: this._source.updateTracking.updating, pipeline: !0 });
+    })]);
+  }
+  set remoteClient(e) {
+    this._connection = new zs(e), this._initialize(this._connection);
+  }
+  get features() {
+    const e = this._source.queryEngine;
+    if (!e)
+      throw new D("no-queryEngine", "No query engine defined");
+    return e;
+  }
+  get aggregates() {
+    const e = this._processor.aggregateQueryEngine;
+    if (!e)
+      throw new D("no-queryEngine", "No aggregate query engine defined");
+    return e;
+  }
+  get processor() {
+    return this._processor;
+  }
+  get streamMessenger() {
+    return this._source.streamMessenger;
+  }
+  getDisplayFeatures(e) {
+    return this._processor.getDisplayFeatures(e);
+  }
+  async updateSchema(e, t) {
+    return y("esri-2d-update-debug") && this._updateSchemaState && console.error("InternalError: Schema already updating"), this._updateSchemaState = new Zr(e, t), this._requestUpdate(), this._updateSchemaState.resolver.promise;
+  }
+  updateSubscriptions(e) {
+    this._updateSubscriptionRequests.push(e), this._requestUpdate();
+  }
+  updateHighlight(e) {
+    this._updateHighlightRequests.push(e), this._requestUpdate();
+  }
+  async onEdits(e) {
+    if (this._editState != null)
+      throw new D("InternalError - Already processing an edit");
+    this._editState = new Qr(e);
+    const t = this._editState.resolver.promise;
+    return this._requestUpdate(), t;
+  }
+  queryStatistics() {
+    return this._source.statistics.toJSON();
+  }
+  async queryVisibleFeatures(e, t) {
+    return this.features.executeQuery(e, t);
+  }
+  async queryHeatmapStatistics(e) {
+    const t = Math.round(us(e.radius));
+    let s = Number.POSITIVE_INFINITY, r = Number.NEGATIVE_INFINITY;
+    const i = typeof e.fieldOffset == "string", n = e.fieldOffset ?? 0, a = Array.from(this._subscriptions.values()), o = this._source.chunks(), h = t ** 2, c = 3 / (Math.PI * h), d = 2 * t, l = Math.ceil(x / d);
+    for (const g of a) {
+      const _ = g.tile, m = new Float64Array(l * l);
+      for (const p of o) {
+        const I = p.getTileReader(_);
+        if (!I)
+          continue;
+        const f = I.getCursor();
+        for (; f.next(); ) {
+          let k = 1;
+          if (e.field != null) {
+            const O = f.readAttribute(e.field);
+            k = i ? -1 * +O : +O + n;
+          }
+          const b = f.readXForDisplay() / d, v = f.readYForDisplay() / d, S = Math.floor(b), w = Math.floor(v);
+          if (S < 0 || w < 0 || S >= l || w >= l)
+            continue;
+          const $ = ((0.5 + S - b) * d) ** 2 + ((0.5 + w - v) * d) ** 2;
+          if ($ > h)
+            continue;
+          const F = k * (c * (1 - $ / h) ** 2);
+          m[w + S * l] += F;
+        }
+      }
+      for (let p = 0; p < m.length; p++)
+        s = Math.min(s, m[p]), r = Math.max(r, m[p]);
+    }
+    return { max: r, min: s };
+  }
+  async getSampleFeatures(e) {
+    const t = this._source.chunks();
+    if (t.reduce((o, h) => o + h.size(), 0) <= e.minFeatureCount) {
+      if (!this._source.updateTracking.updating) {
+        const o = [];
+        return this._source.store.forEachUnsafe((h) => o.push(h.readLegacyFeatureWorldSpace())), o;
+      }
+      return null;
+    }
+    const s = /* @__PURE__ */ new Set(), r = [], i = t.map((o) => o.reader.getCursor()), n = new pt(), a = 3 * e.sampleSize;
+    for (let o = 0; o < a && r.length < e.sampleSize; o++) {
+      const h = i[n.getIntRange(0, t.length - 1)];
+      if (h.getSize() === 0)
+        continue;
+      const c = n.getIntRange(0, h.getSize() - 1);
+      h.setIndex(c);
+      const d = h.getObjectId();
+      s.has(d) || (s.add(d), r.push(h.readLegacyFeatureWorldSpace()));
+    }
+    return r.length >= e.sampleSize ? r : null;
+  }
+  _requestUpdate() {
+    this._updateRequested || (this._updateRequested = !0, ds(() => this._scheduleNextUpdate()));
+  }
+  _scheduleNextUpdate() {
+    this._updateRequested && (this._ongoingUpdate || (this._ongoingUpdate = this._doUpdate().finally(() => {
+      this._ongoingUpdate = null, this._scheduleNextUpdate();
+    }), this._updateRequested = !1));
+  }
+  _subscribe(e) {
+    const t = e.tileId;
+    if (this._subscriptions.has(t)) {
+      const i = this._subscriptions.get(t);
+      return void (i.paused && (y("esri-2d-update-debug") && console.debug(`Tile[${t}] Pipeline.resume`), i.resume(), i.version = e.version, this._source.onResume(i)));
+    }
+    y("esri-2d-update-debug") && console.debug(`Tile[${t}] Pipeline.subscribe`);
+    const s = new cs(this._tileInfoView, t), r = new Xr(s, e.version);
+    this._subscriptions.set(t, r), this._source.onSubscribe(r), this._processor.onSubscribe(r);
+  }
+  _unsubscribe(e) {
+    const t = this._subscriptions.get(e);
+    t && (y("esri-2d-update-debug") && console.debug(`Tile[${e}] Pipeline.unsubscribe`), this._source.onUnsubscribe(t), this._processor.onUnsubscribe(t), this._subscriptions.delete(t.key.id), t.destroy());
+  }
+  _pauseSubscription(e) {
+    const t = this._subscriptions.get(e);
+    t && (y("esri-2d-update-debug") && console.debug(`Tile[${e}] Pipeline.pause`), t.pause());
+  }
+  async _doUpdate() {
+    if (y("esri-2d-update-debug") && console.debug("Pipeline._doUpdateStart"), await this._connection.layerView.setUpdating({ data: this._source.updateTracking.updating, pipeline: !0 }), this._updateSubscriptionRequests.length) {
+      const r = this._updateSubscriptionRequests;
+      this._updateSubscriptionRequests = [];
+      for (const i of r)
+        this._doUpdateSubscriptions(i);
+    }
+    const e = this._updateSchemaState;
+    if (this._updateSchemaState = null, e != null) {
+      const { schema: r, version: i } = e;
+      await this._doUpdateSchema(r, i);
+    }
+    const t = this._editState;
+    if (this._editState = null, t != null) {
+      y("esri-2d-update-debug") && console.debug("Pipeline.applyEditOverride", t.edit);
+      const r = await this._source.getOverride(t.edit);
+      await this._processor.applyOverride(r), y("esri-2d-update-debug") && console.debug("Pipeline.endEditOverride", t.edit);
+    }
+    if (this._updateHighlightRequests.length) {
+      const r = this._updateHighlightRequests;
+      this._updateHighlightRequests = [];
+      for (const i of r)
+        this._processor.updateHighlight(i);
+    }
+    const s = this._source.cleanupRemovedChunks();
+    this._processor.removeChunks(s);
+    try {
+      this._subscriptions.size && (y("esri-2d-update-debug") && console.debug("Pipeline.updateChunksStart"), await this._processor.updateChunks(), y("esri-2d-update-debug") && console.debug("Pipeline.updateChunksEnd"));
+    } catch (r) {
+      Fe(r);
+    }
+    t != null && t.resolver.resolve(), e != null && e.resolver.resolve(), this._updateRequested ? (y("esri-2d-update-debug") && console.debug("Pipeline._doUpdateEnd [updateRequested=true]"), await this._connection.layerView.setUpdating({ data: this._source.updateTracking.updating, pipeline: !0 })) : (y("esri-2d-update-debug") && console.debug("Pipeline._doUpdateEnd [updateRequested=false, After flush]"), await this._connection.layerView.setUpdating({ data: this._source.updateTracking.updating, pipeline: this._updateRequested }));
+  }
+  async _doUpdateSchema(e, t) {
+    var r;
+    if (y("esri-2d-update-debug") && console.debug(`Version[${t}] Pipeline.updateStart`, { schema: e }), !this._tileInfoView) {
+      const i = De.fromJSON(e.source.tileInfoJSON);
+      this._tileInfoView = new Le(i);
+    }
+    const s = { tileInfo: (r = this._tileInfoView) == null ? void 0 : r.tileInfo };
+    try {
+      const i = await this._source.update(e, t), n = Array.from(this._subscriptions.values());
+      await this._processor.update(e, t, s, i, n);
+    } catch (i) {
+      console.error(i);
+    }
+    y("esri-2d-update-debug") && console.debug(`Version[${t}] Pipeline.updateEnd`);
+  }
+  _doUpdateSubscriptions(e) {
+    if (y("esri-2d-update-debug") && console.debug("Pipeline.updateSubscriptions", e), !this._tileInfoView) {
+      const t = De.fromJSON(e.tileInfoJSON);
+      this._tileInfoView = new Le(t);
+    }
+    for (const t of e.subscribe)
+      this._subscribe(t);
+    for (const t of e.unsubscribe)
+      this._unsubscribe(t);
+    if (y("featurelayer-query-pausing-enabled"))
+      for (const t of e.pause)
+        this._pauseSubscription(t);
+  }
+}
+export {
+  Un as default
+};