(self.webpackChunkRemoteClient = self.webpackChunkRemoteClient || []).push([
  [1503],
  {
    76996: (e, t, s) => {
      'use strict';
      s.d(t, { E: () => a });
      var r = s(29768),
        i = s(21972),
        n = s(22723),
        o = s(17533);
      class h {
        constructor() {
          this._emitter = new h.EventEmitter(this);
        }
        emit(e, t) {
          return this._emitter.emit(e, t);
        }
        on(e, t) {
          return this._emitter.on(e, t);
        }
        once(e, t) {
          return this._emitter.once(e, t);
        }
        hasEventListener(e) {
          return this._emitter.hasEventListener(e);
        }
      }
      !(function (e) {
        class t {
          constructor(e = null) {
            (this.target = e), (this._listenersMap = null);
          }
          clear() {
            this._listenersMap && this._listenersMap.clear();
          }
          emit(e, t) {
            const s = this._listenersMap && this._listenersMap.get(e);
            if (!s) return !1;
            const r = this.target || this;
            return (
              [...s].forEach((e) => {
                e.call(r, t);
              }),
              s.length > 0
            );
          }
          on(e, t) {
            if (Array.isArray(e)) {
              const s = e.map((e) => this.on(e, t));
              return (0, n.h)(s);
            }
            if (e.indexOf(',') > -1)
              throw new TypeError(
                'Evented.on() with a comma delimited string of event types is not supported',
              );
            this._listenersMap || (this._listenersMap = new Map());
            const s = this._listenersMap.get(e) || [];
            return (
              s.push(t),
              this._listenersMap.set(e, s),
              {
                remove: () => {
                  const s = (this._listenersMap && this._listenersMap.get(e)) || [],
                    r = s.indexOf(t);
                  r >= 0 && s.splice(r, 1);
                },
              }
            );
          }
          once(e, t) {
            const s = this.on(e, (e) => {
              s.remove(), t.call(null, e);
            });
            return s;
          }
          hasEventListener(e) {
            const t = this._listenersMap && this._listenersMap.get(e);
            return null != t && t.length > 0;
          }
        }
        (e.EventEmitter = t),
          (e.EventedMixin = (e) => {
            let s = class extends e {
              constructor() {
                super(...arguments), (this._emitter = new t());
              }
              destroy() {
                this._emitter.clear();
              }
              emit(e, t) {
                return this._emitter.emit(e, t);
              }
              on(e, t) {
                return this._emitter.on(e, t);
              }
              once(e, t) {
                return this._emitter.once(e, t);
              }
              hasEventListener(e) {
                return this._emitter.hasEventListener(e);
              }
            };
            return (s = (0, r._)([(0, o.j)('esri.core.Evented')], s)), s;
          });
        let s = class extends i.Z {
          constructor() {
            super(...arguments), (this._emitter = new h.EventEmitter(this));
          }
          emit(e, t) {
            return this._emitter.emit(e, t);
          }
          on(e, t) {
            return this._emitter.on(e, t);
          }
          once(e, t) {
            return this._emitter.once(e, t);
          }
          hasEventListener(e) {
            return this._emitter.hasEventListener(e);
          }
        };
        (s = (0, r._)([(0, o.j)('esri.core.Evented')], s)), (e.EventedAccessor = s);
      })(h || (h = {}));
      var a = h;
    },
    20543: (e, t, s) => {
      'use strict';
      s.d(t, { E: () => c, a: () => l });
      var r = s(29768),
        i = s(21972),
        n = s(76506),
        o = s(50406),
        h = s(17533);
      class a {
        constructor(e) {
          (this.instance = e),
            (this._resolver = (0, o.dD)()),
            (this._status = 0),
            (this._resolvingPromises = []),
            this._resolver.promise.then(
              () => {
                (this._status = 1), this._cleanUp();
              },
              () => {
                (this._status = 2), this._cleanUp();
              },
            );
        }
        addResolvingPromise(e) {
          this._resolvingPromises.push(e), this._tryResolve();
        }
        isResolved() {
          return 1 === this._status;
        }
        isRejected() {
          return 2 === this._status;
        }
        isFulfilled() {
          return 0 !== this._status;
        }
        abort() {
          this._resolver.reject((0, o.zE)());
        }
        when(e, t) {
          return this._resolver.promise.then(e, t);
        }
        _cleanUp() {
          this._allPromise = this._resolvingPromises = this._allPromise = null;
        }
        _tryResolve() {
          if (this.isFulfilled()) return;
          const e = (0, o.dD)(),
            t = [...this._resolvingPromises, (0, n.a)(e.promise)],
            s = (this._allPromise = Promise.all(t));
          s.then(
            () => {
              this.isFulfilled() || this._allPromise !== s || this._resolver.resolve(this.instance);
            },
            (e) => {
              this.isFulfilled() ||
                this._allPromise !== s ||
                (0, o.D_)(e) ||
                this._resolver.reject(e);
            },
          ),
            e.resolve();
        }
      }
      const l = (e) => {
        let t = class extends e {
          constructor(...e) {
            super(...e),
              (this._promiseProps = new a(this)),
              this.addResolvingPromise(Promise.resolve());
          }
          isResolved() {
            return this._promiseProps.isResolved();
          }
          isRejected() {
            return this._promiseProps.isRejected();
          }
          isFulfilled() {
            return this._promiseProps.isFulfilled();
          }
          when(e, t) {
            return new Promise((e, t) => {
              this._promiseProps.when(e, t);
            }).then(e, t);
          }
          catch(e) {
            return this.when(null, e);
          }
          addResolvingPromise(e) {
            e &&
              !this._promiseProps.isFulfilled() &&
              this._promiseProps.addResolvingPromise('_promiseProps' in e ? e.when() : e);
          }
        };
        return (t = (0, r._)([(0, h.j)('esri.core.Promise')], t)), t;
      };
      let c = class extends l(i.Z) {};
      c = (0, r._)([(0, h.j)('esri.core.Promise')], c);
    },
    73173: (e, t, s) => {
      'use strict';
      s.d(t, { g: () => a });
      var r = s(31450),
        i = (s(82058), s(60991)),
        n = s(92143),
        o = s(32101);
      const h = n.L.getLogger('esri.assets');
      function a(e) {
        if (!r.Z.assetsPath)
          throw (
            (h.errorOnce(
              'The API assets location needs to be set using config.assetsPath. More information: https://arcg.is/1OzLe50',
            ),
            new i.Z('assets:path-not-set', 'config.assetsPath is not set'))
          );
        return (0, o.v_)(r.Z.assetsPath, e);
      }
    },
    33921: (e, t, s) => {
      'use strict';
      s.d(t, { a: () => v, b: () => L, c: () => p, f: () => C });
      var r = s(57251),
        i = s(3482),
        n = s(76506);
      const o = { year: 'numeric', month: 'numeric', day: 'numeric' },
        h = { year: 'numeric', month: 'long', day: 'numeric' },
        a = { year: 'numeric', month: 'short', day: 'numeric' },
        l = { year: 'numeric', month: 'long', weekday: 'long', day: 'numeric' },
        c = { hour: 'numeric', minute: 'numeric' },
        u = { ...c, second: 'numeric' },
        m = {
          'short-date': o,
          'short-date-short-time': { ...o, ...c },
          'short-date-short-time-24': { ...o, ...c, hour12: !1 },
          'short-date-long-time': { ...o, ...u },
          'short-date-long-time-24': { ...o, ...u, hour12: !1 },
          'short-date-le': o,
          'short-date-le-short-time': { ...o, ...c },
          'short-date-le-short-time-24': { ...o, ...c, hour12: !1 },
          'short-date-le-long-time': { ...o, ...u },
          'short-date-le-long-time-24': { ...o, ...u, hour12: !1 },
          'long-month-day-year': h,
          'long-month-day-year-short-time': { ...h, ...c },
          'long-month-day-year-short-time-24': { ...h, ...c, hour12: !1 },
          'long-month-day-year-long-time': { ...h, ...u },
          'long-month-day-year-long-time-24': { ...h, ...u, hour12: !1 },
          'day-short-month-year': a,
          'day-short-month-year-short-time': { ...a, ...c },
          'day-short-month-year-short-time-24': { ...a, ...c, hour12: !1 },
          'day-short-month-year-long-time': { ...a, ...u },
          'day-short-month-year-long-time-24': { ...a, ...u, hour12: !1 },
          'long-date': l,
          'long-date-short-time': { ...l, ...c },
          'long-date-short-time-24': { ...l, ...c, hour12: !1 },
          'long-date-long-time': { ...l, ...u },
          'long-date-long-time-24': { ...l, ...u, hour12: !1 },
          'long-month-year': { month: 'long', year: 'numeric' },
          'short-month-year': { month: 'short', year: 'numeric' },
          year: { year: 'numeric' },
          'short-time': c,
          'long-time': u,
        },
        d = (0, r.s)()({
          shortDate: 'short-date',
          shortDateShortTime: 'short-date-short-time',
          shortDateShortTime24: 'short-date-short-time-24',
          shortDateLongTime: 'short-date-long-time',
          shortDateLongTime24: 'short-date-long-time-24',
          shortDateLE: 'short-date-le',
          shortDateLEShortTime: 'short-date-le-short-time',
          shortDateLEShortTime24: 'short-date-le-short-time-24',
          shortDateLELongTime: 'short-date-le-long-time',
          shortDateLELongTime24: 'short-date-le-long-time-24',
          longMonthDayYear: 'long-month-day-year',
          longMonthDayYearShortTime: 'long-month-day-year-short-time',
          longMonthDayYearShortTime24: 'long-month-day-year-short-time-24',
          longMonthDayYearLongTime: 'long-month-day-year-long-time',
          longMonthDayYearLongTime24: 'long-month-day-year-long-time-24',
          dayShortMonthYear: 'day-short-month-year',
          dayShortMonthYearShortTime: 'day-short-month-year-short-time',
          dayShortMonthYearShortTime24: 'day-short-month-year-short-time-24',
          dayShortMonthYearLongTime: 'day-short-month-year-long-time',
          dayShortMonthYearLongTime24: 'day-short-month-year-long-time-24',
          longDate: 'long-date',
          longDateShortTime: 'long-date-short-time',
          longDateShortTime24: 'long-date-short-time-24',
          longDateLongTime: 'long-date-long-time',
          longDateLongTime24: 'long-date-long-time-24',
          longMonthYear: 'long-month-year',
          shortMonthYear: 'short-month-year',
          year: 'year',
        });
      d.toJSON.bind(d), d.fromJSON.bind(d);
      const f = { ar: 'ar-u-nu-latn-ca-gregory' };
      let g = new WeakMap(),
        _ = m['short-date-short-time'];
      function p(e) {
        return m[e] || null;
      }
      function v(e, t) {
        return (function (e) {
          const t = e || _;
          if (!g.has(t)) {
            const e = (0, i.g)(),
              s = f[(0, i.g)()] || e;
            g.set(t, new Intl.DateTimeFormat(s, t));
          }
          return g.get(t);
        })(t).format(e);
      }
      (0, i.b)(() => {
        (g = new WeakMap()), (_ = m['short-date-short-time']);
      });
      const b = { ar: 'ar-u-nu-latn' };
      let y = new WeakMap(),
        w = {};
      function L(e = {}) {
        const t = {};
        return (
          null != e.digitSeparator && (t.useGrouping = e.digitSeparator),
          null != e.places && (t.minimumFractionDigits = t.maximumFractionDigits = e.places),
          t
        );
      }
      function C(e, t) {
        return (function (e) {
          const t = e || w;
          if (!y.has(t)) {
            const s = (0, i.g)(),
              r = b[(0, i.g)()] || s;
            y.set(t, new Intl.NumberFormat(r, e));
          }
          return (0, n.a)(y.get(t));
        })(t).format(e);
      }
      (0, i.b)(() => {
        (y = new WeakMap()), (w = {});
      });
    },
    15324: (e, t, s) => {
      'use strict';
      s.d(t, { Z: () => M });
      var r,
        i = s(29768),
        n = s(91055),
        o = s(76996),
        h = s(76506),
        a = s(6906),
        l = s(91306),
        c = s(17533),
        u = s(34250),
        m = s(21972);
      s(22723),
        s(27794),
        s(50406),
        s(60991),
        s(92143),
        s(31450),
        s(71552),
        s(40642),
        s(81172),
        s(86656),
        s(23639);
      class d {
        constructor() {
          this._observers = [];
        }
        observe(e) {
          return (
            this._observers.includes(e) || this._observers.push(e), new m.O(this._observers, e)
          );
        }
        notify() {
          const e = this._observers.slice();
          for (let t = 0; t < e.length; ++t) {
            const s = e[t];
            s.onInvalidated(), s.onCommitted();
          }
        }
      }
      const f = new n.O(
          class {
            constructor() {
              (this.target = null),
                (this.cancellable = !1),
                (this.defaultPrevented = !1),
                (this.item = void 0),
                (this.type = void 0);
            }
            preventDefault() {
              this.cancellable && (this.defaultPrevented = !0);
            }
            reset(e) {
              (this.defaultPrevented = !1), (this.item = e);
            }
          },
          void 0,
          (e) => {
            (e.item = null), (e.target = null), (e.defaultPrevented = !1), (e.cancellable = !1);
          },
        ),
        g = () => {};
      function _(e) {
        return e
          ? e instanceof A
            ? e.toArray()
            : e.length
            ? Array.prototype.slice.apply(e)
            : []
          : [];
      }
      function p(e) {
        if (e && e.length) return e[0];
      }
      function v(e, t, s, r) {
        const i = Math.min(e.length - s, t.length - r);
        let n = 0;
        for (; n < i && e[s + n] === t[r + n]; ) n++;
        return n;
      }
      function b(e, t, s, r) {
        t &&
          t.forEach((t, i, n) => {
            e.push(t), b(e, s.call(r, t, i, n), s, r);
          });
      }
      const y = new Set(),
        w = new Set(),
        L = new Set(),
        C = new Map();
      let E = 0,
        A = (r = class extends o.E.EventedAccessor {
          constructor(e) {
            super(e),
              (this._chgListeners = []),
              (this._notifications = null),
              (this._timer = null),
              (this._observable = new d()),
              (this.length = 0),
              (this._items = []),
              Object.defineProperty(this, 'uid', { value: E++ });
          }
          static isCollection(e) {
            return null != e && e instanceof r;
          }
          normalizeCtorArgs(e) {
            return e ? (Array.isArray(e) || e instanceof r ? { items: e } : e) : {};
          }
          *[Symbol.iterator]() {
            yield* this.items;
          }
          get items() {
            return (0, c.t)(this._observable), this._items;
          }
          set items(e) {
            this._emitBeforeChanges(1) ||
              (this._splice(0, this.length, ..._(e)), this._emitAfterChanges(1));
          }
          hasEventListener(e) {
            return 'change' === e
              ? this._chgListeners.length > 0
              : this._emitter.hasEventListener(e);
          }
          on(e, t) {
            if ('change' === e) {
              const e = this._chgListeners,
                s = { removed: !1, callback: t };
              return (
                e.push(s),
                this._notifications &&
                  this._notifications.push({
                    listeners: e.slice(),
                    items: this._items.slice(),
                    changes: [],
                  }),
                {
                  remove() {
                    (this.remove = g), (s.removed = !0), e.splice(e.indexOf(s), 1);
                  },
                }
              );
            }
            return this._emitter.on(e, t);
          }
          once(e, t) {
            const s = this.on(e, t);
            return {
              remove() {
                s.remove();
              },
            };
          }
          add(e, t) {
            if (((0, c.t)(this._observable), this._emitBeforeChanges(1))) return this;
            const s = this.getNextIndex(null != t ? t : null);
            return this._splice(s, 0, e), this._emitAfterChanges(1), this;
          }
          addMany(e, t = this._items.length) {
            if (((0, c.t)(this._observable), !e || !e.length)) return this;
            if (this._emitBeforeChanges(1)) return this;
            const s = this.getNextIndex(t);
            return this._splice(s, 0, ..._(e)), this._emitAfterChanges(1), this;
          }
          removeAll() {
            if (((0, c.t)(this._observable), !this.length || this._emitBeforeChanges(2))) return [];
            const e = this._splice(0, this.length) || [];
            return this._emitAfterChanges(2), e;
          }
          clone() {
            return (
              (0, c.t)(this._observable), this._createNewInstance({ items: this._items.map(h.d9) })
            );
          }
          concat(...e) {
            (0, c.t)(this._observable);
            const t = e.map(_);
            return this._createNewInstance({ items: this._items.concat(...t) });
          }
          drain(e, t) {
            if (((0, c.t)(this._observable), !this.length || this._emitBeforeChanges(2))) return;
            const s = (0, h.a)(this._splice(0, this.length)),
              r = s.length;
            for (let i = 0; i < r; i++) e.call(t, s[i], i, s);
            this._emitAfterChanges(2);
          }
          every(e, t) {
            return (0, c.t)(this._observable), this._items.every(e, t);
          }
          filter(e, t) {
            let s;
            return (
              (0, c.t)(this._observable),
              (s = 2 === arguments.length ? this._items.filter(e, t) : this._items.filter(e)),
              this._createNewInstance({ items: s })
            );
          }
          find(e, t) {
            return (0, c.t)(this._observable), this._items.find(e, t);
          }
          findIndex(e, t) {
            return (0, c.t)(this._observable), this._items.findIndex(e, t);
          }
          flatten(e, t) {
            (0, c.t)(this._observable);
            const s = [];
            return b(s, this, e, t), new r(s);
          }
          forEach(e, t) {
            return (0, c.t)(this._observable), this._items.forEach(e, t);
          }
          getItemAt(e) {
            return (0, c.t)(this._observable), this._items[e];
          }
          getNextIndex(e) {
            (0, c.t)(this._observable);
            const t = this.length;
            return (e = null == e ? t : e) < 0 ? (e = 0) : e > t && (e = t), e;
          }
          includes(e, t = 0) {
            return (0, c.t)(this._observable), this._items.includes(e, t);
          }
          indexOf(e, t = 0) {
            return (0, c.t)(this._observable), this._items.indexOf(e, t);
          }
          join(e = ',') {
            return (0, c.t)(this._observable), this._items.join(e);
          }
          lastIndexOf(e, t = this.length - 1) {
            return (0, c.t)(this._observable), this._items.lastIndexOf(e, t);
          }
          map(e, t) {
            (0, c.t)(this._observable);
            const s = this._items.map(e, t);
            return new r({ items: s });
          }
          reorder(e, t = this.length - 1) {
            (0, c.t)(this._observable);
            const s = this.indexOf(e);
            if (-1 !== s) {
              if ((t < 0 ? (t = 0) : t >= this.length && (t = this.length - 1), s !== t)) {
                if (this._emitBeforeChanges(4)) return e;
                this._splice(s, 1), this._splice(t, 0, e), this._emitAfterChanges(4);
              }
              return e;
            }
          }
          pop() {
            if (((0, c.t)(this._observable), !this.length || this._emitBeforeChanges(2))) return;
            const e = p(this._splice(this.length - 1, 1));
            return this._emitAfterChanges(2), e;
          }
          push(...e) {
            return (
              (0, c.t)(this._observable),
              this._emitBeforeChanges(1) ||
                (this._splice(this.length, 0, ...e), this._emitAfterChanges(1)),
              this.length
            );
          }
          reduce(e, t) {
            (0, c.t)(this._observable);
            const s = this._items;
            return 2 === arguments.length ? s.reduce(e, t) : s.reduce(e);
          }
          reduceRight(e, t) {
            (0, c.t)(this._observable);
            const s = this._items;
            return 2 === arguments.length ? s.reduceRight(e, t) : s.reduceRight(e);
          }
          remove(e) {
            return (0, c.t)(this._observable), this.removeAt(this.indexOf(e));
          }
          removeAt(e) {
            if (
              ((0, c.t)(this._observable), e < 0 || e >= this.length || this._emitBeforeChanges(2))
            )
              return;
            const t = p(this._splice(e, 1));
            return this._emitAfterChanges(2), t;
          }
          removeMany(e) {
            if (((0, c.t)(this._observable), !e || !e.length || this._emitBeforeChanges(2)))
              return [];
            const t = e instanceof r ? e.toArray() : e,
              s = this._items,
              i = [],
              n = t.length;
            for (let e = 0; e < n; e++) {
              const r = t[e],
                n = s.indexOf(r);
              if (n > -1) {
                const r = 1 + v(t, s, e + 1, n + 1),
                  o = this._splice(n, r);
                o && o.length > 0 && i.push.apply(i, o), (e += r - 1);
              }
            }
            return this._emitAfterChanges(2), i;
          }
          reverse() {
            if (((0, c.t)(this._observable), this._emitBeforeChanges(4))) return this;
            const e = this._splice(0, this.length);
            return e && (e.reverse(), this._splice(0, 0, ...e)), this._emitAfterChanges(4), this;
          }
          shift() {
            if (((0, c.t)(this._observable), !this.length || this._emitBeforeChanges(2))) return;
            const e = p(this._splice(0, 1));
            return this._emitAfterChanges(2), e;
          }
          slice(e = 0, t = this.length) {
            return (
              (0, c.t)(this._observable),
              this._createNewInstance({ items: this._items.slice(e, t) })
            );
          }
          some(e, t) {
            return (0, c.t)(this._observable), this._items.some(e, t);
          }
          sort(e) {
            if (((0, c.t)(this._observable), !this.length || this._emitBeforeChanges(4)))
              return this;
            const t = (0, h.a)(this._splice(0, this.length));
            return (
              arguments.length ? t.sort(e) : t.sort(),
              this._splice(0, 0, ...t),
              this._emitAfterChanges(4),
              this
            );
          }
          splice(e, t, ...s) {
            (0, c.t)(this._observable);
            const r = (t ? 2 : 0) | (s.length ? 1 : 0);
            if (this._emitBeforeChanges(r)) return [];
            const i = this._splice(e, t, ...s) || [];
            return this._emitAfterChanges(r), i;
          }
          toArray() {
            return (0, c.t)(this._observable), this._items.slice();
          }
          toJSON() {
            return (0, c.t)(this._observable), this.toArray();
          }
          toLocaleString() {
            return (0, c.t)(this._observable), this._items.toLocaleString();
          }
          toString() {
            return (0, c.t)(this._observable), this._items.toString();
          }
          unshift(...e) {
            return (
              (0, c.t)(this._observable),
              !e.length ||
                this._emitBeforeChanges(1) ||
                (this._splice(0, 0, ...e), this._emitAfterChanges(1)),
              this.length
            );
          }
          _createNewInstance(e) {
            return new this.constructor(e);
          }
          _splice(e, t, ...s) {
            const r = this._items,
              i = this.constructor.prototype.itemType;
            let n, o;
            if (
              (!this._notifications &&
                this.hasEventListener('change') &&
                ((this._notifications = [
                  {
                    listeners: this._chgListeners.slice(),
                    items: this._items.slice(),
                    changes: [],
                  },
                ]),
                this._timer && this._timer.remove(),
                (this._timer = (0, a.Os)(() => this._dispatchChange()))),
              t)
            ) {
              if (((o = r.splice(e, t)), this.hasEventListener('before-remove'))) {
                const t = f.acquire();
                (t.target = this), (t.cancellable = !0);
                for (let s = 0, i = o.length; s < i; s++)
                  (n = o[s]),
                    t.reset(n),
                    this.emit('before-remove', t),
                    t.defaultPrevented &&
                      (o.splice(s, 1), r.splice(e, 0, n), (e += 1), (s -= 1), (i -= 1));
                f.release(t);
              }
              if (((this.length = this._items.length), this.hasEventListener('after-remove'))) {
                const e = f.acquire();
                (e.target = this), (e.cancellable = !1);
                const t = o.length;
                for (let s = 0; s < t; s++) e.reset(o[s]), this.emit('after-remove', e);
                f.release(e);
              }
            }
            if (s && s.length) {
              if (i) {
                const e = [];
                for (const t of s) {
                  const s = i.ensureType(t);
                  (null == s && null != t) || e.push(s);
                }
                s = e;
              }
              const t = this.hasEventListener('before-add'),
                n = this.hasEventListener('after-add'),
                o = e === this.length;
              if (t || n) {
                const i = f.acquire();
                (i.target = this), (i.cancellable = !0);
                const h = f.acquire();
                (h.target = this), (h.cancellable = !1);
                for (const a of s)
                  t
                    ? (i.reset(a),
                      this.emit('before-add', i),
                      i.defaultPrevented ||
                        (o ? r.push(a) : r.splice(e++, 0, a),
                        this._set('length', r.length),
                        n && (h.reset(a), this.emit('after-add', h))))
                    : (o ? r.push(a) : r.splice(e++, 0, a),
                      this._set('length', r.length),
                      h.reset(a),
                      this.emit('after-add', h));
                f.release(h), f.release(i);
              } else {
                if (o) for (const e of s) r.push(e);
                else r.splice(e, 0, ...s);
                this._set('length', r.length);
              }
            }
            return ((s && s.length) || (o && o.length)) && this._notifyChangeEvent(s, o), o;
          }
          _emitBeforeChanges(e) {
            let t = !1;
            if (this.hasEventListener('before-changes')) {
              const s = f.acquire();
              (s.target = this),
                (s.cancellable = !0),
                (s.type = e),
                this.emit('before-changes', s),
                (t = s.defaultPrevented),
                f.release(s);
            }
            return t;
          }
          _emitAfterChanges(e) {
            if (this.hasEventListener('after-changes')) {
              const t = f.acquire();
              (t.target = this),
                (t.cancellable = !1),
                (t.type = e),
                this.emit('after-changes', t),
                f.release(t);
            }
            this._observable.notify();
          }
          _notifyChangeEvent(e, t) {
            this.hasEventListener('change') &&
              this._notifications &&
              this._notifications[this._notifications.length - 1].changes.push({
                added: e,
                removed: t,
              });
          }
          _dispatchChange() {
            if ((this._timer && (this._timer.remove(), (this._timer = null)), !this._notifications))
              return;
            const e = this._notifications;
            this._notifications = null;
            for (const t of e) {
              const e = t.changes;
              y.clear(), w.clear(), L.clear();
              for (const { added: t, removed: s } of e) {
                if (t)
                  if (0 === L.size && 0 === w.size) for (const e of t) y.add(e);
                  else for (const e of t) w.has(e) ? (L.add(e), w.delete(e)) : L.has(e) || y.add(e);
                if (s)
                  if (0 === L.size && 0 === y.size) for (const e of s) w.add(e);
                  else for (const e of s) y.has(e) ? y.delete(e) : (L.delete(e), w.add(e));
              }
              const s = n.A.acquire();
              y.forEach((e) => {
                s.push(e);
              });
              const r = n.A.acquire();
              w.forEach((e) => {
                r.push(e);
              });
              const i = this._items,
                o = t.items,
                h = n.A.acquire();
              if (
                (L.forEach((e) => {
                  o.indexOf(e) !== i.indexOf(e) && h.push(e);
                }),
                t.listeners && (s.length || r.length || h.length))
              ) {
                const e = { target: this, added: s, removed: r, moved: h },
                  i = t.listeners.length;
                for (let s = 0; s < i; s++) {
                  const r = t.listeners[s];
                  r.removed || r.callback.call(this, e);
                }
              }
              n.A.release(s), n.A.release(r), n.A.release(h);
            }
            y.clear(), w.clear(), L.clear();
          }
        });
      (A.ofType = (e) => {
        if (!e) return r;
        if (C.has(e)) return C.get(e);
        let t = null;
        if ('function' == typeof e) t = e.prototype.declaredClass;
        else if (e.base) t = e.base.prototype.declaredClass;
        else
          for (const s in e.typeMap) {
            const r = e.typeMap[s].prototype.declaredClass;
            t ? (t += ` | ${r}`) : (t = r);
          }
        let s = class extends r {};
        s = (0, i._)([(0, c.j)(`esri.core.Collection<${t}>`)], s);
        const n = { Type: e, ensureType: 'function' == typeof e ? (0, l.e)(e) : (0, l.a)(e) };
        return Object.defineProperty(s.prototype, 'itemType', { value: n }), C.set(e, s), s;
      }),
        (0, i._)([(0, u.Cb)()], A.prototype, 'length', void 0),
        (0, i._)([(0, u.Cb)()], A.prototype, 'items', null),
        (A = r = (0, i._)([(0, c.j)('esri.core.Collection')], A));
      const M = A;
    },
    66284: (e, t, s) => {
      'use strict';
      s.d(t, { ME: () => w, ng: () => f });
      var r = s(33921),
        i = s(92143),
        n = s(71552),
        o = s(40642),
        h = s(3482),
        a = s(60991),
        l = s(50406),
        c = s(82058),
        u = s(76506),
        m = s(73173);
      s(57251), s(31450), s(81172), s(88762), s(32101);
      const d = i.L.getLogger('esri.intl');
      function f(e, t, s = {}) {
        const { format: i = {} } = s;
        return (0, o.r)(e, (e) =>
          (function (e, t, s) {
            let i, o;
            const h = e.indexOf(':');
            if (
              (-1 === h
                ? (i = e.trim())
                : ((i = e.slice(0, h).trim()), (o = e.slice(h + 1).trim())),
              !i)
            )
              return '';
            const a = (0, n.g)(i, t);
            if (null == a) return '';
            const l = s[o] || s[i];
            return l
              ? (function (e, t) {
                  switch (t.type) {
                    case 'date':
                      return (0, r.a)(e, t.intlOptions);
                    case 'number':
                      return (0, r.f)(e, t.intlOptions);
                    default:
                      return d.warn('missing format descriptor for key {key}'), g(e);
                  }
                })(a, l)
              : o
              ? (function (e, t) {
                  switch (t.toLowerCase()) {
                    case 'dateformat':
                      return (0, r.a)(e);
                    case 'numberformat':
                      return (0, r.f)(e);
                    default:
                      return (
                        d.warn(`inline format is unsupported since 4.12: ${t}`),
                        /^(dateformat|datestring)/i.test(t)
                          ? (0, r.a)(e)
                          : /^numberformat/i.test(t)
                          ? (0, r.f)(e)
                          : g(e)
                      );
                  }
                })(a, o)
              : g(a);
          })(e, t, i),
        );
      }
      function g(e) {
        switch (typeof e) {
          case 'string':
            return e;
          case 'number':
            return (0, r.f)(e);
          case 'boolean':
            return '' + e;
          default:
            return e instanceof Date ? (0, r.a)(e) : '';
        }
      }
      const _ = /^([a-z]{2})(?:[-_]([A-Za-z]{2}))?$/,
        p = {
          ar: !0,
          bs: !0,
          ca: !0,
          cs: !0,
          da: !0,
          de: !0,
          el: !0,
          en: !0,
          es: !0,
          et: !0,
          fi: !0,
          fr: !0,
          he: !0,
          hr: !0,
          hu: !0,
          id: !0,
          it: !0,
          ja: !0,
          ko: !0,
          lt: !0,
          lv: !0,
          nb: !0,
          nl: !0,
          pl: !0,
          'pt-BR': !0,
          'pt-PT': !0,
          ro: !0,
          ru: !0,
          sk: !0,
          sl: !0,
          sr: !0,
          sv: !0,
          th: !0,
          tr: !0,
          uk: !0,
          vi: !0,
          'zh-CN': !0,
          'zh-HK': !0,
          'zh-TW': !0,
        };
      function v(e) {
        var t;
        return null != (t = p[e]) && t;
      }
      const b = [],
        y = new Map();
      async function w(e) {
        const t = (0, h.g)();
        y.has(e) ||
          y.set(
            e,
            (async function (e, t) {
              const s = [];
              for (const r of b)
                if (L(r.pattern, e))
                  try {
                    return await r.fetchMessageBundle(e, t);
                  } catch (e) {
                    s.push(e);
                  }
              if (s.length)
                throw new a.Z('intl:message-bundle-error', `Errors occurred while loading "${e}"`, {
                  errors: s,
                });
              throw new a.Z(
                'intl:no-message-bundle-loader',
                `No loader found for message bundle "${e}"`,
              );
            })(e, t),
          );
        const s = y.get(e);
        return await C.add(s), s;
      }
      function L(e, t) {
        return 'string' == typeof e ? t.startsWith(e) : e.test(t);
      }
      (0, h.b)(() => {
        y.clear();
      });
      const C = new (class {
        constructor() {
          this._numLoading = 0;
        }
        async waitForAll() {
          this._dfd && (await this._dfd.promise);
        }
        add(e) {
          return (
            this._increase(),
            e.then(
              () => this._decrease(),
              () => this._decrease(),
            ),
            this.waitForAll()
          );
        }
        _increase() {
          this._numLoading++, this._dfd || (this._dfd = (0, l.dD)());
        }
        _decrease() {
          (this._numLoading = Math.max(this._numLoading - 1, 0)),
            this._dfd && 0 === this._numLoading && (this._dfd.resolve(), (this._dfd = null));
        }
      })();
      async function E(e) {
        if ((0, u.i)(M.fetchBundleAsset)) return M.fetchBundleAsset(e);
        const t = await (0, c.default)(e, { responseType: 'text' });
        return JSON.parse(t.data);
      }
      class A {
        constructor({ base: e = '', pattern: t, location: s = new URL(window.location.href) }) {
          let r;
          (r =
            'string' == typeof s
              ? (e) => new URL(e, new URL(s, u.g.location)).href
              : s instanceof URL
              ? (e) => new URL(e, s).href
              : s),
            (this.pattern = 'string' == typeof t ? new RegExp(`^${t}`) : t),
            (this.getAssetUrl = r),
            (e = e ? (e.endsWith('/') ? e : e + '/') : ''),
            (this.matcher = new RegExp(`^${e}(?:(.*)/)?(.*)$`));
        }
        fetchMessageBundle(e, t) {
          return (async function (e, t, s, r) {
            const i = t.exec(s);
            if (!i)
              throw new a.Z(
                'esri-intl:invalid-bundle',
                `Bundle id "${s}" is not compatible with the pattern "${t}"`,
              );
            const n = i[1] ? `${i[1]}/` : '',
              o = i[2],
              h = (function (e) {
                if (!_.test(e)) return null;
                const [, t, s] = _.exec(e),
                  r = t + (s ? '-' + s.toUpperCase() : '');
                return v(r) ? r : v(t) ? t : null;
              })(r),
              l = `${n}${o}.json`,
              c = h ? `${n}${o}_${h}.json` : l;
            let u;
            try {
              u = await E(e(c));
            } catch (t) {
              if (c === l)
                throw new a.Z('intl:unknown-bundle', `Bundle "${s}" cannot be loaded`, {
                  error: t,
                });
              try {
                u = await E(e(l));
              } catch (e) {
                throw new a.Z('intl:unknown-bundle', `Bundle "${s}" cannot be loaded`, {
                  error: e,
                });
              }
            }
            return u;
          })(this.getAssetUrl, this.matcher, e, t);
        }
      }
      const M = {};
      var P;
      !(function (e) {
        b.includes(e) ||
          ((function (e) {
            for (const t of y.keys()) L(e.pattern, t) && y.delete(t);
          })(e),
          b.unshift(e));
      })(((P = { pattern: 'esri/', location: m.g }), new A(P)));
    },
  },
]);
