npm - @agrotools1/at-components - Versions diffs - 0.6.15 → 0.6.17 - Mend

@agrotools1/at-components 0.6.15 → 0.6.17

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (818) hide show

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/3d/layers/graphics/Graphics3DCore.js ADDED Viewed

@@ -0,0 +1,1110 @@
+import { _ as d } from "../../../../chunks/tslib.es6.js";
+import "../../../../geometry.js";
+import "../../../../renderers/ClassBreaksRenderer.js";
+import "../../../../renderers/DictionaryRenderer.js";
+import "../../../../renderers/DotDensityRenderer.js";
+import "../../../../renderers/HeatmapRenderer.js";
+import "../../../../renderers/PieChartRenderer.js";
+import "../../../../renderers/Renderer.js";
+import "../../../../renderers/SimpleRenderer.js";
+import L from "../../../../renderers/UniqueValueRenderer.js";
+import "../../../../renderers/support/jsonUtils.js";
+import _ from "../../../../core/Logger.js";
+import "../../../../symbols.js";
+import X from "../../../../core/Accessor.js";
+import { isSome as O } from "../../../../core/arrayUtils.js";
+import "../../../../core/has.js";
+import P from "../../../../core/Error.js";
+import { makeHandle as K } from "../../../../core/handleUtils.js";
+import { someMap as ee, findInMap as ie } from "../../../../core/MapUtils.js";
+import { destroyMaybe as f, removeMaybe as V, disposeMaybe as F } from "../../../../core/maybe.js";
+import { MinPriority as te } from "../../../../core/MemCache.js";
+import T from "../../../../core/PooledArray.js";
+import { throwIfAborted as R, createResolver as re, isAbortError as D } from "../../../../core/promiseUtils.js";
+import { watch as C, when as se, on as ae, syncAndInitial as ne, whenOnce as oe } from "../../../../core/reactiveUtils.js";
+import { schedule as le } from "../../../../core/scheduling.js";
+import { property as c } from "../../../../core/accessorSupport/decorators/property.js";
+import { subclass as he } from "../../../../core/accessorSupport/decorators/subclass.js";
+import { diff as M, isEmpty as de } from "../../../../core/accessorSupport/diffUtils.js";
+import { s as $, g as k, h as pe } from "../../../../chunks/vec32.js";
+import { create as x } from "../../../../core/libs/gl-matrix-2/factories/vec3f64.js";
+import { canProjectWithoutEngine as ce } from "../../../../geometry/projection.js";
+import { projectBuffer as z } from "../../../../geometry/projection/projectBuffer.js";
+import { projectVectorToVector as W } from "../../../../geometry/projection/projectVectorToVector.js";
+import { projectXYZToVector as j } from "../../../../geometry/projection/projectXYZToVector.js";
+import { create as J, center as ye, fromRect as ge, equals as ue } from "../../../../geometry/support/aaBoundingBox.js";
+import { create as me } from "../../../../geometry/support/aaBoundingRect.js";
+import { equals as be } from "../../../../geometry/support/spatialReferenceUtils.js";
+import _e from "../../../../layers/Layer.js";
+import { getObjectId as H, computeAABB as fe, hasGeometry as ve } from "../../../../layers/graphics/dehydratedFeatures.js";
+import { hydrateGraphic as I } from "../../../../layers/graphics/hydratedFeatures.js";
+import { PromiseQueue as B } from "../../../../layers/support/PromiseQueue.js";
+import { isSupportedRenderer3D as Ce, validateTo3D as Se } from "../../../../renderers/support/rendererConversion.js";
+import { loadArcade as we } from "../../../../support/arcadeOnDemand.js";
+import { isBasemapLayer as Ge } from "../../../../support/basemapUtils.js";
+import { getDefaultSymbol3D as Pe } from "../../../../symbols/support/defaults3D.js";
+import { to3D as N } from "../../../../symbols/support/symbolConversion.js";
+import { averageSymbolComplexities as Re, defaultSymbolComplexity as xe } from "./defaultSymbolComplexity.js";
+import { DisplayFeatureLimit as De } from "./DisplayFeatureLimit.js";
+import { ViewElevationProvider as Ie } from "./ElevationQuery.js";
+import { VisibilityGroup as S, VisibilityFlag as w } from "./enums.js";
+import { extractExpressionInfo as q, createContext as Y } from "./featureExpressionInfoUtils.js";
+import { Graphics3DFeatureStore as Ee } from "./Graphics3DFeatureStore.js";
+import { Graphics3DGraphicCreationContext as Ue } from "./Graphics3DGraphicCreationContext.js";
+import { Graphics3DSymbolCreationContext as Ae } from "./Graphics3DSymbolCreationContext.js";
+import { make as Le } from "./Graphics3DSymbolFactory.js";
+import { Graphics3DWebStyleSymbol as Oe } from "./Graphics3DWebStyleSymbol.js";
+import { GraphicsCorePerformanceInfo as Ve } from "./GraphicsCorePerformanceInfo.js";
+import { GraphicStateTracking as Fe } from "./GraphicStateTracking.js";
+import { computeCentroid as Te } from "./graphicUtils.js";
+import { ApplyRendererDiffResult as E } from "./interfaces.js";
+import { LoadStatus as Me } from "./Loadable.js";
+import { SpatialIndex2D as $e } from "./SpatialIndex2D.js";
+import { getSymbolMemorySize as ke } from "./symbolMemory.js";
+import { StageLayerElevationProvider as ze } from "../support/StageLayerElevationProvider.js";
+import { toBoundingRect as We } from "../../support/extentUtils.js";
+import { PropertiesPool as je } from "../../support/PropertiesPool.js";
+import { GridLocalOriginFactory as He } from "../../webgl-engine/lib/GridLocalOriginFactory.js";
+import { UpdatePolicy as b } from "../../webgl-engine/lib/UpdatePolicy.js";
+import { affectsGeometry as Be } from "../../webgl-engine/lib/VertexAttribute.js";
+import { WebGLLayer as Ne } from "../../webgl-engine/lib/WebGLLayer.js";
+import { hasPopupTemplate as qe } from "../../../layers/support/popupUtils.js";
+import { ImmediateTask as Q, noBudget as Ye, TaskPriority as Qe } from "../../../support/Scheduler.js";
+import { Yield as Ze } from "../../../support/Yield.js";
+import Je from "../../../../geometry/Extent.js";
+import Xe from "../../../../geometry/Point.js";
+import Z from "../../../../symbols/LabelSymbol3D.js";
+import Ke from "../../../../symbols/TextSymbol.js";
+import ei from "../../../../symbols/WebStyleSymbol.js";
+var A;
+const U = x(), ii = J();
+let h = A = class extends X {
+  get _viewSpatialReference() {
+    return this.owner.view.spatialReference;
+  }
+  get spatialIndex() {
+    var e;
+    return this._spatialIndex || (this._spatialIndex = new $e({ objectIdField: (e = this.owner.layer) == null ? void 0 : e.objectIdField, spatialReference: this._viewSpatialReference, hasZ: !!this.hasZ, hasM: !!this.hasM }), this._spatialIndex.setup(Array.from(this.graphics3DGraphics.values()))), this._spatialIndex.update(), this._spatialIndex;
+  }
+  get numberOfGraphics() {
+    return this._numberOfGraphics;
+  }
+  get effectiveUpdatePolicy() {
+    return this.currentRenderer != null && this.currentRenderer.type === "dictionary" ? b.ASYNC : this._forcedUpdatePolicy ?? this.preferredUpdatePolicy;
+  }
+  get featureStore() {
+    return this._featureStore;
+  }
+  get initializePromise() {
+    return this._initializePromise;
+  }
+  get scaleVisibility() {
+    return this._scaleVisibility;
+  }
+  get elevationAlignment() {
+    return this._elevationAlignment;
+  }
+  get objectStates() {
+    return this._objectStates;
+  }
+  get filterVisibility() {
+    return this._filterVisibility;
+  }
+  get updating() {
+    var e, i, t;
+    return !!(this.dataUpdating || (e = this._elevationAlignment) != null && e.updating || (i = this._scaleVisibility) != null && i.updating || (t = this._filterVisibility) != null && t.updating || this._rendererChangeAbortController || this._elevationInfoChangeAbortController || this._frameTaskHandle.updating || this.running);
+  }
+  get dataUpdating() {
+    var e;
+    return !!(this._graphicsWaitingForSymbol.size > 0 || this._pendingUpdates.size > 0 || (e = this._spatialIndex) != null && e.updating || this._updatingPendingLoadedGraphicsChange || this._dataUpdateQueue.running || this._loadingSymbols > 0);
+  }
+  get running() {
+    var e;
+    return this._pendingUpdates.size > 0 || !!((e = this._spatialIndex) != null && e.updating) || this._dataUpdateQueue.running || this._updateQueue.running;
+  }
+  get suspendedOrOutsideOfView() {
+    var e;
+    return this.owner.suspended || !!((e = this.owner.suspendInfo) != null && e.outsideOfView);
+  }
+  get updatingRemaining() {
+    var e, i;
+    return this.updating ? this._pendingUpdates.size + 0.1 * (((e = this._spatialIndex) == null ? void 0 : e.updatingRemaining) || 0) + 0.1 * (((i = this._elevationAlignment) == null ? void 0 : i.updatingRemaining) || 0) : 0;
+  }
+  get displayFeatureLimit() {
+    const e = this.owner && this.owner.view && this.owner.view.qualitySettings, i = (e == null ? void 0 : e.graphics3D.minTotalNumberOfFeatures) ?? 0, t = (e == null ? void 0 : e.graphics3D.maxTotalNumberOfFeatures) ?? 0, r = (e == null ? void 0 : e.graphics3D.maxNumberOfDrawCalls) ?? 0, s = (e == null ? void 0 : e.graphics3D.maxTotalNumberOfVertices) ?? 0, a = this.averageSymbolComplexity, n = Math.max(1, (a == null ? void 0 : a.verticesPerFeature) ?? 1), l = a && a.drawCallsPerFeature > 0 && r > 0 ? r / a.drawCallsPerFeature : t, o = Math.ceil(s / n), p = Math.max(i, Math.min(t, o, l)), y = this._get("displayFeatureLimit");
+    return y && y.maximumTotalNumberOfVertices === s && y.averageSymbolComplexity === a && y.maximumNumberOfFeatures === p ? y : new De(s, p, a);
+  }
+  get averageSymbolComplexity() {
+    const e = Re(this._symbolComplexities), i = this._get("averageSymbolComplexity");
+    return e.numComplexities === 0 || i != null && (e.estimated && (i.verticesPerFeature >= e.verticesPerFeature || i.verticesPerCoordinate >= e.verticesPerCoordinate || i.drawCallsPerFeature >= e.drawCallsPerFeature) || i.verticesPerFeature === e.verticesPerFeature && i.verticesPerCoordinate === e.verticesPerCoordinate && i.drawCallsPerFeature === e.drawCallsPerFeature) ? i : e;
+  }
+  get usedMemory() {
+    const e = this.averageSymbolComplexity != null && this.labelsEnabled ? this.averageSymbolComplexity.memory.bytesPerFeatureLabel * this._numberOfGraphics : 0, i = this._getSymbolComplexitiesUsed().reduce((a, n) => a + n.memory.resourceBytes, 0), t = this.owner.view._stage.renderer, r = this.owner.view.basemapTerrain.overlayManager.renderer, s = Array.from(this._symbols.values()).reduce((a, n) => a + ((n == null ? void 0 : n.symbolLayers.reduce((l, o) => l + ((o == null ? void 0 : o.materials.reduce((p, y) => {
+      var g;
+      return y ? p + (((g = t.plugins.getMaterialRenderer(y)) == null ? void 0 : g.usedMemory) ?? 0) + r.getMemoryForMaterial(y) : p;
+    }, 0)) ?? 0), 0)) ?? 0), 0);
+    return this._usedMemory + e + i + s;
+  }
+  get usedMemoryPerGraphic() {
+    if (this._usedMemory && this._numberOfGraphics) {
+      const e = this._numberOfGraphics / (this._numberOfGraphics + Math.max(this._pendingAdds, this._pendingRemoves));
+      return this._usedMemory / this._numberOfGraphics * e;
+    }
+    if (this.averageSymbolComplexity != null) {
+      const e = this.labelsEnabled ? this.averageSymbolComplexity.memory.bytesPerFeatureLabel : 0;
+      return this.averageSymbolComplexity.memory.bytesPerFeature + e;
+    }
+    return 0;
+  }
+  get unprocessedMemoryEstimate() {
+    return (this._pendingAdds - this._pendingRemoves) * this.usedMemoryPerGraphic;
+  }
+  get _symbolComplexities() {
+    return this.currentRenderer ? this._getSymbolComplexitiesUsedOrRenderer(this.currentRenderer) : this._getSymbolComplexitiesUsed();
+  }
+  get visible() {
+    return this._visible;
+  }
+  _getConvertedSymbol(e) {
+    var s;
+    if (e.type === "web-style")
+      return e.clone();
+    const i = this._symbolConversionCache.get(e.id);
+    if (i != null)
+      return i;
+    const t = N(e, { geometryType: ((s = this.layer) == null ? void 0 : s.geometryType) ?? void 0, retainId: !0, hasLabelingContext: this._hasLabelingContext(e) }), r = t.symbol || null;
+    return r == null && t.error && _.getLogger(this).error(t.error.message), this._symbolConversionCache.set(e.id, r), r;
+  }
+  _getSymbolComplexitiesUsedOrRenderer(e) {
+    if (e == null)
+      return [];
+    const i = e.getSymbols(), t = "backgroundFillSymbol" in e ? e.backgroundFillSymbol : null;
+    if (!t && !(i != null && i.length))
+      return [];
+    const r = [], s = this._getSymbolComplexityUsedOrRenderer(t);
+    s != null && r.push(s);
+    for (const a of i) {
+      const n = this._getSymbolComplexityUsedOrRenderer(a);
+      n != null && r.push(n);
+    }
+    return r;
+  }
+  _getSymbolComplexityUsedOrRenderer(e) {
+    if (e == null)
+      return null;
+    const i = this._symbols.get(e.id);
+    if (i != null)
+      return i.complexity;
+    const t = this._getConvertedSymbol(e);
+    return t != null ? xe(t) : null;
+  }
+  _getSymbolComplexitiesUsed() {
+    const e = [];
+    return this._symbols.forEach((i) => {
+      i != null && e.push(i.complexity);
+    }), e;
+  }
+  get _objectIdField() {
+    return this.layer.objectIdField;
+  }
+  constructor(e) {
+    super(e), this._propertiesPool = new je({ computedExtent: Je }, this), this.computedExtent = null, this.currentRenderer = null, this.rendererHasGeometryOperations = !1, this._graphicStateTracking = null, this.graphics3DGraphics = /* @__PURE__ */ new Map(), this.stageLayer = null, this.stage = null, this._graphicsDrapedUids = /* @__PURE__ */ new Set(), this._graphicsBySymbol = /* @__PURE__ */ new Map(), this._symbolConversionCache = /* @__PURE__ */ new Map(), this._symbols = /* @__PURE__ */ new Map(), this._graphicsWithoutSymbol = /* @__PURE__ */ new Map(), this._graphicsWaitingForSymbol = /* @__PURE__ */ new Map(), this._graphicsUpdateId = 0, this._frameTaskHandle = Q, this._dataUpdateQueue = new B(), this._updateQueue = new B(), this._suspendSymbolCleanup = !1, this._arcadeOnDemand = null, this._rendererChangeAbortController = null, this._elevationInfoChangeAbortController = null, this._initializeAbortController = null, this._scaleVisibility = null, this._filterVisibility = null, this._spatialIndex = null, this.extentPadding = 0, this._updatingPendingLoadedGraphicsChange = null, this._featureStore = null, this._deconflictor = null, this._labeler = null, this._objectStates = null, this._viewElevationProvider = null, this._stageLayerElevationProvider = null, this._sharedSymbolResourcesOwnerHandle = null, this._whenGraphics3DGraphicRequests = {}, this._pendingUpdates = /* @__PURE__ */ new Map(), this._numberOfGraphics = 0, this._numberOfGraphicsProvidingElevation = 0, this._pendingAdds = 0, this._pendingRemoves = 0, this._applyPendingRemovesFirst = !1, this._loadingSymbols = 0, this._pendingUpdatesPool = new T({ allocator: (i) => i || new ti(), deallocator: (i) => (i.clear(), i) }), this._symbolWarningLogged = !1, this._geometryWarningLogged = !1, this._objectIdInvisibleSet = /* @__PURE__ */ new Set(), this._whenSymbolRemoved = new T(), this.preferredUpdatePolicy = b.SYNC, this._forcedUpdatePolicy = null, this.elevationFeatureExpressionEnabled = !0, this.owner = null, this.layer = null, this.graphicSymbolSupported = !0, this.getRenderingInfoWithoutRenderer = !1, this.setUidToIdOnAdd = !0, this.hasZ = null, this.hasM = null, this._usedMemory = 0, this._visible = !1, this._startCreateGraphics = !1, this._unusedSymbolsCache = e.owner.view.resourceController.memoryController.newCache("graphics-3d-unused-symbols", (i) => i.destroy()), this.symbolCreationContext = new Ae(e.owner.view.resourceController.scheduler, (i, t) => this._updateQueue.push(i, t));
+  }
+  initialize() {
+    var t;
+    this._featureStore = new Ee({ objectIdField: (t = this.owner.layer) == null ? void 0 : t.objectIdField, hasZ: !!this.hasZ, hasM: !!this.hasM, viewSpatialReference: this._viewSpatialReference, featureSpatialReference: this.owner.featureSpatialReference, getSpatialIndex: () => this.spatialIndex, forEach: (r) => this.graphics3DGraphics.forEach(r) });
+    const e = (r, s, a) => this.spatialIndex.queryGraphicUIDsInExtent(r, s, a), { componentFactories: i } = this;
+    if (i.elevationAlignment != null) {
+      const r = i.elevationAlignment(this, e);
+      this._elevationAlignment = r;
+    }
+    if (i.scaleVisibility != null) {
+      const r = i.scaleVisibility(this, e);
+      this._scaleVisibility = r;
+    }
+    if (i.filterVisibility != null) {
+      const r = i.filterVisibility({ featureStore: this._featureStore, getFeatureCount: () => this.graphics3DGraphics.size, updateFeatureVisibilities: (s) => this.modifyGraphics3DGraphicVisibilities((a) => a.setVisibilityFlag(S.GRAPHIC, w.FILTER, s(H(a.graphic, this._objectIdField)))), setAllFeaturesVisibility: (s) => this.modifyGraphics3DGraphicVisibilities((a) => a.setVisibilityFlag(S.GRAPHIC, w.FILTER, s)), clearFeaturesVisibility: () => this.modifyGraphics3DGraphicVisibilities((s) => s.setVisibilityFlag(S.GRAPHIC, w.FILTER, !0)) });
+      this._filterVisibility = r;
+    }
+    if (i.deconflictor != null) {
+      const r = i.deconflictor(this);
+      this._deconflictor = r;
+    }
+    if (i.labeler != null && this._scaleVisibility != null) {
+      const r = i.labeler(this, this._scaleVisibility);
+      this._labeler = r;
+    }
+    if (i.objectStates != null) {
+      const r = i.objectStates(this);
+      this._objectStates = r;
+    }
+    this._initializeAbortController = new AbortController(), this._initializePromise = this._initializeAsync();
+  }
+  async _initializeAsync() {
+    var s, a, n, l;
+    const e = (s = this._initializeAbortController) == null ? void 0 : s.signal, i = this.owner.view;
+    this._viewElevationProvider = new Ie(this._viewSpatialReference, i), this._initializeStage(i, this.layer.uid);
+    const t = i.sharedSymbolResources;
+    this.symbolCreationContext.sharedResources = t, this._sharedSymbolResourcesOwnerHandle = t.addGraphicsOwner(this.owner), this.currentRenderer != null && (this.symbolCreationContext.renderer = this.currentRenderer), this.symbolCreationContext.stage = this.stage, this.symbolCreationContext.streamDataRequester = t.streamDataRequester, this.symbolCreationContext.renderCoordsHelper = i.renderCoordsHelper, this.symbolCreationContext.layer = this.layer, this.symbolCreationContext.graphicsCoreOwner = this.owner, this.symbolCreationContext.localOriginFactory = new He(i.renderSpatialReference), this.symbolCreationContext.elevationProvider = i.elevationProvider, this.symbolCreationContext.notifyGraphicGeometryChanged = (o) => this.notifyGraphicGeometryChanged(o), this.symbolCreationContext.notifyGraphicVisibilityChanged = (o) => this.notifyGraphicVisibilityChanged(o);
+    const r = q(this.layer.elevationInfo, this.elevationFeatureExpressionEnabled);
+    if (this.symbolCreationContext.featureExpressionInfoContext = await Y(r, this._viewSpatialReference, e, _.getLogger(this)), R(e), this.symbolCreationContext.screenSizePerspectiveEnabled = i.screenSizePerspectiveEnabled && !!this.layer.screenSizePerspectiveEnabled, this.symbolCreationContext.slicePlaneEnabled = !!this.owner.slicePlaneEnabled, this.symbolCreationContext.physicalBasedRenderingEnabled = !!((a = this.owner.view.qualitySettings) != null && a.physicallyBasedRenderingEnabled), this.symbolCreationContext.skipHighSymbolLods = !!((l = (n = this.owner.view.qualitySettings) == null ? void 0 : n.graphics3D) != null && l.skipHighSymbolLods), "drapeSourceType" in this.owner) {
+      const { owner: o } = this;
+      this.symbolCreationContext.drapeSourceRenderer = i.basemapTerrain.overlayManager.registerGeometryDrapeSource(o), this.addHandles(K(() => i.basemapTerrain.overlayManager.unregisterDrapeSource(o)));
+    }
+    this.addHandles([C(() => this.suspendedOrOutsideOfView, () => this._updateQueue.unshift(() => this._updateLayerVisibility(), null)), C(() => {
+      var o, p;
+      return [(o = this.layer) == null ? void 0 : o.screenSizePerspectiveEnabled, (p = this.owner.view) == null ? void 0 : p.screenSizePerspectiveEnabled];
+    }, () => {
+      var p;
+      const o = i.screenSizePerspectiveEnabled && !!this.layer.screenSizePerspectiveEnabled;
+      o !== this.symbolCreationContext.screenSizePerspectiveEnabled && (this.symbolCreationContext.screenSizePerspectiveEnabled = o, (p = this._labeler) == null || p.reset(), this.recreateAllGraphicsAndSymbols());
+    }), C(() => this.owner.slicePlaneEnabled, (o) => this._slicePlaneEnabledChange(!!o)), C(() => {
+      var o;
+      return (o = this.owner.view.state) == null ? void 0 : o.rasterPixelRatio;
+    }, () => this._pixelRatioChange()), C(() => {
+      var o;
+      return !!((o = this.owner.view.qualitySettings) != null && o.physicallyBasedRenderingEnabled);
+    }, (o) => this._physicalBasedRenderingChange(o)), C(() => {
+      var o, p;
+      return !!((p = (o = this.owner.view.qualitySettings) == null ? void 0 : o.graphics3D) != null && p.skipHighSymbolLods);
+    }, (o) => this._skipHighSymbolLoDsChange(o)), se(() => {
+      var o;
+      return (o = i.basemapTerrain) == null ? void 0 : o.tilingScheme;
+    }, (o) => {
+      if (o.spatialReference.equals(this.symbolCreationContext.overlaySR) || i.basemapTerrain.spatialReference == null || (this.symbolCreationContext.overlaySR = i.basemapTerrain.spatialReference), this.hasHandles("loaded-graphics"))
+        this.recreateAllGraphics();
+      else {
+        const p = () => {
+          var y;
+          return (y = this.owner) == null ? void 0 : y.loadedGraphics;
+        };
+        this.addHandles([ae(p, "change", (y) => {
+          this._graphicsCollectionChanged(y), this._signalUpdatingDuringAsyncLoadedGraphicsChange();
+        }, { onListenerAdd: () => {
+          this.recreateAllGraphics(), this._signalUpdatingDuringAsyncLoadedGraphicsChange();
+        } })], "loaded-graphics");
+      }
+    }, { initial: !0 }), C(() => this.effectiveUpdatePolicy, (o) => {
+      this.stageLayer != null && (this.stageLayer.updatePolicy = o), this.symbolCreationContext.isAsync = this.effectiveUpdatePolicy === b.ASYNC, o === b.SYNC && this.runTask(Ye);
+    }, ne)]), this._frameTaskHandle = i.resourceController.scheduler.registerTask(Qe.GRAPHICS_CORE, this), this.layer && "featureReduction" in this.layer && this.addHandles(C(() => this.layer.featureReduction, () => this._deconflictor.featureReductionChange())), this.notifyChange("averageSymbolComplexity"), this.rendererChange(this.owner.renderer).catch(() => {
+    }), this._initializeAbortController = null;
+  }
+  _abortInitialize() {
+    this._initializeAbortController && (this._initializeAbortController.abort(), this._initializeAbortController = null);
+  }
+  destroy() {
+    var e, i, t, r;
+    this._unusedSymbolsCache.destroy(), this._abortInitialize(), this._abortRendererChange(), this._abortElevationInfoChange(), this._frameTaskHandle.remove(), this._frameTaskHandle = Q, this._dataUpdateQueue.cancelAll(), this._updateQueue.cancelAll(), (i = (e = this.owner.view) == null ? void 0 : e.deconflictor) == null || i.removeGraphicsOwner(this), (r = (t = this.owner.view) == null ? void 0 : t.labeler) == null || r.removeGraphicsOwner(this), this._elevationAlignment = f(this._elevationAlignment), this._scaleVisibility = f(this._scaleVisibility), this._filterVisibility = f(this._filterVisibility), this._deconflictor = null, this._labeler = null, this._objectStates = f(this._objectStates), this.clear(), this._featureStore = f(this._featureStore), this._updatingPendingLoadedGraphicsChange = V(this._updatingPendingLoadedGraphicsChange), this._graphicStateTracking = f(this._graphicStateTracking), this.stage && (this.stageLayer = f(this.stageLayer), this.stage = null), this._set("owner", null);
+    for (const s in this._whenGraphics3DGraphicRequests)
+      this._whenGraphics3DGraphicRequests[s].reject(new P("graphic:layer-destroyed", "Layer has been destroyed"));
+    this._whenGraphics3DGraphicRequests = null, this._sharedSymbolResourcesOwnerHandle = V(this._sharedSymbolResourcesOwnerHandle), this._propertiesPool = f(this._propertiesPool), this._pendingUpdatesPool = null, this._symbolConversionCache.clear(), this._objectIdInvisibleSet.clear(), this._spatialIndex = f(this._spatialIndex);
+  }
+  clear() {
+    var e, i;
+    (e = this._objectStates) == null || e.allGraphicsDeleted(), this._graphicStateTracking != null && this._graphicStateTracking.allGraphicsDeleted(), this.graphics3DGraphics.forEach((t) => t.destroy()), (i = this._spatialIndex) == null || i.clear(), this.graphics3DGraphics.clear(), this._numberOfGraphics = 0, this._usedMemory = 0, this._updateLayerVisibility(), this._symbols.forEach(f), this._symbols.clear(), this._graphicsBySymbol.clear(), this._graphicsWithoutSymbol.clear(), this._graphicsWaitingForSymbol.clear(), this._pendingUpdates.clear(), this._pendingUpdatesPool.clear(), this._pendingAdds = 0, this._pendingRemoves = 0, this._applyPendingRemovesFirst = !1, this.notifyChange("dataUpdating"), this.notifyChange("running"), this.notifyChange("updatingRemaining"), this._featureStore.events.emit("changed");
+  }
+  _initializeStage(e, i) {
+    this.stage = e._stage, this.stageLayer = new Ne(this.stage, { pickable: !this.suspendedOrOutsideOfView, updatePolicy: this.effectiveUpdatePolicy }, i);
+    const t = this.stageLayer.events;
+    t.on("transformationChanged", (r) => this.notifyGraphicGeometryChanged(r.graphicUid)), t.on("shaderTransformationChanged", (r) => this.notifyGraphicGeometryChanged(r.graphicUid)), t.on("visibilityChanged", (r) => this.notifyGraphicVisibilityChanged(r.graphicUid)), t.on("geometryAdded", (r) => this.notifyGraphicGeometryChanged(r.object.graphicUid)), t.on("geometryRemoved", (r) => this.notifyGraphicGeometryChanged(r.object.graphicUid)), t.on("attributesChanged", (r) => Be(r.attribute) && this.notifyGraphicGeometryChanged(r.object.graphicUid));
+  }
+  notifyGraphicGeometryChanged(e) {
+    if (this._graphicStateTracking == null || e == null)
+      return;
+    const i = this.graphics3DGraphics.get(e);
+    i && this._graphicStateTracking.updateGraphicGeometry(i);
+  }
+  notifyGraphicVisibilityChanged(e) {
+    if (this._graphicStateTracking == null || e == null)
+      return;
+    const i = this.graphics3DGraphics.get(e);
+    i && this._graphicStateTracking.updateGraphicVisibility(i);
+  }
+  _updateLayerVisibility() {
+    const e = this.displayFeatureLimit.maximumNumberOfFeatures, i = this._numberOfGraphics > e * ri, t = !this.suspendedOrOutsideOfView && !i;
+    t !== this._visible && (this._visible = t, t ? (this.stageLayer.pickable = !0, this.updateAllGraphicsVisibility()) : (this.stageLayer.pickable = !1, this._hideAllGraphics()), this._updateStageLayerVisibility());
+  }
+  _updateStageLayerVisibility() {
+    this.stageLayer.visible = this._visible && (this.layer.opacity == null || this.layer.opacity > 0);
+  }
+  getGraphics3DGraphicById(e) {
+    return e != null ? this.graphics3DGraphics.get(e) : void 0;
+  }
+  getGraphics3DGraphicByObjectId(e) {
+    var i;
+    return (i = this.owner.layer) != null && i.objectIdField ? this._findGraphics3DGraphicByObjectId(e) : null;
+  }
+  _getGraphicObjectID(e, i = ((t) => (t = this.owner.layer) == null ? void 0 : t.objectIdField)()) {
+    return H(e, i);
+  }
+  get graphics3DGraphicsByObjectID() {
+    var t;
+    const e = (t = this.owner.layer) == null ? void 0 : t.objectIdField;
+    if (!e)
+      return;
+    const i = /* @__PURE__ */ new Map();
+    return this.graphics3DGraphics.forEach((r) => {
+      if (!r)
+        return;
+      const s = r.graphic, a = this._getGraphicObjectID(s, e);
+      a != null && i.set(a, r);
+    }), i;
+  }
+  get labelsEnabled() {
+    return !(!this._labeler || !this._labeler.layerLabelsEnabled());
+  }
+  async updateLabelingInfo(e) {
+    const i = this._deconflictor && this._deconflictor.labelingInfoChange(e), t = this._labeler && this._labeler.labelingInfoChange(e);
+    await Promise.allSettled([i, t]);
+  }
+  updateVisibilityInfo() {
+    this._deconflictor && this._deconflictor.labelingInfoChange(), this._labeler && this._labeler.visibilityInfoChange();
+  }
+  get symbolUpdateType() {
+    if (this._pendingUpdates.size > 0)
+      return "unknown";
+    let e = 0, i = 0;
+    return ee(this._symbols, (t, r) => {
+      if (t != null) {
+        const s = t.getFastUpdateStatus();
+        if (s.loading > 0)
+          return !0;
+        this._graphicsBySymbol.has(r) && (i += s.fast, e += s.slow);
+      }
+      return !1;
+    }) ? "unknown" : i >= 0 && e === 0 ? "fast" : e >= 0 && i === 0 ? "slow" : "mixed";
+  }
+  runTask(e) {
+    if (this._dataUpdateQueue.runTask(e), this._updateQueue.runTask(e), this._applyPendingUpdates(e), this.notifyChange("running"), this.running || this.notifyChange("dataUpdating"), this.notifyChange("updatingRemaining"), !e.hasProgressed)
+      return Ze;
+  }
+  setObjectIdVisibility(e, i) {
+    i ? this._objectIdInvisibleSet.delete(e) : this._objectIdInvisibleSet.add(e);
+    const t = this._findGraphics3DGraphicByObjectId(e);
+    t != null && this._updateUserVisibility(t);
+  }
+  _findGraphics3DGraphicByObjectId(e) {
+    return ie(this.graphics3DGraphics, (i) => this._getGraphicObjectID(i.graphic) === e);
+  }
+  _updateUserVisibility(e) {
+    if (e == null)
+      return !1;
+    const i = e.graphic, t = this._getGraphicObjectID(i), r = i.visible && !this.owner.suspended && (t == null || !this._objectIdInvisibleSet.has(t));
+    return e.setVisibilityFlag(S.GRAPHIC, w.USER, r);
+  }
+  _whenGraphics3DGraphic(e) {
+    const i = this.graphics3DGraphics.get(e.uid);
+    if (i)
+      return Promise.resolve(i);
+    const t = this._whenGraphics3DGraphicRequests[e.uid];
+    if (t)
+      return t.promise;
+    const r = re();
+    return this._whenGraphics3DGraphicRequests[e.uid] = r, r.promise;
+  }
+  async _boundsForGraphics3DGraphic(e, i) {
+    const t = this._viewSpatialReference, r = this.owner.view.renderSpatialReference, s = this.owner.view.basemapTerrain.spatialReference, a = (y, g, m) => z(y, r, g, y, t, g, m), n = (y, g, m) => z(y, s, g, y, t, g, m), l = this._viewElevationProvider ? { service: this._viewElevationProvider, useViewElevation: i != null && !!i.useViewElevation, minDemResolution: i != null ? i.minDemResolution : null, minDemResolutionForPoints: this.owner.view.resolution } : null, o = await e.getProjectedBoundingBox(a, n, l, i == null ? void 0 : i.signal);
+    if (!o)
+      return null;
+    const p = o.boundingBox;
+    if (o.requiresDrapedElevation) {
+      const y = this.symbolCreationContext.elevationProvider;
+      if (y) {
+        ye(p, U);
+        const g = y.getElevation(U[0], U[1], 0, t, "ground") ?? 0;
+        p[2] = Math.min(p[2], g), p[5] = Math.max(p[5], g);
+      }
+    }
+    return { boundingBox: p, screenSpaceObjects: o.screenSpaceObjects };
+  }
+  async whenGraphicBounds(e, i) {
+    var a;
+    await oe(() => {
+      var n;
+      return (n = this.owner) == null ? void 0 : n.loadedGraphics;
+    });
+    const t = (a = this.owner.layer) == null ? void 0 : a.objectIdField, r = this.owner.loadedGraphics.find((n) => n === e || t != null && n.attributes != null && e.attributes && n.attributes[t] === e.attributes[t]);
+    if (!r)
+      throw new P("internal:graphic-not-part-of-view", "Graphic is not part of this view");
+    const s = await this._whenGraphics3DGraphic(r);
+    return this._boundsForGraphics3DGraphic(s, i);
+  }
+  computeAttachmentOrigin(e, i) {
+    const t = this.graphics3DGraphics.get(e.uid);
+    if (!t)
+      return null;
+    const r = t.computeAttachmentOrigin();
+    if (r.render.num === 0 && r.draped.num === 0)
+      return null;
+    $(v, 0, 0, 0);
+    let s = 0;
+    if (r.render.num > 0) {
+      if (!W(r.render.origin, this.symbolCreationContext.renderCoordsHelper.spatialReference, G, i))
+        return null;
+      k(v, v, G), s++;
+    }
+    if (r.draped.num > 0) {
+      const [a, n] = r.draped.origin, l = this._viewElevationProvider.getElevation(a, n, "ground") ?? 0;
+      if ($(G, a, n, l), !W(G, this._viewElevationProvider.spatialReference, G, i))
+        return null;
+      k(v, v, G), s++;
+    }
+    return s > 1 && pe(v, v, 1 / s), new Xe({ x: v[0], y: v[1], z: v[2], spatialReference: i });
+  }
+  getSymbolLayerSize(e, i) {
+    const t = this._symbols.get(e.id);
+    if (t == null)
+      throw new P("internal:symbol-not-part-of-view", "Symbol is not part of this view");
+    const r = e.symbolLayers.indexOf(i);
+    if (r === -1)
+      throw new P("internal:missing-symbol-layer", "Symbol layer is not in symbol");
+    const s = t.getSymbolLayerSize(r);
+    if (s == null)
+      throw new P("internal:missing-size", "Symbol layer has no valid size");
+    return s;
+  }
+  _graphicsCollectionChanged(e) {
+    this._startCreateGraphics && (this.add(e.added), this.remove(e.removed));
+  }
+  graphicUpdateHandler(e) {
+    const i = e.graphic.uid, t = this.graphics3DGraphics.get(i);
+    if (t != null || this._graphicsWithoutSymbol.get(i) != null)
+      switch (e.property) {
+        case "visible":
+          this._graphicUpdateVisibleHandler(t);
+          break;
+        case "geometry":
+          this._graphicUpdateGeometryHandler(t, e);
+          break;
+        case "symbol":
+          this._graphicUpdateSymbolHandler(t, e);
+          break;
+        case "attributes":
+          break;
+        case "origin-transform":
+          this._graphicUpdateTransformHandler(t, e);
+      }
+  }
+  _graphicUpdateGeometryHandler(e, i) {
+    this._graphicUpdateGeometryOrTransformHandler(e, i, () => i.newValue != null && e != null && e.graphics3DSymbol.updateGeometry(e, i.newValue));
+    const t = i.graphic.geometry;
+    t != null && this._expandComputedExtent(t);
+  }
+  _graphicUpdateTransformHandler(e, i) {
+    const t = i.graphic.geometry;
+    this._graphicUpdateGeometryOrTransformHandler(e, i, () => i.newValue != null && e != null && t != null && e.graphics3DSymbol.updateTransform(e, t.spatialReference, i.newValue, i.action));
+  }
+  _graphicUpdateGeometryOrTransformHandler(e, i, t) {
+    var r;
+    if (i.graphic.geometry != null)
+      if (e != null)
+        t() || this._recreateGraphic(e.graphic);
+      else {
+        const s = (r = i.graphic.symbol) == null ? void 0 : r.id;
+        if (s) {
+          const a = this._symbols.get(s);
+          if (a != null && a.loadStatus === Me.LOADING)
+            return;
+        }
+        this._recreateGraphic(i.graphic);
+      }
+    else
+      this._recreateGraphic(i.graphic);
+  }
+  _graphicUpdateSymbolHandler(e, i) {
+    const t = i.graphic, r = e != null ? e.graphics3DSymbol : i.oldValue != null ? this._symbols.get(i.oldValue.id) : null;
+    if (r == null || i.newValue == null)
+      return void this._recreateGraphic(t);
+    const s = r.symbol, a = this._getConvertedSymbol(i.newValue);
+    if (a != null && (a.type !== s.type || a.type === "web-style") || s.type === "web-style")
+      return void this._recreateGraphic(t);
+    const n = this._graphicsBySymbol.get(s.id);
+    if (n && n.size !== 1)
+      return void this._recreateGraphic(t);
+    const l = M(s, a);
+    if (l == null)
+      return void this._updateSymbolMapping(s.id, a);
+    const o = { diff: l, graphics3DGraphicPatches: [], symbolStatePatches: [] };
+    if (r.prepareSymbolPatch(o), !de(o.diff))
+      return void this._recreateGraphic(t);
+    const p = this._getRenderingInfo(t);
+    if (p == null)
+      return void this._recreateGraphic(t);
+    const y = r.extentPadding;
+    for (const g of o.symbolStatePatches)
+      g();
+    if (y !== r.extentPadding && this._recomputeExtentPadding(), e != null)
+      for (const g of o.graphics3DGraphicPatches)
+        g(e, p);
+    this._updateSymbolMapping(s.id, a);
+  }
+  _graphicUpdateVisibleHandler(e) {
+    this._updateUserVisibility(e) && (this._labeler && this.owner.view.labeler.setDirty(), this.owner.view.deconflictor.setDirty());
+  }
+  recreateGraphics(e) {
+    this._suspendSymbolCleanup = !0, this.remove(e), this.add(e), this._suspendSymbolCleanup = !1, this.effectiveUpdatePolicy === b.SYNC && this._cleanupSymbols();
+  }
+  _recreateGraphic(e) {
+    this.recreateGraphics([e]);
+  }
+  _beginGraphicUpdate(e) {
+    const i = this._graphicsUpdateId;
+    return this._graphicsUpdateId++, this._graphicsWaitingForSymbol.set(e.uid, i), this._graphicsWaitingForSymbol.size === 1 && this.notifyChange("dataUpdating"), i;
+  }
+  _endGraphicUpdate(e) {
+    e && (this._graphicsWaitingForSymbol.delete(e.uid), this._graphicsWaitingForSymbol.size === 0 && (this._cleanupSymbols(), this.notifyChange("dataUpdating")));
+  }
+  _recomputeExtentPadding() {
+    let e = 0;
+    this._symbols.forEach((i) => {
+      i != null && (e = Math.max(e, i.extentPadding));
+    }), this._set("extentPadding", e);
+  }
+  _expandComputedExtent(e) {
+    const i = ii, t = e.spatialReference;
+    fe(e, i);
+    const r = this._viewSpatialReference, s = A.tmpVec;
+    if (be(t, r) || j(i[0], i[1], 0, t, s, r) && (i[0] = s[0], i[1] = s[1], j(i[3], i[4], 0, t, s, r), i[3] = s[0], i[4] = s[1]), !(isFinite(i[0]) && isFinite(i[3]) && isFinite(i[1]) && isFinite(i[4])))
+      return;
+    const a = this.computedExtent;
+    let n = null;
+    const l = isFinite(i[2]) && isFinite(i[5]), o = l && ((a == null ? void 0 : a.zmin) == null || i[2] < a.zmin), p = l && ((a == null ? void 0 : a.zmax) == null || i[5] > a.zmax);
+    a ? (i[0] < a.xmin || i[1] < a.ymin || i[3] > a.xmax || i[4] > a.ymax || o || p) && (n = this._propertiesPool.get("computedExtent"), n.xmin = Math.min(i[0], a.xmin), n.ymin = Math.min(i[1], a.ymin), n.xmax = Math.max(i[3], a.xmax), n.ymax = Math.max(i[4], a.ymax), n.spatialReference = r) : (n = this._propertiesPool.get("computedExtent"), n.xmin = i[0], n.ymin = i[1], n.xmax = i[3], n.ymax = i[4], n.spatialReference = r), n && (o && (n.zmin = i[2]), p && (n.zmax = i[5]), this._set("computedExtent", n));
+  }
+  _abortElevationInfoChange() {
+    this._elevationInfoChangeAbortController && (this._elevationInfoChangeAbortController.abort(), this._elevationInfoChangeAbortController = null);
+  }
+  async elevationInfoChange() {
+    var t, r;
+    this._abortElevationInfoChange();
+    const e = new AbortController();
+    this._elevationInfoChangeAbortController = e;
+    const i = q(this.layer.elevationInfo, this.elevationFeatureExpressionEnabled);
+    this.symbolCreationContext.featureExpressionInfoContext = await Y(i, this._viewSpatialReference, e.signal, _.getLogger(this)), R(e.signal), this._elevationInfoChangeAbortController = null, (t = this._labeler) == null || t.elevationInfoChange(), this.forEachGraphics3DSymbol((s, a, n) => {
+      s.globalPropertyChanged("elevationInfo", a) ? a.forEach((l) => {
+        const o = l.graphic, p = l.labelLayers;
+        for (const y of p)
+          y.graphics3DSymbolLayer.updateGraphicElevationContext(o, y);
+      }) : this._recreateSymbol(n);
+    }), this.updateStageLayerElevationProvider(), (r = this._elevationAlignment) == null || r.elevationInfoChange();
+  }
+  updateStageLayerElevationProvider() {
+    this._stageLayerElevationProvider ? (this.layer.elevationInfo && this.layer.elevationInfo.mode === "relative-to-scene" || this._numberOfGraphicsProvidingElevation === 0) && (this.owner.view.elevationProvider.unregister(this._stageLayerElevationProvider), this._stageLayerElevationProvider = F(this._stageLayerElevationProvider)) : (!this.layer.elevationInfo || this.layer.elevationInfo && this.layer.elevationInfo.mode !== "relative-to-scene") && this._numberOfGraphicsProvidingElevation > 0 && (this._stageLayerElevationProvider = new ze({ layer: this.layer, stageLayer: this.stageLayer, view: this.owner.view }), this.owner.view.elevationProvider.register("scene", this._stageLayerElevationProvider));
+  }
+  _clearSymbolsAndGraphics() {
+    var e, i, t, r;
+    this.clear(), this._filterVisibility != null && this._filterVisibility.clear(), (e = this._labeler) == null || e.reset(), (i = this._deconflictor) == null || i.clear(), (t = this._elevationAlignment) == null || t.clear(), (r = this.stageLayer) == null || r.invalidateSpatialQueryAccelerator(), this._stageLayerElevationProvider && (this.owner.view.elevationProvider.unregister(this._stageLayerElevationProvider), this._stageLayerElevationProvider = F(this._stageLayerElevationProvider));
+  }
+  startCreateGraphics() {
+    this._startCreateGraphics = !0, this.recreateAllGraphics();
+  }
+  recreateAllGraphics() {
+    this._recreateAllGraphics(!1);
+  }
+  recreateAllGraphicsAndSymbols() {
+    this._recreateAllGraphics(!0);
+  }
+  _recreateAllGraphics(e = !1) {
+    if (!this._startCreateGraphics)
+      return;
+    const { loadedGraphics: i, view: t } = this.owner, r = t.basemapTerrain.tilingScheme && (i != null && i.length) ? i.toArray() : null;
+    !e && r || this._clearSymbolsAndGraphics(), this.symbolCreationContext.screenSizePerspectiveEnabled = this.owner.view.screenSizePerspectiveEnabled && !!this.layer.screenSizePerspectiveEnabled, this.symbolCreationContext.slicePlaneEnabled = !!this.owner.slicePlaneEnabled, this._set("computedExtent", null), r && (e ? this.add(r) : this.recreateGraphics(r));
+  }
+  _recreateSymbol(e) {
+    const i = this._graphicsBySymbol.get(e), t = [];
+    i && (i.forEach((s, a) => {
+      var l;
+      const n = s.usedMemory;
+      this._conditionalRemove(s, a), (l = this._spatialIndex) == null || l.remove(s), t.push(s.graphic), s.destroy(), this._removeGraphics3DGraphic(a, n), this._updateLayerVisibility(), this._featureStore.events.emit("changed");
+    }), this._graphicsBySymbol.set(e, /* @__PURE__ */ new Map()));
+    const r = this._symbols.get(e);
+    f(r), this._symbols.delete(e), this.add(t);
+  }
+  _recreateGraphicsForSymbol(e) {
+    const i = this._graphicsBySymbol.get(e);
+    if (i) {
+      const t = [];
+      i.forEach((r) => t.push(r.graphic)), this.recreateGraphics(t);
+    }
+  }
+  _conditionalRemove(e, i) {
+    var t, r, s;
+    this._graphicsDrapedUids.delete(i), (t = this._objectStates) == null || t.removeGraphic(e), (r = this._labeler) == null || r.removeGraphic(e), (s = this._deconflictor) == null || s.removeGraphic(e), this._graphicStateTracking != null && this._graphicStateTracking.removeGraphic(e);
+  }
+  add(e) {
+    var i;
+    e && e.length !== 0 && ((i = this.owner.view.basemapTerrain) != null && i.tilingScheme ? (this._updatePolicyForGraphics(e) === b.ASYNC ? this._addDelayed(e) : this._addImmediate(e), this.notifyChange("dataUpdating")) : _.getLogger(this).error("#add()", "Cannot add graphics before terrain surface has been initialized"));
+  }
+  _updatePolicyForGraphics(e) {
+    if (this.effectiveUpdatePolicy === b.SYNC && (this.layer.geometryType === "mesh" || this.layer.geometryType == null)) {
+      for (const i of e)
+        if (i.geometry != null && i.geometry.type === "mesh" && !i.geometry.loaded)
+          return b.ASYNC;
+    }
+    return this.effectiveUpdatePolicy;
+  }
+  _addImmediate(e) {
+    this._geometryWarningLogged = !1, this._symbolWarningLogged = !1;
+    for (const i of e)
+      this._addGraphic(i, this._getRenderingInfo(i, _.getLogger(this)), b.SYNC);
+    this._cleanupSymbols(), this._labeler && (this.owner.view.labeler.setDirty(), this._cleanupSymbols()), this.owner.view.deconflictor.setDirty();
+  }
+  _addDelayed(e) {
+    var i;
+    for (const t of e) {
+      const r = t.uid;
+      let s = this._pendingUpdates.get(r);
+      s ? s.add ? s.state !== u.NEW && ((i = s.abortController) == null || i.abort()) : this._pendingAdds++ : (s = this._pendingUpdatesPool.pushNew(), this._pendingAdds++, this._pendingUpdates.set(r, s)), s.add = t;
+    }
+    this.notifyChange("running"), this.notifyChange("updatingRemaining"), this.notifyChange("dataUpdating");
+  }
+  remove(e) {
+    this.effectiveUpdatePolicy === b.ASYNC ? this._removeDelayed(e) : this._removeImmediate(e), this.notifyChange("dataUpdating");
+  }
+  _removeImmediate(e) {
+    for (const i of e)
+      this._removeGraphic(i);
+    this._cleanupSymbols(), this._labeler && this.owner.view.labeler.setDirty(), this.owner.view.deconflictor.setDirty();
+  }
+  _removeDelayed(e) {
+    var i;
+    for (const t of e) {
+      const r = t.uid, s = this._pendingUpdates.get(r);
+      if (s)
+        s.add && (s.remove ? s.add = null : this._pendingUpdates.delete(r), s.state === u.LOADING && ((i = s.abortController) == null || i.abort()), this._pendingAdds--);
+      else {
+        const a = this._pendingUpdatesPool.pushNew();
+        a.remove = t, this._pendingUpdates.set(r, a), this._pendingRemoves++, this._applyPendingRemovesFirst = !0;
+      }
+    }
+    this._pendingUpdates.size === 0 && this._finishPendingUpdates(), this.notifyChange("running"), this.notifyChange("updatingRemaining"), this.notifyChange("dataUpdating");
+  }
+  _finishPendingUpdates() {
+    this._pendingUpdatesPool.clear(), this._cleanupSymbols(), (this._pendingAdds || this._pendingRemoves) && _.getLogger(this).warn("pendingAdds/Removes in inconsistent state!"), this._pendingAdds = 0, this._pendingRemoves = 0, this._applyPendingRemovesFirst = !1;
+  }
+  _applyPendingUpdates(e) {
+    var i;
+    if (this._geometryWarningLogged = !1, this._symbolWarningLogged = !1, this._pendingUpdates.size === 0 && ((i = this._spatialIndex) == null ? void 0 : i.updating))
+      return this._spatialIndex.update(), void e.madeProgress();
+    if (this._applyPendingRemovesFirst) {
+      this._applyPendingRemovesFirst = !1;
+      for (const [t, r] of this._pendingUpdates) {
+        if (e.done) {
+          this._applyPendingRemovesFirst = !0;
+          break;
+        }
+        if (r.remove && !r.add && (this._pendingRemoves--, e.madeProgress(), this._removeGraphic(r.remove), r.remove = null, this._pendingUpdates.delete(t), this._pendingRemoves === 0))
+          break;
+      }
+    }
+    for (const [t, r] of this._pendingUpdates) {
+      if (e.done)
+        break;
+      r.add && r.state === u.NEW && this._processPendingUpdateNew(r);
+      let s = this.effectiveUpdatePolicy;
+      if (!r.remove || r.add && r.state !== u.READY || (this._pendingRemoves--, e.madeProgress(), this._removeGraphic(r.remove), r.remove = null, s = b.SYNC), r.add)
+        switch (r.state) {
+          case u.READY:
+            this._addGraphic(r.add, r.renderingInfo, s), r.add = null, this._pendingAdds--, e.madeProgress();
+            break;
+          case u.REJECTED:
+            r.add = null, this._pendingAdds--;
+          case u.LOADING:
+        }
+      r.remove == null && r.add == null && this._pendingUpdates.delete(t);
+    }
+    this._pendingUpdates.size === 0 && (this._finishPendingUpdates(), this.notifyChange("running"), this.notifyChange("dataUpdating"));
+  }
+  _processPendingUpdateNew(e) {
+    if (!e.add)
+      return void (e.state = u.READY);
+    const i = e.add.geometry;
+    i == null || i.type !== "mesh" || i.loaded ? this._processPendingUpdateNewRenderingInfo(e) : this._processPendingUpdateNewMesh(e, i);
+  }
+  async _processPendingUpdateNewMesh(e, i) {
+    e.state = u.LOADING, e.abortController = new AbortController();
+    const t = e.abortController.signal;
+    try {
+      await i.load({ signal: t });
+    } catch (r) {
+      return this._processPendingUpdateNewError(e, r);
+    }
+    e.abortController = null, this._processPendingUpdateNewRenderingInfo(e);
+  }
+  _processPendingUpdateNewError(e, i) {
+    e.abortController = null, D(i) ? e.state = u.NEW : e.state = u.REJECTED;
+  }
+  async _processPendingUpdateNewRenderingInfo(e) {
+    if (this.layer.renderer == null || this.layer.renderer.type !== "dictionary")
+      return e.renderingInfo = this._getRenderingInfo(e.add, _.getLogger(this)), void (e.state = u.READY);
+    e.state = u.LOADING, e.abortController = new AbortController();
+    let i = null;
+    try {
+      i = await this._getRenderingInfoAsync(e.add, { signal: e.abortController.signal });
+    } catch (t) {
+      return e.abortController = null, void (D(t) ? e.state = u.NEW : e.state = u.REJECTED);
+    }
+    (i == null ? void 0 : i.symbol) == null ? (this._symbolWarningLogged || (this._symbolWarningLogged = !0, _.getLogger(this).warn(`Graphic in layer ${this.layer.id} has no symbol and will not render`)), e.renderingInfo = null) : e.renderingInfo = i, e.state = u.READY;
+  }
+  _addGraphic(e, i, t) {
+    var g;
+    if (this._graphicsWithoutSymbol.set(e.uid, e), (i == null ? void 0 : i.symbol) == null || !ve(e))
+      return;
+    if (this.stage.renderView.objectAndLayerIdRenderHelper != null && this.setUidToIdOnAdd) {
+      const m = Ge(this.owner.view.map, this.layer.uid);
+      this.stage.renderView.objectAndLayerIdRenderHelper.setUidToObjectAndLayerId(e.objectId, e.uid, this.layer.id, this.layer.uid, !!this.layer.popupEnabled && !m && qe(this.layer, (g = this.owner.view.popup) == null ? void 0 : g.defaultPopupTemplateEnabled));
+    }
+    const r = i.symbol, s = this.getOrCreateGraphics3DSymbol(r, i.renderer);
+    if (s == null)
+      return;
+    this._expandComputedExtent(e.geometry);
+    const a = this._beginGraphicUpdate(e), n = new Ue(e, i, this.layer);
+    let l = !1;
+    const o = (m) => {
+      m === s.symbol.id && (l = !0);
+    };
+    this._whenSymbolRemoved.push(o);
+    const p = () => {
+      if (--this._loadingSymbols, !this.destroyed) {
+        if (this._whenSymbolRemoved.removeUnordered(o), this._graphicsWaitingForSymbol.get(e.uid) !== a || l || s.destroyed || this.graphicSymbolSupported && e.symbol && e.symbol.id !== s.symbol.id)
+          --s.referenced, this._cleanupSymbols();
+        else {
+          const m = this._createGraphics3DGraphic(s, n);
+          this._spatialIndex && m != null && this._spatialIndex.add(m), --s.referenced, this._endGraphicUpdate(e);
+        }
+        this._featureStore.events.emit("changed"), this._labeler && this.owner.view.labeler.setDirty();
+      }
+    }, y = (m) => {
+      --this._loadingSymbols, this.destroyed || (this._whenSymbolRemoved.removeUnordered(o), l || (D(m) ? this.add([e]) : s.destroyed || this._endGraphicUpdate(e)));
+    };
+    ++this._loadingSymbols, t === b.ASYNC ? s.load(() => this._dataUpdateQueue.push(p, null), (m) => this._dataUpdateQueue.push(() => y(m), null)) : s.load(p, y);
+  }
+  _removeGraphic(e) {
+    var r, s;
+    const i = e.uid, t = this.graphics3DGraphics.get(i);
+    if (t) {
+      t.graphics3DSymbol.onRemoveGraphic(t);
+      const a = t.usedMemory, n = t.isElevationSource;
+      this._conditionalRemove(t, i), (r = this._spatialIndex) == null || r.remove(t);
+      const l = t.graphics3DSymbol.symbol.id;
+      (s = this._graphicsBySymbol.get(l)) == null || s.delete(i), this._graphicsWithoutSymbol.delete(i), this._removeGraphics3DGraphic(i, a, n), t.destroy(), this._featureStore.events.emit("changed");
+    } else
+      this._graphicsWithoutSymbol.delete(i), this._graphicsWaitingForSymbol.delete(i), this._graphicsWaitingForSymbol.size === 0 && (this._cleanupSymbols(), this.notifyChange("dataUpdating"));
+  }
+  _hasLabelingContext(e) {
+    if (e instanceof Z || e instanceof Ke) {
+      const i = this.symbolCreationContext.layer;
+      return !!i.labelingInfo && i.labelingInfo.some((t) => t.symbol === e);
+    }
+    return !1;
+  }
+  _hasValidSymbolCreationContext(e) {
+    return !(e instanceof Z && !this._hasLabelingContext(e)) || (_.getLogger(this).error("LabelSymbol3D is only valid as part of a LabelClass. Using LabelSymbol3D as a renderer symbol is not supported."), !1);
+  }
+  _getRenderingInfo(e, i) {
+    const t = e.geometry;
+    if (t == null)
+      return i && !this._geometryWarningLogged && (this._geometryWarningLogged = !0, i.warn(`Graphic in layer ${this.layer.id} has no geometry and will not render`)), null;
+    if (!ce(t.spatialReference, this._viewSpatialReference))
+      return i && !this._geometryWarningLogged && (this._geometryWarningLogged = !0, i.warn(`Graphic in layer ${this.layer.id} has incompatible spatial reference and will not render`)), null;
+    if (!this.graphicSymbolSupported && e.symbol != null)
+      return i && !this._symbolWarningLogged && (this._symbolWarningLogged = !0, i.warn(`Graphic in layer ${this.layer.id} is not allowed to have a symbol, use a renderer instead`)), null;
+    const r = this.rendererHasGeometryOperations ? I(e, this.layer) : e;
+    let s;
+    return this.owner.getRenderingInfo && (this.getRenderingInfoWithoutRenderer || this.currentRenderer != null) ? s = this.owner.getRenderingInfo(r, this.currentRenderer, this._arcadeOnDemand) : s = { symbol: r.symbol || Pe(r.geometry) }, (s == null ? void 0 : s.symbol) == null ? (i && !this._symbolWarningLogged && (this._symbolWarningLogged = !0, i.warn(`Graphic in layer ${this.layer.id} has no symbol and will not render`)), null) : s;
+  }
+  _getRenderingInfoAsync(e, i) {
+    if (e.geometry == null)
+      return this._geometryWarningLogged || (this._geometryWarningLogged = !0, _.getLogger(this).warn(`Graphic in layer ${this.layer.id} has no geometry and will not render`)), null;
+    if (!this.graphicSymbolSupported && e.symbol != null)
+      return this._symbolWarningLogged || (this._symbolWarningLogged = !0, _.getLogger(this).warn(`Graphic in layer ${this.layer.id} is not allowed to have a symbol, use a renderer instead`)), null;
+    const t = this.rendererHasGeometryOperations ? I(e, this.layer) : e;
+    return this.owner.getRenderingInfoAsync(t, this.currentRenderer, this._arcadeOnDemand, i);
+  }
+  _createGraphics3DSymbol(e, i) {
+    if (!this._hasValidSymbolCreationContext(e))
+      return null;
+    const t = this._getConvertedSymbol(e);
+    if (!t)
+      return null;
+    let r;
+    if (i != null && "backgroundFillSymbol" in i && i.backgroundFillSymbol) {
+      const a = N(i.backgroundFillSymbol, { ignoreDrivers: !0 });
+      a.symbol != null && a.symbol.type !== "web-style" && a.symbol.type !== "cim" && (r = a.symbol.symbolLayers);
+    }
+    const s = Le(t, this.symbolCreationContext, r);
+    return s.load(() => {
+      const a = s.extentPadding;
+      a > this.extentPadding && this._set("extentPadding", a), this.notifyChange("averageSymbolComplexity");
+    }, () => {
+    }), s;
+  }
+  getOrCreateGraphics3DSymbol(e, i) {
+    let t = this._symbols.get(e.id);
+    if (t === void 0) {
+      const r = this._unusedSymbolsCache.pop(e.id);
+      t = r ?? (e instanceof ei ? new Oe(e, (s) => this._dataUpdateQueue.push(s, null), (s) => this._createGraphics3DSymbol(s, i)) : this._createGraphics3DSymbol(e, i)), this._symbols.set(e.id, t);
+    }
+    return t != null && ++t.referenced, t;
+  }
+  trackGraphicState(e) {
+    return this._graphicStateTracking == null && (this._graphicStateTracking = new Fe(this)), this._graphicStateTracking.add(e);
+  }
+  _addGraphics3DGraphic(e) {
+    this._usedMemory += e.usedMemory, this.graphics3DGraphics.set(e.graphic.uid, e), this._numberOfGraphics++, e.isElevationSource && (this._numberOfGraphicsProvidingElevation++, this.updateStageLayerElevationProvider()), this._updateLayerVisibility();
+  }
+  _removeGraphics3DGraphic(e, i, t = !1) {
+    this._usedMemory -= i, this.graphics3DGraphics.delete(e), this._numberOfGraphics--, t && (this._numberOfGraphicsProvidingElevation--, this.updateStageLayerElevationProvider()), this._updateLayerVisibility();
+  }
+  _createGraphics3DGraphic(e, i) {
+    var n, l, o;
+    const t = i.graphic;
+    if (this._graphicsWithoutSymbol.delete(t.uid), !this._symbols.has(e.symbol.id))
+      return this.add([t]), null;
+    if (this.graphics3DGraphics.has(t.uid))
+      return null;
+    const r = e.createGraphics3DGraphic(i);
+    if (r == null)
+      return null;
+    this._addGraphics3DGraphic(r);
+    const s = e.symbol.id;
+    if (this._graphicsBySymbol.has(s) || this._graphicsBySymbol.set(s, /* @__PURE__ */ new Map()), this._graphicsBySymbol.get(s).set(t.uid, r), r.isDraped && this._graphicsDrapedUids.add(t.uid), r.centroid = null, t.geometry != null && t.geometry.type !== "point" && (r.centroid = Te(t.geometry, this._viewSpatialReference)), this._updateUserVisibility(r), this._scaleVisibility != null && this._scaleVisibility.updateVisibility(r), this._filterVisibility != null) {
+      const { defaultVisibility: p } = this._filterVisibility;
+      r.setVisibilityFlag(S.GRAPHIC, w.FILTER, p), p || this._filterVisibility.reapply();
+    }
+    (n = this._deconflictor) == null || n.addGraphic(r), (l = this._labeler) == null || l.addGraphic(r), (o = this._objectStates) == null || o.addGraphic(r), this._deconflictor && this.owner.view.deconflictor.setInitialIconVisibilityFlag(this, r), r.initialize(this.stageLayer, this.owner), this._graphicStateTracking != null && this._graphicStateTracking.addGraphic(r);
+    const a = this._whenGraphics3DGraphicRequests[t.uid];
+    return a && (delete this._whenGraphics3DGraphicRequests[t.uid], a.resolve(r)), r;
+  }
+  _abortRendererChange() {
+    this._rendererChangeAbortController && (this._rendererChangeAbortController.abort(), this._rendererChangeAbortController = null);
+  }
+  async rendererChange(e) {
+    if (this._abortRendererChange(), e !== this.currentRenderer)
+      if (this._validateRenderer(e), e == null && this._currentRendererChange(null, !1), Ce(e))
+        if (e != null && e.arcadeRequired) {
+          const i = new AbortController();
+          this._rendererChangeAbortController = i;
+          const { arcadeUtils: t } = await this._ensureArcade();
+          R(i);
+          const r = t.hasGeometryOperations(e);
+          r && (await t.enableGeometryOperations(), R(i)), this.effectiveUpdatePolicy === b.ASYNC ? await this._updateQueue.push(() => this._currentRendererChange(e, r), i.signal) : this._currentRendererChange(e, r), this._rendererChangeAbortController = null;
+        } else if (this.effectiveUpdatePolicy === b.ASYNC) {
+          const i = new AbortController();
+          this._rendererChangeAbortController = i, await this._updateQueue.push(() => this._currentRendererChange(e, !1), i.signal), this._rendererChangeAbortController = null;
+        } else
+          this._currentRendererChange(e, !1);
+      else
+        this._currentRendererChange(e, !1);
+  }
+  async _ensureArcade() {
+    return this._arcadeOnDemand == null ? (this._arcadeOnDemand = await we(), this._arcadeOnDemand) : this._arcadeOnDemand;
+  }
+  _currentRendererChange(e, i) {
+    var s;
+    this.currentRenderer = e, this.rendererHasGeometryOperations = i, this.symbolCreationContext.arcade = this._arcadeOnDemand;
+    const t = this.symbolCreationContext.renderer;
+    if (e === t)
+      return;
+    if (this._symbolConversionCache.clear(), this._unusedSymbolsCache.clear(), e == null)
+      return this.symbolCreationContext.renderer = null, void this.recreateAllGraphicsAndSymbols();
+    const r = M(t, e);
+    this._updateUnchangedSymbolMappings(r, e, t), this.symbolCreationContext.renderer = e, r != null && (r.type === "complete" ? this.recreateAllGraphicsAndSymbols() : r.type === "partial" && (this._applyRendererDiff(r, e, t) ? (s = this._labeler) == null || s.reset() : this.recreateAllGraphicsAndSymbols()), this.notifyChange("averageSymbolComplexity"));
+  }
+  _diffHasSymbolChange(e) {
+    for (const i in e.diff)
+      switch (i) {
+        case "visualVariables":
+        case "defaultSymbol":
+        case "uniqueValueInfos":
+          break;
+        case "uniqueValueGroups":
+        case "authoringInfo":
+        case "fieldDelimiter":
+          delete e.diff[i];
+          break;
+        default:
+          return !0;
+      }
+    return !1;
+  }
+  _applySymbolSetDiff(e, i, t) {
+    e = e || [], i = i || [];
+    const r = [];
+    for (const s of i) {
+      const a = this._graphicsBySymbol.get(s.id);
+      a && a.forEach((n, l) => {
+        const o = n.graphic, p = this.layer instanceof _e ? this.layer : null, y = this._arcadeOnDemand;
+        if (s === t.defaultSymbol && t.getSymbol(I(o, p), { arcade: y }) === t.defaultSymbol)
+          return;
+        const g = n.usedMemory;
+        e.length || t.defaultSymbol ? r.push(o) : this._graphicsWithoutSymbol.set(l, o);
+        const m = this.graphics3DGraphics.get(l);
+        this._conditionalRemove(m, l), n.destroy(), a.delete(l), this._removeGraphics3DGraphic(l, g), this._updateLayerVisibility();
+      }), this._whenSymbolRemoved.forAll((n) => n(s.id));
+    }
+    (e.length || r.length) && (this._graphicsWithoutSymbol.forEach((s) => r.push(s)), this._graphicsWithoutSymbol.clear(), this.add(r)), this._cleanupSymbols(), this._labeler && this.owner.view.labeler.setDirty(), this.owner.view.deconflictor.setDirty();
+  }
+  _applyUniqueValueRendererDiff(e, i, t) {
+    const r = e.diff.defaultSymbol, s = e.diff.uniqueValueInfos;
+    if (r || s) {
+      const a = s ? s.added.map((l) => l.symbol).filter(O) : [], n = s ? s.removed.map((l) => l.symbol).filter(O) : [];
+      if (s)
+        for (let l = 0; l < s.changed.length; l++)
+          a.push(s.changed[l].newValue.symbol), n.push(s.changed[l].oldValue.symbol);
+      return r ? (t.defaultSymbol && n.push(t.defaultSymbol), i.defaultSymbol && a.push(i.defaultSymbol)) : t.defaultSymbol && a.length && n.push(i.defaultSymbol), this._applySymbolSetDiff(a, n, i), delete e.diff.defaultSymbol, delete e.diff.uniqueValueInfos, !0;
+    }
+    return !1;
+  }
+  _calculateUnchangedSymbolMapping(e, i, t) {
+    var o;
+    if ((i == null ? void 0 : i.type) !== "unique-value" || (t == null ? void 0 : t.type) !== "unique-value" || e != null && e.type !== "partial")
+      return [];
+    const r = (p) => p != null ? p.id : null, s = e && e.diff, a = s == null ? void 0 : s.defaultSymbol, n = s && s.uniqueValueInfos;
+    let l;
+    if (n)
+      l = n.unchanged.map((p) => ({ oldId: r(p.oldValue.symbol), newId: r(p.newValue.symbol) }));
+    else {
+      l = [];
+      for (const p of t.uniqueValueInfos ?? []) {
+        const y = r(p.symbol), g = (o = i.uniqueValueInfos) == null ? void 0 : o.find((m) => m.value === p.value);
+        g && y !== r(g.symbol) && l.push({ oldId: y, newId: r(g.symbol) });
+      }
+    }
+    return !a && t.defaultSymbol && l.push({ oldId: r(t.defaultSymbol), newId: r(i.defaultSymbol) }), l;
+  }
+  _updateSymbolMapping(e, i) {
+    const t = i != null && i ? typeof i == "string" ? i : i.id : null;
+    if (e == null || e === t)
+      return;
+    const r = this._graphicsBySymbol.get(e);
+    this._graphicsBySymbol.delete(e), r !== void 0 && this._graphicsBySymbol.set(t, r);
+    const s = this._symbols.get(e);
+    if (s !== void 0 && (this._symbols.delete(e), this._symbols.set(t, s), s != null)) {
+      const a = typeof i == "string" ? null : i;
+      a != null ? s.symbol = a : s.symbol.id = t;
+    }
+  }
+  _updateUnchangedSymbolMappings(e, i, t) {
+    const r = this._calculateUnchangedSymbolMapping(e, i, t);
+    for (const { oldId: s, newId: a } of r)
+      this._updateSymbolMapping(s, a);
+  }
+  _applyRendererDiff(e, i, t) {
+    if (this._diffHasSymbolChange(e))
+      return !1;
+    if (i instanceof L && t instanceof L && this._applyUniqueValueRendererDiff(e, i, t) && Object.keys(e.diff).length === 0)
+      return !0;
+    for (const [r] of this._graphicsBySymbol) {
+      const s = this._symbols.get(r);
+      if (s != null)
+        switch (s.applyRendererDiff(e, i)) {
+          case E.RecreateSymbol:
+            this._recreateSymbol(r);
+            break;
+          case E.RecreateGraphics:
+            this._recreateGraphicsForSymbol(r);
+          case E.FastUpdate:
+        }
+    }
+    return !0;
+  }
+  opacityChange() {
+    this.forEachGraphics3DSymbol((e, i) => e.globalPropertyChanged("opacity", i)), this._updateStageLayerVisibility();
+  }
+  _slicePlaneEnabledChange(e) {
+    e !== this.symbolCreationContext.slicePlaneEnabled && (this.symbolCreationContext.slicePlaneEnabled = e, this.stageLayer.sliceable = e, this.forEachGraphics3DSymbol((i, t) => i.globalPropertyChanged("slicePlaneEnabled", t)), this._deconflictor && this._deconflictor.slicePlaneEnabledChange(), this._labeler && this._labeler.slicePlaneEnabledChange());
+  }
+  _physicalBasedRenderingChange(e) {
+    this.symbolCreationContext.physicalBasedRenderingEnabled = e, this.forEachGraphics3DSymbol((i, t, r) => {
+      i.globalPropertyChanged("physicalBasedRenderingEnabled", t) || this._recreateSymbol(r);
+    });
+  }
+  _skipHighSymbolLoDsChange(e) {
+    this.symbolCreationContext.skipHighSymbolLods = e, this.forEachGraphics3DSymbol((i, t, r) => {
+      i.globalPropertyChanged("skipHighSymbolLods", t) || this._recreateSymbol(r);
+    });
+  }
+  _pixelRatioChange() {
+    this.forEachGraphics3DSymbol((e, i, t) => {
+      e.globalPropertyChanged("pixelRatio", i) || this._recreateSymbol(t);
+    });
+  }
+  _signalUpdatingDuringAsyncLoadedGraphicsChange() {
+    this._updatingPendingLoadedGraphicsChange && this._updatingPendingLoadedGraphicsChange.remove(), this._updatingPendingLoadedGraphicsChange = le(() => {
+      this._updatingPendingLoadedGraphicsChange = null;
+    });
+  }
+  setClippingExtent(e, i) {
+    const t = this.symbolCreationContext.clippingExtent, r = me();
+    return We(e, r, i) ? this.symbolCreationContext.clippingExtent = ge(J(), r) : this.symbolCreationContext.clippingExtent = null, !ue(this.symbolCreationContext.clippingExtent, t);
+  }
+  modifyGraphics3DGraphicVisibilities(e) {
+    var t, r;
+    if (this.destroyed)
+      return;
+    let i = !1;
+    this.graphics3DGraphics.forEach((s) => {
+      e(s) && (i = !0);
+    }), i && ((t = this.owner.view.labeler) == null || t.setDirty(), (r = this.owner.view.deconflictor) == null || r.setDirty());
+  }
+  forEachGraphics3DSymbol(e) {
+    for (const [i, t] of this._symbols) {
+      if (t == null)
+        return;
+      e(t, this._graphicsBySymbol.get(i) || si, i);
+    }
+  }
+  updateAllGraphicsVisibility() {
+    this._filterVisibility != null && this._filterVisibility.reapply(), this.modifyGraphics3DGraphicVisibilities((e) => {
+      const i = this._updateUserVisibility(e), t = this._scaleVisibility != null && this._scaleVisibility.updateVisibility(e);
+      return i || t;
+    });
+  }
+  _hideAllGraphics() {
+    this.modifyGraphics3DGraphicVisibilities((e) => e.setVisibilityFlag(S.GRAPHIC, w.USER, !1));
+  }
+  _validateRenderer(e) {
+    var t;
+    const i = Se(e, { geometryType: (t = this.layer) == null ? void 0 : t.geometryType });
+    if (i) {
+      const r = `Renderer for layer '${this.layer.title ? `${this.layer.title}, ` : ""}, id:${this.layer.id}' is not supported in a SceneView`;
+      _.getLogger(this).warn(r, i.message);
+    }
+  }
+  _cleanupSymbols() {
+    if (this._graphicsWaitingForSymbol.size > 0 || this._suspendSymbolCleanup)
+      return;
+    let e = !1;
+    this._symbols.forEach((i, t) => {
+      if (i == null || i.referenced > 0)
+        return;
+      const r = this._graphicsBySymbol.get(t);
+      r && r.size !== 0 || (this._graphicsBySymbol.delete(t), this._symbols.delete(t), this._unusedSymbolsCache.put(t, i, ke(i), te), e = !0);
+    }), e && (this._recomputeExtentPadding(), this.notifyChange("averageSymbolComplexity"));
+  }
+  get test() {
+    return { snapshotInternals: () => ({ graphics: [...this.graphics3DGraphics.keys()].sort(), symbols: [...this._symbols.keys()].sort(), graphicsBySymbol: [...this._graphicsBySymbol.keys()].sort().map((e) => ({ symbolId: e, graphics: [...this._graphicsBySymbol.get(e).keys()].sort() })), graphicsWithoutSymbol: [...this._graphicsWithoutSymbol.keys()].sort(), graphicsDrapedUids: [...this._graphicsDrapedUids].sort(), pendingUpdates: this._pendingUpdates }), symbols: this._symbols, filterVisibility: this._filterVisibility, numPending: this._pendingUpdates.size, forceUpdatePolicy: (e) => {
+      this._forcedUpdatePolicy = e;
+    } };
+  }
+  get performanceInfo() {
+    return new Ve(this.graphics3DGraphics.size, this._graphicsWithoutSymbol.size, this._pendingUpdates.size);
+  }
+};
+var u;
+h.tmpVec = x(), d([c({ readOnly: !0 })], h.prototype, "computedExtent", void 0), d([c()], h.prototype, "currentRenderer", void 0), d([c()], h.prototype, "rendererHasGeometryOperations", void 0), d([c()], h.prototype, "_frameTaskHandle", void 0), d([c()], h.prototype, "_dataUpdateQueue", void 0), d([c()], h.prototype, "_updateQueue", void 0), d([c({ readOnly: !0 })], h.prototype, "_viewSpatialReference", null), d([c()], h.prototype, "_rendererChangeAbortController", void 0), d([c()], h.prototype, "_elevationInfoChangeAbortController", void 0), d([c()], h.prototype, "_initializeAbortController", void 0), d([c()], h.prototype, "_elevationAlignment", void 0), d([c()], h.prototype, "_scaleVisibility", void 0), d([c()], h.prototype, "_filterVisibility", void 0), d([c()], h.prototype, "_initializePromise", void 0), d([c()], h.prototype, "_spatialIndex", void 0), d([c({ readOnly: !0 })], h.prototype, "extentPadding", void 0), d([c()], h.prototype, "_updatingPendingLoadedGraphicsChange", void 0), d([c()], h.prototype, "_featureStore", void 0), d([c()], h.prototype, "_deconflictor", void 0), d([c()], h.prototype, "_labeler", void 0), d([c()], h.prototype, "_objectStates", void 0), d([c()], h.prototype, "_loadingSymbols", void 0), d([c()], h.prototype, "preferredUpdatePolicy", void 0), d([c()], h.prototype, "_forcedUpdatePolicy", void 0), d([c({ readOnly: !0 })], h.prototype, "effectiveUpdatePolicy", null), d([c({ constructOnly: !0 })], h.prototype, "elevationFeatureExpressionEnabled", void 0), d([c({ constructOnly: !0 })], h.prototype, "owner", void 0), d([c({ constructOnly: !0 })], h.prototype, "layer", void 0), d([c({ constructOnly: !0 })], h.prototype, "graphicSymbolSupported", void 0), d([c({ constructOnly: !0 })], h.prototype, "getRenderingInfoWithoutRenderer", void 0), d([c({ constructOnly: !0 })], h.prototype, "componentFactories", void 0), d([c({ constructOnly: !0 })], h.prototype, "setUidToIdOnAdd", void 0), d([c()], h.prototype, "featureStore", null), d([c()], h.prototype, "initializePromise", null), d([c()], h.prototype, "scaleVisibility", null), d([c()], h.prototype, "elevationAlignment", null), d([c()], h.prototype, "objectStates", null), d([c()], h.prototype, "filterVisibility", null), d([c({ readOnly: !0 })], h.prototype, "updating", null), d([c({ readOnly: !0 })], h.prototype, "dataUpdating", null), d([c({ readOnly: !0 })], h.prototype, "running", null), d([c({ readOnly: !0 })], h.prototype, "suspendedOrOutsideOfView", null), d([c({ readOnly: !0, dependsOn: [] })], h.prototype, "updatingRemaining", null), d([c({ readOnly: !0 })], h.prototype, "displayFeatureLimit", null), d([c({ readOnly: !0, dependsOn: [] })], h.prototype, "averageSymbolComplexity", null), d([c({ constructOnly: !0 })], h.prototype, "hasZ", void 0), d([c({ constructOnly: !0 })], h.prototype, "hasM", void 0), d([c()], h.prototype, "_objectIdField", null), h = A = d([he("esri.views.3d.layers.graphics.Graphics3DCore")], h), function(e) {
+  e[e.NEW = 0] = "NEW", e[e.LOADING = 1] = "LOADING", e[e.READY = 2] = "READY", e[e.REJECTED = 3] = "REJECTED";
+}(u || (u = {}));
+class ti {
+  constructor() {
+    this.add = null, this.renderingInfo = null, this.state = u.NEW, this.abortController = null, this.remove = null;
+  }
+  clear() {
+    this.add = null, this.renderingInfo = null, this.state = u.NEW, this.abortController = null, this.remove = null;
+  }
+}
+const ri = 10, v = x(), G = x(), si = /* @__PURE__ */ new Map();
+export {
+  h as Graphics3DCore
+};