@agrotools1/at-components 0.2.3 → 0.2.5

package/dist/FeatureLayerView2D-23240236.js

@@ -0,0 +1,1967 @@
+import { e as h, y as f, c as W, z as Ie, S as Ye, aO as g, c5 as lt, bR as ot, gY as ut, n as xe, aG as ct, W as C, s as q, dF as dt, bJ as pe, dO as et, c$ as pt, dc as ht, jR as ft, b as tt, cs as ae, q as fe, ab as yt, dQ as N, bz as ne, ci as ge, iF as mt, cy as ke, o as Ee, fG as gt, H as qe, ch as Ue, hI as Le, by as ye, da as bt, jS as Be, jT as St, jU as Je, jV as vt, jW as _t, hA as oe, iW as ve, jX as wt, k as Vt, cv as It, V as xt, B as Et, g as De, b3 as Ft, P as Rt, x as Ot, fc as $t, i as _e, jY as zt } from "./index-6ebf29c1.js";
+import { m as je } from "./diffUtils-54c1c039.js";
+import { b as He, E as we, R as H, a as Tt, N as Qe } from "./Container-f931e682.js";
+import { d as te } from "./FeatureFilter-1635b86a.js";
+import { d as Fe } from "./FeatureSet-ffd45984.js";
+import { t as Ct } from "./highlightReasons-b0f772b2.js";
+import { m as At, u as Pt } from "./LayerView-e41297e4.js";
+import { i as Ge, r as Mt } from "./TechniqueInstance-397b7dc2.js";
+import { r as Ke, K as Z, o as Nt, e as kt, Z as qt } from "./UpdateTracking2D-23c8ff3f.js";
+import { b as Ut } from "./WGLContainer-f05c906a.js";
+import { o as Lt } from "./tileUtils-3e0c8c1d.js";
+import { m as Bt } from "./lengthUtils-6a89d855.js";
+import { i as M } from "./sizeVariableUtils-a1b694d8.js";
+import { c as Jt } from "./OrderByInfo-e9ed942d.js";
+import { c as Dt } from "./labelingInfo-62fc9d21.js";
+import { f as jt } from "./heatmapUtils-b512588d.js";
+import { i as G, o as ue } from "./enums-fa8f05ab.js";
+import { e as Ht } from "./SDFHelper-b08be611.js";
+import "./LabelMetric-ee740bd1.js";
+import { P as ce } from "./definitions-a00a3a6c.js";
+import { n as me, h as x, c as z, d as de, e as U, f as ie, i as Re, x as be, t as Oe, m as L, g as Qt, b as Gt } from "./FeatureCommandQueue-4e426066.js";
+import { t as Kt } from "./HighlightCounter-fda615cd.js";
+import { j as Wt } from "./commonProperties-d1f695a2.js";
+import { m as Zt } from "./FeatureEffect-0a86f0ba.js";
+import { o as We } from "./floorFilterUtils-936f7587.js";
+import { p as Ve, n as Xt } from "./popupUtils-b72d32fb.js";
+import { i as Yt } from "./RefreshableLayerView-4956f17c.js";
+let he = class extends Ie {
+  constructor() {
+    super(...arguments), this.isAggregate = !0;
+  }
+  getEffectivePopupTemplate(e = !1) {
+    var r;
+    if (this.popupTemplate)
+      return this.popupTemplate;
+    const t = (r = this.sourceLayer) == null ? void 0 : r.featureReduction;
+    return t && "popupTemplate" in t && t.popupEnabled ? t.popupTemplate : null;
+  }
+  getObjectId() {
+    return this.attributes.aggregateId;
+  }
+};
+h([f({ type: Boolean })], he.prototype, "isAggregate", void 0), he = h([W("esri.AggregateGraphic")], he);
+const $e = he;
+let E = class extends Ye {
+  constructor(e) {
+    super(e), this._filter = null, this.duration = g("mapview-transitions-duration"), this._excludedEffectView = new He(e), this._includedEffectView = new He(e);
+  }
+  get excludedEffects() {
+    return this._excludedEffectView.effects;
+  }
+  set featureEffect(e) {
+    this._get("featureEffect") !== e && this._transitionTo(e);
+  }
+  get filter() {
+    var e;
+    return this._filter || ((e = this.featureEffect) == null ? void 0 : e.filter) || null;
+  }
+  get hasEffects() {
+    return this._excludedEffectView.hasEffects || this._includedEffectView.hasEffects;
+  }
+  get includedEffects() {
+    return this._includedEffectView.effects;
+  }
+  set scale(e) {
+    this._set("scale", e), this._excludedEffectView.scale = e, this._includedEffectView.scale = e;
+  }
+  get transitioning() {
+    return this._excludedEffectView.transitioning || this._includedEffectView.transitioning;
+  }
+  transitionStep(e, t) {
+    this._set("scale", t), this.transitioning ? (this._includedEffectView.transitionStep(e, t), this._excludedEffectView.transitionStep(e, t), this.transitioning || (this._filter = null)) : (this._excludedEffectView.scale = t, this._includedEffectView.scale = t);
+  }
+  endTransitions() {
+    this._includedEffectView.endTransitions(), this._excludedEffectView.endTransitions(), this._filter = null;
+  }
+  _transitionTo(e) {
+    const t = this._get("featureEffect"), r = e, s = r == null ? void 0 : r.includedEffect, a = r == null ? void 0 : r.excludedEffect, n = this._includedEffectView.canTransitionTo(s) && this._excludedEffectView.canTransitionTo(a);
+    this._includedEffectView.effect = s, this._excludedEffectView.effect = a, this._set("featureEffect", r), this._filter = (r == null ? void 0 : r.filter) || (t == null ? void 0 : t.filter) || null, n || this.endTransitions();
+  }
+};
+h([f()], E.prototype, "_filter", void 0), h([f()], E.prototype, "_excludedEffectView", void 0), h([f()], E.prototype, "_includedEffectView", void 0), h([f()], E.prototype, "duration", void 0), h([f()], E.prototype, "excludedEffects", null), h([f()], E.prototype, "featureEffect", null), h([f()], E.prototype, "filter", null), h([f()], E.prototype, "hasEffects", null), h([f()], E.prototype, "includedEffects", null), h([f({ value: 0 })], E.prototype, "scale", null), h([f()], E.prototype, "transitioning", null), E = h([W("esri.layers.effects.FeatureEffectView")], E);
+const ei = E;
+let ee = class extends Fe {
+  constructor() {
+    super(...arguments), this.features = [];
+  }
+  readFeatures(e, t) {
+    var a;
+    const r = ot.fromJSON(t.spatialReference), s = [];
+    for (let n = 0; n < e.length; n++) {
+      const o = e[n], u = $e.fromJSON(o), l = (a = o.geometry) == null ? void 0 : a.spatialReference;
+      u.geometry == null || l || (u.geometry.spatialReference = r);
+      const c = o.aggregateGeometries, d = u.aggregateGeometries;
+      if (c && d != null)
+        for (const p in d) {
+          const y = d[p], m = c[p], b = m == null ? void 0 : m.spatialReference;
+          y == null || b || (y.spatialReference = r);
+        }
+      s.push(u);
+    }
+    return s;
+  }
+};
+h([f({ type: [$e], json: { write: !0 } })], ee.prototype, "features", void 0), h([lt("features")], ee.prototype, "readFeatures", null), ee = h([W("esri.rest.support.AggregateFeatureSet")], ee);
+const ti = ee;
+let ii = class {
+  constructor() {
+    this._instanceById = /* @__PURE__ */ new Map();
+  }
+  destroy() {
+    this._instanceById.clear();
+  }
+  get size() {
+    return this._instanceById.size;
+  }
+  updateStart() {
+    this._instanceByIdNext = /* @__PURE__ */ new Map();
+  }
+  updateEnd() {
+    if (!this._instanceByIdNext)
+      throw new Error("InternalError: Found updateEnd call without corresponding updateStart");
+    for (const e of this._instanceById.keys())
+      this._instanceByIdNext.has(e) || this._instanceById.delete(e);
+    for (const [e, t] of this._instanceByIdNext.entries()) {
+      const r = this._instanceById.get(e);
+      r ? r.setInput(t.getInput()) : this._instanceById.set(e, t);
+    }
+    this._instanceByIdNext = null;
+  }
+  values() {
+    return this._instanceById.values();
+  }
+  ensureInstance(e, t, r) {
+    let s = `${e.registryName}`;
+    for (const n in t) {
+      const o = t[n];
+      if (typeof o == "object" && n === "geometry")
+        for (const u in o)
+          s += `.${n}.${u}.${o[u] != null}`;
+      else
+        s += `.${n}.${t[n] != null}`;
+    }
+    if (r != null)
+      for (const n in r)
+        r[n] && (s += `-${n}`);
+    const a = ut(s);
+    if (this._instanceByIdNext) {
+      const n = new Ge(Ke(a), e, e.meshWriter.name, t, r);
+      return this._instanceByIdNext.set(a, n), n;
+    }
+    if (!this._instanceById.has(a)) {
+      const n = new Ge(Ke(a), e, e.meshWriter.name, t, r);
+      this._instanceById.set(a, n);
+    }
+    return this._instanceById.get(a);
+  }
+  getInstance(e) {
+    return this._instanceById.get(e);
+  }
+}, ri = class {
+  constructor(e, t, r) {
+    this.getStage = e, this.version = t, this._tileInfoView = r, this._tiles = /* @__PURE__ */ new Map(), this._pendingUpdates = [], this._locked = !1;
+  }
+  destroy() {
+  }
+  tiles() {
+    return this._tiles.values();
+  }
+  size() {
+    return this._tiles.size;
+  }
+  setTiles(e) {
+    this._tiles.clear();
+    for (const t of e)
+      this._tiles.set(t.key.id, t);
+  }
+  lockUploads() {
+    this._locked = !0;
+  }
+  unlockUploads() {
+    this._locked = !1;
+    for (const e of this._pendingUpdates)
+      this.updateTile(e);
+    this._pendingUpdates = [];
+  }
+  updateTile(e) {
+    var a;
+    if (this._locked)
+      return void this._pendingUpdates.push(e);
+    if (g("esri-2d-update-debug")) {
+      const n = ((a = e.debugInfo) == null ? void 0 : a.chunkId) ?? "<EnsureEnd>";
+      console.debug(`Version[${e.version}] Tile[${e.id}] Chunk[${n}] RenderState.updateTile [${e.type}]`, e);
+    }
+    const t = this._ensureTile(e.id);
+    if (e.type === "update") {
+      const [n, ...o] = e.modify;
+      t.onMessage({ type: "update", modify: n, remove: e.remove, end: e.end, attributeEpoch: e.attributeEpoch });
+      for (const u of o) {
+        const l = this._tiles.get(u.tileId);
+        l && l.onMessage({ type: "update", modify: u, remove: e.remove, end: !1, isPixelBuffer: !0, attributeEpoch: null });
+      }
+      return;
+    }
+    if (e.append == null)
+      return void t.onMessage({ type: "append", clear: e.clear, debugInfo: e.debugInfo, end: e.end, attributeEpoch: e.attributeEpoch });
+    const [r, ...s] = e.append;
+    t.onMessage({ type: "append", clear: e.clear, append: r, debugInfo: e.debugInfo, end: e.end, attributeEpoch: e.attributeEpoch });
+    for (const n of s) {
+      const o = this._tiles.get(n.tileId);
+      o && o.onMessage({ type: "update", modify: n, remove: [], sort: !1, end: !1, isPixelBuffer: !0, attributeEpoch: null });
+    }
+  }
+  removeTile(e) {
+    const t = this._tiles.get(e);
+    g("esri-2d-update-debug") && console.debug(`Tile[${e}] RenderState.removeTile`), t == null || t.destroy(), this._tiles.delete(e);
+  }
+  isTileDone(e) {
+    const t = this._tiles.get(e.id);
+    return !!t && t.isReady;
+  }
+  _ensureTile(e) {
+    if (!this._tiles.has(e)) {
+      const t = this._createTile(e);
+      this._copyPixelBufferedEntitiesInto(t), this._tiles.set(e, t);
+    }
+    return this._tiles.get(e);
+  }
+  _createTile(e) {
+    g("esri-2d-update-debug") && console.debug(`Version[${this.version}] Tile[${e}] RenderState.createTile`);
+    const t = new xe(e), r = this._tileInfoView.getTileBounds(ct(), t), s = this._tileInfoView.getTileResolution(t.level), a = new Ut(t, s, r[0], r[3], !0);
+    if (a.stage = this.getStage(), !a.stage) {
+      const n = new C("featurelayerview:webgl", "Cannot create tile with empty stage");
+      q.getLogger("esri.views.2d.layers.features.RenderState").error(n);
+    }
+    return a;
+  }
+  _copyPixelBufferedEntitiesInto(e) {
+    let t = 7;
+    for (let r = -1; r <= 1; r++)
+      for (let s = -1; s <= 1; s++) {
+        if (r === 0 && s === 0)
+          continue;
+        const a = this._tileInfoView.tileInfo.isWrappable, n = Lt(e.key, s, r, a).id, o = this._tiles.get(n);
+        if (o != null) {
+          const u = 1 << t;
+          e.copyPixelBufferedEntitesFrom(o, u, s, r);
+        }
+        t--;
+      }
+  }
+}, si = class {
+  constructor(e, t) {
+    this.id = e, this.version = t, this._resolver = et(), this._done = !1;
+  }
+  get done() {
+    return this._done;
+  }
+  get promise() {
+    return this._resolver.promise;
+  }
+  end() {
+    this._resolver.resolve(), this._done = !0;
+  }
+  destroy() {
+    this._resolver.reject();
+  }
+}, ai = class extends Mt {
+  constructor(e) {
+    super(e.view.featuresTilingScheme), this.updatingHandles = new dt(), this._hitTestsRequests = [], this._store = new ii(), this._visibleTiles = /* @__PURE__ */ new Set(), this._subscriptions = /* @__PURE__ */ new Map(), this._updateStatisticsRequests = [], this._lockStatisticUpdates = !1, this._layerView = e;
+  }
+  renderChildren(e) {
+    if (this.attributeView.update(), this._renderState) {
+      const t = Array.from(this._renderState.tiles()).filter((r) => r.needsUpload);
+      t.length && (t[Math.floor(Math.random() * t.length)].upload(), t.length >= 2 && this.requestRender());
+      for (const r of this._renderState.tiles())
+        r.tryReady(this.attributeView.currentEpoch) && (this._layerView.requestUpdate(), this.hasLabels && this._layerView.view.labelManager.requestUpdate(), this.requestRender());
+    }
+    for (const t of this.children)
+      t.setTransform(e.state);
+    switch (this.hasAnimation && e.painter.effects.integrate.draw(e, e.attributeView), super.renderChildren(e), e.drawPhase) {
+      case we.MAP:
+        return this._renderMapPhase(e);
+      case we.HIGHLIGHT:
+        return this._renderHighlightPhase(e);
+      case we.LABEL:
+        return this._renderLabelPhase(e);
+    }
+  }
+  subscriptions() {
+    return this._subscriptions.values();
+  }
+  get _instanceStore() {
+    return this._store;
+  }
+  get instanceStore() {
+    return this._store;
+  }
+  get layerView() {
+    return this._layerView;
+  }
+  get hasLabels() {
+    return this._layerView.labelingCollisionInfos.length > 0;
+  }
+  get hasHighlight() {
+    return this._layerView.hasHighlight();
+  }
+  get _layer() {
+    return this._layerView.layer;
+  }
+  _getExclusivePostprocessingInstance({ drawPhase: e }) {
+    if (this._instanceStore == null)
+      return null;
+    let t = 0, r = null;
+    for (const s of this._instanceStore.values())
+      s.techniqueRef.drawPhase & e && (t++, s.techniqueRef.postProcessingEnabled && (r = s));
+    return t > 1 ? null : r;
+  }
+  _getOverrideStencilRef({ drawPhase: e }) {
+    if (this._instanceStore == null)
+      return null;
+    let t = null;
+    for (const r of this._instanceStore.values()) {
+      if (!(r.techniqueRef.drawPhase & e))
+        continue;
+      const { overrideStencilRef: s } = r.techniqueRef;
+      if (t == null)
+        t = s;
+      else if (t !== s) {
+        t = null;
+        break;
+      }
+    }
+    return t;
+  }
+  get children() {
+    return this._renderState ? Array.from(this._renderState.tiles()).filter((e) => this._visibleTiles.has(e.key.id)) : [];
+  }
+  async updateAttributeView(e) {
+    this.requestRender(), await this.updatingHandles.addPromise(this.attributeView.requestUpdate(e)), this.hasLabels && this._layerView.view.labelManager.requestUpdate();
+  }
+  updateSubscriptions(e) {
+    for (const { tileId: t, version: r } of e.subscribe)
+      if (this._subscriptions.has(t))
+        this._subscriptions.get(t).version = r;
+      else {
+        const s = new si(t, r);
+        this._subscriptions.set(t, s), this.updatingHandles.addPromise(s.promise);
+      }
+    for (const t of e.unsubscribe) {
+      const r = this._subscriptions.get(t);
+      r == null || r.destroy(), this._subscriptions.delete(t), this.removeTile(t);
+    }
+  }
+  isDone(e) {
+    return !!this._renderState && this._renderState.isTileDone(e);
+  }
+  async updateRenderState(e) {
+    g("esri-2d-update-debug") && console.debug(`Version[${e}] FeatureContainer.updateRenderState`), this._renderStateNext = new ri(() => this._stage, e, this._tileInfoView);
+  }
+  getDisplayStatistics(e, t) {
+    const r = this._statisticsByLevel.get(e);
+    return r ? r.get(t) : null;
+  }
+  updateStatistics(e, t) {
+    if (this._lockStatisticUpdates)
+      return void this._updateStatisticsRequests.push({ level: e, statistics: t });
+    let r = this._statisticsByLevel.get(e);
+    r || (r = /* @__PURE__ */ new Map(), this._statisticsByLevel.set(e, r));
+    for (const s of t)
+      r.set(s.fieldName, { minValue: s.minValue, maxValue: s.maxValue });
+  }
+  editStart() {
+    var e;
+    (e = this._renderState) == null || e.lockUploads(), this.attributeView.lockTextureUploads(), this._lockStatisticUpdates = !0;
+  }
+  editEnd() {
+    var e;
+    (e = this._renderState) == null || e.unlockUploads(), this.attributeView.unlockTextureUploads(), this._lockStatisticUpdates = !1;
+    for (const t of this._updateStatisticsRequests)
+      this.updateStatistics(t.level, t.statistics);
+    this._updateStatisticsRequests = [], this.requestRender();
+  }
+  swapRenderState() {
+    var e;
+    if (this._renderStateNext && (g("esri-2d-update-debug") && console.debug(`Version[${this._renderStateNext.version}] FeatureContainer.update.swapRenderState`), (e = this._renderState) == null || e.destroy(), this._renderState = this._renderStateNext, this._renderStateNext = null), this._renderState)
+      for (const t of this._renderState.tiles())
+        t.upload();
+    this.requestRender();
+  }
+  setVisibleTiles(e) {
+    this._visibleTiles = e;
+  }
+  async onMessage(e, t) {
+    if (pe(t), !this._subscriptions.has(e.id))
+      return;
+    const r = this._subscriptions.get(e.id);
+    if (r.version !== e.subscriptionVesrion) {
+      if (g("esri-2d-update-debug")) {
+        const a = `${e.subscriptionVesrion} != ${r.version}`;
+        console.debug(`Version[${a}] Tile[${e.id}] FeatureContainer - Dropping message, outdated version]`, e);
+      }
+      return;
+    }
+    const s = this._renderStateNext ?? this._renderState;
+    if (!s)
+      throw new Error("InternalError: No renderState defined");
+    s.version !== e.version && console.error(`InternalError: Version mismatch. [renderState: ${s.version}, message: ${e.version}]`), s.updateTile(e), e.end && this._subscriptions.get(e.id).end(), this.requestRender(), this._layerView.view.labelManager.requestUpdate(), this._layerView.requestUpdate();
+  }
+  removeTile(e) {
+    (this._renderState || this._renderStateNext) && (this._renderState && this._renderState.removeTile(e), this._renderStateNext && this._renderStateNext.removeTile(e));
+  }
+  hitTest(e) {
+    let t = this._hitTestsRequests.find(({ x: s, y: a }) => s === e.x && a === e.y);
+    const r = et();
+    return t ? t.resolvers.push(r) : (t = { x: e.x, y: e.y, resolvers: [r] }, this._hitTestsRequests.push(t)), this.requestRender(), r.promise;
+  }
+  getSortKeys(e) {
+    const t = new Set(e), r = /* @__PURE__ */ new Map();
+    for (const s of this.children)
+      if (s.getSortKeys(t).forEach((a, n) => r.set(n, a)), r.size === t.size)
+        break;
+    return r;
+  }
+  get hasAnimation() {
+    return this.hasLabels;
+  }
+  updateTransitionProperties(e, t) {
+    super.updateTransitionProperties(e, t), this._layerView.featureEffectView.transitionStep(e, t), this._layerView.featureEffectView.transitioning && this.requestRender();
+  }
+  doRender(e) {
+    const { minScale: t, maxScale: r } = this._layer.effectiveScaleRange, s = e.state.scale;
+    s <= (t || 1 / 0) && s >= r && super.doRender(e);
+  }
+  afterRender(e) {
+    super.afterRender(e), this._hitTestsRequests.length && this.requestRender();
+  }
+  setStencilReference(e) {
+    const t = this._getOverrideStencilRef(e);
+    if (t == null)
+      super.setStencilReference(e);
+    else
+      for (const r of this.children)
+        r.stencilRef = t(r);
+  }
+  _renderMapPhase(e) {
+    this._layerView.featureEffectView.hasEffects ? (this._renderOutsideEffect(e), this._renderInsideEffect(e)) : this._renderFeatures(e, H.All), this._hitTestsRequests.length > 0 && this._renderHittest(e);
+  }
+  _renderHighlightPhase(e) {
+    this.hasHighlight && Tt(e, !1, (t) => {
+      this._renderFeatures(t, H.Highlight);
+    });
+  }
+  _renderLabelPhase(e) {
+    this._renderFeatures(e, H.All);
+  }
+  _renderInsideEffect(e) {
+    const t = e.painter.effects.insideEffect;
+    t.bind(e), this._renderFeatures(e, H.InsideEffect), t.draw(e, this._layerView.featureEffectView.includedEffects), t.unbind();
+  }
+  _renderOutsideEffect(e) {
+    const t = e.painter.effects.outsideEffect;
+    t.bind(e), this._renderFeatures(e, H.OutsideEffect), t.draw(e, this._layerView.featureEffectView.excludedEffects), t.unbind();
+  }
+  _renderHittest(e) {
+    const { context: t } = e, r = e.painter.effects.hittest, s = t.getBoundFramebufferObject(), a = t.getViewport(), n = e.passOptions;
+    r.bind(e), e.passOptions = r.createOptions(e, this._hitTestsRequests), this._renderFeatures(e, H.All), r.draw(e), r.unbind(), t.bindFramebuffer(s), t.restoreViewport(a), e.passOptions = n;
+  }
+  _renderFeatures(e, t) {
+    for (const s of this.children) {
+      if (!s.visible)
+        continue;
+      const a = g("featurelayer-force-marker-text-draw-order") ? Qe.STRICT_MARKERS_AND_TEXT : Qe.BATCHING, n = s.getDisplayList(e.drawPhase, this._instanceStore, a);
+      e.selection = t, n == null || n.render(e);
+    }
+    const r = this._getExclusivePostprocessingInstance(e);
+    r != null && r.techniqueRef.postProcess(e, r);
+  }
+};
+async function ni(i) {
+  const e = await pt("FeaturePipelineWorker", { client: i, strategy: "dedicated" });
+  return new li(e);
+}
+let li = class {
+  constructor(e) {
+    this._connection = e, this.pipeline = this._connection.createInvokeProxy(), this.features = this._connection.createInvokeProxy("features"), this.aggregates = this._connection.createInvokeProxy("aggregates"), this.streamMessenger = this._connection.createInvokeProxy("streamMessenger");
+  }
+  destroy() {
+    this._connection.destroy();
+  }
+  get closed() {
+    return this._connection.closed;
+  }
+};
+const oi = "esri.views.2d.layers.features.FeatureSourceEventLog";
+let T = class extends Ye {
+  constructor() {
+    super(...arguments), this.events = new ht(), this._updatingStrategy = !0, this._tileToEvent = new ft(), this._fetchStatus = { outstanding: 0, done: 0 };
+  }
+  get hasAllFeatures() {
+    var e;
+    return this._hasAllData() && (((e = this._strategyInfo) == null ? void 0 : e.willQueryAllFeatures) ?? !1);
+  }
+  get hasAllFeaturesInView() {
+    return this._hasAllData();
+  }
+  get hasFullGeometries() {
+    var e;
+    return this._hasAllData() && (((e = this._strategyInfo) == null ? void 0 : e.willQueryFullResolutionGeometry) ?? !1);
+  }
+  onEvent(e) {
+    switch (e.type) {
+      case "subscribe":
+      case "unsubscribe":
+      case "loaded":
+      case "error":
+        this._handleTileEvent(e);
+        break;
+      case "updateStrategyStart":
+        this._updatingStrategy = !0, this._fetchStatus = { done: 0, outstanding: 0 }, this._strategyInfo = e.about;
+        break;
+      case "updateStrategyEnd":
+        this._updatingStrategy = !1;
+        break;
+      case "updateFieldsStart":
+        this._fetchStatus = { done: 0, outstanding: 0 };
+        break;
+      case "updateFieldsEnd":
+        break;
+      case "updateFieldsError":
+        this.events.emit("error", e);
+        break;
+      case "fetchStart":
+        this._fetchStatus.outstanding += 1, this.events.emit("status", this._fetchStatus);
+        break;
+      case "fetchEnd":
+        this._fetchStatus.done += 1, this.events.emit("status", this._fetchStatus), e.done && (this._fetchStatus = { done: 0, outstanding: 0 });
+    }
+  }
+  _hasAllData() {
+    return !this._updatingStrategy && this._hasAllTileData();
+  }
+  _hasAllTileData() {
+    for (const e of this._tileToEvent.values())
+      if (e[e.length - 1].type !== "loaded")
+        return !1;
+    return !0;
+  }
+  _handleTileEvent(e) {
+    switch (e.type) {
+      case "subscribe":
+        this._tileToEvent.set(e.tile, [e]);
+        break;
+      case "unsubscribe":
+        this._tileToEvent.delete(e.tile);
+        break;
+      case "loaded": {
+        const t = this._tileToEvent.get(e.tile);
+        if (!t)
+          return;
+        t.push(e), this._tileToEvent.set(e.tile, t);
+        break;
+      }
+      case "error": {
+        const t = this._tileToEvent.get(e.tile);
+        if (!t)
+          return;
+        t.push(e), this._tileToEvent.set(e.tile, t), this.events.emit("error", e);
+        break;
+      }
+    }
+  }
+};
+h([f({ readOnly: !0 })], T.prototype, "hasAllFeatures", null), h([f({ readOnly: !0 })], T.prototype, "hasAllFeaturesInView", null), h([f({ readOnly: !0 })], T.prototype, "hasFullGeometries", null), h([f()], T.prototype, "_updatingStrategy", void 0), h([f()], T.prototype, "_strategyInfo", void 0), h([f()], T.prototype, "_tileToEvent", void 0), T = h([W(oi)], T);
+function P(i) {
+  switch (i.geometryType) {
+    case "point":
+      return "esriGeometryPoint";
+    case "polyline":
+      return "esriGeometryPolyline";
+    case "polygon":
+    case "multipatch":
+      return "esriGeometryPolygon";
+    case "multipoint":
+      return "esriGeometryMultipoint";
+    default:
+      return null;
+  }
+}
+function R(i, e) {
+  const t = i.featureReduction;
+  return t && t.type !== "selection" && (!("maxScale" in t) || !t.maxScale || t.maxScale < e.scale) ? t : null;
+}
+const ui = Math.PI;
+function it(i, e) {
+  switch (e.transformationType) {
+    case M.Additive:
+      return ci(i, e);
+    case M.Constant:
+      return di(e, i);
+    case M.ClampedLinear:
+      return pi(i, e);
+    case M.Proportional:
+      return hi(i, e);
+    case M.Stops:
+      return fi(i, e);
+    case M.RealWorldSize:
+      return yi(i, e);
+    case M.Identity:
+      return i;
+    case M.Unknown:
+      return null;
+  }
+}
+function O(i, e) {
+  return typeof i == "number" ? i : it(e, i);
+}
+function ci(i, e) {
+  return i + (O(e.minSize, i) || e.minDataValue);
+}
+function di(i, e) {
+  const t = i.stops;
+  let r = (t == null ? void 0 : t.length) && t[0].size;
+  return r == null && (r = i.minSize), O(r, e);
+}
+function pi(i, e) {
+  const t = e.minDataValue, r = e.maxDataValue, s = (i - t) / (r - t), a = O(e.minSize, i), n = O(e.maxSize, i);
+  return i <= t ? a : i >= r ? n : a + s * (n - a);
+}
+function hi(i, e) {
+  const t = i / e.minDataValue, r = O(e.minSize, i), s = O(e.maxSize, i);
+  let a = null;
+  return a = t * r, tt(a, r, s);
+}
+function fi(i, e) {
+  const [t, r, s] = mi(i, e.cache.ipData);
+  if (t === r)
+    return O(e.stops[t].size, i);
+  {
+    const a = O(e.stops[t].size, i);
+    return a + (O(e.stops[r].size, i) - a) * s;
+  }
+}
+function yi(i, e) {
+  const t = Bt[e.valueUnit], r = O(e.minSize, i), s = O(e.maxSize, i), { valueRepresentation: a } = e;
+  let n = null;
+  return n = a === "area" ? 2 * Math.sqrt(i / ui) / t : a === "radius" || a === "distance" ? 2 * i / t : i / t, tt(n, r, s);
+}
+function mi(i, e) {
+  if (!e)
+    return;
+  let t = 0, r = e.length - 1;
+  return e.some((s, a) => i < s ? (r = a, !0) : (t = a, !1)), [t, r, (i - e[t]) / (e[r] - e[t])];
+}
+function k(i) {
+  var e;
+  return (i.labelsVisible && ((e = i.labelingInfo) == null ? void 0 : e.every((t) => t.deconflictionStrategy !== "none"))) ?? !1;
+}
+function X(i, e) {
+  var r;
+  const t = R(i, e);
+  if (t != null && t.labelsVisible && ((r = t.labelingInfo) != null && r.length))
+    return t.labelingInfo.every((s) => s.deconflictionStrategy !== "none");
+}
+function gi(i) {
+  return (e) => ae(it(e, i));
+}
+function B(i) {
+  const e = i != null && "visualVariables" in i && i.visualVariables;
+  if (!e)
+    return null;
+  for (const t of e)
+    if (t.type === "size")
+      return gi(t);
+  return null;
+}
+function J(i, e, t, r, s) {
+  var u, l;
+  const a = e.subtypeCode != null ? `${e.subtypeField} = ${e.subtypeCode}` : null, n = fe(e.definitionExpression, a), o = e.customParameters ?? {};
+  return s && (o.token = s), { type: "feature", mutable: { sourceRefreshVersion: r, availableFields: t.availableFields, dataFilter: { definitionExpression: n, gdbVersion: e.gdbVersion, historicMoment: (u = e.historicMoment) == null ? void 0 : u.getTime(), outSpatialReference: t.outSpatialReference.toJSON(), timeExtent: (l = e.timeExtent) == null ? void 0 : l.toJSON(), customParameters: o } }, service: i, tileInfoJSON: t.tileInfoJSON };
+}
+function bi(i, e, t = 0) {
+  if (e == null)
+    return i[t] = 0, i[t + 1] = 0, i[t + 2] = 0, void (i[t + 3] = 0);
+  const { r, g: s, b: a, a: n } = e;
+  i[t] = r * n / 255, i[t + 1] = s * n / 255, i[t + 2] = a * n / 255, i[t + 3] = n;
+}
+async function A(i, e) {
+  if (!i)
+    return [];
+  switch (i.type) {
+    case "simple-fill":
+      return st(i, e);
+    case "picture-fill":
+      return Oi(i, e);
+    case "simple-marker":
+      return wi(i, e);
+    case "picture-marker":
+      return Vi(i, e);
+    case "simple-line":
+      return le(i, e, !1);
+    case "text":
+      return xi(i, e);
+    case "label":
+      return Ei(i, e);
+    case "cim":
+      return me(i.data, e);
+    case "web-style": {
+      const t = await i.fetchCIMSymbol();
+      return me(t.data, e);
+    }
+    default:
+      throw new Error(`symbol not supported ${i.type}`);
+  }
+}
+async function Si(i, e) {
+  const { schemaOptions: t } = e, { store: r } = t, s = new Array(ce), a = new Array(ce / 4);
+  for (let l = 0; l < ce; l++) {
+    const c = l < i.attributes.length ? i.attributes[l].color : null;
+    s[l] = [0, 0, 0, 0], bi(s[l], c);
+  }
+  for (let l = 0; l < ce / 4; l++)
+    a[l] = [0, 0, 0, 0], a[l][0] = 4 * l < i.attributes.length ? 1 : 0, a[l][1] = 4 * l + 1 < i.attributes.length ? 1 : 0, a[l][2] = 4 * l + 2 < i.attributes.length ? 1 : 0, a[l][3] = 4 * l + 3 < i.attributes.length ? 1 : 0;
+  const n = { isActive: a, colors: s, dotValue: i.dotValue, dotScale: i.referenceScale, blending: i.dotBlendingEnabled, dotSize: i.dotSize, seed: i.seed }, o = r.ensureInstance(x.dotDensity, n, {}).createMeshInfo({ params: { effects: null } }), u = [];
+  if (i.backgroundColor) {
+    const l = new yt({ color: i.backgroundColor, outline: null }), c = await A(l, e);
+    u.push(...c);
+  }
+  if (u.push(o), i.outline) {
+    const l = le(i.outline, e, !0);
+    u.push(...l);
+  }
+  return u;
+}
+async function vi(i, e) {
+  const { store: t } = e, { radius: r, minDensity: s, maxDensity: a, referenceScale: n, field: o, valueExpression: u, colorStops: l } = i, c = jt(l);
+  return [t.ensureInstance(x.heatmap, { radius: ae(r), minDensity: s, maxDensity: a, referenceScale: n, isFieldActive: !(!o && !u), gradient: c, gradientHash: c.join(",") }, {}).createMeshInfo({ params: { effects: null } })];
+}
+function _i(i, e) {
+  var n, o, u, l;
+  const { store: t } = e, r = ((n = i.outline) == null ? void 0 : n.width) || 0, s = z(i), a = t.ensureInstance(x.pieChart, { geometry: { outlineWidth: Math.round(ae(r)), defaultColor: de(i.defaultColor), outlineColor: de((o = i.outline) == null ? void 0 : o.color), othersColor: de((u = i.othersCategory) == null ? void 0 : u.color), donutRatio: i.holePercentage, sectorThreshold: ((l = i.othersCategory) == null ? void 0 : l.threshold) || 0, colors: i.attributes.map((c) => de(c.color)), visualVariableOpacity: s.visualVariableOpacity, visualVariableSizeMinMaxValue: s.visualVariableSizeMinMaxValue, visualVariableSizeScaleStops: s.visualVariableSizeScaleStops, visualVariableSizeStops: s.visualVariableSizeStops, visualVariableSizeUnitValue: s.visualVariableSizeUnitValue, hittestUniforms: null }, numberOfFields: i.attributes.length }, {}).createMeshInfo({ params: { size: i.size, outlineWidth: r, effects: null, scaleInfo: null, minPixelBuffer: U(s) } });
+  return [...i.backgroundFillSymbol ? st(i.backgroundFillSymbol, { schemaOptions: e, path: "", uniforms: be }) : [], a];
+}
+function rt(i) {
+  if (i.style === "path") {
+    if (i.path == null)
+      throw new Error("Symbol with a style of type path must define a path");
+    return { type: "sprite-rasterization-param", overrides: [], resource: { type: "path", path: i.path, asFill: !0 } };
+  }
+  const e = Z.fromSimpleMarker(i);
+  if ("outline" in i && i.outline && i.outline.style !== "none" && i.outline.style !== "solid") {
+    if (!e || !e.symbolLayers)
+      throw new Error("Error handling marker! ");
+    return { type: "sprite-rasterization-param", resource: e.symbolLayers[0], overrides: [] };
+  }
+  return { type: "sprite-rasterization-param", resource: Ht(e), overrides: [] };
+}
+async function wi(i, e) {
+  var p, y, m, b, V;
+  const { uniforms: t, schemaOptions: r } = e, { store: s } = r;
+  if (i.style === "path" || i.outline && i.outline.style !== "solid" && i.outline.style !== "none") {
+    const S = Z.fromSimpleMarker(i);
+    if (!S || !S.symbolLayers)
+      throw new Error("Error handling marker! ");
+    if (t.visualVariableRotation && (S.angleAlignment = "Map"), i.style !== "path") {
+      const w = S.symbolLayers[0];
+      if (ie(e.uniforms)) {
+        const v = U(e.uniforms, 0, 1);
+        if (v > w.size) {
+          const F = v / w.size;
+          w.size = v;
+          const $ = (p = w.markerGraphics) == null ? void 0 : p[0].symbol;
+          ($.symbolLayers && $.symbolLayers[0]).width *= F;
+        }
+      }
+    }
+    return me({ type: "CIMSymbolReference", symbol: S }, e);
+  }
+  const a = s.ensureInstance(x.marker, { geometry: { visualVariableColor: t.visualVariableColor, visualVariableOpacity: t.visualVariableOpacity, visualVariableSizeMinMaxValue: t.visualVariableSizeMinMaxValue, visualVariableSizeScaleStops: t.visualVariableSizeScaleStops, visualVariableSizeStops: t.visualVariableSizeStops, visualVariableSizeUnitValue: t.visualVariableSizeUnitValue, visualVariableRotation: t.visualVariableRotation } }, { zoomRange: !1 }), n = rt(i);
+  let o = ((y = i.color) == null ? void 0 : y.toArray()) ?? [0, 0, 0, 0];
+  n.resource.type === "CIMVectorMarker" && (o = [255, 255, 255, 255]);
+  const u = i.style === "triangle" ? 124 / 116 : 1, l = i.size, c = l * u, d = t.visualVariableColor != null && (i.style === "cross" || i.style === "x");
+  return [a.createMeshInfo({ params: { type: "simple", color: o, height: l, width: c, offsetX: i.xoffset, offsetY: i.yoffset, angle: i.angle, alignment: Re(t) ? G.MAP : G.SCREEN, outlineColor: ((b = (m = i.outline) == null ? void 0 : m.color) == null ? void 0 : b.toArray()) ?? [0, 0, 0, 0], outlineSize: ((V = i.outline) == null ? void 0 : V.width) ?? 1, referenceSize: l, sprite: n, overrideOutlineColor: d, hasSizeVV: ie(t), placement: null, effects: null, transforms: null, scaleInfo: null, minPixelBuffer: U(t) } })];
+}
+function Vi(i, e) {
+  const { uniforms: t, schemaOptions: r } = e, { store: s } = r, a = s.ensureInstance(x.marker, { geometry: { visualVariableColor: t.visualVariableColor, visualVariableOpacity: t.visualVariableOpacity, visualVariableSizeMinMaxValue: t.visualVariableSizeMinMaxValue, visualVariableSizeScaleStops: t.visualVariableSizeScaleStops, visualVariableSizeStops: t.visualVariableSizeStops, visualVariableSizeUnitValue: t.visualVariableSizeUnitValue, visualVariableRotation: t.visualVariableRotation } }, { zoomRange: !1 }), n = Z.createPictureMarkerRasterizationParam(i);
+  return n ? [a.createMeshInfo({ params: { type: "picture", color: [255, 255, 255, 255], height: i.height, width: i.width, offsetX: i.xoffset, offsetY: i.yoffset, angle: i.angle, alignment: Re(t) ? G.MAP : G.SCREEN, outlineColor: null, outlineSize: 0, referenceSize: i.height, sprite: n, overrideOutlineColor: !1, hasSizeVV: ie(t), placement: null, effects: null, transforms: null, scaleInfo: null, minPixelBuffer: U(t) } })] : [];
+}
+function Ii(i, e, t) {
+  var b, V;
+  const { uniforms: r, schemaOptions: s } = t, { store: a } = s, n = a.ensureInstance(x.marker, { geometry: { visualVariableColor: r.visualVariableColor, visualVariableOpacity: r.visualVariableOpacity, visualVariableSizeMinMaxValue: r.visualVariableSizeMinMaxValue, visualVariableSizeScaleStops: r.visualVariableSizeScaleStops, visualVariableSizeStops: r.visualVariableSizeStops, visualVariableSizeUnitValue: r.visualVariableSizeUnitValue, visualVariableRotation: r.visualVariableRotation } }, { zoomRange: !1 }), o = rt(i), u = 6, l = u * e.width, c = l, d = ((b = i.color) == null ? void 0 : b.toArray()) ?? ((V = e.color) == null ? void 0 : V.toArray()) ?? [0, 0, 0, 0], p = i.style === "cross" || i.style === "x";
+  let y;
+  switch (i.placement) {
+    case "begin-end":
+      y = ue.Both;
+      break;
+    case "begin":
+      y = ue.JustBegin;
+      break;
+    case "end":
+      y = ue.JustEnd;
+      break;
+    default:
+      y = ue.None;
+  }
+  const m = { type: "cim-marker-placement-info", placement: { type: "CIMMarkerPlacementAtExtremities", angleToLine: !0, offset: 0, extremityPlacement: y, offsetAlongLine: 0 }, overrides: [] };
+  return [n.createMeshInfo({ params: { type: "simple", color: d, height: c, width: l, offsetX: 0, offsetY: 0, angle: 0, alignment: Re(r) ? G.MAP : G.SCREEN, outlineColor: d, outlineSize: p ? e.width : 0, referenceSize: c / u, sprite: o, overrideOutlineColor: p && r.visualVariableColor != null, hasSizeVV: ie(r), placement: m, transforms: null, effects: null, scaleInfo: null, minPixelBuffer: U(r) } })];
+}
+function xi(i, e) {
+  var a, n, o, u;
+  const { uniforms: t, schemaOptions: r } = e, { store: s } = r;
+  return [s.ensureInstance(x.text, { geometry: { visualVariableColor: t.visualVariableColor, visualVariableOpacity: t.visualVariableOpacity, visualVariableRotation: t.visualVariableRotation, visualVariableSizeMinMaxValue: t.visualVariableSizeMinMaxValue, visualVariableSizeScaleStops: t.visualVariableSizeScaleStops, visualVariableSizeStops: t.visualVariableSizeStops, visualVariableSizeUnitValue: t.visualVariableSizeUnitValue } }, { zoomRange: !1, clipAngle: !1, referenceSymbol: !1 }).createMeshInfo({ params: { boxBackgroundColor: (a = i.backgroundColor) == null ? void 0 : a.toArray(), boxBorderLineColor: (n = i.borderLineColor) == null ? void 0 : n.toArray(), boxBorderLineSize: i.borderLineSize ?? 0, color: ((o = i.color) == null ? void 0 : o.toArray()) ?? [0, 0, 0, 0], offsetX: i.xoffset, offsetY: i.yoffset, postAngle: i.angle, fontSize: i.font.size, decoration: i.font.decoration, haloColor: ((u = i.haloColor) == null ? void 0 : u.toArray()) ?? [0, 0, 0, 0], haloFontSize: i.haloSize ?? 0, lineWidth: i.lineWidth, lineHeightRatio: i.lineHeight, horizontalAlignment: i.horizontalAlignment, verticalAlignment: i.verticalAlignment, useCIMAngleBehavior: !1, glyphs: { type: "text-rasterization-param", resource: { type: "text", font: i.font.toJSON(), textString: i.text, symbol: Z.createCIMTextSymbolfromTextSymbol(i) }, overrides: [] }, referenceSize: null, effects: null, placement: null, scaleInfo: null, transforms: null, scaleFactor: 1, minPixelBuffer: U(t), repeatLabel: null, repeatLabelDistance: null, allowOverrun: null, labelPosition: null, isLineLabel: !1 } })];
+}
+function Ei(i, e) {
+  var m, b, V, S, w, v;
+  const { schemaOptions: t, uniforms: r } = e, { store: s } = t, a = i.symbol, { allowOverrun: n, repeatLabel: o, repeatLabelDistance: u } = i, l = { maxScale: i.maxScale ?? 0, minScale: i.minScale ?? 0 }, c = s.ensureInstance(x.label, { geometry: { visualVariableColor: null, visualVariableOpacity: null, visualVariableRotation: r.visualVariableRotation, visualVariableSizeMinMaxValue: r.visualVariableSizeMinMaxValue, visualVariableSizeScaleStops: r.visualVariableSizeScaleStops, visualVariableSizeStops: r.visualVariableSizeStops, visualVariableSizeUnitValue: r.visualVariableSizeUnitValue } }, { zoomRange: !0, clipAngle: !0, referenceSymbol: !0 }), d = i.labelPlacement, [p, y] = Nt(d);
+  return [c.createMeshInfo({ params: { boxBackgroundColor: (m = a.backgroundColor) == null ? void 0 : m.toArray(), boxBorderLineColor: (b = a.borderLineColor) == null ? void 0 : b.toArray(), boxBorderLineSize: a.borderLineSize ?? 0, color: ((V = a.color) == null ? void 0 : V.toArray()) ?? [0, 0, 0, 0], offsetX: a.xoffset, offsetY: a.yoffset, postAngle: a.angle, fontSize: a.font.size, decoration: a.font.decoration, haloColor: ((S = a.haloColor) == null ? void 0 : S.toArray()) ?? [0, 0, 0, 0], haloFontSize: a.haloSize ?? 0, lineWidth: a.lineWidth, lineHeightRatio: a.lineHeight, horizontalAlignment: p, verticalAlignment: y, repeatLabel: o, repeatLabelDistance: ae(u), allowOverrun: n, labelPosition: i.labelPosition, scaleInfo: l, minPixelBuffer: U(r), useCIMAngleBehavior: !1, glyphs: { type: "text-rasterization-param", resource: { type: "text", font: a.font.toJSON(), textString: a.text, symbol: Z.createCIMTextSymbolfromTextSymbol(a), primitiveName: "label-override" }, useLegacyLabelEvaluationRules: ((w = i.labelExpressionInfo) == null ? void 0 : w.expression) == null, overrides: [{ type: "CIMPrimitiveOverride", valueExpressionInfo: { type: "CIMExpressionInfo", expression: ((v = i.labelExpressionInfo) == null ? void 0 : v.expression) ?? i.labelExpression, returnType: "String" }, primitiveName: "label-override", propertyName: "textString", defaultValue: "" }] }, referenceSize: null, effects: null, placement: null, transforms: null, scaleFactor: 1, isLineLabel: !1 } })];
+}
+function ze(i, e) {
+  var r;
+  const t = i.width;
+  return { outlineColor: ((r = i.color) == null ? void 0 : r.toArray()) || [0, 0, 0, 1], width: t, referenceWidth: t, capType: i.cap ?? "round", joinType: i.join ?? "round", miterLimit: i.miterLimit, hasSizeVV: e };
+}
+function Fi(i, e) {
+  var l, c, d;
+  const { uniforms: t, schemaOptions: r } = e, { store: s } = r, a = ((l = i.color) == null ? void 0 : l.toArray()) ?? [0, 0, 0, 0], n = { type: "sprite-rasterization-param", resource: { type: "fill-style", style: i.style }, overrides: [] };
+  if (((c = i.outline) == null ? void 0 : c.style) === "solid")
+    return [s.ensureInstance(x.patternOutlineFill, { geometry: { visualVariableColor: t.visualVariableColor, visualVariableOpacity: t.visualVariableOpacity, visualVariableSizeScaleStops: t.visualVariableSizeOutlineScaleStops, visualVariableSizeMinMaxValue: null, visualVariableSizeStops: null, visualVariableSizeUnitValue: null } }, { zoomRange: !1 }).createMeshInfo({ params: { color: a, ...ze(i.outline, !!t.visualVariableSizeOutlineScaleStops), sprite: n, scaleInfo: null, effects: null } })];
+  const o = [], u = s.ensureInstance(x.patternFill, { geometry: { visualVariableColor: t.visualVariableColor, visualVariableOpacity: t.visualVariableOpacity } }, { zoomRange: !1 }).createMeshInfo({ params: { color: ((d = i.color) == null ? void 0 : d.toArray()) ?? [0, 0, 0, 0], sprite: n, scaleInfo: null, effects: null } });
+  return o.push(u), i.outline && o.push(...le(i.outline, e, !0)), o;
+}
+function Ri(i, e) {
+  var o, u;
+  const { uniforms: t, schemaOptions: r } = e, { store: s } = r, a = ((o = i.color) == null ? void 0 : o.toArray()) ?? [0, 0, 0, 0];
+  if (i.style !== "none" && ((u = i.outline) == null ? void 0 : u.style) === "solid")
+    return [s.ensureInstance(x.outlineFill, { geometry: { visualVariableColor: t.visualVariableColor, visualVariableOpacity: t.visualVariableOpacity, visualVariableSizeScaleStops: t.visualVariableSizeOutlineScaleStops, visualVariableSizeMinMaxValue: null, visualVariableSizeStops: null, visualVariableSizeUnitValue: null } }, { zoomRange: !1 }).createMeshInfo({ params: { color: a, ...ze(i.outline, !!t.visualVariableSizeOutlineScaleStops), scaleInfo: null, effects: null } })];
+  const n = [];
+  if (i.style !== "none") {
+    const l = s.ensureInstance(x.fill, { geometry: { visualVariableColor: t.visualVariableColor, visualVariableOpacity: t.visualVariableOpacity } }, { zoomRange: !1 }).createMeshInfo({ params: { color: a, scaleInfo: null, effects: null } });
+    n.push(l);
+  }
+  return i.outline && n.push(...le(i.outline, e, !0)), n;
+}
+function st(i, e) {
+  const { style: t } = i;
+  return t && t !== "none" && t !== "solid" ? Fi(i, e) : Ri(i, e);
+}
+function Oi(i, e) {
+  const { outline: t } = i, { uniforms: r, schemaOptions: s } = e, { store: a } = s, n = [], o = Z.createPictureFillRasterizationParam(i);
+  if (!o)
+    return [];
+  const { width: u, height: l, xoffset: c, yoffset: d, xscale: p, yscale: y } = i, m = { color: [255, 255, 255, 255], sprite: o, height: l, aspectRatio: u / l, offsetX: c, offsetY: d, scaleX: p, scaleY: y, angle: 0, applyRandomOffset: !1, sampleAlphaOnly: !1, scaleProportionally: !1, effects: null, scaleInfo: null };
+  if ((t == null ? void 0 : t.style) === "solid")
+    return [a.ensureInstance(x.complexOutlineFill, { geometry: { visualVariableColor: r.visualVariableColor, visualVariableOpacity: r.visualVariableOpacity, visualVariableSizeScaleStops: r.visualVariableSizeOutlineScaleStops, visualVariableSizeMinMaxValue: null, visualVariableSizeStops: null, visualVariableSizeUnitValue: null } }, { zoomRange: !1 }).createMeshInfo({ params: { ...m, ...ze(t, !!r.visualVariableSizeOutlineScaleStops) } })];
+  const b = a.ensureInstance(x.complexFill, { geometry: { visualVariableColor: r.visualVariableColor, visualVariableOpacity: r.visualVariableOpacity } }, { zoomRange: !1 });
+  return n.push(b.createMeshInfo({ params: m })), t && n.push(...le(t, e, !0)), n;
+}
+function le(i, e, t) {
+  const { color: r, style: s, width: a, cap: n, join: o } = i, { schemaOptions: u } = e, { store: l } = u, c = [], d = t ? { ...be, visualVariableSizeScaleStops: e.uniforms.visualVariableSizeOutlineScaleStops } : e.uniforms, p = { geometry: { visualVariableColor: d.visualVariableColor, visualVariableOpacity: d.visualVariableOpacity, visualVariableSizeMinMaxValue: d.visualVariableSizeMinMaxValue, visualVariableSizeScaleStops: d.visualVariableSizeScaleStops, visualVariableSizeStops: d.visualVariableSizeStops, visualVariableSizeUnitValue: d.visualVariableSizeUnitValue } }, y = { color: (r == null ? void 0 : r.toArray()) ?? [0, 0, 0, 0], width: a, referenceWidth: a, capType: n, joinType: o, miterLimit: i.miterLimit, hasSizeVV: ie(d), effects: null, scaleInfo: null };
+  if (s == null || s === "solid") {
+    const m = l.ensureInstance(x.line, p, { zoomRange: !1 }).createMeshInfo({ params: y });
+    c.push(m);
+  } else if (s !== "none") {
+    const m = l.ensureInstance(x.texturedLine, p, { zoomRange: !1 }).createMeshInfo({ params: { ...y, shouldScaleDash: !0, shouldSampleAlphaOnly: !1, isSDF: !0, sprite: { type: "sprite-rasterization-param", resource: { type: "dash", dashTemplate: kt(s, n), capStyle: qt(n) }, overrides: [] } } });
+    c.push(m);
+  }
+  return i.marker != null && c.push(...Ii(i.marker, i, e)), c;
+}
+async function re(i, e, t) {
+  const r = e.labelsVisible && e.labelingInfo || [], s = P(e), a = Dt(r, s);
+  return { type: "label", classes: await Promise.all(a.map((n, o) => $i(i, n, o, t))) };
+}
+async function $i(i, e, t, r) {
+  var a;
+  const s = await A(e, { path: `${t}`, schemaOptions: i, uniforms: r });
+  return { maxScale: e.maxScale, minScale: e.minScale, expression: ((a = e.labelExpressionInfo) == null ? void 0 : a.expression) ?? e.labelExpression, where: e.where, meshes: s };
+}
+async function se(i, e) {
+  if (!e)
+    return { type: "simple", meshes: [] };
+  switch (e.type) {
+    case "simple":
+      return zi(i, e);
+    case "dot-density":
+      return Ti(i, e);
+    case "class-breaks":
+      return Ci(i, e);
+    case "unique-value":
+      return Ai(i, e);
+    case "dictionary":
+      return Pi(e);
+    case "heatmap":
+      return Mi(i, e);
+    case "pie-chart":
+      return Ni(i, e);
+  }
+}
+async function zi(i, e) {
+  const t = e.getSymbols(), r = t.length ? t[0] : null, s = z(e);
+  return { type: "simple", meshes: await A(r, { schemaOptions: i, uniforms: s, path: "renderer.symbol" }) };
+}
+async function Ti(i, e) {
+  const t = z(e);
+  return { type: "dot-density", meshes: await Si(e, { schemaOptions: i, uniforms: t, path: "renderer.symbol" }) };
+}
+async function Ci(i, e) {
+  const t = z(e), r = e.backgroundFillSymbol, s = e.normalizationType, a = s === "log" ? "esriNormalizeByLog" : s === "percent-of-total" ? "esriNormalizeByPercentOfTotal" : s === "field" ? "esriNormalizeByField" : null, n = e.classBreakInfos.map(async (c) => ({ meshes: await A(c.symbol, { path: `renderer-stop-${c.minValue}-${c.maxValue}`, schemaOptions: i, uniforms: t }), min: c.minValue, max: c.maxValue })), o = (await Promise.all(n)).sort((c, d) => c.min - d.min), u = await A(r, { schemaOptions: i, path: "renderer.backgroundFill", uniforms: { ...be, visualVariableSizeOutlineScaleStops: t.visualVariableSizeOutlineScaleStops } }), l = await A(e.defaultSymbol, { schemaOptions: i, path: "renderer.defaultSymbol", uniforms: t });
+  return { type: "interval", field: e.field, expression: e.valueExpression, backgroundFill: u, defaultSymbol: l, intervals: o, normalizationField: e.normalizationField, normalizationTotal: e.normalizationTotal, normalizationType: a, isMaxInclusive: e.isMaxInclusive };
+}
+async function Ai(i, e) {
+  const t = [], r = z(e), s = await A(e.backgroundFillSymbol, { schemaOptions: i, path: "renderer.backgroundFill", uniforms: { ...be, visualVariableSizeOutlineScaleStops: r.visualVariableSizeOutlineScaleStops } }), a = await A(e.defaultSymbol, { schemaOptions: i, path: "renderer.defaultSymbol", uniforms: r });
+  for (const n of e.uniqueValueInfos ?? []) {
+    const o = await A(n.symbol, { path: `renderer-unique-value-${n.value}`, schemaOptions: i, uniforms: r });
+    t.push({ value: "" + n.value, symbol: o });
+  }
+  return { type: "map", field: e.field, expression: e.valueExpression, field2: e.field2, field3: e.field3, fieldDelimiter: e.fieldDelimiter, backgroundFill: s, defaultSymbol: a, map: t };
+}
+function Pi(i) {
+  const e = z(i), t = i.scaleExpression, r = t != null && t !== "1" ? { valueExpressionInfo: { type: "CIMExpressionInfo", expression: i.scaleExpression, returnType: "Numeric" }, defaultValue: 1 } : void 0;
+  return { type: "dictionary", fieldMap: i.fieldMap, scaleExpression: r, visualVariableUniforms: e };
+}
+async function Mi(i, e) {
+  return { type: "heatmap", meshes: await vi(e, i) };
+}
+async function Ni(i, e) {
+  return { type: "pie-chart", meshes: _i(e, i) };
+}
+async function ki(i, e) {
+  const t = e.renderer, r = z(t);
+  return { symbology: await se(i, t), labels: await re(i, e, r) };
+}
+async function D(i, e, t, r) {
+  const s = t.featureReduction;
+  if (s)
+    switch (s.type) {
+      case "binning":
+        return Ui(s, i, e, t, r);
+      case "cluster":
+        return Li(s, i, e, t, r);
+    }
+  const a = Bi(t.orderBy, t.renderer, t.objectIdField);
+  return { storage: Oe(t.renderer, e.filters), mesh: { displayRefreshVersion: r, strategy: { type: "feature" }, factory: await ki(i, t), sortKey: a, timeZone: e.timeZone } };
+}
+function at(i, e) {
+  return i.fields.map((t) => ({ ...t.toJSON(), type: qi(t, e) }));
+}
+function qi(i, e) {
+  const { onStatisticExpression: t, onStatisticField: r, statisticType: s } = i;
+  switch (s) {
+    case "min":
+    case "max":
+    case "avg":
+    case "avg_angle":
+    case "sum":
+    case "count":
+      return "esriFieldTypeDouble";
+    case "mode": {
+      if (t) {
+        const { returnType: n } = t;
+        return n ? n === "string" ? "esriFieldTypeString" : "esriFieldTypeDouble" : "esriFieldTypeString";
+      }
+      const a = e.find((n) => n.name === r);
+      return a ? a.type : "esriFieldTypeString";
+    }
+  }
+}
+async function Ui(i, e, t, r, s) {
+  const a = at(i, r.fields), n = i.renderer, o = await se(e, n), u = Oe(n, [null, null]), l = z(n), c = await re(e, { geometryType: "polygon", labelingInfo: i.labelingInfo, labelsVisible: i.labelsVisible }, l);
+  return { storage: u, mesh: { displayRefreshVersion: s, strategy: { type: "binning", fields: a, fixedBinLevel: i.fixedBinLevel, featureFilter: t.filters[0] }, factory: { labels: c, symbology: o }, sortKey: null, timeZone: t.timeZone } };
+}
+async function Li(i, e, t, r, s) {
+  const a = at(i, r.fields), n = { type: "cluster", feature: await se(e, i.effectiveFeatureRenderer), cluster: await se(e, i.effectiveClusterRenderer) }, o = z(i.effectiveFeatureRenderer), u = { type: "cluster", feature: await re(e, r, o), cluster: await re(e, { geometryType: "point", labelingInfo: i.labelingInfo, labelsVisible: i.labelsVisible }, o) };
+  return { storage: Oe(i.effectiveFeatureRenderer, [null, null]), mesh: { displayRefreshVersion: s, strategy: { type: "cluster", fields: a, featureFilter: t.filters[0], clusterRadius: ae(i.clusterRadius / 2) }, factory: { labels: u, symbology: n }, sortKey: null, timeZone: t.timeZone } };
+}
+function Bi(i, e, t) {
+  const r = e != null && e.type === "unique-value" && e.orderByClassesEnabled;
+  if (i !== "default" || r || (i = [new Jt({ field: t, order: "descending" })]), i !== "default" && i.length) {
+    i.length;
+    const s = i[0], a = s.order === "ascending" ? "asc" : "desc";
+    return s.field ? { field: s.field, order: a } : s.valueExpression ? { expression: s.valueExpression, order: a } : null;
+  }
+  return r ? { byRenderer: !0, order: "asc" } : null;
+}
+let Ji = class {
+  constructor(e) {
+    this.layer = e;
+  }
+  getLabelingDeconflictionInfo(e) {
+    const t = this.layer, r = k(t);
+    return [{ vvEvaluators: { 0: B(t.renderer) }, deconflictionEnabled: r }];
+  }
+  async createServiceOptions(e) {
+    var v, F;
+    const t = this.layer, r = t.parent, s = N(r), { capabilities: a, editingInfo: n, objectIdField: o, globalIdField: u, datesInUnknownTimezone: l, orderBy: c, subtypeField: d, parsedUrl: p } = r, y = r.fieldsIndex.toJSON(), m = P(t), b = (v = r.timeInfo) == null ? void 0 : v.toJSON(), V = t.spatialReference.toJSON(), S = ne(p);
+    let w = o;
+    if (c != null && c.length) {
+      const $ = !c[0].valueExpression && c[0].field;
+      $ && (w = $);
+    }
+    return { type: "feature-service", source: S, isSourceHosted: ge(S.path), orderByFields: w, metadata: { timeReferenceUnknownClient: l, subtypeField: d, globalIdField: u, fieldsIndex: y, geometryType: m, objectIdField: o, timeInfo: b, spatialReference: V, subtypes: null, typeIdField: null, types: null }, queryMetadata: { capabilities: a, effectiveCapabilities: s, lastEditDate: (F = n == null ? void 0 : n.lastEditDate) == null ? void 0 : F.getTime(), snapshotInfo: null } };
+  }
+  createSourceSchema(e, t, r) {
+    const { definitionExpression: s, customParameters: a, timeExtent: n, apiKey: o } = this.layer.parent;
+    return J(e, { definitionExpression: s, customParameters: a, timeExtent: n }, t, r, o);
+  }
+  createProcessorSchema(e, t, r) {
+    const { parent: { fields: s, geometryType: a, orderBy: n, objectIdField: o }, renderer: u, labelingInfo: l, labelsVisible: c } = this.layer, d = { featureReduction: null, fields: s.map((p) => p.toJSON()), geometryType: a, labelingInfo: l, labelsVisible: c, objectIdField: o, orderBy: n ?? "default", renderer: u == null ? void 0 : u.clone() };
+    return D(e, t, d, r);
+  }
+  get hasRequiredSupport() {
+    return L(this.layer.renderer);
+  }
+  getUpdateHashProperties(e) {
+    const t = this.layer, { parent: r, parent: { definitionExpression: s, apiKey: a }, renderer: n } = t, o = this.layer.labelsVisible ? this.layer.labelingInfo : null;
+    return { apiKey: a, customParameters: JSON.stringify(r.customParameters), definitionExpression: s, labelingInfo: o, orderBy: JSON.stringify(r.orderBy), renderer: n };
+  }
+  setGraphicOrigin(e) {
+    e.origin = { type: "catalog", layer: this.layer };
+  }
+};
+function Te(i, e) {
+  const t = i.extent, r = e == null ? void 0 : e.clone().intersection(t), s = r != null ? r.width * r.height : 0, a = e ? e.width * e.height : 0, n = a === 0 ? 0 : s / a, o = g("featurelayer-snapshot-point-coverage");
+  return !isNaN(n) && n >= o;
+}
+function K(i, e) {
+  return i.floorInfo != null && (i.floorInfo.viewAllLevelIds.length > 0 || e.floors.length > 0);
+}
+function Ce(i, e, t) {
+  const r = Di(i, e == null ? void 0 : e.where, t);
+  return r && (e ?? (e = new te()), e.where = r), e;
+}
+function Di(i, e, t) {
+  var u;
+  if (i.floorInfo == null || !((u = t.floors) != null && u.length))
+    return e;
+  let r = t.floors;
+  const { floorField: s, viewAllLevelIds: a } = i.floorInfo;
+  a.length && (r = a);
+  const n = r.filter((l) => l !== "").map((l) => "'" + l + "'");
+  if (n.push("''"), e == null ? void 0 : e.includes(s)) {
+    let l = new RegExp("AND \\(" + s + ".*NULL\\)", "g");
+    e = e.replace(l, ""), l = new RegExp("\\(" + s + ".*NULL\\)", "g"), e = (e = e.replace(l, "")).replaceAll(/\s+/g, " ").trim();
+  }
+  let o = "(" + s + " IN ({ids}) OR " + s + " IS NULL)";
+  return o = o.replace("{ids}", n.join(", ")), fe(e, o);
+}
+let ji = class {
+  constructor(e) {
+    this.layer = e;
+  }
+  getLabelingDeconflictionInfo(e) {
+    const t = this.layer, r = X(t, e) ?? k(t);
+    return [{ vvEvaluators: { 0: B(t.renderer) }, deconflictionEnabled: r }];
+  }
+  async createServiceOptions(e) {
+    var Ae, Pe, Me, Ne;
+    const t = this.layer, r = N(t), { capabilities: s, editingInfo: a, objectIdField: n, typeIdField: o, globalIdField: u, datesInUnknownTimezone: l, orderBy: c, subtypeField: d, refreshInterval: p } = t, y = t.fieldsIndex.toJSON(), m = y.fields, b = P(t), V = (Ae = t.timeInfo) == null ? void 0 : Ae.toJSON(), S = t.spatialReference.toJSON(), w = (Pe = t.types) == null ? void 0 : Pe.map((j) => j.toJSON()), v = ne(this.layer.parsedUrl);
+    this.layer.dynamicDataSource && (v.query = { layer: JSON.stringify({ source: this.layer.dynamicDataSource }) });
+    let F = this.layer.objectIdField;
+    if (c != null && c.length) {
+      const j = !c[0].valueExpression && c[0].field;
+      j && (F = j);
+    }
+    const $ = (a == null ? void 0 : a.lastEditDate) == null && p > 0, Y = g("featurelayer-snapshot-enabled") && t.geometryType === "point" && (s == null ? void 0 : s.query.supportsPagination) && !(s != null && s.operations.supportsEditing) && !$, Se = Y && Te(e, t.fullExtent);
+    return { type: "feature-service", source: v, isSourceHosted: ge(v.path), orderByFields: F, metadata: { typeIdField: o ?? void 0, types: w, timeReferenceUnknownClient: l, subtypeField: d, globalIdField: u, fields: m, fieldsIndex: y, geometryType: b, objectIdField: n, timeInfo: V, spatialReference: S, subtypes: (Me = this.layer.subtypes) == null ? void 0 : Me.map((j) => j.toJSON()) }, queryMetadata: { capabilities: s, effectiveCapabilities: r, lastEditDate: (Ne = a == null ? void 0 : a.lastEditDate) == null ? void 0 : Ne.getTime(), snapshotInfo: { supportsSnapshotMinThreshold: Y, supportsSnapshotMaxThreshold: Se, snapshotCountThresholds: { min: g("featurelayer-snapshot-point-min-threshold"), max: g("featurelayer-snapshot-point-max-threshold") } } } };
+  }
+  createSourceSchema(e, t, r) {
+    const { definitionExpression: s, customParameters: a, gdbVersion: n, historicMoment: o, subtypeCode: u, subtypeField: l, timeExtent: c, apiKey: d } = this.layer;
+    return J(e, { definitionExpression: s, customParameters: a, gdbVersion: n, historicMoment: o, subtypeCode: u, subtypeField: l, timeExtent: c }, t, r, d);
+  }
+  createProcessorSchema(e, t, r) {
+    const { fields: s, renderer: a, geometryType: n, labelingInfo: o, labelsVisible: u, orderBy: l, objectIdField: c } = this.layer, d = { fields: s.map((p) => p.toJSON()), renderer: a == null ? void 0 : a.clone(), featureReduction: R(this.layer, t), geometryType: n, labelingInfo: o, labelsVisible: u, objectIdField: c, orderBy: l ?? "default" };
+    return D(e, t, d, r);
+  }
+  get hasRequiredSupport() {
+    return L(this.layer.renderer);
+  }
+  hasFilters(e) {
+    return K(this.layer, e);
+  }
+  addFilters(e, t) {
+    return Ce(this.layer, e, t);
+  }
+  getUpdateHashProperties(e) {
+    var y, m;
+    const t = this.layer, { definitionExpression: r, renderer: s, gdbVersion: a, apiKey: n, subtypeCode: o } = t, u = this.layer.labelsVisible ? this.layer.labelingInfo : null, l = ((y = t.historicMoment) == null ? void 0 : y.getTime()) ?? void 0, c = JSON.stringify(t.customParameters), d = (m = R(t, e)) == null ? void 0 : m.toJSON(), p = JSON.stringify(t.orderBy);
+    return { apiKey: n, customParameters: c, definitionExpression: r, featureReduction: d, floors: K(this.layer, e) ? e.floors : null, gdbVersion: a, historicMoment: l, labelingInfo: u, orderBy: p, renderer: s, subtypeCode: o };
+  }
+};
+function Hi(i) {
+  if (!("openPorts" in i))
+    throw new C("source-not-supported");
+}
+class Ze {
+  constructor(e) {
+    this.layer = e;
+  }
+  getLabelingDeconflictionInfo(e) {
+    const t = this.layer, r = X(t, e) ?? k(t);
+    return [{ vvEvaluators: { 0: B(t.renderer) }, deconflictionEnabled: r }];
+  }
+  async createServiceOptions(e) {
+    var c;
+    const t = this.layer, r = N(t), { capabilities: s, objectIdField: a } = t, n = t.fieldsIndex.toJSON(), o = P(t), u = (c = t.timeInfo) == null ? void 0 : c.toJSON(), l = t.spatialReference.toJSON();
+    return Hi(t.source), { type: "memory", source: await t.source.openPorts(), orderByFields: a, metadata: { fieldsIndex: n, geometryType: o, objectIdField: a, timeInfo: u, spatialReference: l, subtypes: null, subtypeField: null, globalIdField: null, typeIdField: null, types: null, timeReferenceUnknownClient: null }, queryMetadata: { capabilities: s, effectiveCapabilities: r, lastEditDate: null, snapshotInfo: null } };
+  }
+  createSourceSchema(e, t, r) {
+    const { definitionExpression: s, timeExtent: a } = this.layer;
+    return J(e, { definitionExpression: s, timeExtent: a, customParameters: null }, t, r, null);
+  }
+  createProcessorSchema(e, t, r) {
+    const { fields: s, renderer: a, geometryType: n, labelingInfo: o, labelsVisible: u, orderBy: l, objectIdField: c } = this.layer, d = { fields: s.map((p) => p.toJSON()), renderer: a == null ? void 0 : a.clone(), featureReduction: R(this.layer, t), geometryType: n, labelingInfo: o, labelsVisible: u, objectIdField: c, orderBy: l ?? "default" };
+    return D(e, t, d, r);
+  }
+  get hasRequiredSupport() {
+    return L(this.layer.renderer);
+  }
+  getUpdateHashProperties(e) {
+    var o;
+    const t = this.layer, { definitionExpression: r, renderer: s } = t, a = this.layer.labelsVisible ? this.layer.labelingInfo : null, n = (o = R(t, e)) == null ? void 0 : o.toJSON();
+    return { orderBy: JSON.stringify(t.orderBy), definitionExpression: r, renderer: s, labelingInfo: a, featureReduction: n };
+  }
+}
+let Qi = class {
+  constructor(e) {
+    this.layer = e;
+  }
+  getLabelingDeconflictionInfo(e) {
+    const t = this.layer, r = X(t, e) ?? k(t);
+    return [{ vvEvaluators: { 0: B(t.renderer) }, deconflictionEnabled: r }];
+  }
+  async createServiceOptions(e) {
+    const t = this.layer, r = N(t), { capabilities: s, objectIdField: a } = t, n = t.fieldsIndex.toJSON(), o = P(t), u = t.spatialReference.toJSON();
+    return { type: "memory", source: await t.source.openPorts(), orderByFields: a, metadata: { fieldsIndex: n, geometryType: o, objectIdField: a, spatialReference: u, globalIdField: null, subtypeField: null, subtypes: null, timeInfo: null, timeReferenceUnknownClient: null, typeIdField: null, types: null }, queryMetadata: { capabilities: s, effectiveCapabilities: r, lastEditDate: null, snapshotInfo: null } };
+  }
+  createSourceSchema(e, t, r) {
+    const { definitionExpression: s } = this.layer;
+    return J(e, { definitionExpression: s, customParameters: null }, t, r, null);
+  }
+  createProcessorSchema(e, t, r) {
+    const { fields: s, renderer: a, geometryType: n, labelingInfo: o, labelsVisible: u, objectIdField: l } = this.layer, c = { fields: s.map((d) => d.toJSON()), renderer: a == null ? void 0 : a.clone(), featureReduction: R(this.layer, t), geometryType: n, labelingInfo: o, labelsVisible: u, objectIdField: l, orderBy: "default" };
+    return D(e, t, c, r);
+  }
+  get hasRequiredSupport() {
+    return L(this.layer.renderer);
+  }
+  getUpdateHashProperties(e) {
+    var o;
+    const t = this.layer, { definitionExpression: r, renderer: s } = t, a = this.layer.labelsVisible ? this.layer.labelingInfo : null, n = (o = R(t, e)) == null ? void 0 : o.toJSON();
+    return { definitionExpression: r, renderer: s, labelingInfo: a, featureReduction: n };
+  }
+}, Gi = class {
+  constructor(e) {
+    this.layer = e;
+  }
+  getLabelingDeconflictionInfo(e) {
+    const t = this.layer, r = X(t, e) ?? k(t);
+    return [{ vvEvaluators: { 0: B(t.renderer) }, deconflictionEnabled: r }];
+  }
+  async createServiceOptions(e) {
+    var y;
+    const t = this.layer, r = N(t), { capabilities: s, objectIdField: a } = t, n = t.fieldsIndex.toJSON(), o = P(t), u = (y = t.timeInfo) == null ? void 0 : y.toJSON(), l = t.spatialReference.toJSON(), c = t.source.getSource(), d = this.layer.objectIdField, p = ne(s);
+    return p.query.maxRecordCount = c.maxRecordCount, { type: "ogc", source: c, orderByFields: d, metadata: { fieldsIndex: n, geometryType: o, objectIdField: a, timeInfo: u, spatialReference: l, globalIdField: null, subtypeField: null, subtypes: null, timeReferenceUnknownClient: null, typeIdField: null, types: null }, queryMetadata: { capabilities: p, effectiveCapabilities: r, lastEditDate: null, snapshotInfo: null } };
+  }
+  createSourceSchema(e, t, r) {
+    const { customParameters: s, timeExtent: a, apiKey: n } = this.layer;
+    return J(e, { customParameters: s, timeExtent: a }, t, r, n);
+  }
+  createProcessorSchema(e, t, r) {
+    const { fields: s, renderer: a, geometryType: n, labelingInfo: o, labelsVisible: u, orderBy: l, objectIdField: c } = this.layer, d = { fields: s.map((p) => p.toJSON()), renderer: a == null ? void 0 : a.clone(), featureReduction: R(this.layer, t), geometryType: n, labelingInfo: o, labelsVisible: u, objectIdField: c, orderBy: l ?? "default" };
+    return D(e, t, d, r);
+  }
+  get hasRequiredSupport() {
+    return L(this.layer.renderer);
+  }
+  getUpdateHashProperties(e) {
+    var u;
+    const t = this.layer, { renderer: r, apiKey: s } = t, a = this.layer.labelsVisible ? this.layer.labelingInfo : null, n = JSON.stringify(t.customParameters), o = (u = R(t, e)) == null ? void 0 : u.toJSON();
+    return { apiKey: s, customParameters: n, featureReduction: o, labelingInfo: a, orderBy: JSON.stringify(t.orderBy), renderer: r };
+  }
+}, Ki = class {
+  constructor(e) {
+    this.layer = e;
+  }
+  getLabelingDeconflictionInfo(e) {
+    const t = this.layer, r = X(t, e) ?? k(t);
+    return [{ vvEvaluators: { 0: B(t.renderer) }, deconflictionEnabled: r }];
+  }
+  async createServiceOptions(e) {
+    var v;
+    const t = this.layer, r = N(t), { capabilities: s, objectIdField: a, globalIdField: n, orderBy: o, refreshInterval: u } = t, l = t.fieldsIndex.toJSON(), c = l.fields, d = P(t), p = (v = t.timeInfo) == null ? void 0 : v.toJSON(), y = t.spatialReference.toJSON(), m = ne(this.layer.parsedUrl);
+    let b = this.layer.objectIdField;
+    if (o != null && o.length) {
+      const F = !o[0].valueExpression && o[0].field;
+      F && (b = F);
+    }
+    const V = u > 0, S = g("featurelayer-snapshot-enabled") && t.geometryType === "point" && (s == null ? void 0 : s.query.supportsPagination) && !(s != null && s.operations.supportsEditing) && !V, w = S && Te(e, t.fullExtent);
+    return { type: "feature-service", source: m, isSourceHosted: ge(m.path), orderByFields: b, metadata: { globalIdField: n, fields: c, fieldsIndex: l, geometryType: d, objectIdField: a, timeInfo: p, spatialReference: y, timeReferenceUnknownClient: !1, subtypeField: null, subtypes: null, typeIdField: null, types: null }, queryMetadata: { capabilities: s, effectiveCapabilities: r, lastEditDate: null, snapshotInfo: { supportsSnapshotMinThreshold: S, supportsSnapshotMaxThreshold: w, snapshotCountThresholds: { min: g("featurelayer-snapshot-point-min-threshold"), max: g("featurelayer-snapshot-point-max-threshold") } } } };
+  }
+  createSourceSchema(e, t, r) {
+    const { definitionExpression: s, customParameters: a, timeExtent: n } = this.layer;
+    return J(e, { definitionExpression: s, customParameters: a, timeExtent: n }, t, r, null);
+  }
+  createProcessorSchema(e, t, r) {
+    const { fields: s, renderer: a, geometryType: n, labelingInfo: o, labelsVisible: u, orderBy: l, objectIdField: c } = this.layer, d = { fields: s.map((p) => p.toJSON()), renderer: a == null ? void 0 : a.clone(), featureReduction: R(this.layer, t), geometryType: n, labelingInfo: o, labelsVisible: u, objectIdField: c, orderBy: l ?? "default" };
+    return D(e, t, d, r);
+  }
+  get hasRequiredSupport() {
+    return L(this.layer.renderer);
+  }
+  hasFilters(e) {
+    return K(this.layer, e);
+  }
+  addFilters(e, t) {
+    return Ce(this.layer, e, t);
+  }
+  getUpdateHashProperties(e) {
+    var u;
+    const t = this.layer, { definitionExpression: r, renderer: s } = t, a = this.layer.labelsVisible ? this.layer.labelingInfo : null, n = JSON.stringify(t.customParameters), o = (u = R(t, e)) == null ? void 0 : u.toJSON();
+    return { orderBy: JSON.stringify(t.orderBy), definitionExpression: r, renderer: s, labelingInfo: a, featureReduction: o, customParameters: n, floors: K(this.layer, e) ? e.floors : null };
+  }
+};
+class Wi {
+  constructor(e) {
+    this.layer = e;
+  }
+  getLabelingDeconflictionInfo(e) {
+    const t = this.layer, r = X(t, e) ?? k(t);
+    return [{ vvEvaluators: { 0: B(t.renderer) }, deconflictionEnabled: r }];
+  }
+  async createServiceOptions(e) {
+    var o;
+    const t = this.layer, { objectIdField: r } = t, s = P(t), a = ((o = t.timeInfo) == null ? void 0 : o.toJSON()) || null, n = t.spatialReference ? t.spatialReference.toJSON() : null;
+    return { source: this.layer.parsedUrl, metadata: { fieldsIndex: this.layer.fieldsIndex.toJSON(), geometryType: s, objectIdField: r, timeInfo: a, timeReferenceUnknownClient: null, spatialReference: n, subtypeField: null, subtypes: null, globalIdField: null, typeIdField: null, types: null } };
+  }
+  createSourceSchema(e, t, r) {
+    const { definitionExpression: s, geometryDefinition: a, customParameters: n } = this.layer;
+    return { type: "stream", service: e, tileInfoJSON: t.tileInfoJSON, mutable: { sourceRefreshVersion: r, availableFields: t.availableFields, dataFilter: { geometryDefinition: a == null ? void 0 : a.toJSON(), definitionExpression: s, outSpatialReference: t.outSpatialReference.toJSON(), customParameters: n ?? null, maxReconnectionAttempts: this.layer.maxReconnectionAttempts, maxReconnectionInterval: this.layer.maxReconnectionInterval, purgeOptions: this.layer.purgeOptions.toJSON() } } };
+  }
+  createProcessorSchema(e, t, r) {
+    const { fields: s, renderer: a, geometryType: n, labelingInfo: o, labelsVisible: u, objectIdField: l } = this.layer, c = { fields: s.map((d) => d.toJSON()), renderer: a == null ? void 0 : a.clone(), featureReduction: R(this.layer, t), geometryType: n, labelingInfo: o, labelsVisible: u, objectIdField: l, orderBy: "default" };
+    return D(e, t, c, r);
+  }
+  get hasRequiredSupport() {
+    return L(this.layer.renderer);
+  }
+  getUpdateHashProperties(e) {
+    var u;
+    const t = this.layer, { definitionExpression: r, renderer: s } = t, a = this.layer.labelsVisible ? this.layer.labelingInfo : null, n = JSON.stringify(t.customParameters), o = (u = R(t, e)) == null ? void 0 : u.toJSON();
+    return { definitionExpression: r, renderer: s, labelingInfo: a, featureReduction: o, customParameters: n, streamFilter: `${JSON.stringify(t.geometryDefinition)}${t.definitionExpression}` };
+  }
+}
+async function Zi(i, { subtypeField: e, sublayers: t }) {
+  const r = await Promise.all(t.map(({ renderer: s }) => se(i, s)));
+  return { type: "subtype", subtypeField: e, renderers: t.reduce((s, { subtypeCode: a }, n) => ({ ...s, [a]: r[n] }), {}) };
+}
+function Xi(i, e) {
+  const t = mt();
+  return { type: "subtype", filters: i.filters, capabilities: { maxTextureSize: t.maxTextureSize }, subtypeField: e.subtypeField, target: "feature", bindings: e.sublayers.reduce((r, { renderer: s, subtypeCode: a }) => ({ ...r, [a]: Qt(s) }), {}) };
+}
+async function Yi(i, { subtypeField: e, sublayers: t }) {
+  const r = await Promise.all(t.map((s) => {
+    const a = z(s.renderer), n = { ...s, geometryType: s.geometryType ?? null };
+    return re(i, n, a);
+  }));
+  return { type: "subtype", subtypeField: e, renderers: t.reduce((s, { subtypeCode: a }, n) => ({ ...s, [a]: r[n] }), {}) };
+}
+async function er(i, e, t, r) {
+  return { storage: Xi(e, t), mesh: { displayRefreshVersion: r, strategy: { type: "feature" }, factory: { symbology: await Zi(i, t), labels: await Yi(i, t) }, sortKey: null, timeZone: e.timeZone } };
+}
+class tr {
+  constructor(e) {
+    this.layer = e;
+  }
+  getLabelingDeconflictionInfo(e) {
+    return [{ vvEvaluators: {}, deconflictionEnabled: this.layer.sublayers.every((t) => k(t)) }];
+  }
+  async createServiceOptions(e) {
+    var F, $, Y;
+    const t = this.layer, r = N(t), { capabilities: s, datesInUnknownTimezone: a, editingInfo: n, globalIdField: o, objectIdField: u, refreshInterval: l, subtypeField: c } = t, d = t.fieldsIndex.toJSON(), p = P(t), y = (F = t.timeInfo) == null ? void 0 : F.toJSON(), m = t.spatialReference.toJSON(), b = ne(this.layer.parsedUrl), V = u, S = (n == null ? void 0 : n.lastEditDate) == null && l > 0, w = g("featurelayer-snapshot-enabled") && t.geometryType === "point" && (s == null ? void 0 : s.query.supportsPagination) && !(s != null && s.operations.supportsEditing) && !S, v = w && Te(e, t.fullExtent);
+    return { type: "feature-service", source: b, isSourceHosted: ge(b.path), orderByFields: V, metadata: { timeReferenceUnknownClient: a, subtypeField: c, globalIdField: o, fieldsIndex: d, geometryType: p, objectIdField: u, timeInfo: y, spatialReference: m, subtypes: ($ = this.layer.subtypes) == null ? void 0 : $.map((Se) => Se.toJSON()), typeIdField: null, types: null }, queryMetadata: { capabilities: s, effectiveCapabilities: r, lastEditDate: (Y = n == null ? void 0 : n.lastEditDate) == null ? void 0 : Y.getTime(), snapshotInfo: { supportsSnapshotMinThreshold: w, supportsSnapshotMaxThreshold: v, snapshotCountThresholds: { min: g("featurelayer-snapshot-point-min-threshold"), max: g("featurelayer-snapshot-point-max-threshold") } } } };
+  }
+  createSourceSchema(e, t, r) {
+    const { definitionExpression: s, customParameters: a, gdbVersion: n, historicMoment: o, subtypeField: u, timeExtent: l, apiKey: c } = this.layer, d = this.layer.sublayers.map((m) => m.subtypeCode).join(","), p = this.layer.sublayers.length ? `${this.layer.subtypeField} IN (${d})` : "1=2", y = { definitionExpression: fe(s, p), customParameters: a, gdbVersion: n, historicMoment: o, subtypeField: u, timeExtent: l };
+    return J(e, y, t, r, c);
+  }
+  createProcessorSchema(e, t, r) {
+    const s = { subtypeField: this.layer.subtypeField, sublayers: Array.from(this.layer.sublayers, (a) => ({ featureReduction: null, geometryType: this.layer.geometryType, labelingInfo: a.labelingInfo, labelsVisible: a.labelsVisible, renderer: a.renderer, subtypeCode: a.subtypeCode, orderBy: null })) };
+    return er(e, t, s, r);
+  }
+  hasFilters(e) {
+    return K(this.layer, e) || ir(this.layer, e);
+  }
+  addFilters(e, t) {
+    e = Ce(this.layer, e, t);
+    const r = this.layer.sublayers.filter((a) => !nt(a, t)).map((a) => a.subtypeCode);
+    if (!r.length)
+      return e;
+    e ?? (e = new te());
+    const s = `NOT ${this.layer.subtypeField} IN (${r.join(",")})`;
+    return e.where = fe(e.where, s), e;
+  }
+  get hasRequiredSupport() {
+    return !0;
+  }
+  getUpdateHashProperties(e) {
+    var l;
+    const t = this.layer, { definitionExpression: r, gdbVersion: s, apiKey: a } = t, n = ((l = t.historicMoment) == null ? void 0 : l.getTime()) ?? void 0, o = JSON.stringify(t.customParameters), u = K(this.layer, e) ? e.floors : null;
+    return { gdbVersion: s, definitionExpression: r, historicMoment: n, customParameters: o, apiKey: a, sublayerHash: "sublayers" in this.layer && this.layer.sublayers.items.reduce((c, d) => c + `${d.visible ? 1 : 0}.${JSON.stringify(d.renderer)}.${d.labelsVisible}
+.${JSON.stringify(d.labelingInfo)}`, ""), floors: u };
+  }
+  setGraphicOrigin(e) {
+    const t = this.layer.fieldsIndex.get(this.layer.subtypeField), r = e.attributes[t.name], s = this.layer.sublayers.find((a) => a.subtypeCode === r);
+    e.layer = e.sourceLayer = s;
+  }
+}
+function ir(i, e) {
+  return i.sublayers.some((t) => !nt(t, e));
+}
+function nt(i, e) {
+  return i.visible && (i.minScale === 0 || ke(e.scale, i.minScale) || e.scale < i.minScale) && (i.maxScale === 0 || ke(e.scale, i.maxScale) || e.scale > i.maxScale);
+}
+async function _(i, e) {
+  try {
+    return await i;
+  } catch (t) {
+    if (t.name !== "no-queryEngine")
+      throw t;
+    return e;
+  }
+}
+function Q(i, e) {
+  const t = /* @__PURE__ */ new Set();
+  for (const r of i instanceof Set ? i.values() : i.keys())
+    e.has(r) || t.add(r);
+  return t;
+}
+class rr {
+  constructor(e) {
+    this.version = e;
+  }
+}
+class sr {
+  constructor(e) {
+    this._subscriptions = /* @__PURE__ */ new Map(), this._visible = /* @__PURE__ */ new Set(), this._paused = /* @__PURE__ */ new Set(), this._version = 0, this._config = e;
+  }
+  destroy() {
+  }
+  get _coverageSet() {
+    const e = this._coverage ? Array.from(this._coverage.keys()).map((t) => t.id) : [];
+    return new Set(e);
+  }
+  suspend() {
+    this._suspendedOverage = this._coverage, this._coverage = null, this._updateSubscriptions();
+  }
+  resume() {
+    this._coverage == null && (this._coverage = this._suspendedOverage, this._suspendedOverage = null, this._updateSubscriptions());
+  }
+  update(e) {
+    return this._version = this._version + 1 % Number.MAX_SAFE_INTEGER, this._updateCoverage(e), this._updateSubscriptions(), new Set(this._visible);
+  }
+  _updateCoverage(e) {
+    this._coverage = this._config.tileInfoView.getTileCoverage(e.state, 0, !0, "closest");
+  }
+  _updateSubscriptions() {
+    const e = this._coverageSet, t = this._updateVisibility(), r = Q(t, e), s = Q(this._subscriptions, t), a = Q(e, this._subscriptions), n = Q(s, e), o = Q(r, n), u = Q(o, this._paused);
+    this._visible = t;
+    for (const l of a.values())
+      this._subscriptions.set(l, new rr(this._version));
+    for (const l of u.values())
+      this._paused.add(l);
+    for (const l of n.values())
+      this._subscriptions.delete(l), this._paused.delete(l);
+    (a.size || n.size || u.size) && this._sendUpdateSubscriptions(a, n, u);
+  }
+  _sendUpdateSubscriptions(e, t, r) {
+    const s = Array.from(e.values()).map((a) => ({ tileId: a, version: this._subscriptions.get(a).version }));
+    this._config.updateSubscriptions({ subscribe: s, unsubscribe: Array.from(t.values()), pause: Array.from(r.values()), tileInfoJSON: this._config.tileInfoView.tileInfo.toJSON() });
+  }
+  _updateVisibility() {
+    const e = /* @__PURE__ */ new Set();
+    if (!this._coverage)
+      return e;
+    for (const t of this._coverage.keys()) {
+      if (this._config.isDone(t)) {
+        e.add(t.id);
+        continue;
+      }
+      this._addVisibleParent(e, t) || this._addVisibleChildren(e, t) || e.add(t.id);
+    }
+    return e;
+  }
+  _addVisibleParent(e, t) {
+    let r = !1;
+    for (const s of this._visible.values())
+      new xe(s).containsChild(t) && (e.add(s), r = !0);
+    return r;
+  }
+  _addVisibleChildren(e, t) {
+    let r = !1;
+    for (const s of this._visible.values()) {
+      const a = new xe(s);
+      t.containsChild(a) && (e.add(s), r = !0);
+    }
+    return r;
+  }
+}
+const ar = (i) => {
+  let e = class extends i {
+    constructor(...t) {
+      super(...t), this._updatingRequiredFieldsPromise = null, this.dataUpdating = !1, this.filter = null, this.timeExtent = null, this.layer = null, this.requiredFields = [], this.view = null;
+    }
+    initialize() {
+      this.addHandles([Ee(() => {
+        var r;
+        const t = this.layer;
+        return [t && "elevationInfo" in t ? (r = t.elevationInfo) == null ? void 0 : r.featureExpressionInfo : null, t && "displayField" in t ? t.displayField : null, t && "timeInfo" in t && t.timeInfo, t && "renderer" in t && t.renderer, t && "labelingInfo" in t && t.labelingInfo, t && "floorInfo" in t && t.floorInfo, this.filter, this.featureEffect, this.timeExtent];
+      }, () => this._handleRequiredFieldsChange(), gt), qe(() => {
+        var t;
+        return (t = this.view) == null ? void 0 : t.floors;
+      }, "change", () => this._handleRequiredFieldsChange()), qe(() => {
+        const t = this.layer;
+        return t && "sublayers" in t ? t.sublayers : null;
+      }, "change", () => this._handleRequiredFieldsChange())]);
+    }
+    get availableFields() {
+      if (!this.layer)
+        return [];
+      const { layer: t, layer: { fieldsIndex: r }, requiredFields: s } = this;
+      return "outFields" in t && t.outFields ? Ue(r, [...Le(r, t.outFields), ...s]) : Ue(r, s);
+    }
+    get featureEffect() {
+      return this.layer && "featureEffect" in this.layer ? this.layer.featureEffect : null;
+    }
+    set featureEffect(t) {
+      this._override("featureEffect", t);
+    }
+    get maximumNumberOfFeatures() {
+      return 0;
+    }
+    set maximumNumberOfFeatures(t) {
+      q.getLogger(this).error("#maximumNumberOfFeatures=", "Setting maximum number of features is not supported");
+    }
+    get maximumNumberOfFeaturesExceeded() {
+      return !1;
+    }
+    highlight(t) {
+      throw new Error("missing implementation");
+    }
+    createQuery() {
+      const t = { outFields: ["*"], returnGeometry: !0, outSpatialReference: this.view.spatialReference }, r = this.filter != null ? this.filter.createQuery(t) : new ye(t);
+      if ("floorInfo" in this.layer && this.layer.floorInfo) {
+        const s = We(this);
+        s != null && (r.where = r.where ? `(${r.where}) AND (${s})` : s);
+      }
+      return this.timeExtent != null && (r.timeExtent = r.timeExtent != null ? r.timeExtent.intersection(this.timeExtent) : this.timeExtent.clone()), r;
+    }
+    createAggregateQuery() {
+      const t = { outFields: ["*"], returnGeometry: !0, outSpatialReference: this.view.spatialReference };
+      return new ye(t);
+    }
+    queryFeatures(t, r) {
+      throw new Error("missing implementation");
+    }
+    queryObjectIds(t, r) {
+      throw new Error("missing implementation");
+    }
+    queryFeatureCount(t, r) {
+      throw new Error("missing implementation");
+    }
+    queryExtent(t, r) {
+      throw new Error("missing implementation");
+    }
+    async fetchPopupFeaturesFromGraphics(t, r) {
+      return this._validateFetchPopupFeatures(t, r), this._fetchPopupFeatures(t, r);
+    }
+    _loadArcadeModules(t) {
+      var r;
+      return (r = t.expressionInfos) != null && r.length || Array.isArray(t.content) && t.content.some((s) => s.type === "expression") ? bt() : Promise.resolve();
+    }
+    _handleRequiredFieldsChange() {
+      const t = this._updateRequiredFields();
+      this._set("_updatingRequiredFieldsPromise", t), t.then(() => {
+        this._updatingRequiredFieldsPromise === t && this._set("_updatingRequiredFieldsPromise", null);
+      });
+    }
+    async _updateRequiredFields() {
+      if (!this.layer || !this.view)
+        return;
+      const t = this.view.type === "3d", { layer: r, layer: { fieldsIndex: s, objectIdField: a } } = this, n = "renderer" in r && r.renderer, o = "orderBy" in r && r.orderBy, u = "featureReduction" in r ? r.featureReduction : null, l = /* @__PURE__ */ new Set(), c = await Promise.allSettled([n ? n.collectRequiredFields(l, s) : null, Be(l, r), t && "elevationInfo" in r ? St(l, r) : null, this.filter != null ? Je(l, r, this.filter) : null, t || this.featureEffect == null ? null : Je(l, r, this.featureEffect.filter), !t && u ? vt(l, r, u) : null, !t && o ? _t(l, r, o) : null]);
+      if ("timeInfo" in r && r.timeInfo && this.timeExtent && oe(l, r.fieldsIndex, [r.timeInfo.startField, r.timeInfo.endField]), "floorInfo" in r && r.floorInfo && oe(l, r.fieldsIndex, [r.floorInfo.floorField]), r.type === "feature" && t && r.infoFor3D != null && (r.globalIdField == null && q.getLogger(this).error("globalIdField missing on 3DObjectFeatureLayer"), oe(l, r.fieldsIndex, [r.globalIdField])), r.type === "subtype-group") {
+        ve(l, s, r.subtypeField);
+        const p = r.sublayers.map((y) => {
+          var m;
+          return Promise.all([(m = y.renderer) == null ? void 0 : m.collectRequiredFields(l, s), Be(l, y)]);
+        });
+        await Promise.allSettled(p);
+      }
+      r.type === "catalog-footprint" && oe(l, s, [r.parent.itemSourceField, r.parent.itemTypeField]);
+      for (const p of c)
+        p.status === "rejected" && q.getLogger(this).error(p.reason);
+      ve(l, s, a), t && "displayField" in r && r.displayField && ve(l, s, r.displayField);
+      const d = Array.from(l).sort();
+      this._set("requiredFields", d);
+    }
+    _validateFetchPopupFeatures(t, r) {
+      if (r != null)
+        for (const s of t) {
+          const a = s.origin && "layer" in s.origin ? s.origin.layer : s.layer;
+          if ("popupEnabled" in a && !a.popupEnabled)
+            throw new C("featurelayerview:fetchPopupFeatures", "Popups are disabled", { layer: a });
+          if (s.isAggregate) {
+            const n = "featureReduction" in a ? a.featureReduction : null;
+            if (!(n && "popupTemplate" in n && n.popupEnabled && n.popupTemplate))
+              throw new C("featurelayerview:fetchPopupFeatures", "Popups are disabled", { layer: a });
+          } else if ("popupTemplate" in a && !Ve(a, r))
+            throw new C("featurelayerview:fetchPopupFeatures", "Layer does not define a popup template", { layer: a });
+        }
+    }
+    _popupFeatureHasRequiredFields(t, r) {
+      return wt(r, t);
+    }
+    async _fetchPopupFeatures(t, r) {
+      var o;
+      const s = new Array(t.length), a = /* @__PURE__ */ new Map(), n = await this._createPopupQuery(t.map((u) => {
+        var l;
+        return ((l = u.origin) == null ? void 0 : l.layer) ?? u.layer;
+      }), r);
+      for (let u = 0; u < t.length; u++) {
+        const l = t[u];
+        if (l.isAggregate) {
+          s[u] = l;
+          continue;
+        }
+        const c = ((o = l.origin) == null ? void 0 : o.layer) ?? l.layer;
+        if (!c || !("popupEnabled" in c))
+          continue;
+        const d = Le(this.layer.fieldsIndex, n.outFields), p = Ve(c, r);
+        if (p == null)
+          continue;
+        const y = await this._loadArcadeModules(p);
+        pe(r), y && y.arcadeUtils.hasGeometryOperations(p) || !this._popupFeatureHasRequiredFields(l, d) ? a.set(l.getObjectId(), { graphic: l, index: u }) : s[u] = l;
+      }
+      if (this.layer.type === "stream" || a.size === 0)
+        return s.filter(Boolean);
+      n.objectIds = Array.from(a.keys());
+      try {
+        const u = await this.layer.queryFeatures(n, r);
+        for (const l of u.features) {
+          const { graphic: { geometry: c, origin: d }, index: p } = a.get(l.getObjectId());
+          l.geometry || (l.geometry = c), l.origin = d, s[p] = l;
+        }
+      } catch {
+      }
+      return s.filter(Boolean);
+    }
+    async _createPopupQuery(t, r) {
+      const s = this.layer.createQuery(), a = /* @__PURE__ */ new Set();
+      let n = !1;
+      const o = t ?? [this.layer];
+      for (const u of o) {
+        if (!("popupEnabled" in u))
+          continue;
+        const l = Ve(u, r);
+        if (l == null)
+          continue;
+        const c = await this._loadArcadeModules(l);
+        pe(r);
+        const d = c && c.arcadeUtils.hasGeometryOperations(l);
+        n = !(this.layer.geometryType !== "point" && !d);
+        const p = await Xt(this.layer, l);
+        pe(r);
+        for (const y of p)
+          a.add(y);
+      }
+      if (s.returnGeometry = n, s.returnZ = n, s.returnM = n, s.outFields = Array.from(a), s.outSpatialReference = this.view.spatialReference, "floorInfo" in this.layer && this.layer.floorInfo) {
+        const u = We(this);
+        u != null && (s.where = s.where ? `(${s.where}) AND (${u})` : u);
+      }
+      return s;
+    }
+    canResume() {
+      return !!super.canResume() && (this.timeExtent == null || !this.timeExtent.isEmpty);
+    }
+    getTest() {
+      return { createPopupQuery: (t) => this._createPopupQuery(void 0, t) };
+    }
+    get test() {
+      return this.getTest();
+    }
+  };
+  return h([f()], e.prototype, "_updatingRequiredFieldsPromise", void 0), h([f({ readOnly: !0 })], e.prototype, "availableFields", null), h([f({ readOnly: !0 })], e.prototype, "dataUpdating", void 0), h([f({ type: Zt })], e.prototype, "featureEffect", null), h([f({ type: te })], e.prototype, "filter", void 0), h([f(Wt)], e.prototype, "timeExtent", void 0), h([f()], e.prototype, "layer", void 0), h([f({ type: Number })], e.prototype, "maximumNumberOfFeatures", null), h([f({ readOnly: !0, type: Boolean })], e.prototype, "maximumNumberOfFeaturesExceeded", null), h([f({ readOnly: !0 })], e.prototype, "requiredFields", void 0), h([f()], e.prototype, "suspended", void 0), h([f()], e.prototype, "view", void 0), e = h([W("esri.views.layers.FeatureLayerView")], e), e;
+};
+function nr(i, e) {
+  const t = /* @__PURE__ */ new Set();
+  return i && i.forEach((r) => t.add(r)), e && e.forEach((r) => t.add(r)), t.has("*") ? ["*"] : Array.from(t);
+}
+const lr = "esri.views.2d.layers.FeatureLayerView2D", Xe = 4294967294;
+let I = class extends ar(Yt(At(Pt))) {
+  constructor() {
+    super(...arguments), this._commandsQueue = new Gt({ process: (i) => {
+      switch (i.type) {
+        case "processed-edit":
+          return this._doEdit(i);
+        case "update":
+          return this._doUpdate();
+      }
+    } }), this._visibilityOverrides = /* @__PURE__ */ new Set(), this._highlightCounter = new Kt(), this._updateHighlight = Vt(async () => {
+      const i = [];
+      for (const e of this._highlightCounter.ids()) {
+        const t = this._highlightCounter.getHighestReason(e), r = Ct(t);
+        i.push({ objectId: e, highlightFlags: r });
+      }
+      this._worker.pipeline.updateHighlight({ highlights: i });
+    }), this._lastAvailableFields = [], this.eventLog = new T(), this._sourceRefreshVersion = 1, this._displayRefreshVersion = 1, this._pipelineUpdating = !1, this._fields = null, this.featureEffectView = new ei();
+  }
+  destroy() {
+    var i;
+    (i = this._worker) == null || i.destroy(), this._commandsQueue.destroy();
+  }
+  initialize() {
+    this.addResolvingPromise(this._initProxy()), this.featureEffectView.featureEffect = this.featureEffect, this.featureEffectView.endTransitions();
+  }
+  async _initProxy() {
+    var t;
+    const i = this.layer;
+    if ("isTable" in i && i.isTable)
+      throw new C("featurelayerview:table-not-supported", "table feature layer can't be displayed", { layer: i });
+    if (i.geometryType === "mesh")
+      throw new C("featurelayerview:geometry-type-not-supported", `Geometry type of ${i.geometryType} is not supported`, { layer: i });
+    if ((i.type === "feature" || i.type === "subtype-group") && ((t = N(i)) == null ? void 0 : t.operations.supportsQuery) === !1)
+      throw new C("featurelayerview:query-not-supported", "layer view requires a layer with query capability", { layer: i });
+    this._worker && this._worker.destroy();
+    const e = this._createClientOptions();
+    this._worker = await ni(e);
+  }
+  get hasAllFeatures() {
+    return this.layer.visible && this.eventLog.hasAllFeatures;
+  }
+  get hasAllFeaturesInView() {
+    return this.layer.visible && this.eventLog.hasAllFeaturesInView;
+  }
+  get hasFullGeometries() {
+    return this.layer.visible && this.eventLog.hasFullGeometries;
+  }
+  get labelingCollisionInfos() {
+    const i = this.layerAdapter.getLabelingDeconflictionInfo(this.view), e = this.layer.geometryType, t = !this.suspended;
+    return i.map(({ vvEvaluators: r, deconflictionEnabled: s }) => ({ container: this.featureContainer, vvEvaluators: r, deconflictionEnabled: s, geometryType: e, visible: t }));
+  }
+  get layerAdapter() {
+    switch (this.layer.type) {
+      case "feature":
+        return this.layer.source.type === "memory" ? new Ze(this.layer) : new ji(this.layer);
+      case "geojson":
+      case "csv":
+      case "wfs":
+        return new Ze(this.layer);
+      case "subtype-group":
+        return new tr(this.layer);
+      case "ogc-feature":
+        return new Gi(this.layer);
+      case "stream":
+        return new Wi(this.layer);
+      case "oriented-imagery":
+        return new Ki(this.layer);
+      case "knowledge-graph-sublayer":
+        return new Qi(this.layer);
+      case "catalog-footprint":
+        return new Ji(this.layer);
+      default:
+        It(this.layer);
+    }
+    return null;
+  }
+  get updateHash() {
+    if (!this.layerAdapter)
+      return null;
+    const { availableFields: i, _displayRefreshVersion: e, timeExtent: t, clips: r, filter: s, featureEffect: a, _sourceRefreshVersion: n, view: { timeZone: o } } = this, u = JSON.stringify(r), l = a == null ? void 0 : a.toJSON(), c = s == null ? void 0 : s.toJSON();
+    return JSON.stringify({ availableFields: i, clipsHash: u, displayRefreshVersion: e, effectHash: l, filterHash: c, sourceRefreshVersion: n, timeExtent: t, timeZone: o, ...this.layerAdapter.getUpdateHashProperties(this.view) });
+  }
+  getDisplayStatistics(i, e) {
+    var t;
+    return (t = this.featureContainer) == null ? void 0 : t.getDisplayStatistics(i, e);
+  }
+  async queryHeatmapStatistics(i) {
+    return this._worker.pipeline.queryHeatmapStatistics(i);
+  }
+  highlight(i, e = "highlight") {
+    let t;
+    i instanceof Ie ? t = [i.getObjectId()] : typeof i == "number" || typeof i == "string" ? t = [i] : xt.isCollection(i) && i.length > 0 ? t = i.map((s) => s == null ? void 0 : s.getObjectId()).toArray() : Array.isArray(i) && i.length > 0 && (t = typeof i[0] == "number" || typeof i[0] == "string" ? i : i.map((s) => s == null ? void 0 : s.getObjectId()));
+    const r = t == null ? void 0 : t.filter(Et);
+    return r != null && r.length ? (this._addHighlight(r, e), De(() => this._removeHighlight(r, e))) : De();
+  }
+  getHighlightIds() {
+    return Array.from(this._highlightCounter.ids());
+  }
+  hasHighlight() {
+    return !this._highlightCounter.empty;
+  }
+  async hitTest(i, e) {
+    const t = await this.featureContainer.hitTest(e);
+    if (t.length === 0)
+      return null;
+    const { features: r, aggregates: s } = await this._worker.pipeline.getDisplayFeatures(t), a = this.featureContainer.getSortKeys(t), n = ({ displayId: o }, { displayId: u }) => a.has(o) && a.has(u) ? a.get(o) - a.get(u) : o - u;
+    return r.sort(n).reverse(), s.sort(n).reverse(), [...s.map((o) => this._createGraphicHit(i, $e.fromJSON(o))), ...r.map((o) => this._createGraphicHit(i, Ie.fromJSON(o)))];
+  }
+  queryStatistics() {
+    return _(this._worker.pipeline.queryStatistics(), { featureCount: 0, ringCount: 0, vertexCount: 0 });
+  }
+  querySummaryStatistics(i, e, t) {
+    const r = { ...e, scale: this.view.scale }, s = this._worker.features.executeQueryForSummaryStatistics(this._cleanUpQuery(i), r, t);
+    return _(s, {});
+  }
+  async queryAggregateSummaryStatistics(i, e, t) {
+    const r = { ...e, scale: this.view.scale }, s = this._worker.aggregates.executeQueryForSummaryStatistics(this._cleanUpAggregateQuery(i), r, t);
+    return _(s, {});
+  }
+  async queryUniqueValues(i, e, t) {
+    const r = { ...e, scale: this.view.scale }, s = this._worker.features.executeQueryForUniqueValues(this._cleanUpQuery(i), r, t);
+    return _(s, { uniqueValueInfos: [] });
+  }
+  async queryAggregateUniqueValues(i, e, t) {
+    const r = { ...e, scale: this.view.scale }, s = this._worker.aggregates.executeQueryForUniqueValues(this._cleanUpAggregateQuery(i), r, t);
+    return _(s, { uniqueValueInfos: [] });
+  }
+  async queryClassBreaks(i, e, t) {
+    const r = { ...e, scale: this.view.scale }, s = this._worker.features.executeQueryForClassBreaks(this._cleanUpQuery(i), r, t);
+    return _(s, { classBreakInfos: [] });
+  }
+  async queryAggregateClassBreaks(i, e, t) {
+    const r = { ...e, scale: this.view.scale }, s = this._worker.aggregates.executeQueryForClassBreaks(this._cleanUpAggregateQuery(i), r, t);
+    return _(s, { classBreakInfos: [] });
+  }
+  async queryHistogram(i, e, t) {
+    const r = { ...e, scale: this.view.scale }, s = this._worker.features.executeQueryForHistogram(this._cleanUpQuery(i), r, t);
+    return _(s, { bins: [], maxValue: null, minValue: null, normalizationTotal: null });
+  }
+  async queryAggregateHistogram(i, e, t) {
+    const r = { ...e, scale: this.view.scale }, s = this._worker.aggregates.executeQueryForHistogram(this._cleanUpAggregateQuery(i), r, t);
+    return _(s, { bins: [], maxValue: null, minValue: null, normalizationTotal: null });
+  }
+  queryFeatures(i, e) {
+    return this.queryFeaturesJSON(i, e).then((t) => {
+      const r = Fe.fromJSON(t);
+      return r.features.forEach((s) => this._setLayersForFeature(s)), r;
+    });
+  }
+  async queryVisibleFeatures(i, e) {
+    const t = this._worker.pipeline.queryVisibleFeatures(this._cleanUpQuery(i), e), r = await _(t, { features: [] }), s = Fe.fromJSON(r);
+    return s.features.forEach((a) => this._setLayersForFeature(a)), s;
+  }
+  async queryAggregates(i, e) {
+    const t = this._worker.aggregates.executeQuery(this._cleanUpAggregateQuery(i), e), r = await _(t, { features: [] }), s = ti.fromJSON(r);
+    return s.features.forEach((a) => this._setLayersForFeature(a)), s;
+  }
+  queryAggregateIds(i, e) {
+    const t = this._worker.aggregates.executeQueryForIds(this._cleanUpAggregateQuery(i), e);
+    return _(t, []);
+  }
+  queryAggregateCount(i, e) {
+    const t = this._worker.aggregates.executeQueryForCount(this._cleanUpAggregateQuery(i), e);
+    return _(t, 0);
+  }
+  queryAggregateJSON(i, e) {
+    const t = this._worker.aggregates.executeQuery(this._cleanUpAggregateQuery(i), e);
+    return _(t, { features: [] });
+  }
+  async queryFeaturesJSON(i, e) {
+    const t = this._worker.features.executeQuery(this._cleanUpQuery(i), e);
+    return _(t, { features: [] });
+  }
+  queryObjectIds(i, e) {
+    const t = this._worker.features.executeQueryForIds(this._cleanUpQuery(i), e);
+    return _(t, []);
+  }
+  queryFeatureCount(i, e) {
+    const t = this._worker.features.executeQueryForCount(this._cleanUpQuery(i), e);
+    return _(t, 0);
+  }
+  async queryExtent(i, e) {
+    const t = this._worker.features.executeQueryForExtent(this._cleanUpQuery(i), e), r = await _(t, { count: 0, extent: null });
+    return { count: r.count, extent: Ft.fromJSON(r.extent) };
+  }
+  async getSampleFeatures(i) {
+    return this._worker.pipeline.getSampleFeatures(i);
+  }
+  setVisibility(i, e) {
+    e ? this._visibilityOverrides.delete(i) : this._visibilityOverrides.add(i), this._update();
+  }
+  update(i) {
+    if (!this._subscriptionManager)
+      return;
+    const e = this._subscriptionManager.update(i);
+    this.featureContainer.setVisibleTiles(e);
+  }
+  attach() {
+    g("esri-2d-update-debug") && console.debug("FeatureLayerView2D.attach"), this.featureContainer = new ai(this), this.container.addChild(this.featureContainer), this.view.timeline.record(`${this.layer.title} (FeatureLayer) Attach`), this._subscriptionManager = new sr({ tileInfoView: this.view.featuresTilingScheme, updateSubscriptions: (i) => {
+      this.featureContainer.updateSubscriptions(i), this._worker.pipeline.updateSubscriptions(i);
+    }, isDone: (i) => this.featureContainer.isDone(i) }), this.requestUpdate(), this.addAttachHandles([Ee(() => this.updateHash, () => this._update(), Rt), Ee(() => this.updateSuspended, (i) => {
+      i || this._subscriptionManager.resume();
+    })]), this.layer.type !== "stream" && this.layer.type !== "catalog-footprint" && this.addAttachHandles(this.layer.on("edits", (i) => this._edit(i)));
+  }
+  detach() {
+    g("esri-2d-update-debug") && console.debug("FeatureLayerView2D.detach"), this._fields = null, this.featureContainer.destroy(), this._commandsQueue.clear(), this.container.removeAllChildren(), this._subscriptionManager = Ot(this._subscriptionManager), this._worker.pipeline.onDetach();
+  }
+  moveStart() {
+    this.requestUpdate();
+  }
+  viewChange() {
+    this.requestUpdate();
+  }
+  moveEnd() {
+    this.requestUpdate();
+  }
+  isUpdating() {
+    const i = "renderer" in this.layer && this.layer.renderer != null, e = this._commandsQueue.updateTracking.updating, t = this._updatingRequiredFieldsPromise != null, r = this.featureContainer.updatingHandles.updating, s = i && (e || t) || r || this._pipelineUpdating || this.dataUpdating;
+    if (g("esri-2d-log-updating")) {
+      console.log(`Updating FLV2D (${this.layer.id}): ${s}
+  -> hasRenderer ${i}
+  -> updatingRequiredFields ${t}
+  -> hasPendingCommand ${e}
+  -> dataUpdating ${this.dataUpdating}
+  -> processing ${this._pipelineUpdating}
+  -> updatingContainer ${r}
+`);
+      for (const a of this.featureContainer.subscriptions())
+        console.log(`    -> Tile[${a.id}] Done: ${a.done}`);
+    }
+    return s;
+  }
+  _createClientOptions() {
+    const i = this;
+    return { get container() {
+      return i.featureContainer;
+    }, setUpdating: (e) => {
+      this._set("_pipelineUpdating", e.pipeline), this._set("dataUpdating", e.data);
+    }, emitEvent: (e) => {
+      this.emit(e.name, e.event);
+    }, get eventLog() {
+      return i.eventLog;
+    }, fetch: (e) => Promise.all(e.map((t) => i.view.stage.painter.textureManager.rasterizeItem(t))), fetchDictionary: (e) => Promise.all(e.map((t) => this._fetchDictionaryRequest(t))) };
+  }
+  async _fetchDictionaryRequest(i) {
+    try {
+      if (this.layer.type === "subtype-group")
+        throw new Error("InternalError: SubtypeGroupLayer does not support dictionary renderer");
+      const e = this.layer.renderer;
+      if (!e || e.type !== "dictionary")
+        throw new Error("InternalError: Expected layer to have a DictionaryRenderer");
+      const t = this._lastSchema.processor.mesh.factory.symbology;
+      if (t.type !== "dictionary")
+        throw new Error("InternalError: Expected schema to be of type 'dictionary'");
+      const r = { cimAnalyzer: this.view.stage.cimAnalyzer, cimResourceManager: this.view.stage.painter.textureManager.resourceManager, store: this.featureContainer.instanceStore, scaleExpression: t.scaleExpression };
+      this._fields || (this._fields = this.layer.fields.map((n) => n.toJSON()));
+      const s = t.visualVariableUniforms, a = await e.getSymbolAsync(i.feature, { fields: this._fields });
+      return !a || !a.data ? { type: "dictionary-response", meshes: [] } : { type: "dictionary-response", meshes: await me(a.data, { uniforms: s, path: "renderer", schemaOptions: r }) };
+    } catch {
+      return { type: "dictionary-response", meshes: [] };
+    }
+  }
+  _cleanUpQuery(i) {
+    const e = ye.from(i) || this.createQuery();
+    return e.outSpatialReference || (e.outSpatialReference = this.view.spatialReference), e.toJSON();
+  }
+  _cleanUpAggregateQuery(i) {
+    const e = ye.from(i) || this.createAggregateQuery();
+    e.outSpatialReference || (e.outSpatialReference = this.view.spatialReference);
+    const t = e.objectIds ?? [];
+    for (const r of e.aggregateIds ?? [])
+      t.push(r);
+    return e.objectIds = t, e.aggregateIds = [], e.toJSON();
+  }
+  async _update() {
+    return this._commandsQueue.push({ type: "update" });
+  }
+  async _edit(i) {
+    return this.updateSuspended ? void this._subscriptionManager.suspend() : this._validateEdit(i) ? this._commandsQueue.push({ type: "edit", edits: i }).catch($t) : void 0;
+  }
+  async doRefresh(i) {
+    this.attached && (this.updateSuspended && i || (i ? this.incrementSourceRefreshVersion() : this.incrementDisplayRefreshVersion()));
+  }
+  incrementSourceRefreshVersion() {
+    this._sourceRefreshVersion = (this._sourceRefreshVersion + 1) % Xe + 1;
+  }
+  incrementDisplayRefreshVersion() {
+    this._displayRefreshVersion = (this._displayRefreshVersion + 1) % Xe + 1;
+  }
+  _validateEdit(i) {
+    const e = "globalIdField" in this.layer && this.layer.globalIdField, t = i.deletedFeatures.some((s) => s.objectId === -1 || !s.objectId), r = e && this.availableFields.includes(e);
+    return t && !r ? (q.getLogger(this).error(new C("mapview-apply-edits", `Editing the specified service requires the layer's globalIdField, ${e} to be included the layer's outFields for updates to be reflected on the map`)), null) : i;
+  }
+  async _doUpdate() {
+    var i, e, t, r;
+    "featureReduction" in this.layer && this.layer.featureReduction && this.layer.featureReduction !== this._lastFeatureReduction && (this.layer.featureReduction = (i = this.layer.featureReduction) == null ? void 0 : i.clone(), this._lastFeatureReduction = this.layer.featureReduction);
+    try {
+      if (await this._updateRequiredFields(), this.destroyed || !((e = this.layerAdapter) != null && e.hasRequiredSupport) || !this._subscriptionManager)
+        return;
+      const s = this.featureContainer.instanceStore;
+      this.featureContainer.attributeView.lockTextureUploads(), s.updateStart();
+      const a = this.featureEffect, n = { store: s, cimAnalyzer: this.view.stage.cimAnalyzer, cimResourceManager: this.view.stage.painter.textureManager.resourceManager, scaleExpression: void 0 }, o = await this.layerAdapter.createServiceOptions(this.view), u = this._createViewSchemaConfig(), l = { source: this.layerAdapter.createSourceSchema(o, u, this._sourceRefreshVersion), processor: await this.layerAdapter.createProcessorSchema(n, u, this._displayRefreshVersion) }, c = !!je((t = this._lastSchema) == null ? void 0 : t.source.mutable, l.source.mutable) || !!je((r = this._lastSchema) == null ? void 0 : r.processor, l.processor);
+      if (!c)
+        return this.featureContainer.requestRender(), this.featureContainer.attributeView.unlockTextureUploads(), s.updateEnd(), void (this.featureEffectView.featureEffect = a);
+      this._lastSchema = l, this._fields = null;
+      const d = Math.round(performance.now());
+      g("esri-2d-update-debug") && console.debug(`Id[${this.layer.uid}] Version[${d}] FeatureLayerView2D._doUpdate`, { changes: c });
+      let p = [];
+      Array.isArray(o.source) && (p = o.source), await this._worker.pipeline.updateSchema(l, d, { transferList: p }), s.updateEnd(), this.featureEffectView.featureEffect = a, this.featureEffectView.endTransitions(), this.featureContainer.attributeView.unlockTextureUploads(), this.featureContainer.swapRenderState(), this.featureContainer.requestRender(), g("esri-2d-update-debug") && console.debug(`Version[${d}] FeatureLayerView2D.updateEnd`), this.requestUpdate();
+    } catch (s) {
+      g("esri-2d-update-debug") && console.error("Encountered an error during update", s);
+    }
+  }
+  async _doEdit(i) {
+    try {
+      this.featureContainer.editStart(), await this._worker.pipeline.onEdits(i), this.featureContainer.editEnd();
+    } catch (e) {
+      _e(e);
+    }
+  }
+  get hasFilter() {
+    var e, t;
+    const i = ((t = (e = this.layerAdapter).hasFilters) == null ? void 0 : t.call(e, this.view)) ?? !1;
+    return this.filter != null || this.timeExtent != null || this._visibilityOverrides.size > 0 || i;
+  }
+  _getEffectiveAvailableFields(i) {
+    const e = nr(this._lastAvailableFields, i);
+    return this._lastAvailableFields = e, zt(this.layer.fieldsIndex, e);
+  }
+  _createViewSchemaConfig() {
+    var e, t;
+    const i = [or(this.view, this.layerAdapter, this.timeExtent, this._visibilityOverrides, this.filter), ((t = (e = this.featureEffect) == null ? void 0 : e.filter) == null ? void 0 : t.toJSON()) ?? null];
+    return { availableFields: this._getEffectiveAvailableFields(this.availableFields), filters: i, outSpatialReference: this.view.spatialReference, tileInfoJSON: this.view.featuresTilingScheme.tileInfo.toJSON(), scale: this.view.scale, timeZone: this.view.timeZone };
+  }
+  _addHighlight(i, e) {
+    this._highlightCounter.addReason(i, e), this._updateHighlight().catch((t) => {
+      _e(t) || q.getLogger(this).error(t);
+    });
+  }
+  _removeHighlight(i, e) {
+    this._highlightCounter.deleteReason(i, e), this._updateHighlight().catch((t) => {
+      _e(t) || q.getLogger(this).error(t);
+    });
+  }
+  _setLayersForFeature(i) {
+    i.layer = i.sourceLayer = this.layer, this.layerAdapter.setGraphicOrigin && this.layerAdapter.setGraphicOrigin(i);
+  }
+  _createGraphicHit(i, e) {
+    return this._setLayersForFeature(e), e.geometry != null && (e.geometry.spatialReference = this.view.spatialReference), { type: "graphic", graphic: e, layer: this.layer, mapPoint: i };
+  }
+};
+function or(i, e, t, r, s) {
+  var u;
+  s && (s = s.clone());
+  const a = s != null ? s.timeExtent : null, n = t != null && a != null ? t.intersection(a) : t || a;
+  n && (s ?? (s = new te()), s.timeExtent = n), s = ((u = e.addFilters) == null ? void 0 : u.call(e, s, i)) ?? s;
+  let o = (s == null ? void 0 : s.toJSON()) ?? null;
+  return r.size && (o ?? (o = new te().toJSON()), o.hiddenIds = Array.from(r)), o;
+}
+h([f()], I.prototype, "_worker", void 0), h([f()], I.prototype, "_commandsQueue", void 0), h([f()], I.prototype, "_sourceRefreshVersion", void 0), h([f()], I.prototype, "_displayRefreshVersion", void 0), h([f({ readOnly: !0 })], I.prototype, "_pipelineUpdating", void 0), h([f({ readOnly: !0 })], I.prototype, "hasAllFeatures", null), h([f({ readOnly: !0 })], I.prototype, "hasAllFeaturesInView", null), h([f({ readOnly: !0 })], I.prototype, "hasFullGeometries", null), h([f()], I.prototype, "featureEffectView", void 0), h([f()], I.prototype, "labelingCollisionInfos", null), h([f()], I.prototype, "layerAdapter", null), h([f()], I.prototype, "updateHash", null), h([f()], I.prototype, "updating", void 0), I = h([W(lr)], I);
+const ur = I, Zr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  default: ur
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  Zr as F,
+  ur as X,
+  _ as n
+};