@arcgis/coding-components 4.30.0-next.21 → 4.30.0-next.23

package/dist/components/Accessor-YDTURKZ7.js

@@ -0,0 +1,1247 @@
+/*!
+ * All material copyright Esri, All Rights Reserved, unless otherwise specified.
+ * See https://js.arcgis.com/4.30/esri/copyright.txt for details.
+ * v4.30.0-next.23
+ */
+import { v as v$1, S, j, r as r$1, y, a as a7, o as o3, I, b as o2$1, n as n2$1, t as t2, e as e$3, h as has, s as s3$1, i as i$1, f as f$1, c as j$1, m as m$1, p as p$1, k as k2$1, g as g$1, d as a2, u as u$1, O } from './chunk-OMA4PI5N.js';
+
+// ../../../node_modules/@arcgis/core/core/ObjectPool.js
+function t$3(t2) {
+  return t2?.release && "function" == typeof t2.release;
+}
+function i(t2) {
+  return t2?.acquire && "function" == typeof t2.acquire;
+}
+var e$2 = class _e {
+  constructor(t2, i2, e2, o = 1, s = 0) {
+    if (this._ctor = t2, this._acquireFunction = i2, this._releaseFunction = e2, this.allocationSize = o, this._pool = new Array(s), this._initialSize = s, this._ctor)
+      for (let n = 0; n < s; n++)
+        this._pool[n] = new this._ctor();
+    this.allocationSize = Math.max(o, 1);
+  }
+  destroy() {
+    this.prune(0);
+  }
+  acquire(...t2) {
+    let o;
+    if (_e.test.disabled)
+      o = new this._ctor();
+    else {
+      if (0 === this._pool.length) {
+        const t3 = this.allocationSize;
+        for (let i2 = 0; i2 < t3; i2++)
+          this._pool[i2] = new this._ctor();
+      }
+      o = this._pool.pop();
+    }
+    return this._acquireFunction ? this._acquireFunction(o, ...t2) : i(o) && o.acquire(...t2), o;
+  }
+  release(i2) {
+    i2 && !_e.test.disabled && (this._releaseFunction ? this._releaseFunction(i2) : t$3(i2) && i2.release(), this._pool.push(i2));
+  }
+  prune(t2 = this._initialSize) {
+    if (!(t2 >= this._pool.length)) {
+      for (let i2 = t2; i2 < this._pool.length; ++i2) {
+        const t3 = this._pool[i2];
+        this._dispose(t3);
+      }
+      this._pool.length = t2;
+    }
+  }
+  _dispose(t2) {
+    t2.dispose && "function" == typeof t2.dispose && t2.dispose();
+  }
+};
+e$2.test = { disabled: false };
+
+// ../../../node_modules/@arcgis/core/core/nextTick.js
+var o$1 = [];
+function t$2(t2) {
+  o$1.push(t2), 1 === o$1.length && queueMicrotask(() => {
+    const t3 = o$1.slice();
+    o$1.length = 0;
+    for (const o2 of t3)
+      o2();
+  });
+}
+
+// ../../../node_modules/@arcgis/core/core/time.js
+function n$1(n2) {
+  return n2;
+}
+
+// ../../../node_modules/@arcgis/core/core/HeapSort.js
+var o;
+!function(o2) {
+  const t2 = (o3, t3, n3, e3) => {
+    let i2 = t3, c = t3;
+    const l2 = n3 >>> 1, r = o3[i2 - 1];
+    for (; c <= l2; ) {
+      c = i2 << 1, c < n3 && e3(o3[c - 1], o3[c]) < 0 && ++c;
+      const t4 = o3[c - 1];
+      if (e3(t4, r) <= 0)
+        break;
+      o3[i2 - 1] = t4, i2 = c;
+    }
+    o3[i2 - 1] = r;
+  }, n2 = (o3, t3) => o3 < t3 ? -1 : o3 > t3 ? 1 : 0;
+  function e2(o3, e3, i2, c) {
+    void 0 === e3 && (e3 = 0), void 0 === i2 && (i2 = o3.length), void 0 === c && (c = n2);
+    for (let n3 = i2 >>> 1; n3 > e3; n3--)
+      t2(o3, n3, i2, c);
+    const l2 = e3 + 1;
+    for (let n3 = i2 - 1; n3 > e3; n3--) {
+      const i3 = o3[e3];
+      o3[e3] = o3[n3], o3[n3] = i3, t2(o3, l2, n3, c);
+    }
+  }
+  function* i(o3, e3, i2, c) {
+    void 0 === e3 && (e3 = 0), void 0 === i2 && (i2 = o3.length), void 0 === c && (c = n2);
+    for (let n3 = i2 >>> 1; n3 > e3; n3--)
+      t2(o3, n3, i2, c), yield;
+    const l2 = e3 + 1;
+    for (let n3 = i2 - 1; n3 > e3; n3--) {
+      const i3 = o3[e3];
+      o3[e3] = o3[n3], o3[n3] = i3, t2(o3, l2, n3, c), yield;
+    }
+  }
+  o2.sort = e2, o2.iterableSort = i;
+}(o || (o = {}));
+var t$1 = o;
+
+// ../../../node_modules/@arcgis/core/core/PooledArray.js
+var a = 1.5;
+var e$1 = 1.1;
+var l$1 = class {
+  constructor(h) {
+    this.data = [], this._length = 0, this._allocator = void 0, this._deallocator = () => null, this._shrink = () => {
+    }, this._hint = new v$1(), h && (h.initialSize && (this.data = new Array(h.initialSize)), h.allocator && (this._allocator = h.allocator), void 0 !== h.deallocator && (this._deallocator = h.deallocator), h.shrink && (this._shrink = () => n(this)));
+  }
+  toArray() {
+    return this.data.slice(0, this.length);
+  }
+  filter(t2) {
+    const h = new Array();
+    for (let i = 0; i < this._length; i++) {
+      const s = this.data[i];
+      t2(s) && h.push(s);
+    }
+    return h;
+  }
+  at(t2) {
+    if ((t2 = Math.trunc(t2) || 0) < 0 && (t2 += this._length), !(t2 < 0 || t2 >= this._length))
+      return this.data[t2];
+  }
+  includes(t2, h) {
+    const i = this.data.indexOf(t2, h);
+    return -1 !== i && i < this.length;
+  }
+  get length() {
+    return this._length;
+  }
+  set length(t2) {
+    if (t2 > this._length) {
+      if (this._allocator) {
+        for (; this._length < t2; )
+          this.data[this._length++] = this._allocator(this.data[this._length]);
+        return;
+      }
+      this._length = t2;
+    } else {
+      if (this._deallocator)
+        for (let h = t2; h < this._length; ++h)
+          this.data[h] = this._deallocator(this.data[h]);
+      this._length = t2, this._shrink();
+    }
+  }
+  clear() {
+    this.length = 0;
+  }
+  prune() {
+    this.clear(), this.data = [];
+  }
+  push(t2) {
+    this.data[this._length++] = t2;
+  }
+  pushArray(t2, h = t2.length) {
+    for (let i = 0; i < h; i++)
+      this.data[this._length++] = t2[i];
+  }
+  fill(t2, h) {
+    for (let i = 0; i < h; i++)
+      this.data[this._length++] = t2;
+  }
+  pushNew() {
+    this._allocator && (this.data[this.length] = this._allocator(this.data[this.length]));
+    const t2 = this.data[this._length];
+    return ++this._length, t2;
+  }
+  unshift(t2) {
+    this.data.unshift(t2), this._length++, n(this);
+  }
+  pop() {
+    if (0 === this.length)
+      return;
+    const t2 = this.data[this.length - 1];
+    return this.length = this.length - 1, this._shrink(), t2;
+  }
+  remove(t2) {
+    const i = S(this.data, t2, this.length, this._hint);
+    if (-1 !== i)
+      return this.data.splice(i, 1), this.length = this.length - 1, t2;
+  }
+  removeUnordered(t2) {
+    return this.removeUnorderedIndex(S(this.data, t2, this.length, this._hint));
+  }
+  removeUnorderedIndex(t2) {
+    if (!(t2 >= this.length || t2 < 0))
+      return this.swapElements(t2, this.length - 1), this.pop();
+  }
+  removeUnorderedMany(t2, h = t2.length, s) {
+    this.length = j(this.data, t2, this.length, h, this._hint, s), this._shrink();
+  }
+  front() {
+    if (0 !== this.length)
+      return this.data[0];
+  }
+  back() {
+    if (0 !== this.length)
+      return this.data[this.length - 1];
+  }
+  swapElements(t2, h) {
+    if (t2 >= this.length || h >= this.length || t2 === h)
+      return;
+    const i = this.data[t2];
+    this.data[t2] = this.data[h], this.data[h] = i;
+  }
+  sort(t2) {
+    t$1.sort(this.data, 0, this.length, t2);
+  }
+  iterableSort(t2) {
+    return t$1.iterableSort(this.data, 0, this.length, t2);
+  }
+  some(t2, h) {
+    for (let i = 0; i < this.length; ++i)
+      if (t2.call(h, this.data[i], i, this.data))
+        return true;
+    return false;
+  }
+  find(t2, h) {
+    for (let i = 0; i < this.length; ++i) {
+      const s = this.data[i];
+      if (t2.call(h, s, i))
+        return s;
+    }
+  }
+  filterInPlace(t2, h) {
+    let i = 0;
+    for (let s = 0; s < this._length; ++s) {
+      const a2 = this.data[s];
+      t2.call(h, a2, s, this.data) && (this.data[s] = this.data[i], this.data[i] = a2, i++);
+    }
+    if (this._deallocator)
+      for (let s = i; s < this._length; s++)
+        this.data[s] = this._deallocator(this.data[s]);
+    return this._length = i, this._shrink(), this;
+  }
+  forAll(t2, h) {
+    const { data: i, length: s } = this;
+    for (let a2 = 0; a2 < s; ++a2)
+      t2.call(h, i[a2], a2, i);
+  }
+  forEach(t2, h) {
+    this.data.slice(0, this.length).forEach(t2, h);
+  }
+  map(t2, h) {
+    const i = new Array(this.length);
+    for (let s = 0; s < this.length; ++s)
+      i[s] = t2.call(h, this.data[s], s, this.data);
+    return i;
+  }
+  reduce(t2, h) {
+    let i = h;
+    for (let s = 0; s < this.length; ++s)
+      i = t2(i, this.data[s], s, this.data);
+    return i;
+  }
+  has(t2) {
+    const h = this.length, i = this.data;
+    for (let s = 0; s < h; ++s)
+      if (i[s] === t2)
+        return true;
+    return false;
+  }
+  *[Symbol.iterator]() {
+    for (let t2 = 0; t2 < this.length; t2++)
+      yield this.data[t2];
+  }
+};
+function n(t2) {
+  t2.data.length > a * t2.length && (t2.data.length = Math.floor(t2.length * e$1));
+}
+
+// ../../../node_modules/@arcgis/core/core/maybe.js
+function u(n2) {
+  return n2?.destroy(), null;
+}
+
+// ../../../node_modules/@arcgis/core/core/PerformanceSampler.js
+var s$1 = class {
+  constructor(s2, e = 30) {
+    this.name = s2, this._counter = 0, this._samples = new Array(e);
+  }
+  record(s2) {
+    null != s2 && (this._samples[++this._counter % this._samples.length] = s2);
+  }
+  get median() {
+    return this._samples.slice().sort((s2, e) => s2 - e)[Math.floor(this._samples.length / 2)];
+  }
+  get average() {
+    return this._samples.reduce((s2, e) => s2 + e, 0) / this._samples.length;
+  }
+  get last() {
+    return this._samples[this._counter % this._samples.length];
+  }
+};
+var c2$1 = class {
+  constructor(e) {
+    this.callback = e, this.isActive = true;
+  }
+  remove() {
+    this.isActive = false;
+  }
+};
+var m = 0;
+var u2 = { time: n$1(0), deltaTime: n$1(0), elapsedFrameTime: n$1(0), frameDuration: n$1(0) };
+var p = ["prepare", "preRender", "render", "postRender", "update", "finish"];
+var f = [];
+var h = new l$1();
+function w() {
+}
+var k = { frameTasks: h, willDispatch: false, clearFrameTasks: T$1, dispatch: _$1, executeFrameTasks: D, reschedule: w };
+function v(t2) {
+  const r = new c2$1(t2);
+  return f.push(r), k.willDispatch || (k.willDispatch = true, t$2(_$1)), r;
+}
+function T$1(e = false) {
+  h.forAll((e2) => {
+    e2.removed = true;
+  }), e && q$1();
+}
+function D(e) {
+  const t2 = n$1(e - m);
+  m = e;
+  const r = 1e3 / 60, n2 = Math.max(0, t2 - r);
+  u2.time = e, u2.frameDuration = n$1(r - n2);
+  for (let s2 = 0; s2 < p.length; s2++) {
+    const r2 = performance.now(), n3 = p[s2];
+    h.forAll((r3) => {
+      if (r3.paused || r3.removed)
+        return;
+      0 === s2 && r3.ticks++;
+      r3.phases[n3] && (u2.elapsedFrameTime = n$1(performance.now() - e), u2.deltaTime = 0 === r3.ticks ? n$1(0) : t2, r3.phases[n3]?.call(r3, u2));
+    }), b$1[s2].record(performance.now() - r2);
+  }
+  q$1(), U.record(performance.now() - e);
+}
+var g = new l$1();
+function q$1() {
+  h.forAll((e) => {
+    e.removed && g.push(e);
+  }), h.removeUnorderedMany(g.data, g.length), g.clear();
+}
+function _$1() {
+  for (; f.length; ) {
+    const e = f.shift();
+    e.isActive && e.callback();
+  }
+  k.willDispatch = false;
+}
+var b$1 = p.map((e) => new s$1(e));
+var U = new s$1("total");
+
+// ../../../node_modules/@arcgis/core/core/iteratorUtils.js
+function t(n2) {
+  return null != n2 && "function" == typeof n2[Symbol.iterator];
+}
+
+// ../../../node_modules/@arcgis/core/core/Handles.js
+var r = class {
+  constructor() {
+    this._groups = /* @__PURE__ */ new Map();
+  }
+  destroy() {
+    this.removeAll();
+  }
+  get size() {
+    let t2 = 0;
+    return this._groups.forEach((r2) => {
+      t2 += r2.length;
+    }), t2;
+  }
+  add(r2, e2) {
+    if (t(r2)) {
+      const t2 = this._getOrCreateGroup(e2);
+      for (const e3 of r2)
+        o2(e3) && t2.push(e3);
+    } else if (o2(r2)) {
+      this._getOrCreateGroup(e2).push(r2);
+    }
+    return this;
+  }
+  forEach(t2, r2) {
+    if ("function" == typeof t2)
+      this._groups.forEach((r3) => r3.forEach(t2));
+    else {
+      const e2 = this._getGroup(t2);
+      e2 && r2 && e2.forEach(r2);
+    }
+  }
+  has(t2) {
+    return this._groups.has(e(t2));
+  }
+  remove(r2) {
+    if ("string" != typeof r2 && t(r2)) {
+      for (const t2 of r2)
+        this.remove(t2);
+      return this;
+    }
+    return this.has(r2) ? (s(this._getGroup(r2)), this._groups.delete(e(r2)), this) : this;
+  }
+  removeAll() {
+    return this._groups.forEach(s), this._groups.clear(), this;
+  }
+  _getOrCreateGroup(t2) {
+    if (this.has(t2))
+      return this._getGroup(t2);
+    const r2 = [];
+    return this._groups.set(e(t2), r2), r2;
+  }
+  _getGroup(t2) {
+    return this._groups.get(e(t2));
+  }
+};
+function e(t2) {
+  return t2 || "_default_";
+}
+function s(t2) {
+  for (const e2 of t2)
+    e2 instanceof r ? e2.removeAll() : e2.remove();
+}
+function o2(t2) {
+  return null != t2 && (!!t2.remove || t2 instanceof r);
+}
+
+// ../../../node_modules/@arcgis/core/core/deprecate.js
+var e3 = /* @__PURE__ */ new WeakMap();
+function n2(n6, t11, i6 = false) {
+  const o9 = `\u{1F6D1} DEPRECATED - ${t11}`;
+  if (!i6)
+    return void n6.warn(o9);
+  let r9 = e3.get(n6);
+  r9 || (r9 = /* @__PURE__ */ new Set(), e3.set(n6, r9)), r9.has(t11) || (r9.add(t11), n6.warn(o9));
+}
+function i2(e9, n6, t11 = {}) {
+  if (has("esri-deprecation-warnings")) {
+    const { moduleName: i6 } = t11;
+    r3(e9, `Function: ${(i6 ? i6 + "::" : "") + n6 + "()"}`, t11);
+  }
+}
+function r3(e9, t11, i6 = {}) {
+  if (has("esri-deprecation-warnings")) {
+    const { replacement: o9, version: r9, see: a3, warnOnce: s6 } = i6;
+    let c3 = t11;
+    o9 && (c3 += `
+	\u{1F6E0}\uFE0F Replacement: ${o9}`), r9 && (c3 += `
+	\u2699\uFE0F Version: ${r9}`), a3 && (c3 += `
+	\u{1F517} See ${a3} for more details.`), n2(e9, c3, s6);
+  }
+}
+
+// ../../../node_modules/@arcgis/core/core/accessorSupport/tracking/ObservationHandle.js
+var s2 = class {
+  constructor(r9, s6) {
+    this._observers = r9, this._observer = s6;
+  }
+  remove() {
+    O(this._observers, this._observer);
+  }
+};
+
+// ../../../node_modules/@arcgis/core/core/accessorSupport/ObservableBase.js
+var r4 = class {
+  constructor() {
+    this._observers = null, this.destroyed = false;
+  }
+  observe(e9) {
+    if (this.destroyed || e9.destroyed)
+      return t3;
+    null == this._observers && (this._observers = []);
+    const r9 = this._observers;
+    let o9 = false, i6 = false;
+    const n6 = r9.length;
+    for (let s6 = 0; s6 < n6; ++s6) {
+      const t11 = r9[s6];
+      if (t11.destroyed)
+        i6 = true;
+      else if (t11 === e9) {
+        o9 = true;
+        break;
+      }
+    }
+    return o9 || (r9.push(e9), i6 && this._removeDestroyedObservers()), new s2(r9, e9);
+  }
+  _removeDestroyedObservers() {
+    const e9 = this._observers;
+    if (!e9 || 0 === e9.length)
+      return;
+    const s6 = e9.length;
+    let r9 = 0;
+    for (let t11 = 0; t11 < s6; ++t11) {
+      for (; t11 + r9 < s6; ) {
+        if (!e9[t11 + r9].destroyed)
+          break;
+        ++r9;
+      }
+      if (r9 > 0) {
+        if (!(t11 + r9 < s6))
+          break;
+        e9[t11] = e9[t11 + r9];
+      }
+    }
+    e9.length = s6 - r9;
+  }
+  destroy() {
+    if (this.destroyed)
+      return;
+    this.destroyed = true;
+    const e9 = this._observers;
+    if (null != e9) {
+      for (const s6 of e9)
+        s6.onCommitted();
+      this._observers = null;
+    }
+  }
+};
+var t3 = e$3();
+
+// ../../../node_modules/@arcgis/core/core/accessorSupport/PropertyOrigin.js
+var e4;
+!function(e9) {
+  e9[e9.DEFAULTS = 0] = "DEFAULTS", e9[e9.COMPUTED = 1] = "COMPUTED", e9[e9.SERVICE = 2] = "SERVICE", e9[e9.PORTAL_ITEM = 3] = "PORTAL_ITEM", e9[e9.WEB_SCENE = 4] = "WEB_SCENE", e9[e9.WEB_MAP = 5] = "WEB_MAP", e9[e9.LINK_CHART = 6] = "LINK_CHART", e9[e9.USER = 7] = "USER";
+}(e4 || (e4 = {}));
+function n3(r9) {
+  switch (r9) {
+    case "defaults":
+      return e4.DEFAULTS;
+    case "service":
+      return e4.SERVICE;
+    case "portal-item":
+      return e4.PORTAL_ITEM;
+    case "web-scene":
+      return e4.WEB_SCENE;
+    case "web-map":
+      return e4.WEB_MAP;
+    case "link-chart":
+      return e4.LINK_CHART;
+    case "user":
+      return e4.USER;
+    default:
+      return null;
+  }
+}
+function t4(r9) {
+  switch (r9) {
+    case e4.DEFAULTS:
+      return "defaults";
+    case e4.SERVICE:
+      return "service";
+    case e4.PORTAL_ITEM:
+      return "portal-item";
+    case e4.WEB_SCENE:
+      return "web-scene";
+    case e4.WEB_MAP:
+      return "web-map";
+    case e4.LINK_CHART:
+      return "link-chart";
+    case e4.USER:
+      return "user";
+  }
+}
+
+// ../../../node_modules/@arcgis/core/core/accessorSupport/Property.js
+var o4 = class extends r4 {
+  constructor(t11, s6) {
+    super(), this.propertyName = t11, this.metadata = s6, this._accessed = null, this._handles = null, this.flags = 0, this.flags = i$1.Dirty | (s6.nonNullable ? i$1.NonNullable : 0) | (s6.hasOwnProperty("value") ? i$1.HasDefaultValue : 0) | (void 0 === s6.get ? i$1.DepTrackingInitialized : 0) | (void 0 === s6.dependsOn ? i$1.AutoTracked : 0);
+  }
+  destroy() {
+    this.flags & i$1.Dirty && this.onCommitted(), super.destroy(), this._accessed = null, this._clearObservationHandles();
+  }
+  getComputed(t11) {
+    s3$1(this);
+    const o9 = t11.store, r9 = this.propertyName, h3 = this.flags, d2 = o9.get(r9);
+    if (h3 & i$1.Computing)
+      return d2;
+    if (~h3 & i$1.Dirty && o9.has(r9))
+      return d2;
+    this.flags |= i$1.Computing;
+    const c3 = t11.host;
+    let g5;
+    h3 & i$1.AutoTracked ? g5 = f$1(this, this.metadata.get, c3) : (k2$1(c3, this), g5 = this.metadata.get.call(c3)), o9.set(r9, g5, e4.COMPUTED);
+    const f6 = o9.get(r9);
+    return f6 === d2 ? this.flags &= ~i$1.Dirty : g$1(this.commit, this), this.flags &= ~i$1.Computing, f6;
+  }
+  onObservableAccessed(t11) {
+    if (t11 === this)
+      return;
+    let s6 = this._accessed;
+    if (null == s6)
+      s6 = [], this._accessed = s6;
+    else if (s6.includes(t11))
+      return;
+    s6.push(t11);
+  }
+  onTrackingEnd() {
+    this._clearObservationHandles(), this.flags |= i$1.DepTrackingInitialized;
+    const t11 = this._accessed;
+    if (null == t11 || 0 === t11.length)
+      return;
+    let s6 = this._handles;
+    null == s6 && (s6 = [], this._handles = s6);
+    for (let e9 = 0; e9 < t11.length; ++e9)
+      s6.push(t11[e9].observe(this));
+    t11.length = 0;
+  }
+  notifyChange() {
+    this.onInvalidated(), this.onCommitted();
+  }
+  invalidate() {
+    this.onInvalidated();
+  }
+  commit() {
+    this.flags &= ~i$1.Dirty, this.onCommitted();
+  }
+  _clearObservationHandles() {
+    const t11 = this._handles;
+    if (null !== t11) {
+      for (let s6 = 0; s6 < t11.length; ++s6)
+        t11[s6].remove();
+      t11.length = 0;
+    }
+  }
+  onInvalidated() {
+    ~this.flags & i$1.Overridden && (this.flags |= i$1.Dirty);
+    const t11 = this._observers;
+    if (t11 && t11.length > 0)
+      for (const s6 of t11)
+        s6.onInvalidated();
+  }
+  onCommitted() {
+    const t11 = this._observers;
+    if (t11 && t11.length > 0) {
+      const s6 = t11.slice();
+      for (const t12 of s6)
+        t12.onCommitted();
+    }
+  }
+};
+
+// ../../../node_modules/@arcgis/core/core/accessorSupport/Store.js
+var t5 = class _t {
+  constructor() {
+    this._values = /* @__PURE__ */ new Map(), this.multipleOriginsSupported = false;
+  }
+  clone(s6) {
+    const r9 = new _t();
+    return this._values.forEach((t11, i6) => {
+      s6 && s6.has(i6) || r9.set(i6, a2(t11));
+    }), r9;
+  }
+  get(e9) {
+    return this._values.get(e9);
+  }
+  originOf() {
+    return e4.USER;
+  }
+  keys() {
+    return [...this._values.keys()];
+  }
+  set(e9, s6) {
+    this._values.set(e9, s6);
+  }
+  delete(e9) {
+    this._values.delete(e9);
+  }
+  has(e9) {
+    return this._values.has(e9);
+  }
+  forEach(e9) {
+    this._values.forEach(e9);
+  }
+};
+
+// ../../../node_modules/@arcgis/core/core/accessorSupport/Properties.js
+function f2(t11, e9, i6) {
+  return void 0 !== t11;
+}
+function d(t11, e9, s6, r9) {
+  return void 0 !== t11 && (!(null == s6 && t11.flags & i$1.NonNullable) || (false));
+}
+var g2 = class {
+  constructor(t11) {
+    this.host = t11, this.propertiesByName = /* @__PURE__ */ new Map(), this.ctorArgs = null, this.lifecycle = I.INITIALIZING, this.store = new t5(), this._origin = e4.USER;
+    const e9 = this.host.constructor.__accessorMetadata__;
+    for (const i6 in e9) {
+      const t12 = new o4(i6, e9[i6]);
+      this.propertiesByName.set(i6, t12);
+    }
+    this.metadata = e9;
+  }
+  initialize() {
+    this.lifecycle = I.CONSTRUCTING;
+  }
+  constructed() {
+    this.lifecycle = I.CONSTRUCTED;
+  }
+  destroy() {
+    this.lifecycle = I.DESTROYED, this.propertiesByName.forEach((t11) => t11.destroy());
+  }
+  get initialized() {
+    return this.lifecycle !== I.INITIALIZING;
+  }
+  get(t11) {
+    const e9 = this.propertiesByName.get(t11);
+    if (e9.metadata.get)
+      return e9.getComputed(this);
+    s3$1(e9);
+    const i6 = this.store;
+    return i6.has(t11) ? i6.get(t11) : e9.metadata.value;
+  }
+  originOf(t11) {
+    const e9 = this.store.originOf(t11);
+    if (void 0 === e9) {
+      const e10 = this.propertiesByName.get(t11);
+      if (void 0 !== e10 && e10.flags & i$1.HasDefaultValue)
+        return "defaults";
+    }
+    return t4(e9);
+  }
+  has(t11) {
+    return this.propertiesByName.has(t11) && this.store.has(t11);
+  }
+  keys() {
+    return [...this.propertiesByName.keys()];
+  }
+  internalGet(t11) {
+    const e9 = this.propertiesByName.get(t11);
+    if (f2(e9))
+      return this.store.has(t11) ? this.store.get(t11) : e9.metadata.value;
+  }
+  internalSet(t11, e9) {
+    const i6 = this.propertiesByName.get(t11);
+    f2(i6) && this._internalSet(i6, e9);
+  }
+  getDependsInfo(t11, e9, i6) {
+    const r9 = this.propertiesByName.get(e9);
+    if (!f2(r9))
+      return "";
+    const o9 = /* @__PURE__ */ new Set(), a3 = f$1({ onObservableAccessed: (t12) => o9.add(t12), onTrackingEnd: () => {
+    } }, () => r9.metadata.get?.call(t11));
+    let n6 = `${i6}${t11.declaredClass.split(".").pop()}.${e9}: ${a3}
+`;
+    if (0 === o9.size)
+      return n6;
+    i6 += "  ";
+    for (const c3 of o9) {
+      if (!(c3 instanceof o4))
+        continue;
+      n6 += `${i6}${c3.propertyName}: undefined
+`;
+    }
+    return n6;
+  }
+  setAtOrigin(t11, e9, i6) {
+    const s6 = this.propertiesByName.get(t11);
+    if (f2(s6))
+      return this._setAtOrigin(s6, e9, i6);
+  }
+  isOverridden(t11) {
+    const e9 = this.propertiesByName.get(t11);
+    return void 0 !== e9 && !!(e9.flags & i$1.Overridden);
+  }
+  clearOverride(t11) {
+    const e9 = this.propertiesByName.get(t11);
+    e9 && e9.flags & i$1.Overridden && (e9.flags &= ~i$1.Overridden, e9.notifyChange());
+  }
+  override(t11, e9) {
+    const i6 = this.propertiesByName.get(t11);
+    if (!d(i6, t11, e9))
+      return;
+    const s6 = i6.metadata.cast;
+    if (s6) {
+      const t12 = this._cast(s6, e9), { valid: i7, value: r9 } = t12;
+      if (u4.release(t12), !i7)
+        return;
+      e9 = r9;
+    }
+    i6.flags |= i$1.Overridden, this._internalSet(i6, e9);
+  }
+  set(t11, e9) {
+    const i6 = this.propertiesByName.get(t11);
+    if (!d(i6, t11, e9))
+      return;
+    const s6 = i6.metadata.cast;
+    if (s6) {
+      const t12 = this._cast(s6, e9), { valid: i7, value: r10 } = t12;
+      if (u4.release(t12), !i7)
+        return;
+      e9 = r10;
+    }
+    const r9 = i6.metadata.set;
+    r9 ? r9.call(this.host, e9) : this._internalSet(i6, e9);
+  }
+  setDefaultOrigin(t11) {
+    this._origin = n3(t11);
+  }
+  getDefaultOrigin() {
+    return t4(this._origin);
+  }
+  notifyChange(t11) {
+    const e9 = this.propertiesByName.get(t11);
+    void 0 !== e9 && e9.notifyChange();
+  }
+  invalidate(t11) {
+    const e9 = this.propertiesByName.get(t11);
+    void 0 !== e9 && e9.invalidate();
+  }
+  commit(t11) {
+    const e9 = this.propertiesByName.get(t11);
+    void 0 !== e9 && e9.commit();
+  }
+  _internalSet(t11, e9) {
+    const s6 = this.lifecycle !== I.INITIALIZING ? this._origin : e4.DEFAULTS;
+    this._setAtOrigin(t11, e9, s6);
+  }
+  _setAtOrigin(e9, i6, s6) {
+    const r9 = this.store, o9 = e9.propertyName;
+    r9.has(o9, s6) && j$1(i6, r9.get(o9)) && ~e9.flags & i$1.Overridden && s6 === r9.originOf(o9) || (e9.invalidate(), r9.set(o9, i6, s6), e9.commit(), m$1(this.host, e9));
+  }
+  _cast(t11, e9) {
+    const i6 = u4.acquire();
+    return i6.valid = true, i6.value = e9, t11 && (i6.value = t11.call(this.host, e9, i6)), i6;
+  }
+};
+var m2 = class {
+  constructor() {
+    this.value = null, this.valid = true;
+  }
+  acquire() {
+    this.valid = true;
+  }
+  release() {
+    this.value = null;
+  }
+};
+var u4 = new e$2(m2);
+
+// ../../../node_modules/@arcgis/core/core/accessorSupport/testSupport.js
+var r6;
+function o5() {
+  return r6;
+}
+var t6;
+!function(r9) {
+  r9[r9.Ignore = 0] = "Ignore", r9[r9.Destroy = 1] = "Destroy", r9[r9.ThrowError = 2] = "ThrowError";
+}(t6 || (t6 = {}));
+
+// ../../../node_modules/@arcgis/core/core/ArrayPool.js
+function r7(e9) {
+  e9.length = 0;
+}
+var t7 = class {
+  constructor(t11 = 50, o9 = 50) {
+    this._pool = new e$2(Array, void 0, r7, o9, t11);
+  }
+  acquire() {
+    return this._pool.acquire();
+  }
+  release(e9) {
+    this._pool.release(e9);
+  }
+  prune() {
+    this._pool.prune(0);
+  }
+  static acquire() {
+    return o6.acquire();
+  }
+  static release(e9) {
+    return o6.release(e9);
+  }
+  static prune() {
+    o6.prune();
+  }
+};
+var o6 = new t7(100);
+
+// ../../../node_modules/@arcgis/core/core/ReentrantObjectPool.js
+var s3 = class extends e$2 {
+  constructor() {
+    super(...arguments), this._set = /* @__PURE__ */ new Set();
+  }
+  destroy() {
+    super.destroy(), this._set = null;
+  }
+  acquire(...e9) {
+    const s6 = super.acquire(...e9);
+    return this._set.delete(s6), s6;
+  }
+  release(e9) {
+    e9 && !this._set.has(e9) && (super.release(e9), this._set.add(e9));
+  }
+  _dispose(e9) {
+    this._set.delete(e9), super._dispose(e9);
+  }
+};
+
+// ../../../node_modules/@arcgis/core/core/uid.js
+var t9 = 0;
+function e6() {
+  return ++t9;
+}
+
+// ../../../node_modules/@arcgis/core/core/accessorSupport/tracking/SimpleTrackingTarget.js
+var t10 = class {
+  constructor(t11) {
+    this._accessed = [], this._handles = [], this._observerObject = new e7(t11), s5.register(this, new WeakRef(this._observerObject), this);
+  }
+  destroy() {
+    s5.unregister(this._observerObject), this._accessed.length = 0, this._observerObject?.destroy(), this.clear();
+  }
+  onObservableAccessed(t11) {
+    const e9 = this._accessed;
+    e9.includes(t11) || e9.push(t11);
+  }
+  onTrackingEnd() {
+    const t11 = this._handles, e9 = this._accessed, s6 = this._observerObject;
+    for (let i6 = 0; i6 < e9.length; ++i6)
+      t11.push(e9[i6].observe(s6));
+    e9.length = 0;
+  }
+  clear() {
+    const t11 = this._handles;
+    for (let e9 = 0; e9 < t11.length; ++e9)
+      t11[e9].remove();
+    t11.length = 0;
+  }
+};
+var e7 = class {
+  constructor(t11) {
+    this._notify = t11, this._invalidCount = 0, this.destroyed = false;
+  }
+  onInvalidated() {
+    this._invalidCount++;
+  }
+  onCommitted() {
+    if (this.destroyed)
+      return;
+    const t11 = this._invalidCount;
+    if (1 === t11)
+      return this._invalidCount = 0, void this._notify();
+    this._invalidCount = t11 > 0 ? t11 - 1 : 0;
+  }
+  destroy() {
+    this.destroyed = true, this._notify = i4;
+  }
+};
+var s5 = new FinalizationRegistry((t11) => {
+  t11.deref()?.destroy();
+});
+function i4() {
+}
+
+// ../../../node_modules/@arcgis/core/core/accessorSupport/trackingUtils.js
+var l = false;
+var u6 = [];
+function o8(u7, o9) {
+  let e9 = new t10(a3), i6 = null, s6 = false;
+  function a3() {
+    if (!e9 || s6)
+      return;
+    if (l)
+      return void c2(a3);
+    const n6 = i6;
+    e9.clear(), l = true, s6 = true, i6 = f$1(e9, u7), s6 = false, l = false, o9(i6, n6), f4();
+  }
+  function m5() {
+    e9 && (e9.destroy(), e9 = null, i6 = null);
+  }
+  return s6 = true, i6 = f$1(e9, u7), s6 = false, e$3(m5);
+}
+function e8(l2, u7) {
+  let o9 = new t10(i6), e9 = null;
+  function i6() {
+    u7(e9, f6);
+  }
+  function c3() {
+    o9 && (o9.destroy(), o9 = null), e9 = null;
+  }
+  function f6() {
+    return o9 ? (o9.clear(), e9 = f$1(o9, l2), e9) : null;
+  }
+  return f6(), e$3(c3);
+}
+function c2(n6) {
+  u6.includes(n6) || u6.unshift(n6);
+}
+function f4() {
+  for (; u6.length; )
+    u6.pop()();
+}
+
+// ../../../node_modules/@arcgis/core/core/accessorSupport/watch.js
+var h2;
+!function(e9) {
+  e9[e9.Untracked = 0] = "Untracked", e9[e9.Tracked = 1] = "Tracked";
+}(h2 || (h2 = {}));
+var m3 = class {
+  constructor() {
+    this.uid = e6(), this.removed = false, this.type = null, this.oldValue = null, this.callback = null, this.getValue = null, this.target = null, this.path = null, this.equals = null;
+  }
+  static acquireUntracked(e9, t11, l2, o9, i6) {
+    return this.pool.acquire(h2.Untracked, e9, t11, l2, o9, i6, j$1);
+  }
+  static acquireTracked(e9, t11, r9, l2) {
+    return this.pool.acquire(h2.Tracked, e9, t11, r9, null, null, l2);
+  }
+  notify(e9, t11) {
+    this.type === h2.Untracked ? this.callback.call(this.target, e9, t11, this.path, this.target) : this.callback.call(null, e9, t11, void 0, void 0);
+  }
+  acquire(e9, t11, r9, l2, o9, i6, n6) {
+    this.uid = e6(), this.removed = false, this.type = e9, this.oldValue = t11, this.callback = r9, this.getValue = l2, this.target = o9, this.path = i6, this.equals = n6;
+  }
+  release() {
+    this.target = this.path = this.oldValue = this.callback = this.getValue = null, this.uid = e6(), this.removed = true;
+  }
+};
+m3.pool = new s3(m3);
+var p2 = new t7();
+var v2 = /* @__PURE__ */ new Set();
+var k2;
+function _(e9) {
+  v2.delete(e9), v2.add(e9), k2 || (k2 = v(q));
+}
+function g3(e9) {
+  if (e9.removed)
+    return;
+  const t11 = e9.oldValue, r9 = e9.getValue();
+  e9.equals(t11, r9) || (e9.oldValue = r9, e9.notify(r9, t11));
+}
+function j2(e9) {
+  for (const t11 of v2.values())
+    t11.target === e9 && (t11.removed = true);
+}
+function q() {
+  let e9 = 10;
+  for (; k2 && e9--; ) {
+    k2 = null;
+    const e10 = V(), t11 = p2.acquire();
+    for (const r9 of e10) {
+      const e11 = r9.uid;
+      g3(r9), e11 === r9.uid && r9.removed && t11.push(r9);
+    }
+    for (const r9 of v2)
+      r9.removed && (t11.push(r9), v2.delete(r9));
+    for (const r9 of t11)
+      m3.pool.release(r9);
+    p2.release(t11), p2.release(e10), y2.forEach((e11) => e11());
+  }
+}
+function V() {
+  const e9 = p2.acquire();
+  e9.length = v2.size;
+  let t11 = 0;
+  for (const r9 of v2)
+    e9[t11] = r9, ++t11;
+  return v2.clear(), e9;
+}
+var y2 = /* @__PURE__ */ new Set();
+function T(e9, r9, l2) {
+  let o9 = p$1(e9, r9, l2, (e10, r10, l3) => {
+    let i6, n6, s6 = e8(() => u$1(e10, r10), (t11, s7) => {
+      e10.__accessor__?.lifecycle === I.DESTROYED || i6 && i6.uid !== n6 ? o9.remove() : (i6 || (i6 = m3.acquireUntracked(t11, l3, s7, e10, r10), n6 = i6.uid), _(i6));
+    });
+    return e$3(() => {
+      s6.remove(), i6 && (i6.uid !== n6 || i6.removed || (i6.removed = true, _(i6)), i6 = null), o9 = s6 = null;
+    });
+  });
+  return o9;
+}
+function E(e9, t11, l2) {
+  const o9 = p$1(e9, t11, l2, (e10, t12, l3) => {
+    let i6 = false;
+    return o8(() => u$1(e10, t12), (n6, s6) => {
+      e10.__accessor__.lifecycle !== I.DESTROYED ? i6 || (i6 = true, j$1(s6, n6) || l3.call(e10, n6, s6, t12, e10), i6 = false) : o9.remove();
+    });
+  });
+  return o9;
+}
+function b(e9, r9, l2, o9 = false) {
+  return e9.__accessor__ && e9.__accessor__.lifecycle !== I.DESTROYED ? o9 ? E(e9, r9, l2) : T(e9, r9, l2) : e$3();
+}
+
+// ../../../node_modules/@arcgis/core/core/Accessor.js
+var y3;
+var m4;
+function f5(r9) {
+  if (null == r9)
+    return { value: r9 };
+  if (Array.isArray(r9))
+    return { type: [r9[0]], value: null };
+  switch (typeof r9) {
+    case "object":
+      return r9.constructor?.__accessorMetadata__ || r9 instanceof Date ? { type: r9.constructor, value: r9 } : r9;
+    case "boolean":
+      return { type: Boolean, value: r9 };
+    case "string":
+      return { type: String, value: r9 };
+    case "number":
+      return { type: Number, value: r9 };
+    case "function":
+      return { type: r9, value: null };
+    default:
+      return;
+  }
+}
+var v3 = Symbol("Accessor-Handles");
+var g4 = Symbol("Accessor-Initialized");
+var S2 = class _S {
+  static createSubclass(r9 = {}) {
+    if (Array.isArray(r9))
+      throw new Error("Multi-inheritance unsupported since 4.16");
+    const { properties: t11, declaredClass: e9, constructor: s6 } = r9;
+    delete r9.declaredClass, delete r9.properties, delete r9.constructor;
+    const o9 = this;
+    class i6 extends o9 {
+      constructor(...r10) {
+        super(...r10), this.inherited = null, s6 && s6.apply(this, r10);
+      }
+    }
+    r$1(i6.prototype);
+    for (const c3 in r9) {
+      const t12 = r9[c3];
+      i6.prototype[c3] = "function" == typeof t12 ? function(...r10) {
+        const e10 = this.inherited;
+        let s7;
+        this.inherited = function(...r11) {
+          if (o9.prototype[c3])
+            return o9.prototype[c3].apply(this, r11);
+        };
+        try {
+          s7 = t12.apply(this, r10);
+        } catch (i7) {
+          throw this.inherited = e10, i7;
+        }
+        return this.inherited = e10, s7;
+      } : r9[c3];
+    }
+    for (const c3 in t11) {
+      const r10 = f5(t11[c3]);
+      y(r10)(i6.prototype, c3);
+    }
+    return a7(e9)(i6);
+  }
+  constructor(...r9) {
+    if (this[y3] = null, this[m4] = false, this.constructor === _S)
+      throw new Error("[accessor] cannot instantiate Accessor. This can be fixed by creating a subclass of Accessor");
+    const t11 = new g2(this);
+    Object.defineProperty(this, "__accessor__", { enumerable: false, value: t11 }), r9.length > 0 && this.normalizeCtorArgs && (t11.ctorArgs = this.normalizeCtorArgs.apply(this, r9)), o5()?.onInstanceConstruct(this);
+  }
+  postscript(r9) {
+    const t11 = this.__accessor__, e9 = t11.ctorArgs || r9;
+    t11.initialize(), e9 && (this.set(e9), t11.ctorArgs = null), t11.constructed(), this.initialize(), this[g4] = true;
+  }
+  initialize() {
+  }
+  [o3]() {
+    this[v3] = u(this[v3]);
+  }
+  destroy() {
+    this.destroyed || (j2(this), this.__accessor__.destroy(), o5()?.onInstanceDestroy(this));
+  }
+  [Symbol.dispose]() {
+    this.destroy();
+  }
+  get constructed() {
+    return this.__accessor__ && this.__accessor__.initialized || false;
+  }
+  get initialized() {
+    return this[g4];
+  }
+  get destroyed() {
+    return this.__accessor__?.lifecycle === I.DESTROYED || false;
+  }
+  commitProperty(r9) {
+    o2$1(this, r9);
+  }
+  get(t11) {
+    return i2(n2$1.getLogger(this), "`Accessor.get` is deprecated in favor of using optional chaining", { version: "4.28", see: "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Optional_chaining" }), o2$1(this, t11);
+  }
+  hasOwnProperty(r9) {
+    return this.__accessor__ ? this.__accessor__.has(r9) : Object.prototype.hasOwnProperty.call(this, r9);
+  }
+  keys() {
+    return this.__accessor__ ? this.__accessor__.keys() : [];
+  }
+  set(r9, t11) {
+    return t2(this, r9, t11), this;
+  }
+  watch(r9, t11, e9) {
+    return b(this, r9, t11, e9);
+  }
+  addHandles(r9, e9) {
+    if (this.destroyed) {
+      const t11 = Array.isArray(r9) ? r9 : [r9];
+      for (const r10 of t11)
+        r10.remove();
+      return;
+    }
+    let s6 = this[v3];
+    null == s6 && (s6 = this[v3] = new r()), s6.add(r9, e9);
+  }
+  removeHandles(r9) {
+    const t11 = this[v3];
+    null != t11 && t11.remove(r9);
+  }
+  removeAllHandles() {
+    const r9 = this[v3];
+    null != r9 && r9.removeAll();
+  }
+  hasHandles(r9) {
+    const t11 = this[v3];
+    return null != t11 && t11.has(r9);
+  }
+  _override(r9, t11) {
+    void 0 === t11 ? this.__accessor__.clearOverride(r9) : this.__accessor__.override(r9, t11);
+  }
+  _clearOverride(r9) {
+    return this.__accessor__.clearOverride(r9);
+  }
+  _overrideIfSome(r9, t11) {
+    null == t11 ? this.__accessor__.clearOverride(r9) : this.__accessor__.override(r9, t11);
+  }
+  _isOverridden(r9) {
+    return this.__accessor__.isOverridden(r9);
+  }
+  notifyChange(r9) {
+    this.__accessor__.notifyChange(r9);
+  }
+  _get(r9) {
+    return this.__accessor__.internalGet(r9);
+  }
+  _set(r9, t11) {
+    return this.__accessor__.internalSet(r9, t11), this;
+  }
+};
+y3 = v3, m4 = g4;
+
+export default S2;