@arcgis/instant-apps-components-react 4.34.0-next.51 → 4.34.0-next.52

package/dist/index.js

@@ -1 +1,2990 @@
-export * from "./components";
+var An = Object.getPrototypeOf;
+var Cn = Reflect.get;
+var It = (s) => {
+  throw TypeError(s);
+};
+var ct = (s, e, t) => e.has(s) || It("Cannot " + t);
+var L = (s, e, t) => (ct(s, e, "read from private field"), t ? t.call(s) : e.get(s)), F = (s, e, t) => e.has(s) ? It("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(s) : e.set(s, t), V = (s, e, t, o) => (ct(s, e, "write to private field"), o ? o.call(s, t) : e.set(s, t), t), ge = (s, e, t) => (ct(s, e, "access private method"), t);
+var Mt = (s, e, t) => Cn(An(s), t, e);
+function On(s) {
+  return s && s.__esModule && Object.prototype.hasOwnProperty.call(s, "default") ? s.default : s;
+}
+var Qe = { exports: {} }, w = {};
+/**
+ * @license React
+ * react.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var jt;
+function Sn() {
+  if (jt) return w;
+  jt = 1;
+  var s = Symbol.for("react.transitional.element"), e = Symbol.for("react.portal"), t = Symbol.for("react.fragment"), o = Symbol.for("react.strict_mode"), r = Symbol.for("react.profiler"), c = Symbol.for("react.consumer"), u = Symbol.for("react.context"), p = Symbol.for("react.forward_ref"), h = Symbol.for("react.suspense"), m = Symbol.for("react.memo"), g = Symbol.for("react.lazy"), _ = Symbol.iterator;
+  function D(i) {
+    return i === null || typeof i != "object" ? null : (i = _ && i[_] || i["@@iterator"], typeof i == "function" ? i : null);
+  }
+  var N = {
+    isMounted: function() {
+      return !1;
+    },
+    enqueueForceUpdate: function() {
+    },
+    enqueueReplaceState: function() {
+    },
+    enqueueSetState: function() {
+    }
+  }, I = Object.assign, Z = {};
+  function q(i, l, E) {
+    this.props = i, this.context = l, this.refs = Z, this.updater = E || N;
+  }
+  q.prototype.isReactComponent = {}, q.prototype.setState = function(i, l) {
+    if (typeof i != "object" && typeof i != "function" && i != null)
+      throw Error(
+        "takes an object of state variables to update or a function which returns an object of state variables."
+      );
+    this.updater.enqueueSetState(this, i, l, "setState");
+  }, q.prototype.forceUpdate = function(i) {
+    this.updater.enqueueForceUpdate(this, i, "forceUpdate");
+  };
+  function pe() {
+  }
+  pe.prototype = q.prototype;
+  function Oe(i, l, E) {
+    this.props = i, this.context = l, this.refs = Z, this.updater = E || N;
+  }
+  var K = Oe.prototype = new pe();
+  K.constructor = Oe, I(K, q.prototype), K.isPureReactComponent = !0;
+  var qe = Array.isArray, k = { H: null, A: null, T: null, S: null, V: null }, Se = Object.prototype.hasOwnProperty;
+  function Re(i, l, E, v, S, M) {
+    return E = M.ref, {
+      $$typeof: s,
+      type: i,
+      key: l,
+      ref: E !== void 0 ? E : null,
+      props: M
+    };
+  }
+  function J(i, l) {
+    return Re(
+      i.type,
+      l,
+      void 0,
+      void 0,
+      void 0,
+      i.props
+    );
+  }
+  function ee(i) {
+    return typeof i == "object" && i !== null && i.$$typeof === s;
+  }
+  function st(i) {
+    var l = { "=": "=0", ":": "=2" };
+    return "$" + i.replace(/[=:]/g, function(E) {
+      return l[E];
+    });
+  }
+  var j = /\/+/g;
+  function Te(i, l) {
+    return typeof i == "object" && i !== null && i.key != null ? st("" + i.key) : l.toString(36);
+  }
+  function se() {
+  }
+  function ie(i) {
+    switch (i.status) {
+      case "fulfilled":
+        return i.value;
+      case "rejected":
+        throw i.reason;
+      default:
+        switch (typeof i.status == "string" ? i.then(se, se) : (i.status = "pending", i.then(
+          function(l) {
+            i.status === "pending" && (i.status = "fulfilled", i.value = l);
+          },
+          function(l) {
+            i.status === "pending" && (i.status = "rejected", i.reason = l);
+          }
+        )), i.status) {
+          case "fulfilled":
+            return i.value;
+          case "rejected":
+            throw i.reason;
+        }
+    }
+    throw i;
+  }
+  function B(i, l, E, v, S) {
+    var M = typeof i;
+    (M === "undefined" || M === "boolean") && (i = null);
+    var $ = !1;
+    if (i === null) $ = !0;
+    else
+      switch (M) {
+        case "bigint":
+        case "string":
+        case "number":
+          $ = !0;
+          break;
+        case "object":
+          switch (i.$$typeof) {
+            case s:
+            case e:
+              $ = !0;
+              break;
+            case g:
+              return $ = i._init, B(
+                $(i._payload),
+                l,
+                E,
+                v,
+                S
+              );
+          }
+      }
+    if ($)
+      return S = S(i), $ = v === "" ? "." + Te(i, 0) : v, qe(S) ? (E = "", $ != null && (E = $.replace(j, "$&/") + "/"), B(S, l, E, "", function(ye) {
+        return ye;
+      })) : S != null && (ee(S) && (S = J(
+        S,
+        E + (S.key == null || i && i.key === S.key ? "" : ("" + S.key).replace(
+          j,
+          "$&/"
+        ) + "/") + $
+      )), l.push(S)), 1;
+    $ = 0;
+    var G = v === "" ? "." : v + ":";
+    if (qe(i))
+      for (var H = 0; H < i.length; H++)
+        v = i[H], M = G + Te(v, H), $ += B(
+          v,
+          l,
+          E,
+          M,
+          S
+        );
+    else if (H = D(i), typeof H == "function")
+      for (i = H.call(i), H = 0; !(v = i.next()).done; )
+        v = v.value, M = G + Te(v, H++), $ += B(
+          v,
+          l,
+          E,
+          M,
+          S
+        );
+    else if (M === "object") {
+      if (typeof i.then == "function")
+        return B(
+          ie(i),
+          l,
+          E,
+          v,
+          S
+        );
+      throw l = String(i), Error(
+        "Objects are not valid as a React child (found: " + (l === "[object Object]" ? "object with keys {" + Object.keys(i).join(", ") + "}" : l) + "). If you meant to render a collection of children, use an array instead."
+      );
+    }
+    return $;
+  }
+  function te(i, l, E) {
+    if (i == null) return i;
+    var v = [], S = 0;
+    return B(i, v, "", "", function(M) {
+      return l.call(E, M, S++);
+    }), v;
+  }
+  function Ne(i) {
+    if (i._status === -1) {
+      var l = i._result;
+      l = l(), l.then(
+        function(E) {
+          (i._status === 0 || i._status === -1) && (i._status = 1, i._result = E);
+        },
+        function(E) {
+          (i._status === 0 || i._status === -1) && (i._status = 2, i._result = E);
+        }
+      ), i._status === -1 && (i._status = 0, i._result = l);
+    }
+    if (i._status === 1) return i._result.default;
+    throw i._result;
+  }
+  var fe = typeof reportError == "function" ? reportError : function(i) {
+    if (typeof window == "object" && typeof window.ErrorEvent == "function") {
+      var l = new window.ErrorEvent("error", {
+        bubbles: !0,
+        cancelable: !0,
+        message: typeof i == "object" && i !== null && typeof i.message == "string" ? String(i.message) : String(i),
+        error: i
+      });
+      if (!window.dispatchEvent(l)) return;
+    } else if (typeof process == "object" && typeof process.emit == "function") {
+      process.emit("uncaughtException", i);
+      return;
+    }
+    console.error(i);
+  };
+  function Ye() {
+  }
+  return w.Children = {
+    map: te,
+    forEach: function(i, l, E) {
+      te(
+        i,
+        function() {
+          l.apply(this, arguments);
+        },
+        E
+      );
+    },
+    count: function(i) {
+      var l = 0;
+      return te(i, function() {
+        l++;
+      }), l;
+    },
+    toArray: function(i) {
+      return te(i, function(l) {
+        return l;
+      }) || [];
+    },
+    only: function(i) {
+      if (!ee(i))
+        throw Error(
+          "React.Children.only expected to receive a single React element child."
+        );
+      return i;
+    }
+  }, w.Component = q, w.Fragment = t, w.Profiler = r, w.PureComponent = Oe, w.StrictMode = o, w.Suspense = h, w.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = k, w.__COMPILER_RUNTIME = {
+    __proto__: null,
+    c: function(i) {
+      return k.H.useMemoCache(i);
+    }
+  }, w.cache = function(i) {
+    return function() {
+      return i.apply(null, arguments);
+    };
+  }, w.cloneElement = function(i, l, E) {
+    if (i == null)
+      throw Error(
+        "The argument must be a React element, but you passed " + i + "."
+      );
+    var v = I({}, i.props), S = i.key, M = void 0;
+    if (l != null)
+      for ($ in l.ref !== void 0 && (M = void 0), l.key !== void 0 && (S = "" + l.key), l)
+        !Se.call(l, $) || $ === "key" || $ === "__self" || $ === "__source" || $ === "ref" && l.ref === void 0 || (v[$] = l[$]);
+    var $ = arguments.length - 2;
+    if ($ === 1) v.children = E;
+    else if (1 < $) {
+      for (var G = Array($), H = 0; H < $; H++)
+        G[H] = arguments[H + 2];
+      v.children = G;
+    }
+    return Re(i.type, S, void 0, void 0, M, v);
+  }, w.createContext = function(i) {
+    return i = {
+      $$typeof: u,
+      _currentValue: i,
+      _currentValue2: i,
+      _threadCount: 0,
+      Provider: null,
+      Consumer: null
+    }, i.Provider = i, i.Consumer = {
+      $$typeof: c,
+      _context: i
+    }, i;
+  }, w.createElement = function(i, l, E) {
+    var v, S = {}, M = null;
+    if (l != null)
+      for (v in l.key !== void 0 && (M = "" + l.key), l)
+        Se.call(l, v) && v !== "key" && v !== "__self" && v !== "__source" && (S[v] = l[v]);
+    var $ = arguments.length - 2;
+    if ($ === 1) S.children = E;
+    else if (1 < $) {
+      for (var G = Array($), H = 0; H < $; H++)
+        G[H] = arguments[H + 2];
+      S.children = G;
+    }
+    if (i && i.defaultProps)
+      for (v in $ = i.defaultProps, $)
+        S[v] === void 0 && (S[v] = $[v]);
+    return Re(i, M, void 0, void 0, null, S);
+  }, w.createRef = function() {
+    return { current: null };
+  }, w.forwardRef = function(i) {
+    return { $$typeof: p, render: i };
+  }, w.isValidElement = ee, w.lazy = function(i) {
+    return {
+      $$typeof: g,
+      _payload: { _status: -1, _result: i },
+      _init: Ne
+    };
+  }, w.memo = function(i, l) {
+    return {
+      $$typeof: m,
+      type: i,
+      compare: l === void 0 ? null : l
+    };
+  }, w.startTransition = function(i) {
+    var l = k.T, E = {};
+    k.T = E;
+    try {
+      var v = i(), S = k.S;
+      S !== null && S(E, v), typeof v == "object" && v !== null && typeof v.then == "function" && v.then(Ye, fe);
+    } catch (M) {
+      fe(M);
+    } finally {
+      k.T = l;
+    }
+  }, w.unstable_useCacheRefresh = function() {
+    return k.H.useCacheRefresh();
+  }, w.use = function(i) {
+    return k.H.use(i);
+  }, w.useActionState = function(i, l, E) {
+    return k.H.useActionState(i, l, E);
+  }, w.useCallback = function(i, l) {
+    return k.H.useCallback(i, l);
+  }, w.useContext = function(i) {
+    return k.H.useContext(i);
+  }, w.useDebugValue = function() {
+  }, w.useDeferredValue = function(i, l) {
+    return k.H.useDeferredValue(i, l);
+  }, w.useEffect = function(i, l, E) {
+    var v = k.H;
+    if (typeof E == "function")
+      throw Error(
+        "useEffect CRUD overload is not enabled in this build of React."
+      );
+    return v.useEffect(i, l);
+  }, w.useId = function() {
+    return k.H.useId();
+  }, w.useImperativeHandle = function(i, l, E) {
+    return k.H.useImperativeHandle(i, l, E);
+  }, w.useInsertionEffect = function(i, l) {
+    return k.H.useInsertionEffect(i, l);
+  }, w.useLayoutEffect = function(i, l) {
+    return k.H.useLayoutEffect(i, l);
+  }, w.useMemo = function(i, l) {
+    return k.H.useMemo(i, l);
+  }, w.useOptimistic = function(i, l) {
+    return k.H.useOptimistic(i, l);
+  }, w.useReducer = function(i, l, E) {
+    return k.H.useReducer(i, l, E);
+  }, w.useRef = function(i) {
+    return k.H.useRef(i);
+  }, w.useState = function(i) {
+    return k.H.useState(i);
+  }, w.useSyncExternalStore = function(i, l, E) {
+    return k.H.useSyncExternalStore(
+      i,
+      l,
+      E
+    );
+  }, w.useTransition = function() {
+    return k.H.useTransition();
+  }, w.version = "19.1.0", w;
+}
+var Pe = { exports: {} };
+/**
+ * @license React
+ * react.development.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+Pe.exports;
+var Ht;
+function Rn() {
+  return Ht || (Ht = 1, function(s, e) {
+    process.env.NODE_ENV !== "production" && function() {
+      function t(n, a) {
+        Object.defineProperty(c.prototype, n, {
+          get: function() {
+            console.warn(
+              "%s(...) is deprecated in plain JavaScript React classes. %s",
+              a[0],
+              a[1]
+            );
+          }
+        });
+      }
+      function o(n) {
+        return n === null || typeof n != "object" ? null : (n = bt && n[bt] || n["@@iterator"], typeof n == "function" ? n : null);
+      }
+      function r(n, a) {
+        n = (n = n.constructor) && (n.displayName || n.name) || "ReactClass";
+        var d = n + "." + a;
+        $t[d] || (console.error(
+          "Can't call %s on a component that is not yet mounted. This is a no-op, but it might indicate a bug in your application. Instead, assign to `this.state` directly or define a `state = {};` class property with the desired state in the %s component.",
+          a,
+          n
+        ), $t[d] = !0);
+      }
+      function c(n, a, d) {
+        this.props = n, this.context = a, this.refs = it, this.updater = d || At;
+      }
+      function u() {
+      }
+      function p(n, a, d) {
+        this.props = n, this.context = a, this.refs = it, this.updater = d || At;
+      }
+      function h(n) {
+        return "" + n;
+      }
+      function m(n) {
+        try {
+          h(n);
+          var a = !1;
+        } catch {
+          a = !0;
+        }
+        if (a) {
+          a = console;
+          var d = a.error, f = typeof Symbol == "function" && Symbol.toStringTag && n[Symbol.toStringTag] || n.constructor.name || "Object";
+          return d.call(
+            a,
+            "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
+            f
+          ), h(n);
+        }
+      }
+      function g(n) {
+        if (n == null) return null;
+        if (typeof n == "function")
+          return n.$$typeof === En ? null : n.displayName || n.name || null;
+        if (typeof n == "string") return n;
+        switch (n) {
+          case i:
+            return "Fragment";
+          case E:
+            return "Profiler";
+          case l:
+            return "StrictMode";
+          case $:
+            return "Suspense";
+          case G:
+            return "SuspenseList";
+          case vn:
+            return "Activity";
+        }
+        if (typeof n == "object")
+          switch (typeof n.tag == "number" && console.error(
+            "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
+          ), n.$$typeof) {
+            case Ye:
+              return "Portal";
+            case S:
+              return (n.displayName || "Context") + ".Provider";
+            case v:
+              return (n._context.displayName || "Context") + ".Consumer";
+            case M:
+              var a = n.render;
+              return n = n.displayName, n || (n = a.displayName || a.name || "", n = n !== "" ? "ForwardRef(" + n + ")" : "ForwardRef"), n;
+            case H:
+              return a = n.displayName || null, a !== null ? a : g(n.type) || "Memo";
+            case ye:
+              a = n._payload, n = n._init;
+              try {
+                return g(n(a));
+              } catch {
+              }
+          }
+        return null;
+      }
+      function _(n) {
+        if (n === i) return "<>";
+        if (typeof n == "object" && n !== null && n.$$typeof === ye)
+          return "<...>";
+        try {
+          var a = g(n);
+          return a ? "<" + a + ">" : "<...>";
+        } catch {
+          return "<...>";
+        }
+      }
+      function D() {
+        var n = C.A;
+        return n === null ? null : n.getOwner();
+      }
+      function N() {
+        return Error("react-stack-top-frame");
+      }
+      function I(n) {
+        if (Be.call(n, "key")) {
+          var a = Object.getOwnPropertyDescriptor(n, "key").get;
+          if (a && a.isReactWarning) return !1;
+        }
+        return n.key !== void 0;
+      }
+      function Z(n, a) {
+        function d() {
+          Rt || (Rt = !0, console.error(
+            "%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)",
+            a
+          ));
+        }
+        d.isReactWarning = !0, Object.defineProperty(n, "key", {
+          get: d,
+          configurable: !0
+        });
+      }
+      function q() {
+        var n = g(this.type);
+        return Nt[n] || (Nt[n] = !0, console.error(
+          "Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."
+        )), n = this.props.ref, n !== void 0 ? n : null;
+      }
+      function pe(n, a, d, f, y, O, b, P) {
+        return d = O.ref, n = {
+          $$typeof: fe,
+          type: n,
+          key: a,
+          props: O,
+          _owner: y
+        }, (d !== void 0 ? d : null) !== null ? Object.defineProperty(n, "ref", {
+          enumerable: !1,
+          get: q
+        }) : Object.defineProperty(n, "ref", { enumerable: !1, value: null }), n._store = {}, Object.defineProperty(n._store, "validated", {
+          configurable: !1,
+          enumerable: !1,
+          writable: !0,
+          value: 0
+        }), Object.defineProperty(n, "_debugInfo", {
+          configurable: !1,
+          enumerable: !1,
+          writable: !0,
+          value: null
+        }), Object.defineProperty(n, "_debugStack", {
+          configurable: !1,
+          enumerable: !1,
+          writable: !0,
+          value: b
+        }), Object.defineProperty(n, "_debugTask", {
+          configurable: !1,
+          enumerable: !1,
+          writable: !0,
+          value: P
+        }), Object.freeze && (Object.freeze(n.props), Object.freeze(n)), n;
+      }
+      function Oe(n, a) {
+        return a = pe(
+          n.type,
+          a,
+          void 0,
+          void 0,
+          n._owner,
+          n.props,
+          n._debugStack,
+          n._debugTask
+        ), n._store && (a._store.validated = n._store.validated), a;
+      }
+      function K(n) {
+        return typeof n == "object" && n !== null && n.$$typeof === fe;
+      }
+      function qe(n) {
+        var a = { "=": "=0", ":": "=2" };
+        return "$" + n.replace(/[=:]/g, function(d) {
+          return a[d];
+        });
+      }
+      function k(n, a) {
+        return typeof n == "object" && n !== null && n.key != null ? (m(n.key), qe("" + n.key)) : a.toString(36);
+      }
+      function Se() {
+      }
+      function Re(n) {
+        switch (n.status) {
+          case "fulfilled":
+            return n.value;
+          case "rejected":
+            throw n.reason;
+          default:
+            switch (typeof n.status == "string" ? n.then(Se, Se) : (n.status = "pending", n.then(
+              function(a) {
+                n.status === "pending" && (n.status = "fulfilled", n.value = a);
+              },
+              function(a) {
+                n.status === "pending" && (n.status = "rejected", n.reason = a);
+              }
+            )), n.status) {
+              case "fulfilled":
+                return n.value;
+              case "rejected":
+                throw n.reason;
+            }
+        }
+        throw n;
+      }
+      function J(n, a, d, f, y) {
+        var O = typeof n;
+        (O === "undefined" || O === "boolean") && (n = null);
+        var b = !1;
+        if (n === null) b = !0;
+        else
+          switch (O) {
+            case "bigint":
+            case "string":
+            case "number":
+              b = !0;
+              break;
+            case "object":
+              switch (n.$$typeof) {
+                case fe:
+                case Ye:
+                  b = !0;
+                  break;
+                case ye:
+                  return b = n._init, J(
+                    b(n._payload),
+                    a,
+                    d,
+                    f,
+                    y
+                  );
+              }
+          }
+        if (b) {
+          b = n, y = y(b);
+          var P = f === "" ? "." + k(b, 0) : f;
+          return Ot(y) ? (d = "", P != null && (d = P.replace(Pt, "$&/") + "/"), J(y, a, d, "", function(ne) {
+            return ne;
+          })) : y != null && (K(y) && (y.key != null && (b && b.key === y.key || m(y.key)), d = Oe(
+            y,
+            d + (y.key == null || b && b.key === y.key ? "" : ("" + y.key).replace(
+              Pt,
+              "$&/"
+            ) + "/") + P
+          ), f !== "" && b != null && K(b) && b.key == null && b._store && !b._store.validated && (d._store.validated = 2), y = d), a.push(y)), 1;
+        }
+        if (b = 0, P = f === "" ? "." : f + ":", Ot(n))
+          for (var A = 0; A < n.length; A++)
+            f = n[A], O = P + k(f, A), b += J(
+              f,
+              a,
+              d,
+              O,
+              y
+            );
+        else if (A = o(n), typeof A == "function")
+          for (A === n.entries && (Lt || console.warn(
+            "Using Maps as children is not supported. Use an array of keyed ReactElements instead."
+          ), Lt = !0), n = A.call(n), A = 0; !(f = n.next()).done; )
+            f = f.value, O = P + k(f, A++), b += J(
+              f,
+              a,
+              d,
+              O,
+              y
+            );
+        else if (O === "object") {
+          if (typeof n.then == "function")
+            return J(
+              Re(n),
+              a,
+              d,
+              f,
+              y
+            );
+          throw a = String(n), Error(
+            "Objects are not valid as a React child (found: " + (a === "[object Object]" ? "object with keys {" + Object.keys(n).join(", ") + "}" : a) + "). If you meant to render a collection of children, use an array instead."
+          );
+        }
+        return b;
+      }
+      function ee(n, a, d) {
+        if (n == null) return n;
+        var f = [], y = 0;
+        return J(n, f, "", "", function(O) {
+          return a.call(d, O, y++);
+        }), f;
+      }
+      function st(n) {
+        if (n._status === -1) {
+          var a = n._result;
+          a = a(), a.then(
+            function(d) {
+              (n._status === 0 || n._status === -1) && (n._status = 1, n._result = d);
+            },
+            function(d) {
+              (n._status === 0 || n._status === -1) && (n._status = 2, n._result = d);
+            }
+          ), n._status === -1 && (n._status = 0, n._result = a);
+        }
+        if (n._status === 1)
+          return a = n._result, a === void 0 && console.error(
+            `lazy: Expected the result of a dynamic import() call. Instead received: %s
+
+Your code should look like: 
+  const MyComponent = lazy(() => import('./MyComponent'))
+
+Did you accidentally put curly braces around the import?`,
+            a
+          ), "default" in a || console.error(
+            `lazy: Expected the result of a dynamic import() call. Instead received: %s
+
+Your code should look like: 
+  const MyComponent = lazy(() => import('./MyComponent'))`,
+            a
+          ), a.default;
+        throw n._result;
+      }
+      function j() {
+        var n = C.H;
+        return n === null && console.error(
+          `Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:
+1. You might have mismatching versions of React and the renderer (such as React DOM)
+2. You might be breaking the Rules of Hooks
+3. You might have more than one copy of React in the same app
+See https://react.dev/link/invalid-hook-call for tips about how to debug and fix this problem.`
+        ), n;
+      }
+      function Te() {
+      }
+      function se(n) {
+        if (Fe === null)
+          try {
+            var a = ("require" + Math.random()).slice(0, 7);
+            Fe = (s && s[a]).call(
+              s,
+              "timers"
+            ).setImmediate;
+          } catch {
+            Fe = function(f) {
+              Dt === !1 && (Dt = !0, typeof MessageChannel > "u" && console.error(
+                "This browser does not have a MessageChannel implementation, so enqueuing tasks via await act(async () => ...) will fail. Please file an issue at https://github.com/facebook/react/issues if you encounter this warning."
+              ));
+              var y = new MessageChannel();
+              y.port1.onmessage = f, y.port2.postMessage(void 0);
+            };
+          }
+        return Fe(n);
+      }
+      function ie(n) {
+        return 1 < n.length && typeof AggregateError == "function" ? new AggregateError(n) : n[0];
+      }
+      function B(n, a) {
+        a !== Ke - 1 && console.error(
+          "You seem to have overlapping act() calls, this is not supported. Be sure to await previous act() calls before making a new one. "
+        ), Ke = a;
+      }
+      function te(n, a, d) {
+        var f = C.actQueue;
+        if (f !== null)
+          if (f.length !== 0)
+            try {
+              Ne(f), se(function() {
+                return te(n, a, d);
+              });
+              return;
+            } catch (y) {
+              C.thrownErrors.push(y);
+            }
+          else C.actQueue = null;
+        0 < C.thrownErrors.length ? (f = ie(C.thrownErrors), C.thrownErrors.length = 0, d(f)) : a(n);
+      }
+      function Ne(n) {
+        if (!at) {
+          at = !0;
+          var a = 0;
+          try {
+            for (; a < n.length; a++) {
+              var d = n[a];
+              do {
+                C.didUsePromise = !1;
+                var f = d(!1);
+                if (f !== null) {
+                  if (C.didUsePromise) {
+                    n[a] = d, n.splice(0, a);
+                    return;
+                  }
+                  d = f;
+                } else break;
+              } while (!0);
+            }
+            n.length = 0;
+          } catch (y) {
+            n.splice(0, a + 1), C.thrownErrors.push(y);
+          } finally {
+            at = !1;
+          }
+        }
+      }
+      typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+      var fe = Symbol.for("react.transitional.element"), Ye = Symbol.for("react.portal"), i = Symbol.for("react.fragment"), l = Symbol.for("react.strict_mode"), E = Symbol.for("react.profiler"), v = Symbol.for("react.consumer"), S = Symbol.for("react.context"), M = Symbol.for("react.forward_ref"), $ = Symbol.for("react.suspense"), G = Symbol.for("react.suspense_list"), H = Symbol.for("react.memo"), ye = Symbol.for("react.lazy"), vn = Symbol.for("react.activity"), bt = Symbol.iterator, $t = {}, At = {
+        isMounted: function() {
+          return !1;
+        },
+        enqueueForceUpdate: function(n) {
+          r(n, "forceUpdate");
+        },
+        enqueueReplaceState: function(n) {
+          r(n, "replaceState");
+        },
+        enqueueSetState: function(n) {
+          r(n, "setState");
+        }
+      }, Ct = Object.assign, it = {};
+      Object.freeze(it), c.prototype.isReactComponent = {}, c.prototype.setState = function(n, a) {
+        if (typeof n != "object" && typeof n != "function" && n != null)
+          throw Error(
+            "takes an object of state variables to update or a function which returns an object of state variables."
+          );
+        this.updater.enqueueSetState(this, n, a, "setState");
+      }, c.prototype.forceUpdate = function(n) {
+        this.updater.enqueueForceUpdate(this, n, "forceUpdate");
+      };
+      var Y = {
+        isMounted: [
+          "isMounted",
+          "Instead, make sure to clean up subscriptions and pending requests in componentWillUnmount to prevent memory leaks."
+        ],
+        replaceState: [
+          "replaceState",
+          "Refactor your code to use setState instead (see https://github.com/facebook/react/issues/3236)."
+        ]
+      }, Ve;
+      for (Ve in Y)
+        Y.hasOwnProperty(Ve) && t(Ve, Y[Ve]);
+      u.prototype = c.prototype, Y = p.prototype = new u(), Y.constructor = p, Ct(Y, c.prototype), Y.isPureReactComponent = !0;
+      var Ot = Array.isArray, En = Symbol.for("react.client.reference"), C = {
+        H: null,
+        A: null,
+        T: null,
+        S: null,
+        V: null,
+        actQueue: null,
+        isBatchingLegacy: !1,
+        didScheduleLegacyUpdate: !1,
+        didUsePromise: !1,
+        thrownErrors: [],
+        getCurrentStack: null,
+        recentlyCreatedOwnerStacks: 0
+      }, Be = Object.prototype.hasOwnProperty, St = console.createTask ? console.createTask : function() {
+        return null;
+      };
+      Y = {
+        "react-stack-bottom-frame": function(n) {
+          return n();
+        }
+      };
+      var Rt, Tt, Nt = {}, _n = Y["react-stack-bottom-frame"].bind(Y, N)(), wn = St(_(N)), Lt = !1, Pt = /\/+/g, kt = typeof reportError == "function" ? reportError : function(n) {
+        if (typeof window == "object" && typeof window.ErrorEvent == "function") {
+          var a = new window.ErrorEvent("error", {
+            bubbles: !0,
+            cancelable: !0,
+            message: typeof n == "object" && n !== null && typeof n.message == "string" ? String(n.message) : String(n),
+            error: n
+          });
+          if (!window.dispatchEvent(a)) return;
+        } else if (typeof process == "object" && typeof process.emit == "function") {
+          process.emit("uncaughtException", n);
+          return;
+        }
+        console.error(n);
+      }, Dt = !1, Fe = null, Ke = 0, Ge = !1, at = !1, Ut = typeof queueMicrotask == "function" ? function(n) {
+        queueMicrotask(function() {
+          return queueMicrotask(n);
+        });
+      } : se;
+      Y = Object.freeze({
+        __proto__: null,
+        c: function(n) {
+          return j().useMemoCache(n);
+        }
+      }), e.Children = {
+        map: ee,
+        forEach: function(n, a, d) {
+          ee(
+            n,
+            function() {
+              a.apply(this, arguments);
+            },
+            d
+          );
+        },
+        count: function(n) {
+          var a = 0;
+          return ee(n, function() {
+            a++;
+          }), a;
+        },
+        toArray: function(n) {
+          return ee(n, function(a) {
+            return a;
+          }) || [];
+        },
+        only: function(n) {
+          if (!K(n))
+            throw Error(
+              "React.Children.only expected to receive a single React element child."
+            );
+          return n;
+        }
+      }, e.Component = c, e.Fragment = i, e.Profiler = E, e.PureComponent = p, e.StrictMode = l, e.Suspense = $, e.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = C, e.__COMPILER_RUNTIME = Y, e.act = function(n) {
+        var a = C.actQueue, d = Ke;
+        Ke++;
+        var f = C.actQueue = a !== null ? a : [], y = !1;
+        try {
+          var O = n();
+        } catch (A) {
+          C.thrownErrors.push(A);
+        }
+        if (0 < C.thrownErrors.length)
+          throw B(a, d), n = ie(C.thrownErrors), C.thrownErrors.length = 0, n;
+        if (O !== null && typeof O == "object" && typeof O.then == "function") {
+          var b = O;
+          return Ut(function() {
+            y || Ge || (Ge = !0, console.error(
+              "You called act(async () => ...) without await. This could lead to unexpected testing behaviour, interleaving multiple act calls and mixing their scopes. You should - await act(async () => ...);"
+            ));
+          }), {
+            then: function(A, ne) {
+              y = !0, b.then(
+                function(me) {
+                  if (B(a, d), d === 0) {
+                    try {
+                      Ne(f), se(function() {
+                        return te(
+                          me,
+                          A,
+                          ne
+                        );
+                      });
+                    } catch ($n) {
+                      C.thrownErrors.push($n);
+                    }
+                    if (0 < C.thrownErrors.length) {
+                      var bn = ie(
+                        C.thrownErrors
+                      );
+                      C.thrownErrors.length = 0, ne(bn);
+                    }
+                  } else A(me);
+                },
+                function(me) {
+                  B(a, d), 0 < C.thrownErrors.length && (me = ie(
+                    C.thrownErrors
+                  ), C.thrownErrors.length = 0), ne(me);
+                }
+              );
+            }
+          };
+        }
+        var P = O;
+        if (B(a, d), d === 0 && (Ne(f), f.length !== 0 && Ut(function() {
+          y || Ge || (Ge = !0, console.error(
+            "A component suspended inside an `act` scope, but the `act` call was not awaited. When testing React components that depend on asynchronous data, you must await the result:\n\nawait act(() => ...)"
+          ));
+        }), C.actQueue = null), 0 < C.thrownErrors.length)
+          throw n = ie(C.thrownErrors), C.thrownErrors.length = 0, n;
+        return {
+          then: function(A, ne) {
+            y = !0, d === 0 ? (C.actQueue = f, se(function() {
+              return te(
+                P,
+                A,
+                ne
+              );
+            })) : A(P);
+          }
+        };
+      }, e.cache = function(n) {
+        return function() {
+          return n.apply(null, arguments);
+        };
+      }, e.captureOwnerStack = function() {
+        var n = C.getCurrentStack;
+        return n === null ? null : n();
+      }, e.cloneElement = function(n, a, d) {
+        if (n == null)
+          throw Error(
+            "The argument must be a React element, but you passed " + n + "."
+          );
+        var f = Ct({}, n.props), y = n.key, O = n._owner;
+        if (a != null) {
+          var b;
+          e: {
+            if (Be.call(a, "ref") && (b = Object.getOwnPropertyDescriptor(
+              a,
+              "ref"
+            ).get) && b.isReactWarning) {
+              b = !1;
+              break e;
+            }
+            b = a.ref !== void 0;
+          }
+          b && (O = D()), I(a) && (m(a.key), y = "" + a.key);
+          for (P in a)
+            !Be.call(a, P) || P === "key" || P === "__self" || P === "__source" || P === "ref" && a.ref === void 0 || (f[P] = a[P]);
+        }
+        var P = arguments.length - 2;
+        if (P === 1) f.children = d;
+        else if (1 < P) {
+          b = Array(P);
+          for (var A = 0; A < P; A++)
+            b[A] = arguments[A + 2];
+          f.children = b;
+        }
+        for (f = pe(
+          n.type,
+          y,
+          void 0,
+          void 0,
+          O,
+          f,
+          n._debugStack,
+          n._debugTask
+        ), y = 2; y < arguments.length; y++)
+          O = arguments[y], K(O) && O._store && (O._store.validated = 1);
+        return f;
+      }, e.createContext = function(n) {
+        return n = {
+          $$typeof: S,
+          _currentValue: n,
+          _currentValue2: n,
+          _threadCount: 0,
+          Provider: null,
+          Consumer: null
+        }, n.Provider = n, n.Consumer = {
+          $$typeof: v,
+          _context: n
+        }, n._currentRenderer = null, n._currentRenderer2 = null, n;
+      }, e.createElement = function(n, a, d) {
+        for (var f = 2; f < arguments.length; f++) {
+          var y = arguments[f];
+          K(y) && y._store && (y._store.validated = 1);
+        }
+        if (f = {}, y = null, a != null)
+          for (A in Tt || !("__self" in a) || "key" in a || (Tt = !0, console.warn(
+            "Your app (or one of its dependencies) is using an outdated JSX transform. Update to the modern JSX transform for faster performance: https://react.dev/link/new-jsx-transform"
+          )), I(a) && (m(a.key), y = "" + a.key), a)
+            Be.call(a, A) && A !== "key" && A !== "__self" && A !== "__source" && (f[A] = a[A]);
+        var O = arguments.length - 2;
+        if (O === 1) f.children = d;
+        else if (1 < O) {
+          for (var b = Array(O), P = 0; P < O; P++)
+            b[P] = arguments[P + 2];
+          Object.freeze && Object.freeze(b), f.children = b;
+        }
+        if (n && n.defaultProps)
+          for (A in O = n.defaultProps, O)
+            f[A] === void 0 && (f[A] = O[A]);
+        y && Z(
+          f,
+          typeof n == "function" ? n.displayName || n.name || "Unknown" : n
+        );
+        var A = 1e4 > C.recentlyCreatedOwnerStacks++;
+        return pe(
+          n,
+          y,
+          void 0,
+          void 0,
+          D(),
+          f,
+          A ? Error("react-stack-top-frame") : _n,
+          A ? St(_(n)) : wn
+        );
+      }, e.createRef = function() {
+        var n = { current: null };
+        return Object.seal(n), n;
+      }, e.forwardRef = function(n) {
+        n != null && n.$$typeof === H ? console.error(
+          "forwardRef requires a render function but received a `memo` component. Instead of forwardRef(memo(...)), use memo(forwardRef(...))."
+        ) : typeof n != "function" ? console.error(
+          "forwardRef requires a render function but was given %s.",
+          n === null ? "null" : typeof n
+        ) : n.length !== 0 && n.length !== 2 && console.error(
+          "forwardRef render functions accept exactly two parameters: props and ref. %s",
+          n.length === 1 ? "Did you forget to use the ref parameter?" : "Any additional parameter will be undefined."
+        ), n != null && n.defaultProps != null && console.error(
+          "forwardRef render functions do not support defaultProps. Did you accidentally pass a React component?"
+        );
+        var a = { $$typeof: M, render: n }, d;
+        return Object.defineProperty(a, "displayName", {
+          enumerable: !1,
+          configurable: !0,
+          get: function() {
+            return d;
+          },
+          set: function(f) {
+            d = f, n.name || n.displayName || (Object.defineProperty(n, "name", { value: f }), n.displayName = f);
+          }
+        }), a;
+      }, e.isValidElement = K, e.lazy = function(n) {
+        return {
+          $$typeof: ye,
+          _payload: { _status: -1, _result: n },
+          _init: st
+        };
+      }, e.memo = function(n, a) {
+        n == null && console.error(
+          "memo: The first argument must be a component. Instead received: %s",
+          n === null ? "null" : typeof n
+        ), a = {
+          $$typeof: H,
+          type: n,
+          compare: a === void 0 ? null : a
+        };
+        var d;
+        return Object.defineProperty(a, "displayName", {
+          enumerable: !1,
+          configurable: !0,
+          get: function() {
+            return d;
+          },
+          set: function(f) {
+            d = f, n.name || n.displayName || (Object.defineProperty(n, "name", { value: f }), n.displayName = f);
+          }
+        }), a;
+      }, e.startTransition = function(n) {
+        var a = C.T, d = {};
+        C.T = d, d._updatedFibers = /* @__PURE__ */ new Set();
+        try {
+          var f = n(), y = C.S;
+          y !== null && y(d, f), typeof f == "object" && f !== null && typeof f.then == "function" && f.then(Te, kt);
+        } catch (O) {
+          kt(O);
+        } finally {
+          a === null && d._updatedFibers && (n = d._updatedFibers.size, d._updatedFibers.clear(), 10 < n && console.warn(
+            "Detected a large number of updates inside startTransition. If this is due to a subscription please re-write it to use React provided hooks. Otherwise concurrent mode guarantees are off the table."
+          )), C.T = a;
+        }
+      }, e.unstable_useCacheRefresh = function() {
+        return j().useCacheRefresh();
+      }, e.use = function(n) {
+        return j().use(n);
+      }, e.useActionState = function(n, a, d) {
+        return j().useActionState(
+          n,
+          a,
+          d
+        );
+      }, e.useCallback = function(n, a) {
+        return j().useCallback(n, a);
+      }, e.useContext = function(n) {
+        var a = j();
+        return n.$$typeof === v && console.error(
+          "Calling useContext(Context.Consumer) is not supported and will cause bugs. Did you mean to call useContext(Context) instead?"
+        ), a.useContext(n);
+      }, e.useDebugValue = function(n, a) {
+        return j().useDebugValue(n, a);
+      }, e.useDeferredValue = function(n, a) {
+        return j().useDeferredValue(n, a);
+      }, e.useEffect = function(n, a, d) {
+        n == null && console.warn(
+          "React Hook useEffect requires an effect callback. Did you forget to pass a callback to the hook?"
+        );
+        var f = j();
+        if (typeof d == "function")
+          throw Error(
+            "useEffect CRUD overload is not enabled in this build of React."
+          );
+        return f.useEffect(n, a);
+      }, e.useId = function() {
+        return j().useId();
+      }, e.useImperativeHandle = function(n, a, d) {
+        return j().useImperativeHandle(n, a, d);
+      }, e.useInsertionEffect = function(n, a) {
+        return n == null && console.warn(
+          "React Hook useInsertionEffect requires an effect callback. Did you forget to pass a callback to the hook?"
+        ), j().useInsertionEffect(n, a);
+      }, e.useLayoutEffect = function(n, a) {
+        return n == null && console.warn(
+          "React Hook useLayoutEffect requires an effect callback. Did you forget to pass a callback to the hook?"
+        ), j().useLayoutEffect(n, a);
+      }, e.useMemo = function(n, a) {
+        return j().useMemo(n, a);
+      }, e.useOptimistic = function(n, a) {
+        return j().useOptimistic(n, a);
+      }, e.useReducer = function(n, a, d) {
+        return j().useReducer(n, a, d);
+      }, e.useRef = function(n) {
+        return j().useRef(n);
+      }, e.useState = function(n) {
+        return j().useState(n);
+      }, e.useSyncExternalStore = function(n, a, d) {
+        return j().useSyncExternalStore(
+          n,
+          a,
+          d
+        );
+      }, e.useTransition = function() {
+        return j().useTransition();
+      }, e.version = "19.1.0", typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+    }();
+  }(Pe, Pe.exports)), Pe.exports;
+}
+var xt;
+function Tn() {
+  return xt || (xt = 1, process.env.NODE_ENV === "production" ? Qe.exports = Sn() : Qe.exports = Rn()), Qe.exports;
+}
+var Nn = Tn();
+const Ln = /* @__PURE__ */ On(Nn);
+/**
+ * @license
+ * Copyright 2018 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+const Pn = /* @__PURE__ */ new Set(["children", "localName", "ref", "style", "className"]), Wt = /* @__PURE__ */ new WeakMap(), zt = (s, e, t, o, r) => {
+  const c = r?.[e];
+  c === void 0 ? (s[e] = t, t == null && e in HTMLElement.prototype && s.removeAttribute(e)) : t !== o && ((u, p, h) => {
+    let m = Wt.get(u);
+    m === void 0 && Wt.set(u, m = /* @__PURE__ */ new Map());
+    let g = m.get(p);
+    h !== void 0 ? g === void 0 ? (m.set(p, g = { handleEvent: h }), u.addEventListener(p, g)) : g.handleEvent = h : g !== void 0 && (m.delete(p), u.removeEventListener(p, g));
+  })(s, c, t);
+}, kn = ({ react: s, tagName: e, elementClass: t, events: o, displayName: r }) => {
+  const c = new Set(Object.keys(o ?? {})), u = s.forwardRef((p, h) => {
+    const m = s.useRef(/* @__PURE__ */ new Map()), g = s.useRef(null), _ = {}, D = {};
+    for (const [N, I] of Object.entries(p)) Pn.has(N) ? _[N === "className" ? "class" : N] = I : c.has(N) || N in t.prototype ? D[N] = I : _[N] = I;
+    return s.useLayoutEffect(() => {
+      if (g.current === null) return;
+      const N = /* @__PURE__ */ new Map();
+      for (const I in D) zt(g.current, I, p[I], m.current.get(I), o), m.current.delete(I), N.set(I, p[I]);
+      for (const [I, Z] of m.current) zt(g.current, I, void 0, Z, o);
+      m.current = N;
+    }), s.useLayoutEffect(() => {
+      g.current?.removeAttribute("defer-hydration");
+    }, []), _.suppressHydrationWarning = !0, s.createElement(e, { ..._, ref: s.useCallback((N) => {
+      g.current = N, typeof h == "function" ? h(N) : h !== null && (h.current = N);
+    }, [h]) });
+  });
+  return u.displayName = r ?? t.name, u;
+};
+class Ie {
+  /**
+   * Creates a new deferred promise.
+   */
+  constructor() {
+    this.promise = new Promise((e, t) => {
+      this.resolve = e, this.reject = t;
+    });
+  }
+}
+const U = () => (
+  /*
+   * `globalThis.` is important here. Some bundlers remove the `typeof process`
+   * checks, but don't remove the usages of undefined variables - this can cause
+   * runtime error. By adding `globalThis.`, we avoid having `typeof process`
+   * check removed by the bundler.
+   * This does meant tree-shaking won't happen for the isEsriInternalEnv()
+   * check, but this is ok since this check is meant to always be behind the
+   * development/test guard.
+   * See https://devtopia.esri.com/WebGIS/arcgis-web-components/pull/2087#issuecomment-5152454
+   */
+  typeof globalThis.process == "object" && !!process.env.ESRI_INTERNAL
+), x = (s, e, ...t) => {
+  try {
+    return s?.call(e, ...t);
+  } catch (o) {
+    console.error(o, s);
+  }
+}, lt = async (s, e, ...t) => {
+  try {
+    return await s?.call(e, ...t);
+  } catch (o) {
+    console.error(o, s);
+  }
+}, Dn = (s) => s.replace(Un, (e, t) => `${t === 0 ? "" : "-"}${e.toLowerCase()}`), Un = /[A-Z]+(?![a-z])|[A-Z]/gu, In = (s, e) => {
+  const t = e / Mn;
+  let o = 0;
+  const r = setInterval(() => {
+    o += t, o >= e && (clearInterval(r), s());
+  }, t);
+  return r;
+}, Mn = 4, ht = Symbol.for("controller"), jn = (s) => typeof s == "object" && s !== null && (ht in s || "hostConnected" in s || "hostDisconnected" in s || "hostUpdate" in s || "hostUpdated" in s);
+let Ee;
+const ke = (s) => {
+  Ee !== s && (Ee = s, queueMicrotask(() => Ee === s ? Ee = void 0 : 0));
+}, nt = (s) => {
+  if (process.env.NODE_ENV !== "production" && Ee === void 0)
+    throw new Error(
+      [
+        `Unable to find out which component ${s || "this"} controller `,
+        `belongs to. Possible causes:
+`,
+        "- You might have multiple versions of ",
+        `@arcgis/lumina package installed
+`,
+        ...U() ? [
+          "- You tried to create controller outside the component. If so, ",
+          "please wrap your controller definition in an arrow function (like",
+          "`const myController = ()=>makeController(...);`) and call that",
+          "function inside the component (`my = myController();`), or ",
+          "define your controller using makeGenericController/GenericController ",
+          `instead.
+`,
+          "- You tried to create a controller inside an async function. ",
+          "This is allowed without calling controller.use(). Make sure you ",
+          "use it like `await controller.use(useController())`."
+        ] : []
+      ].join("")
+    );
+  return Ee;
+};
+let ce = [];
+const Hn = (s) => {
+  if (s === void 0) {
+    ce = [];
+    return;
+  }
+  const e = ce.indexOf(s);
+  ce = e === -1 ? [...ce, s] : ce.slice(0, e + 1), queueMicrotask(() => ce = []);
+}, xn = () => ce;
+let qt;
+const Wn = () => {
+  const s = qt;
+  return qt = void 0, s;
+}, zn = async (s, e) => {
+  const t = pt(s);
+  if (t === void 0) {
+    if (process.env.NODE_ENV !== "production" && U() && typeof e == "function")
+      throw new Error(
+        "Unable to resolve a controller from the provided value, so can't watch it's exports. The value you passed is not a controller and not a controller exports. If your controller exports a literal value, try making your controller export an object instead"
+      );
+    return s;
+  }
+  if (await t.ready, typeof e == "function") {
+    if (process.env.NODE_ENV !== "production" && U() && t.watchExports === void 0)
+      throw new Error("The controller must implement watchExports method to support watching exports");
+    const o = t.watchExports(
+      (r) => e(r, o)
+    );
+  }
+  return t.exports;
+}, qn = async (s) => {
+  const e = pt(s);
+  if (process.env.NODE_ENV !== "production" && U() && e === void 0)
+    throw new Error(
+      "Unable to resolve a controller from the provided value. The value you passed is not a controller and not a controller exports. If your controller exports a literal value, try making your controller export an object instead"
+    );
+  return await e.ready, e;
+}, pt = (s) => {
+  const t = nt().manager.X(s);
+  if (t !== void 0)
+    return t;
+  if (jn(s))
+    return s;
+  const o = Wn();
+  if (o !== void 0)
+    return o;
+};
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+const Xe = globalThis, ft = Xe.ShadowRoot && (Xe.ShadyCSS === void 0 || Xe.ShadyCSS.nativeShadow) && "adoptedStyleSheets" in Document.prototype && "replace" in CSSStyleSheet.prototype, cn = Symbol(), Yt = /* @__PURE__ */ new WeakMap();
+let Yn = class {
+  constructor(e, t, o) {
+    if (this._$cssResult$ = !0, o !== cn) throw Error("CSSResult is not constructable. Use `unsafeCSS` or `css` instead.");
+    this.cssText = e, this.t = t;
+  }
+  get styleSheet() {
+    let e = this.o;
+    const t = this.t;
+    if (ft && e === void 0) {
+      const o = t !== void 0 && t.length === 1;
+      o && (e = Yt.get(t)), e === void 0 && ((this.o = e = new CSSStyleSheet()).replaceSync(this.cssText), o && Yt.set(t, e));
+    }
+    return e;
+  }
+  toString() {
+    return this.cssText;
+  }
+};
+const Vn = (s) => new Yn(typeof s == "string" ? s : s + "", void 0, cn), Bn = (s, e) => {
+  if (ft) s.adoptedStyleSheets = e.map((t) => t instanceof CSSStyleSheet ? t : t.styleSheet);
+  else for (const t of e) {
+    const o = document.createElement("style"), r = Xe.litNonce;
+    r !== void 0 && o.setAttribute("nonce", r), o.textContent = t.cssText, s.appendChild(o);
+  }
+}, Vt = ft ? (s) => s : (s) => s instanceof CSSStyleSheet ? ((e) => {
+  let t = "";
+  for (const o of e.cssRules) t += o.cssText;
+  return Vn(t);
+})(s) : s;
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+const { is: Fn, defineProperty: Kn, getOwnPropertyDescriptor: Gn, getOwnPropertyNames: Qn, getOwnPropertySymbols: Xn, getPrototypeOf: Zn } = Object, ot = globalThis, Bt = ot.trustedTypes, Jn = Bt ? Bt.emptyScript : "", eo = ot.reactiveElementPolyfillSupport, De = (s, e) => s, dt = { toAttribute(s, e) {
+  switch (e) {
+    case Boolean:
+      s = s ? Jn : null;
+      break;
+    case Object:
+    case Array:
+      s = s == null ? s : JSON.stringify(s);
+  }
+  return s;
+}, fromAttribute(s, e) {
+  let t = s;
+  switch (e) {
+    case Boolean:
+      t = s !== null;
+      break;
+    case Number:
+      t = s === null ? null : Number(s);
+      break;
+    case Object:
+    case Array:
+      try {
+        t = JSON.parse(s);
+      } catch {
+        t = null;
+      }
+  }
+  return t;
+} }, yt = (s, e) => !Fn(s, e), Ft = { attribute: !0, type: String, converter: dt, reflect: !1, useDefault: !1, hasChanged: yt };
+Symbol.metadata ??= Symbol("metadata"), ot.litPropertyMetadata ??= /* @__PURE__ */ new WeakMap();
+class ve extends HTMLElement {
+  static addInitializer(e) {
+    this._$Ei(), (this.l ??= []).push(e);
+  }
+  static get observedAttributes() {
+    return this.finalize(), this._$Eh && [...this._$Eh.keys()];
+  }
+  static createProperty(e, t = Ft) {
+    if (t.state && (t.attribute = !1), this._$Ei(), this.prototype.hasOwnProperty(e) && ((t = Object.create(t)).wrapped = !0), this.elementProperties.set(e, t), !t.noAccessor) {
+      const o = Symbol(), r = this.getPropertyDescriptor(e, o, t);
+      r !== void 0 && Kn(this.prototype, e, r);
+    }
+  }
+  static getPropertyDescriptor(e, t, o) {
+    const { get: r, set: c } = Gn(this.prototype, e) ?? { get() {
+      return this[t];
+    }, set(u) {
+      this[t] = u;
+    } };
+    return { get: r, set(u) {
+      const p = r?.call(this);
+      c?.call(this, u), this.requestUpdate(e, p, o);
+    }, configurable: !0, enumerable: !0 };
+  }
+  static getPropertyOptions(e) {
+    return this.elementProperties.get(e) ?? Ft;
+  }
+  static _$Ei() {
+    if (this.hasOwnProperty(De("elementProperties"))) return;
+    const e = Zn(this);
+    e.finalize(), e.l !== void 0 && (this.l = [...e.l]), this.elementProperties = new Map(e.elementProperties);
+  }
+  static finalize() {
+    if (this.hasOwnProperty(De("finalized"))) return;
+    if (this.finalized = !0, this._$Ei(), this.hasOwnProperty(De("properties"))) {
+      const t = this.properties, o = [...Qn(t), ...Xn(t)];
+      for (const r of o) this.createProperty(r, t[r]);
+    }
+    const e = this[Symbol.metadata];
+    if (e !== null) {
+      const t = litPropertyMetadata.get(e);
+      if (t !== void 0) for (const [o, r] of t) this.elementProperties.set(o, r);
+    }
+    this._$Eh = /* @__PURE__ */ new Map();
+    for (const [t, o] of this.elementProperties) {
+      const r = this._$Eu(t, o);
+      r !== void 0 && this._$Eh.set(r, t);
+    }
+    this.elementStyles = this.finalizeStyles(this.styles);
+  }
+  static finalizeStyles(e) {
+    const t = [];
+    if (Array.isArray(e)) {
+      const o = new Set(e.flat(1 / 0).reverse());
+      for (const r of o) t.unshift(Vt(r));
+    } else e !== void 0 && t.push(Vt(e));
+    return t;
+  }
+  static _$Eu(e, t) {
+    const o = t.attribute;
+    return o === !1 ? void 0 : typeof o == "string" ? o : typeof e == "string" ? e.toLowerCase() : void 0;
+  }
+  constructor() {
+    super(), this._$Ep = void 0, this.isUpdatePending = !1, this.hasUpdated = !1, this._$Em = null, this._$Ev();
+  }
+  _$Ev() {
+    this._$ES = new Promise((e) => this.enableUpdating = e), this._$AL = /* @__PURE__ */ new Map(), this._$E_(), this.requestUpdate(), this.constructor.l?.forEach((e) => e(this));
+  }
+  addController(e) {
+    (this._$EO ??= /* @__PURE__ */ new Set()).add(e), this.renderRoot !== void 0 && this.isConnected && e.hostConnected?.();
+  }
+  removeController(e) {
+    this._$EO?.delete(e);
+  }
+  _$E_() {
+    const e = /* @__PURE__ */ new Map(), t = this.constructor.elementProperties;
+    for (const o of t.keys()) this.hasOwnProperty(o) && (e.set(o, this[o]), delete this[o]);
+    e.size > 0 && (this._$Ep = e);
+  }
+  createRenderRoot() {
+    const e = this.shadowRoot ?? this.attachShadow(this.constructor.shadowRootOptions);
+    return Bn(e, this.constructor.elementStyles), e;
+  }
+  connectedCallback() {
+    this.renderRoot ??= this.createRenderRoot(), this.enableUpdating(!0), this._$EO?.forEach((e) => e.hostConnected?.());
+  }
+  enableUpdating(e) {
+  }
+  disconnectedCallback() {
+    this._$EO?.forEach((e) => e.hostDisconnected?.());
+  }
+  attributeChangedCallback(e, t, o) {
+    this._$AK(e, o);
+  }
+  _$ET(e, t) {
+    const o = this.constructor.elementProperties.get(e), r = this.constructor._$Eu(e, o);
+    if (r !== void 0 && o.reflect === !0) {
+      const c = (o.converter?.toAttribute !== void 0 ? o.converter : dt).toAttribute(t, o.type);
+      this._$Em = e, c == null ? this.removeAttribute(r) : this.setAttribute(r, c), this._$Em = null;
+    }
+  }
+  _$AK(e, t) {
+    const o = this.constructor, r = o._$Eh.get(e);
+    if (r !== void 0 && this._$Em !== r) {
+      const c = o.getPropertyOptions(r), u = typeof c.converter == "function" ? { fromAttribute: c.converter } : c.converter?.fromAttribute !== void 0 ? c.converter : dt;
+      this._$Em = r, this[r] = u.fromAttribute(t, c.type) ?? this._$Ej?.get(r) ?? null, this._$Em = null;
+    }
+  }
+  requestUpdate(e, t, o) {
+    if (e !== void 0) {
+      const r = this.constructor, c = this[e];
+      if (o ??= r.getPropertyOptions(e), !((o.hasChanged ?? yt)(c, t) || o.useDefault && o.reflect && c === this._$Ej?.get(e) && !this.hasAttribute(r._$Eu(e, o)))) return;
+      this.C(e, t, o);
+    }
+    this.isUpdatePending === !1 && (this._$ES = this._$EP());
+  }
+  C(e, t, { useDefault: o, reflect: r, wrapped: c }, u) {
+    o && !(this._$Ej ??= /* @__PURE__ */ new Map()).has(e) && (this._$Ej.set(e, u ?? t ?? this[e]), c !== !0 || u !== void 0) || (this._$AL.has(e) || (this.hasUpdated || o || (t = void 0), this._$AL.set(e, t)), r === !0 && this._$Em !== e && (this._$Eq ??= /* @__PURE__ */ new Set()).add(e));
+  }
+  async _$EP() {
+    this.isUpdatePending = !0;
+    try {
+      await this._$ES;
+    } catch (t) {
+      Promise.reject(t);
+    }
+    const e = this.scheduleUpdate();
+    return e != null && await e, !this.isUpdatePending;
+  }
+  scheduleUpdate() {
+    return this.performUpdate();
+  }
+  performUpdate() {
+    if (!this.isUpdatePending) return;
+    if (!this.hasUpdated) {
+      if (this.renderRoot ??= this.createRenderRoot(), this._$Ep) {
+        for (const [r, c] of this._$Ep) this[r] = c;
+        this._$Ep = void 0;
+      }
+      const o = this.constructor.elementProperties;
+      if (o.size > 0) for (const [r, c] of o) {
+        const { wrapped: u } = c, p = this[r];
+        u !== !0 || this._$AL.has(r) || p === void 0 || this.C(r, void 0, c, p);
+      }
+    }
+    let e = !1;
+    const t = this._$AL;
+    try {
+      e = this.shouldUpdate(t), e ? (this.willUpdate(t), this._$EO?.forEach((o) => o.hostUpdate?.()), this.update(t)) : this._$EM();
+    } catch (o) {
+      throw e = !1, this._$EM(), o;
+    }
+    e && this._$AE(t);
+  }
+  willUpdate(e) {
+  }
+  _$AE(e) {
+    this._$EO?.forEach((t) => t.hostUpdated?.()), this.hasUpdated || (this.hasUpdated = !0, this.firstUpdated(e)), this.updated(e);
+  }
+  _$EM() {
+    this._$AL = /* @__PURE__ */ new Map(), this.isUpdatePending = !1;
+  }
+  get updateComplete() {
+    return this.getUpdateComplete();
+  }
+  getUpdateComplete() {
+    return this._$ES;
+  }
+  shouldUpdate(e) {
+    return !0;
+  }
+  update(e) {
+    this._$Eq &&= this._$Eq.forEach((t) => this._$ET(t, this[t])), this._$EM();
+  }
+  updated(e) {
+  }
+  firstUpdated(e) {
+  }
+}
+ve.elementStyles = [], ve.shadowRootOptions = { mode: "open" }, ve[De("elementProperties")] = /* @__PURE__ */ new Map(), ve[De("finalized")] = /* @__PURE__ */ new Map(), eo?.({ ReactiveElement: ve }), (ot.reactiveElementVersions ??= []).push("2.1.0");
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+const mt = globalThis, et = mt.trustedTypes, Kt = et ? et.createPolicy("lit-html", { createHTML: (s) => s }) : void 0, un = "$lit$", oe = `lit$${Math.random().toFixed(9).slice(2)}$`, ln = "?" + oe, to = `<${ln}>`, he = document, Me = () => he.createComment(""), je = (s) => s === null || typeof s != "object" && typeof s != "function", gt = Array.isArray, no = (s) => gt(s) || typeof s?.[Symbol.iterator] == "function", ut = `[ 	
+\f\r]`, Le = /<(?:(!--|\/[^a-zA-Z])|(\/?[a-zA-Z][^>\s]*)|(\/?$))/g, Gt = /-->/g, Qt = />/g, ae = RegExp(`>|${ut}(?:([^\\s"'>=/]+)(${ut}*=${ut}*(?:[^ 	
+\f\r"'\`<>=]|("|')|))|$)`, "g"), Xt = /'/g, Zt = /"/g, dn = /^(?:script|style|textarea|title)$/i, $e = Symbol.for("lit-noChange"), W = Symbol.for("lit-nothing"), Jt = /* @__PURE__ */ new WeakMap(), ue = he.createTreeWalker(he, 129);
+function hn(s, e) {
+  if (!gt(s) || !s.hasOwnProperty("raw")) throw Error("invalid template strings array");
+  return Kt !== void 0 ? Kt.createHTML(e) : e;
+}
+const oo = (s, e) => {
+  const t = s.length - 1, o = [];
+  let r, c = e === 2 ? "<svg>" : e === 3 ? "<math>" : "", u = Le;
+  for (let p = 0; p < t; p++) {
+    const h = s[p];
+    let m, g, _ = -1, D = 0;
+    for (; D < h.length && (u.lastIndex = D, g = u.exec(h), g !== null); ) D = u.lastIndex, u === Le ? g[1] === "!--" ? u = Gt : g[1] !== void 0 ? u = Qt : g[2] !== void 0 ? (dn.test(g[2]) && (r = RegExp("</" + g[2], "g")), u = ae) : g[3] !== void 0 && (u = ae) : u === ae ? g[0] === ">" ? (u = r ?? Le, _ = -1) : g[1] === void 0 ? _ = -2 : (_ = u.lastIndex - g[2].length, m = g[1], u = g[3] === void 0 ? ae : g[3] === '"' ? Zt : Xt) : u === Zt || u === Xt ? u = ae : u === Gt || u === Qt ? u = Le : (u = ae, r = void 0);
+    const N = u === ae && s[p + 1].startsWith("/>") ? " " : "";
+    c += u === Le ? h + to : _ >= 0 ? (o.push(m), h.slice(0, _) + un + h.slice(_) + oe + N) : h + oe + (_ === -2 ? p : N);
+  }
+  return [hn(s, c + (s[t] || "<?>") + (e === 2 ? "</svg>" : e === 3 ? "</math>" : "")), o];
+};
+class He {
+  constructor({ strings: e, _$litType$: t }, o) {
+    let r;
+    this.parts = [];
+    let c = 0, u = 0;
+    const p = e.length - 1, h = this.parts, [m, g] = oo(e, t);
+    if (this.el = He.createElement(m, o), ue.currentNode = this.el.content, t === 2 || t === 3) {
+      const _ = this.el.content.firstChild;
+      _.replaceWith(..._.childNodes);
+    }
+    for (; (r = ue.nextNode()) !== null && h.length < p; ) {
+      if (r.nodeType === 1) {
+        if (r.hasAttributes()) for (const _ of r.getAttributeNames()) if (_.endsWith(un)) {
+          const D = g[u++], N = r.getAttribute(_).split(oe), I = /([.?@])?(.*)/.exec(D);
+          h.push({ type: 1, index: c, name: I[2], strings: N, ctor: I[1] === "." ? so : I[1] === "?" ? io : I[1] === "@" ? ao : rt }), r.removeAttribute(_);
+        } else _.startsWith(oe) && (h.push({ type: 6, index: c }), r.removeAttribute(_));
+        if (dn.test(r.tagName)) {
+          const _ = r.textContent.split(oe), D = _.length - 1;
+          if (D > 0) {
+            r.textContent = et ? et.emptyScript : "";
+            for (let N = 0; N < D; N++) r.append(_[N], Me()), ue.nextNode(), h.push({ type: 2, index: ++c });
+            r.append(_[D], Me());
+          }
+        }
+      } else if (r.nodeType === 8) if (r.data === ln) h.push({ type: 2, index: c });
+      else {
+        let _ = -1;
+        for (; (_ = r.data.indexOf(oe, _ + 1)) !== -1; ) h.push({ type: 7, index: c }), _ += oe.length - 1;
+      }
+      c++;
+    }
+  }
+  static createElement(e, t) {
+    const o = he.createElement("template");
+    return o.innerHTML = e, o;
+  }
+}
+function Ae(s, e, t = s, o) {
+  if (e === $e) return e;
+  let r = o !== void 0 ? t._$Co?.[o] : t._$Cl;
+  const c = je(e) ? void 0 : e._$litDirective$;
+  return r?.constructor !== c && (r?._$AO?.(!1), c === void 0 ? r = void 0 : (r = new c(s), r._$AT(s, t, o)), o !== void 0 ? (t._$Co ??= [])[o] = r : t._$Cl = r), r !== void 0 && (e = Ae(s, r._$AS(s, e.values), r, o)), e;
+}
+class ro {
+  constructor(e, t) {
+    this._$AV = [], this._$AN = void 0, this._$AD = e, this._$AM = t;
+  }
+  get parentNode() {
+    return this._$AM.parentNode;
+  }
+  get _$AU() {
+    return this._$AM._$AU;
+  }
+  u(e) {
+    const { el: { content: t }, parts: o } = this._$AD, r = (e?.creationScope ?? he).importNode(t, !0);
+    ue.currentNode = r;
+    let c = ue.nextNode(), u = 0, p = 0, h = o[0];
+    for (; h !== void 0; ) {
+      if (u === h.index) {
+        let m;
+        h.type === 2 ? m = new ze(c, c.nextSibling, this, e) : h.type === 1 ? m = new h.ctor(c, h.name, h.strings, this, e) : h.type === 6 && (m = new co(c, this, e)), this._$AV.push(m), h = o[++p];
+      }
+      u !== h?.index && (c = ue.nextNode(), u++);
+    }
+    return ue.currentNode = he, r;
+  }
+  p(e) {
+    let t = 0;
+    for (const o of this._$AV) o !== void 0 && (o.strings !== void 0 ? (o._$AI(e, o, t), t += o.strings.length - 2) : o._$AI(e[t])), t++;
+  }
+}
+class ze {
+  get _$AU() {
+    return this._$AM?._$AU ?? this._$Cv;
+  }
+  constructor(e, t, o, r) {
+    this.type = 2, this._$AH = W, this._$AN = void 0, this._$AA = e, this._$AB = t, this._$AM = o, this.options = r, this._$Cv = r?.isConnected ?? !0;
+  }
+  get parentNode() {
+    let e = this._$AA.parentNode;
+    const t = this._$AM;
+    return t !== void 0 && e?.nodeType === 11 && (e = t.parentNode), e;
+  }
+  get startNode() {
+    return this._$AA;
+  }
+  get endNode() {
+    return this._$AB;
+  }
+  _$AI(e, t = this) {
+    e = Ae(this, e, t), je(e) ? e === W || e == null || e === "" ? (this._$AH !== W && this._$AR(), this._$AH = W) : e !== this._$AH && e !== $e && this._(e) : e._$litType$ !== void 0 ? this.$(e) : e.nodeType !== void 0 ? this.T(e) : no(e) ? this.k(e) : this._(e);
+  }
+  O(e) {
+    return this._$AA.parentNode.insertBefore(e, this._$AB);
+  }
+  T(e) {
+    this._$AH !== e && (this._$AR(), this._$AH = this.O(e));
+  }
+  _(e) {
+    this._$AH !== W && je(this._$AH) ? this._$AA.nextSibling.data = e : this.T(he.createTextNode(e)), this._$AH = e;
+  }
+  $(e) {
+    const { values: t, _$litType$: o } = e, r = typeof o == "number" ? this._$AC(e) : (o.el === void 0 && (o.el = He.createElement(hn(o.h, o.h[0]), this.options)), o);
+    if (this._$AH?._$AD === r) this._$AH.p(t);
+    else {
+      const c = new ro(r, this), u = c.u(this.options);
+      c.p(t), this.T(u), this._$AH = c;
+    }
+  }
+  _$AC(e) {
+    let t = Jt.get(e.strings);
+    return t === void 0 && Jt.set(e.strings, t = new He(e)), t;
+  }
+  k(e) {
+    gt(this._$AH) || (this._$AH = [], this._$AR());
+    const t = this._$AH;
+    let o, r = 0;
+    for (const c of e) r === t.length ? t.push(o = new ze(this.O(Me()), this.O(Me()), this, this.options)) : o = t[r], o._$AI(c), r++;
+    r < t.length && (this._$AR(o && o._$AB.nextSibling, r), t.length = r);
+  }
+  _$AR(e = this._$AA.nextSibling, t) {
+    for (this._$AP?.(!1, !0, t); e && e !== this._$AB; ) {
+      const o = e.nextSibling;
+      e.remove(), e = o;
+    }
+  }
+  setConnected(e) {
+    this._$AM === void 0 && (this._$Cv = e, this._$AP?.(e));
+  }
+}
+class rt {
+  get tagName() {
+    return this.element.tagName;
+  }
+  get _$AU() {
+    return this._$AM._$AU;
+  }
+  constructor(e, t, o, r, c) {
+    this.type = 1, this._$AH = W, this._$AN = void 0, this.element = e, this.name = t, this._$AM = r, this.options = c, o.length > 2 || o[0] !== "" || o[1] !== "" ? (this._$AH = Array(o.length - 1).fill(new String()), this.strings = o) : this._$AH = W;
+  }
+  _$AI(e, t = this, o, r) {
+    const c = this.strings;
+    let u = !1;
+    if (c === void 0) e = Ae(this, e, t, 0), u = !je(e) || e !== this._$AH && e !== $e, u && (this._$AH = e);
+    else {
+      const p = e;
+      let h, m;
+      for (e = c[0], h = 0; h < c.length - 1; h++) m = Ae(this, p[o + h], t, h), m === $e && (m = this._$AH[h]), u ||= !je(m) || m !== this._$AH[h], m === W ? e = W : e !== W && (e += (m ?? "") + c[h + 1]), this._$AH[h] = m;
+    }
+    u && !r && this.j(e);
+  }
+  j(e) {
+    e === W ? this.element.removeAttribute(this.name) : this.element.setAttribute(this.name, e ?? "");
+  }
+}
+class so extends rt {
+  constructor() {
+    super(...arguments), this.type = 3;
+  }
+  j(e) {
+    this.element[this.name] = e === W ? void 0 : e;
+  }
+}
+class io extends rt {
+  constructor() {
+    super(...arguments), this.type = 4;
+  }
+  j(e) {
+    this.element.toggleAttribute(this.name, !!e && e !== W);
+  }
+}
+class ao extends rt {
+  constructor(e, t, o, r, c) {
+    super(e, t, o, r, c), this.type = 5;
+  }
+  _$AI(e, t = this) {
+    if ((e = Ae(this, e, t, 0) ?? W) === $e) return;
+    const o = this._$AH, r = e === W && o !== W || e.capture !== o.capture || e.once !== o.once || e.passive !== o.passive, c = e !== W && (o === W || r);
+    r && this.element.removeEventListener(this.name, this, o), c && this.element.addEventListener(this.name, this, e), this._$AH = e;
+  }
+  handleEvent(e) {
+    typeof this._$AH == "function" ? this._$AH.call(this.options?.host ?? this.element, e) : this._$AH.handleEvent(e);
+  }
+}
+class co {
+  constructor(e, t, o) {
+    this.element = e, this.type = 6, this._$AN = void 0, this._$AM = t, this.options = o;
+  }
+  get _$AU() {
+    return this._$AM._$AU;
+  }
+  _$AI(e) {
+    Ae(this, e);
+  }
+}
+const uo = mt.litHtmlPolyfillSupport;
+uo?.(He, ze), (mt.litHtmlVersions ??= []).push("3.3.0");
+const lo = (s, e, t) => {
+  const o = t?.renderBefore ?? e;
+  let r = o._$litPart$;
+  if (r === void 0) {
+    const c = t?.renderBefore ?? null;
+    o._$litPart$ = r = new ze(e.insertBefore(Me(), c), c, void 0, t ?? {});
+  }
+  return r._$AI(s), r;
+};
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+const vt = globalThis;
+class re extends ve {
+  constructor() {
+    super(...arguments), this.renderOptions = { host: this }, this._$Do = void 0;
+  }
+  createRenderRoot() {
+    const e = super.createRenderRoot();
+    return this.renderOptions.renderBefore ??= e.firstChild, e;
+  }
+  update(e) {
+    const t = this.render();
+    this.hasUpdated || (this.renderOptions.isConnected = this.isConnected), super.update(e), this._$Do = lo(t, this.renderRoot, this.renderOptions);
+  }
+  connectedCallback() {
+    super.connectedCallback(), this._$Do?.setConnected(!0);
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback(), this._$Do?.setConnected(!1);
+  }
+  render() {
+    return $e;
+  }
+}
+re._$litElement$ = !0, re.finalized = !0, vt.litElementHydrateSupport?.({ LitElement: re });
+const ho = vt.litElementPolyfillSupport;
+ho?.({ LitElement: re });
+(vt.litElementVersions ??= []).push("4.2.0");
+const po = (s, e, t) => {
+  const o = Object.keys(s), r = o.length;
+  _e === void 0 && queueMicrotask(Et), _e ??= /* @__PURE__ */ new Map();
+  let c = _e.get(s);
+  return c === void 0 && (c = { callbacks: [], keyCount: r }, _e.set(s, c)), c.keyCount !== r && (c.callbacks.forEach((u) => u(o)), c.callbacks = [], c.keyCount = r), c.callbacks.push((u) => {
+    const p = (m) => x(e, null, m), h = u[r];
+    h === void 0 ? p(void 0) : s[h] === t ? p(h) : p(void 0);
+  }), t;
+};
+let _e;
+const Et = () => {
+  _e?.forEach(({ callbacks: s }, e) => {
+    const t = Object.keys(e);
+    s.forEach((o) => o(t));
+  }), _e = void 0;
+}, fo = (s, e, t) => {
+  const o = s.manager;
+  return o.V !== W && o.V !== t && o.S(void 0, void 0), o.T.length === 0 && queueMicrotask(() => o.S(void 0, void 0)), o.V = t, o.T.push((r, c) => x(e, void 0, t === c ? r : void 0)), t;
+}, yo = (s = [
+  nt(),
+  ...xn()
+], e, t) => {
+  const o = Array.isArray(s) ? s : [s];
+  let r = o.length + 1;
+  const c = (u) => {
+    r -= 1, u !== void 0 && (r = Math.min(r, 0)), r === 0 && e(u);
+  };
+  o.forEach(
+    (u) => po(
+      u,
+      (p) => c(p === void 0 ? void 0 : { key: p, host: u, isReactive: !1 }),
+      t
+    )
+  );
+  for (const u of o)
+    if ("manager" in u && u.manager.component === u) {
+      fo(
+        u,
+        (p) => c(p === void 0 ? void 0 : { key: p, host: u, isReactive: !0 }),
+        t
+      );
+      break;
+    }
+  return t;
+}, mo = (s = "", e = {}, t = nt()) => {
+  const o = {
+    emit: (r) => {
+      if (process.env.NODE_ENV !== "production" && U() && !t.el.isConnected && console.warn(`Trying to emit an ${s} event on a disconnected element ${t.el.localName}`), s === "" && (Et(), process.env.NODE_ENV !== "production" && U() && s === ""))
+        throw new Error("Unable to resolve event name from property name");
+      const c = new CustomEvent(s, {
+        detail: r,
+        cancelable: !0,
+        bubbles: !0,
+        composed: !0,
+        ...e
+      });
+      return t.el.dispatchEvent(c), c;
+    }
+  };
+  return s === "" && yo(
+    void 0,
+    process.env.NODE_ENV !== "production" && U() ? (r) => {
+      if (r === void 0)
+        throw new Error("createEvent must be called in property default value only");
+      s = r.key;
+    } : (r) => s = r.key,
+    o
+  ), o;
+};
+mo.bind(null, "");
+var pn;
+pn = ht;
+class go {
+  constructor(e) {
+    this.#n = [], this.#t = [], this.#o = [], this.#c = [], this.#u = [], this.#l = [], this.#d = [], this.#h = [], this.#i = [], this.#a = !1, this.P = new Ie(), this.connectedCalled = !1, this.loadedCalled = !1, this[pn] = !0, this.#s = [];
+    const t = this, o = e ?? nt(new.target.name);
+    t.#e = o, t.ready = t.P.promise, t.#r = tn(t), process.env.NODE_ENV !== "production" ? (Object.defineProperty(this, "component", {
+      writable: !1,
+      enumerable: !1,
+      configurable: !0,
+      value: o
+    }), "hostDestroy" in this && t.#e.manager.devOnly$ensureHasDestroy?.()) : t.component = o, t.#e.addController(t), t.#e.manager === void 0 || (Hn(t), queueMicrotask(() => t.catchUpLifecycle()));
+  }
+  #n;
+  #t;
+  #o;
+  #c;
+  #u;
+  #l;
+  #d;
+  #h;
+  #i;
+  #a;
+  #e;
+  /**
+   * If controller is being added dynamically, after the component
+   * construction, then trigger connected and load right away
+   */
+  catchUpLifecycle() {
+    const { manager: e } = this.#e;
+    e.connectedCalled && !this.connectedCalled && this.triggerConnected(), e.#a && this.triggerLoad().then(
+      () => (
+        // Call loaded ourself, unless manager is going to do it
+        e.loadedCalled && this.triggerLoaded()
+      )
+    ).catch(console.error);
+  }
+  #r;
+  get exports() {
+    return this.#r;
+  }
+  /**
+   * Set controller's exports property (for usage with proxyExports()) and mark
+   * controller as ready (for usage in other controllers). Also, triggers
+   * re-render of the component
+   */
+  set exports(e) {
+    const t = this.#r;
+    t !== e && (this.#r = e, this.#s.forEach(x), this.connectedCalled && this.O !== !1 && this.#e.requestUpdate(this.O, t)), this.P.resolve(e);
+  }
+  setProvisionalExports(e, t = !0) {
+    this.#r = t ? tn(e) : e, this.#s.forEach(x);
+  }
+  #s;
+  watchExports(e) {
+    const t = () => e(this.#r);
+    return this.#s.push(t), () => void this.#s.splice(this.#s.indexOf(t), 1);
+  }
+  /**
+   * A flexible utility for making sure a controller is loaded before it's used,
+   * regardless of how or where a controller was defined:
+   *
+   * @example
+   * makeGenericController(async (component, controller) => {
+   *   // Await some controller from the component:
+   *   await controller.use(component.someController);
+   *   // Initialize new controllers
+   *   await controller.use(load(importCoreReactiveUtils));
+   *   await controller.use(new ViewModelController(component,newWidgetsHomeHomeViewModel));
+   *   await controller.use(someController(component));
+   * });
+   *
+   * @remarks
+   * If your controller is not async, and you are not creating it async, then
+   * you are not required to use controller.use - you can use it directly.
+   * Similarly, accessing controllers after componentWillLoad callback does not
+   * require awaiting them as they are guaranteed to be loaded by then.
+   */
+  get use() {
+    return ke(this.#e), zn;
+  }
+  /**
+   * Just like controller.use, but returns the controller itself, rather than it's
+   * exports
+   *
+   * Use cases:
+   * - You have a controller and you want to make sure it's loaded before you
+   *   try to use it
+   * - Your controller is not using exports, so you wish to access some props on
+   *   it directly
+   * - You have a controller exports only, and you want to retrieve the
+   *   controller itself. This is useful if you wish to call .watchExports() or
+   *   some other method on the controller
+   */
+  get useRef() {
+    return ke(this.#e), qn;
+  }
+  /**
+   * Like useRef, but doesn't wait for the controller to get ready
+   *
+   * @private
+   */
+  get useRefSync() {
+    return ke(this.#e), pt;
+  }
+  controllerRemoved() {
+    this.#e.el.isConnected && this.triggerDisconnected(), this.triggerDestroy();
+  }
+  // Register a lifecycle callback
+  onConnected(e) {
+    this.#n.push(e);
+  }
+  onDisconnected(e) {
+    this.#t.push(e);
+  }
+  onLoad(e) {
+    this.#o.push(e);
+  }
+  onLoaded(e) {
+    this.#c.push(e);
+  }
+  onUpdate(e) {
+    this.#u.push(e);
+  }
+  onUpdated(e) {
+    this.#l.push(e);
+  }
+  onDestroy(e) {
+    process.env.NODE_ENV !== "production" && U() && this.#e.manager.devOnly$ensureHasDestroy?.(), this.#d.push(e);
+  }
+  onLifecycle(e) {
+    this.#h.push(e), this.connectedCalled && this.#e.el.isConnected && this.#p(e);
+  }
+  // Call each lifecycle hook
+  /** @private */
+  triggerConnected() {
+    const e = this;
+    e.hostConnected && x(e.hostConnected, e), e.#n.forEach(x), e.triggerLifecycle(), e.connectedCalled = !0;
+  }
+  /** @private */
+  triggerDisconnected() {
+    const e = this;
+    e.hostDisconnected && x(e.hostDisconnected, e), e.#t.forEach(x), e.#i.forEach(x), e.#i = [];
+  }
+  /** @private */
+  async triggerLoad() {
+    if (this.#a)
+      return;
+    this.#a = !0;
+    const e = this;
+    e.hostLoad && await lt(e.hostLoad, e), this.#o.length > 0 && await Promise.allSettled(this.#o.map(lt)), this.P.resolve(this.#r);
+  }
+  /** @private */
+  triggerLoaded() {
+    this.loadedCalled || (this.hostLoaded && x(this.hostLoaded, this), this.#c.forEach(x), this.loadedCalled = !0);
+  }
+  /** @private */
+  triggerUpdate(e) {
+    this.hostUpdate && x(this.hostUpdate, this, e), this.#u.forEach(en, e);
+  }
+  /** @private */
+  triggerUpdated(e) {
+    this.hostUpdated && x(this.hostUpdated, this, e), this.#l.forEach(en, e);
+  }
+  /** @private */
+  triggerDestroy() {
+    this.hostDestroy && x(this.hostDestroy, this), this.#d.forEach(x);
+  }
+  /** @private */
+  triggerLifecycle() {
+    this.hostLifecycle && this.#p(() => this.hostLifecycle()), this.#h.forEach(this.#p, this);
+  }
+  #p(e) {
+    ke(this.#e);
+    const t = x(e);
+    (Array.isArray(t) ? t : [t]).forEach((r) => {
+      typeof r == "function" ? this.#i.push(r) : typeof r == "object" && typeof r.remove == "function" && this.#i.push(r.remove);
+    });
+  }
+}
+function en(s) {
+  x(s, void 0, this);
+}
+const vo = go, tn = (s) => {
+  if (typeof s != "object" && typeof s != "function" || s === null)
+    return s;
+  const e = {
+    get(o, r, c) {
+      if (!((r === "exports" || r === "_exports") && r in o && o[r] === t)) {
+        if (r in o || r in Promise.prototype || typeof r == "symbol")
+          return typeof o == "function" ? o[r] : Reflect.get(o, r, c);
+        if (process.env.NODE_ENV !== "production" && U()) {
+          if (process.env.NODE_ENV === "test" && (r.startsWith("$$") || r.startsWith("@@") || r === "nodeType" || r === "tagName" || r === "toJSON" || r === "hasAttribute"))
+            return;
+          console.error(
+            `Trying to access "${r.toString()}" on the controller before it's loaded. ${nn}`
+          );
+        }
+      }
+    }
+  };
+  process.env.NODE_ENV !== "production" && U() && (e.set = (o, r, c, u) => (console.error(`Trying to set "${r.toString()}" on the controller before it's loaded. ${nn}`), Reflect.set(o, r, c, u)));
+  const t = new Proxy(s, e);
+  return t;
+}, nn = process.env.NODE_ENV !== "production" && U() ? [
+  "This might be the case if you are trying to access an async controller in ",
+  "connectedCallback(). Or, if you are using it inside of ",
+  "componentWillLoad()/another controller without controller.use. Example correct ",
+  `usage:
+`,
+  "makeController(async (component, controller)=>{ await controller.use(someOtherController); });"
+].join("") : void 0, Eo = 1, _o = 2, wo = 4, bo = 8, $o = 16, Ao = 32, Co = 64;
+function Oo(s) {
+  const e = s.prototype, t = Object.getOwnPropertyDescriptor(e, "innerText");
+  if (t !== void 0 && t.set?.name === "setWrapper")
+    return;
+  const o = /* @__PURE__ */ new Set([
+    // We shouldn't be overwriting this property
+    "constructor",
+    // Called by Lit - we proxy it to this.el in ProxyComponent
+    "setAttribute",
+    // Called by Lit SSR - we proxy it to this.el in ProxyComponent
+    "removeAttribute",
+    // Called by Lit - we proxy it to this.el in ProxyComponent
+    "isConnected",
+    // Called by Lit, but only in dev mode for warnings, so we don't have to proxy.
+    "localName",
+    // Called by Lit Context - we proxy it to this.el in ProxyComponent.
+    // Interestingly, they never call removeEventListener.
+    "addEventListener"
+  ]), r = {
+    addEventListener: "use this.listen() or this.el.addEventListener()"
+  };
+  Object.entries({
+    ...Object.getOwnPropertyDescriptors(HTMLElement.prototype),
+    ...Object.getOwnPropertyDescriptors(Element.prototype),
+    ...Object.getOwnPropertyDescriptors(Node.prototype),
+    ...Object.getOwnPropertyDescriptors(EventTarget.prototype)
+  }).forEach(([c, u]) => {
+    if (o.has(c))
+      return;
+    function p(...h) {
+      if (this !== this.el) {
+        if (c === "hasAttribute" && h[0] === "defer-hydration")
+          return !1;
+        throw new Error(
+          `You should not be trying to access this.${c} directly as it won't work correctly in lazy-builds. Instead, ${r[c] ?? `use this.el.${c}`}`
+        );
+      }
+    }
+    if (typeof u.value == "function")
+      e[c] = function(...m) {
+        return p.call(this, ...m) ?? u.value.call(this, ...m);
+      };
+    else if (typeof u.get == "function")
+      Object.defineProperty(e, c, {
+        get() {
+          return p.call(this), u.get.call(this);
+        },
+        set: typeof u.set == "function" ? function(m) {
+          p.call(this), u.set.call(this, m);
+        } : void 0
+      });
+    else {
+      if (c === c.toUpperCase() && typeof u.value == "number")
+        return;
+      throw new Error(`Unexpected value type for ${c}: ${u}`);
+    }
+  });
+}
+const fn = (s) => {
+  let e = s;
+  for (; e = e.parentNode ?? e.host; )
+    if (e?.constructor?.lumina) {
+      const t = e;
+      return t.manager?.loadedCalled || (t.J ?? t._offspring).push(s), (t.I ?? t._postLoad).promise;
+    }
+  return !1;
+};
+if (process.env.NODE_ENV !== "production") {
+  const s = globalThis;
+  s.litIssuedWarnings ??= /* @__PURE__ */ new Set(), s.litIssuedWarnings.add("dev-mode"), s.litIssuedWarnings.add(
+    "Overriding ReactiveElement.createProperty() is deprecated. The override will not be called with standard decorators See https://lit.dev/msg/no-override-create-property for more information."
+  ), s.litIssuedWarnings.add(
+    "Overriding ReactiveElement.getPropertyDescriptor() is deprecated. The override will not be called with standard decorators See https://lit.dev/msg/no-override-get-property-descriptor for more information."
+  ), U() && (globalThis.calciteConfig ??= { version: " " });
+}
+const on = {};
+function _t() {
+}
+process.env.NODE_ENV !== "production" && U();
+const Ze = Object.defineProperty, So = globalThis.HTMLElement ?? _t;
+var z, Q, we, be, Je;
+const wt = class wt extends So {
+  constructor() {
+    var r;
+    super();
+    F(this, be);
+    F(this, z);
+    F(this, Q);
+    F(this, we);
+    V(this, Q, {}), V(this, we, []), this.I = new Ie(), this.H = new Ie(), this.J = [], process.env.NODE_ENV !== "production" && U() && (this.devOnly$hmrSetProps = /* @__PURE__ */ new Set(), this.devOnly$hmrSetAttributes = /* @__PURE__ */ new Set(), globalThis.devOnly$createdElements ??= [], globalThis.devOnly$createdElements.push(new WeakRef(this)), this.devOnly$InitializeComponent = ge(this, be, Je).bind(this), this.devOnly$hmrResetStore = (c) => {
+      V(this, Q, c);
+    });
+    const t = this, o = t.constructor;
+    t._offspring = t.J, t._postLoad = t.I, o.C?.forEach((c) => {
+      Object.hasOwn(t, c) && (L(t, Q)[c] = t[c], delete t[c]);
+    }), o.A ? ge(r = t, be, Je).call(r, { a: o.A }) : o.B.then(async (c) => {
+      var u;
+      await o.K.p, ge(u = t, be, Je).call(
+        u,
+        /**
+         * "$$" is our top-level await polyfill due to broken top-level await
+         * support in Safari. Only applies in CDN build.
+         * See https://devtopia.esri.com/WebGIS/arcgis-web-components/issues/3933
+         * and https://bugs.webkit.org/show_bug.cgi?id=242740
+         */
+        await (c.default?.then(
+          (p) => typeof p == "function" ? { a: p } : p
+        ) ?? c)
+      );
+    }).catch((c) => {
+      t.H.reject(c), setTimeout(() => {
+        throw c;
+      });
+    }), process.env.NODE_ENV !== "production" && U() && (o.devOnly$hmrInstances ??= [], o.devOnly$hmrInstances.push(new WeakRef(this)));
+  }
+  static F() {
+    for (const t of this.C ?? [])
+      Ze(this.prototype, t, {
+        configurable: !0,
+        enumerable: !0,
+        get() {
+          return L(this, Q)[t];
+        },
+        set(o) {
+          L(this, Q)[t] = o, process.env.NODE_ENV !== "production" && U() && this.devOnly$hmrSetProps.add(t);
+        }
+      });
+    for (const t of this.E ?? [])
+      Ze(this.prototype, t, {
+        async value(...o) {
+          return L(this, z) || await this.H.promise, await L(this, z)[t](...o);
+        },
+        configurable: !0
+      });
+    for (const t of this.D ?? [])
+      Ze(this.prototype, t, {
+        value(...o) {
+          if (process.env.NODE_ENV !== "production" && !L(this, z)) {
+            const c = this.constructor;
+            throw new Error(
+              `Tried to call method ${t}() on <${c.L}> component before it's fully loaded. Please do 'await component.componentOnReady();' before calling this method.`
+            );
+          }
+          return L(this, z)[t](...o);
+        },
+        configurable: !0
+      });
+  }
+  get manager() {
+    return L(this, z)?.manager;
+  }
+  /*
+   * This method must be statically present rather than added later, or else,
+   * browsers won't call it. Same for connected and disconnected callbacks.
+   */
+  attributeChangedCallback(t, o, r) {
+    L(this, z)?.attributeChangedCallback(t, o, r), L(this, z) || L(this, we).push(t), process.env.NODE_ENV !== "production" && U() && this.devOnly$hmrSetAttributes.add(t);
+  }
+  connectedCallback() {
+    L(this, z) ? L(this, z).connectedCallback?.() : queueMicrotask(() => this.G = fn(this));
+  }
+  disconnectedCallback() {
+    L(this, z)?.disconnectedCallback?.();
+  }
+  /**
+   * Create a promise that resolves once component is fully loaded
+   */
+  async componentOnReady() {
+    return await this.H.promise, this;
+  }
+  /**
+   * Implemented on the proxy for compatibility with Lit Context.
+   */
+  addController() {
+  }
+  /**
+   * Implemented on the proxy for compatibility with Lit Context.
+   */
+  requestUpdate() {
+    L(this, z)?.requestUpdate();
+  }
+};
+z = new WeakMap(), Q = new WeakMap(), we = new WeakMap(), be = new WeakSet(), Je = function(t) {
+  const o = this.constructor, r = o.L, c = L(this, Q), u = Object.values(t).find(
+    (D) => D.L === r
+  );
+  if (process.env.NODE_ENV !== "production" && U() && !u)
+    throw new Error(
+      `Unable to find the LitElement class for the "${r}" custom element in the lazy-loaded module`
+    );
+  const p = process.env.NODE_ENV !== "production" && U() ? (o.devOnly$hmrIndex ?? 0) === 0 ? `${r}--lazy` : `${r}--lazy-${o.devOnly$hmrIndex}` : `${r}--lazy`;
+  let h = u;
+  for (; h && !Object.hasOwn(h, "lumina"); )
+    h = Object.getPrototypeOf(h);
+  To(h), !o.A && (o.A = u, customElements.define(p, u)), u.N = this;
+  const g = document.createElement(p);
+  if (u.N = void 0, V(this, z, g), process.env.NODE_ENV !== "production" && U() && Object.defineProperty(this, "$component", { value: g, configurable: !0, enumerable: !1 }), V(this, Q, g), L(this, we).forEach(
+    (D) => g.attributeChangedCallback(
+      D,
+      // Lit doesn't look at this value, thus even if attribute already exists, that's ok
+      null,
+      this.getAttribute(D)
+    )
+  ), Object.entries(c).forEach(Ro, g), process.env.NODE_ENV !== "production" && U()) {
+    const D = u.observedAttributes ?? [], N = o.observedAttributes ?? [], I = D.filter((q) => !N.includes(q)), Z = N.filter((q) => !D.includes(q));
+    I.length > 0 && console.warn(
+      `The following attributes on <${o.L}> are present on the Lit element, but are missing from the lazy proxy component: ${I.join(", ")}. This either indicates a bug in Lumina, or you are creating the attribute dynamically in a way that compiler cannot infer statically. For these attributes, lazy-loading version of your component won't work correctly, thus this must be resolved`
+    ), Z.length > 0 && console.warn(
+      `The following attributes on <${o.L}> are defined on the lazy proxy component, but not on the actual Lit element: ${Z.join(", ")}. This either indicates a bug in Lumina, or you are creating the attribute dynamically in a way that compiler cannot infer statically. This is a non-critical issue, but does indicate that something is going wrong and should be fixed`
+    );
+  }
+  const _ = this.isConnected;
+  (_ || this.G) && (g.connectedCallback?.(), _ || g.disconnectedCallback());
+}, wt.lumina = !0;
+let rn = wt;
+function Ro([s, e]) {
+  this[s] = e;
+}
+const To = (s) => {
+  const e = s.prototype, t = Element.prototype;
+  Object.hasOwn(e, "isConnected") || (e.setAttribute = function(r, c) {
+    t.setAttribute.call(this.el, r, c);
+  }, e.removeAttribute = function(r) {
+    t.removeAttribute.call(this.el, r);
+  }, Ze(e, "isConnected", {
+    get() {
+      return Reflect.get(t, "isConnected", this.el);
+    }
+  })), process.env.NODE_ENV !== "production" && U() && Oo(s);
+};
+class yn extends vo {
+  constructor(e) {
+    super(e), this.destroyed = !1, this.R = !1, this.V = W, this.T = [], this.#o = /* @__PURE__ */ new WeakMap(), this.#t = e, this.exports = void 0, this.hasDestroy = tt in e && typeof e.destroy == "function", re.prototype.addController.call(e, {
+      // Lit will call these callbacks
+      // We do not directly implement hostConnected and etc on ControllerManager
+      // because ControllerManager is also included in the list of controllers
+      // we manage - and for each controller we manage we call hostConnected
+      // (from inside of .triggerConnected). So there would be an infinite
+      // loop if Lit calls hostConnected which in turn calls
+      // triggerConnected which calls hostConnected again.
+      hostConnected: () => {
+        if (this.destroyed) {
+          const t = e.el.localName;
+          throw e.el.remove(), new Error(
+            `The ${t} component has already been destroyed. It cannot be used again. If you meant to disconnect and reconnect a component without automatic destroy, set the ${tt} prop.`
+          );
+        }
+        this.#n !== void 0 && clearTimeout(this.#n), Et();
+        for (const t of e.M)
+          "triggerConnected" in t ? t.triggerConnected() : x(t.hostConnected, t);
+      },
+      hostDisconnected: () => {
+        for (const t of e.M)
+          "triggerDisconnected" in t ? t.triggerDisconnected() : x(t.hostDisconnected, t);
+        this.hasDestroy && !this.destroyed && this.U();
+      },
+      hostUpdate: () => {
+        for (const t of e.M)
+          "triggerUpdate" in t ? t.triggerUpdate(this.Q) : x(t.hostUpdate, t, this.Q);
+      },
+      hostUpdated: () => {
+        for (const t of e.M)
+          "triggerUpdated" in t ? t.triggerUpdated(this.Q) : x(t.hostUpdated, t, this.Q);
+        this.Q = void 0;
+      }
+    }), queueMicrotask(() => this.R = !0), ke(e);
+  }
+  #n;
+  #t;
+  // Keep this method async needlessly for now to avoid a breaking change if we
+  // would need to make it async in the future
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async destroy() {
+    if (process.env.NODE_ENV !== "production" && U() && this.devOnly$ensureHasDestroy?.(), !this.destroyed) {
+      this.#t.el.isConnected && (this.hasDestroy = !1, this.#t.el.remove()), this.#n = void 0, this.destroyed = !0;
+      for (const e of this.#t.M)
+        "triggerDestroy" in e ? e.triggerDestroy() : x(e.hostDestroy, e);
+      this.#t.M.splice(0);
+    }
+  }
+  /** @private */
+  U() {
+    if (this.#n !== void 0 && clearTimeout(this.#n), !this.#t.el.isConnected && !this.#t.autoDestroyDisabled) {
+      const e = () => void this.#t.destroy();
+      process.env.NODE_ENV !== "production" && U() && sn === 0 || (this.#n = In(e, sn));
+    }
+  }
+  /** @private */
+  S(e, t) {
+    const o = this.T;
+    this.V = W, this.T = [], o.forEach((r) => r(e, t));
+  }
+  #o;
+  /**
+   * Associate an exports object with a controller for reverse lookup in
+   * controller.use
+   *
+   * @private
+   */
+  W(e, t) {
+    (typeof t == "object" && t !== null || typeof t == "function") && this.#o.set(t, e);
+  }
+  /** @private */
+  X(e) {
+    if (typeof e == "object" && e !== null || typeof e == "function")
+      return this.#o.get(e);
+  }
+}
+process.env.NODE_ENV !== "production" && U() && (yn.prototype.devOnly$ensureHasDestroy = function() {
+  if (!this.hasDestroy)
+    throw new Error(
+      `
+          If the component uses a controller that uses destroy() method, then the
+          component must have the following properties:
+          /**
+           * If true, the component will not be destroyed automatically when it is
+           * disconnected from the document. This is useful when you want to move the
+           * component to a different place on the page, or temporarily hide it. If this
+           * is set, make sure to call the \`destroy\` method when you are done to prevent
+           * memory leaks.
+           */
+          @property() ${tt} = false;
+
+          /** Permanently destroy the component */
+          @method()
+          async destroy(): Promise<void> {
+            await this.manager.destroy();
+          }
+          `.trim().split(`
+`).map((e) => e.trim()).join(`
+`)
+    );
+});
+let sn = 1e3;
+const tt = "autoDestroyDisabled";
+process.env.NODE_ENV !== "production" && U();
+var le, xe, We, de, X, Ce, mn, gn;
+const Ue = class Ue extends re {
+  constructor() {
+    super();
+    F(this, Ce);
+    /**
+     * The JS API's Accessor observables. This is used to integrate with the JS
+     * API's reactivity system.
+     *
+     * @private
+     */
+    F(this, le);
+    F(this, xe);
+    F(this, We);
+    F(this, de);
+    F(this, X);
+    this.M = [], this.manager = new yn(this);
+    const t = this, o = t.constructor, r = o.N, c = o.K.o, u = Ue.prototype.shouldUpdate;
+    if (V(t, de, r?.H ?? new Ie()), t.I = r?.I ?? new Ie(), t.J = r?.J ?? [], t._offspring = t.J, t._postLoad = t.I, t.el = r ?? t, V(t, We, t.enableUpdating), t.enableUpdating = _t, t.shouldUpdate !== u && (V(t, xe, t.shouldUpdate), t.shouldUpdate = u), process.env.NODE_ENV !== "production") {
+      const p = globalThis.devOnly$ownTagNames?.has(t.el.localName), h = this.constructor, m = h.enabledWarnings !== re.enabledWarnings;
+      !p && !m && h.disableWarning?.("change-in-update"), U() && (globalThis.devOnly$luminaComponentRefCallback?.(this), Object.entries({
+        componentDidLoad: "loaded",
+        componentDidRender: "updated",
+        componentDidUpdate: "updated",
+        componentShouldUpdate: "shouldUpdate",
+        componentWillLoad: "load",
+        componentWillRender: "willUpdate",
+        componentWillUpdate: "willUpdate"
+      }).forEach(([_, D]) => {
+        if (_ in this)
+          throw new Error(
+            `Unexpected ${_}() in a Lit component ${this.el.localName}. In Lit, you should use ${D}() instead`
+          );
+      }));
+    }
+    c && (V(t, le, /* @__PURE__ */ new Map()), o.elementProperties.forEach((p, h) => L(t, le).set(h, c())));
+  }
+  /**
+   * Customize Lit's default style handling to support non-shadow-root styles
+   */
+  static finalizeStyles(t) {
+    process.env.NODE_ENV === "test" && Array.isArray(t) && (t = t.filter(Boolean));
+    const o = super.finalizeStyles(t), r = this.shadowRootOptions === on;
+    return this.K?.commonStyles === void 0 || r ? o : [this.K.commonStyles, ...o];
+  }
+  static createProperty(t, o) {
+    const r = typeof o == "number" ? o : Array.isArray(o) ? o[0] : 0, c = Array.isArray(o) ? o[1] : void 0, u = c?.hasChanged ?? yt, p = {
+      /**
+       * By default to infer attribute name from property name, Lit just
+       * converts property name to lowercase. That is consistent with
+       * native DOM attributes.
+       *
+       * However, that is not consistent with Stencil and would be a
+       * breaking change for us. Also, kebab-case is more common among the
+       * web components. But the most important reason is that we have
+       * some pretty long attribute names, which would be utterly
+       * unreadable in lowercase.
+       *
+       * Also, if browsers add new attributes, that may cause a conflict
+       * with our attributes.
+       *
+       * Thus, overwriting Lit's default behavior to use kebab-case:
+       */
+      attribute: r & Eo && typeof t == "string" ? Dn(t) : !1,
+      reflect: !!(r & _o),
+      type: r & wo ? Boolean : r & bo ? Number : void 0,
+      /**
+       * At the moment in Lit, state:true just means attribute:false, so this
+       * line is technically redundant, but let's keep it here just in case Lit
+       * will add more meaning to state:true in the future.
+       */
+      state: !!(r & $o),
+      // Controllers add this option to Lit
+      readOnly: !!(r & Ao),
+      noAccessor: !!(r & Co),
+      c: !1,
+      ...c,
+      hasChanged(h, m) {
+        const g = u(h, m);
+        return p.c = g, g;
+      }
+    };
+    super.createProperty(t, p);
+  }
+  static getPropertyDescriptor(t, o, r) {
+    const c = this.K, u = super.getPropertyDescriptor(t, o, r);
+    return r.d = u, {
+      ...u,
+      get() {
+        return c.t?.(L(this, le).get(t)), u.get?.call(this);
+      },
+      set(p) {
+        const h = this.manager;
+        if (r.readOnly && (h.R || h.connectedCalled))
+          throw Error(
+            `Cannot assign to read-only property "${t}" of ${this.el.localName}. Trying to assign "${p}"`
+          );
+        u.set.call(this, p ?? void 0), r.c && L(this, le)?.get(t)?.notify(), h.T.length > 0 && h?.S(t, p);
+      }
+    };
+  }
+  connectedCallback() {
+    if (this.el.hasAttribute("defer-hydration"))
+      return;
+    const t = this.constructor.K.c?.(() => this.requestUpdate());
+    V(this, X, t);
+    const o = !this.manager.connectedCalled;
+    super.connectedCallback(), o ? queueMicrotask(
+      // eslint-disable-next-line @typescript-eslint/promise-function-async, @typescript-eslint/no-misused-promises
+      () => ge(this, Ce, gn).call(this).catch((r) => {
+        L(this, de).reject(r), setTimeout(() => {
+          throw r;
+        });
+      })
+    ) : t && this.requestUpdate();
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback(), L(this, X)?.destroy(), V(this, X, void 0);
+  }
+  /**
+   * Overwrite Lit's default behavior of attaching shadow root to the lit
+   * element, and instead use this.el to support lazy builds.
+   *
+   * Also, support the case when component asked to not use shadow root
+   */
+  createRenderRoot() {
+    const t = this.el.shadowRoot, o = this.constructor, r = o.shadowRootOptions, u = t ?? (r === on ? this.el : this.el.attachShadow(r));
+    if (t)
+      return re.prototype.createRenderRoot.call(this), t;
+    if (this.isConnected) {
+      const p = u.getRootNode();
+      process.env.NODE_ENV === "test" && (p.adoptedStyleSheets ??= []), p.adoptedStyleSheets = [
+        ...p.adoptedStyleSheets,
+        ...o.elementStyles.map((h) => "styleSheet" in h ? h.styleSheet : h)
+      ];
+    }
+    return u;
+  }
+  /**
+   * Overwriting default shouldUpdate simply to get access to
+   * "changedProperties" so that we can later provide it to ControllerManager
+   */
+  shouldUpdate(t) {
+    var o;
+    return this.manager.Q = t, ((o = L(this, xe)) == null ? void 0 : o.call(this, t)) ?? !0;
+  }
+  update(t) {
+    L(this, X) ? ge(this, Ce, mn).call(this, t) : super.update(t);
+  }
+  listen(t, o, r) {
+    const c = o?.bind(this) ?? o;
+    this.manager.onLifecycle(() => (this.el.addEventListener(t, c, r), () => this.el.removeEventListener(t, c, r)));
+  }
+  listenOn(t, o, r, c) {
+    const u = r?.bind(this) ?? r;
+    this.manager.onLifecycle(() => (t.addEventListener(o, u, c), () => t.removeEventListener(o, u, c)));
+  }
+  /**
+   * Create a promise that resolves once component is fully loaded.
+   *
+   * @example
+   * const map = document.createElement('arcgis-map');
+   * document.body.append(map);
+   * map.componentOnReady().then(() => {
+   *   console.log('Map is ready to go!');
+   * });
+   */
+  async componentOnReady() {
+    return await L(this, de).promise, this;
+  }
+  /**
+   * Adds a controller to the host, which connects the controller's lifecycle
+   * methods to the host's lifecycle.
+   *
+   * @remarks
+   * Even though Lit's LitElement already has addController,
+   * we overwrite it with a compatible version to have more control over
+   * timing, and to add support for load/loaded lifecycle hooks.
+   */
+  addController(t) {
+    this.M.push(t), !(ht in t) && this.renderRoot && this.el.isConnected && t.hostConnected?.();
+  }
+  /**
+   * Removes a controller from the host.
+   */
+  removeController(t) {
+    this.M.splice(this.M.indexOf(t), 1), t.controllerRemoved?.();
+  }
+};
+le = new WeakMap(), xe = new WeakMap(), We = new WeakMap(), de = new WeakMap(), X = new WeakMap(), Ce = new WeakSet(), mn = function(t) {
+  try {
+    L(this, X).clear(), this.constructor.K.r(
+      L(this, X),
+      () => Mt(Ue.prototype, this, "update").call(this, t)
+    );
+  } catch (o) {
+    throw L(this, X).clear(), o;
+  }
+}, gn = async function() {
+  const t = this.el.G ?? fn(this.el);
+  t && await t;
+  const o = [];
+  for (const c of this.M)
+    "triggerLoad" in c ? o.push(c.triggerLoad()) : o.push(lt(c.hostLoad, c));
+  await Promise.all(o), await this.load?.(), this.manager.hasDestroy && this.manager.onUpdate(
+    (c) => c.has(tt) && this.manager.U()
+  ), L(this, We).call(this, !0), this.performUpdate(), this.I.resolve(), await Promise.resolve();
+  const r = this.J.filter((c) => !c.manager?.loadedCalled);
+  r.length && await Promise.allSettled(r.map(async (c) => await c.componentOnReady())), this.J.length = 0, this.el.setAttribute(this.constructor.K.hydratedAttribute, "");
+  for (const c of this.M)
+    "triggerLoaded" in c ? c.triggerLoaded() : x(c.hostLoaded, c);
+  this.loaded?.(), L(this, de).resolve();
+}, Ue.lumina = !0;
+let an = Ue;
+const No = {}, Lo = (s, e) => (t) => {
+  const o = t.tagName;
+  let r = No;
+  const c = {
+    name: o,
+    /**
+     * Lit's createComponent tries to access the elementClass.prototype in
+     * global scope (in development mode). The elementClass may not be defined
+     * yet (because we are in a lazy loading build, or because current app
+     * doesn't import a given custom element as it doesn't use it).
+     *
+     * Thus, we return an empty object as a fake prototype.
+     *
+     * Right after the call to `createComponent`, we set to
+     * customElementPrototype undefined so that the next access of
+     * `.prototype` tries to get the real prototype.
+     * `createPrototypeProxy()` is called, this small proxy delays retrieving the custom
+     * element prototype until it is actually needed, and caches the result for future calls.
+     */
+    get prototype() {
+      if (r === void 0) {
+        const p = customElements.get(o);
+        if (!p)
+          throw new Error(`Custom element "${o}" not found`);
+        p.F?.(), p.F = _t, r = p.prototype, Object.defineProperty(c, "prototype", { value: r });
+      }
+      return r;
+    }
+  }, u = e({
+    ...t,
+    react: s,
+    elementClass: c
+  });
+  return r = void 0, u;
+}, R = (s, e) => ({ tagName: s, events: e }), T = /* @__PURE__ */ Lo(Ln, kn), Do = /* @__PURE__ */ T(
+  R(
+    "instant-apps-app-guide",
+    {}
+  )
+), Uo = /* @__PURE__ */ T(
+  R(
+    "instant-apps-control-panel",
+    {}
+  )
+), Io = /* @__PURE__ */ T(
+  R(
+    "instant-apps-create",
+    {}
+  )
+), Mo = /* @__PURE__ */ T(
+  R(
+    "instant-apps-export",
+    {
+      onExportOutputUpdated: "exportOutputUpdated"
+    }
+  )
+), jo = /* @__PURE__ */ T(
+  R(
+    "instant-apps-export-views",
+    {
+      onExportOutputUpdated: "exportOutputUpdated"
+    }
+  )
+), Ho = /* @__PURE__ */ T(
+  R(
+    "instant-apps-filter-list",
+    {
+      onFilterListReset: "filterListReset",
+      onFilterUpdate: "filterUpdate"
+    }
+  )
+), xo = /* @__PURE__ */ T(
+  R(
+    "instant-apps-header",
+    {
+      onInfoIsOpenChanged: "infoIsOpenChanged"
+    }
+  )
+), Wo = /* @__PURE__ */ T(
+  R(
+    "instant-apps-interactive-legend",
+    {}
+  )
+), zo = /* @__PURE__ */ T(
+  R(
+    "instant-apps-interactive-legend-classic",
+    {}
+  )
+), qo = /* @__PURE__ */ T(
+  R(
+    "instant-apps-interactive-legend-count",
+    {}
+  )
+), Yo = /* @__PURE__ */ T(
+  R(
+    "instant-apps-interactive-legend-group-legend-element",
+    {}
+  )
+), Vo = /* @__PURE__ */ T(
+  R(
+    "instant-apps-interactive-legend-group-legend-element-caption",
+    {
+      onGroupLayerCaptionElementExpandUpdated: "groupLayerCaptionElementExpandUpdated"
+    }
+  )
+), Bo = /* @__PURE__ */ T(
+  R(
+    "instant-apps-interactive-legend-layer-element",
+    {}
+  )
+), Fo = /* @__PURE__ */ T(
+  R(
+    "instant-apps-interactive-legend-layer-element-caption",
+    {
+      onLayerCaptionElementExpandUpdated: "layerCaptionElementExpandUpdated"
+    }
+  )
+), Ko = /* @__PURE__ */ T(
+  R(
+    "instant-apps-interactive-legend-legend-element",
+    {}
+  )
+), Go = /* @__PURE__ */ T(
+  R(
+    "instant-apps-interactive-legend-legend-element-caption",
+    {
+      onLegendLayerExpandUpdated: "legendLayerExpandUpdated",
+      onShowAllSelected: "showAllSelected"
+    }
+  )
+), Qo = /* @__PURE__ */ T(
+  R(
+    "instant-apps-interactive-legend-relationship",
+    {}
+  )
+), Xo = /* @__PURE__ */ T(
+  R(
+    "instant-apps-keyboard-shortcuts",
+    {}
+  )
+), Zo = /* @__PURE__ */ T(
+  R(
+    "instant-apps-landing-page",
+    {
+      onLandingPageClose: "landingPageClose",
+      onLandingPageOpen: "landingPageOpen"
+    }
+  )
+), Jo = /* @__PURE__ */ T(
+  R(
+    "instant-apps-language-switcher",
+    {
+      onSelectedLanguageUpdated: "selectedLanguageUpdated"
+    }
+  )
+), er = /* @__PURE__ */ T(
+  R(
+    "instant-apps-language-translator",
+    {
+      onTranslatorDataUpdated: "translatorDataUpdated"
+    }
+  )
+), tr = /* @__PURE__ */ T(
+  R(
+    "instant-apps-ckeditor-wrapper",
+    {
+      onDataChanged: "dataChanged",
+      onIsFocused: "isFocused"
+    }
+  )
+), nr = /* @__PURE__ */ T(
+  R(
+    "instant-apps-language-translator-item",
+    {
+      onTranslatorItemDataUpdated: "translatorItemDataUpdated"
+    }
+  )
+), or = /* @__PURE__ */ T(
+  R(
+    "instant-apps-language-translator-search",
+    {
+      onSuggestionSelected: "suggestionSelected"
+    }
+  )
+), rr = /* @__PURE__ */ T(
+  R(
+    "instant-apps-measurement",
+    {
+      onMeasureActive: "measureActive"
+    }
+  )
+), sr = /* @__PURE__ */ T(
+  R(
+    "instant-apps-measurement-tool",
+    {}
+  )
+), ir = /* @__PURE__ */ T(
+  R(
+    "instant-apps-popover",
+    {}
+  )
+), ar = /* @__PURE__ */ T(
+  R(
+    "instant-apps-popovers",
+    {}
+  )
+), cr = /* @__PURE__ */ T(
+  R(
+    "instant-apps-scoreboard",
+    {
+      onScoreboardItemsUpdated: "scoreboardItemsUpdated"
+    }
+  )
+), ur = /* @__PURE__ */ T(
+  R(
+    "instant-apps-sign-in",
+    {}
+  )
+), lr = /* @__PURE__ */ T(
+  R(
+    "instant-apps-social-share",
+    {}
+  )
+), dr = /* @__PURE__ */ T(
+  R(
+    "instant-apps-splash",
+    {
+      onSplashClose: "splashClose"
+    }
+  )
+), hr = /* @__PURE__ */ T(
+  R(
+    "instant-apps-time-filter",
+    {}
+  )
+);
+export {
+  Do as InstantAppsAppGuide,
+  tr as InstantAppsCkeditorWrapper,
+  Uo as InstantAppsControlPanel,
+  Io as InstantAppsCreate,
+  Mo as InstantAppsExport,
+  jo as InstantAppsExportViews,
+  Ho as InstantAppsFilterList,
+  xo as InstantAppsHeader,
+  Wo as InstantAppsInteractiveLegend,
+  zo as InstantAppsInteractiveLegendClassic,
+  qo as InstantAppsInteractiveLegendCount,
+  Yo as InstantAppsInteractiveLegendGroupLegendElement,
+  Vo as InstantAppsInteractiveLegendGroupLegendElementCaption,
+  Bo as InstantAppsInteractiveLegendLayerElement,
+  Fo as InstantAppsInteractiveLegendLayerElementCaption,
+  Ko as InstantAppsInteractiveLegendLegendElement,
+  Go as InstantAppsInteractiveLegendLegendElementCaption,
+  Qo as InstantAppsInteractiveLegendRelationship,
+  Xo as InstantAppsKeyboardShortcuts,
+  Zo as InstantAppsLandingPage,
+  Jo as InstantAppsLanguageSwitcher,
+  er as InstantAppsLanguageTranslator,
+  nr as InstantAppsLanguageTranslatorItem,
+  or as InstantAppsLanguageTranslatorSearch,
+  rr as InstantAppsMeasurement,
+  sr as InstantAppsMeasurementTool,
+  ir as InstantAppsPopover,
+  ar as InstantAppsPopovers,
+  cr as InstantAppsScoreboard,
+  ur as InstantAppsSignIn,
+  lr as InstantAppsSocialShare,
+  dr as InstantAppsSplash,
+  hr as InstantAppsTimeFilter
+};