@esri/solutions-components 1.0.0-next.20250422.2 → 1.0.0-next.20250424

package/dist/chunks/useT9n.js

@@ -1,9 +1,869 @@
-import { makeT9nController as o } from "@arcgis/components-controllers";
-import { g as t } from "./runtime.js";
+import { isNotUndefined as oe, isEsriInternalEnv as u, safeCall as d, Deferred as U, safeAsyncCall as S, getElementLocales as ne, startLocaleObserver as se, devToolsAwareTimeout as re } from "@arcgis/components-utils";
+import { g as ie } from "./runtime.js";
 /*! All material copyright Esri, All Rights Reserved, unless otherwise specified.
 See https://js.arcgis.com/1.0/esri/copyright.txt for details.
-v1.0.0-next.20250422.2 */
-const s = o(t);
+v1.0.0-next.20250424 */
+var Y = /* @__PURE__ */ ((e) => (e[e.String = 1] = "String", e[e.Number = 2] = "Number", e[e.Boolean = 4] = "Boolean", e[e.Any = 8] = "Any", e[e.Unknown = 16] = "Unknown", e[e.State = 32] = "State", e[e.Method = 64] = "Method", e[e.Event = 128] = "Event", e[e.Element = 256] = "Element", e[e.ReflectAttr = 512] = "ReflectAttr", e[e.Mutable = 1024] = "Mutable", e[e.Prop = 31] = "Prop", e[e.HasAttribute = 15] = "HasAttribute", e[e.PropLike = 63] = "PropLike", e[e.ReadOnly = 2048] = "ReadOnly", e))(Y || {});
+function ce(e, t) {
+  if (t) {
+    const o = e.constructor.elementProperties;
+    e.manager.internals.members = Object.fromEntries(
+      Array.from(
+        o,
+        ([n, s]) => s.noAccessor ? void 0 : [
+          n,
+          [
+            (s.readOnly ? 2048 : 0) | (s.state ? 32 : 16)
+          ]
+        ]
+      ).filter(oe)
+    );
+  } else {
+    const o = e.constructor, n = o.__registerControllers?.(e) ?? void 0;
+    if (o.__registerControllers = void 0, typeof n != "object")
+      throw new Error(
+        process.env.NODE_ENV !== "production" && u() ? "Failed to retrieve internal component meta. Make sure you have the useComponentsControllers() Rollup Plugin for Stencil Controllers configured in your Stencil config." : "Failed to retrieve component meta"
+      );
+    e.manager.internals.members = Object.fromEntries(
+      Object.entries(n).filter(([s, [r]]) => (r & 63) !== 0)
+    );
+  }
+}
+function ae(e, t = 8) {
+  return e == null || typeof e == "object" || typeof e == "function" ? e : t & 4 ? e === "false" ? !1 : e === "" || !!e : t & 2 ? Number.parseFloat(e) : t & 1 ? String(e) : e;
+}
+const J = (e, t) => e.manager.internals.members?.[t]?.[0], P = Symbol.for("controller"), R = "@arcgis/components-controllers", le = (e) => typeof e == "object" && e !== null && (P in e || "hostConnected" in e || "hostDisconnected" in e || "hostUpdate" in e || "hostUpdated" in e), de = process.env.NODE_ENV !== "production" && u() ? (e, t) => {
+  const o = e.component.manager, n = "_controllers" in o ? o._controllers : void 0;
+  if (n === void 0)
+    return;
+  const s = Array.from(n).indexOf(e);
+  if (s === -1)
+    return;
+  const r = Symbol.for(`${R}: devOnlyControllerData`), c = e.component.el;
+  c[r] ?? (c[r] = {}), c[r][s] = t;
+} : void 0;
+process.env.NODE_ENV !== "production" && u();
+function he(e) {
+  return typeof e?.then == "function";
+}
+let E;
+function k(e) {
+  E !== e && (E = e, queueMicrotask(() => {
+    E === e && (E = void 0);
+  }));
+}
+function j(e) {
+  if (process.env.NODE_ENV !== "production" && E === void 0)
+    throw new Error(
+      [
+        `Unable to find out which component ${e || "this"} controller `,
+        `belongs to. Possible causes:
+`,
+        "- You might have multiple versions of ",
+        `@arcgis/components-controllers 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 E;
+}
+let v = [];
+function z(e) {
+  if (e === void 0) {
+    v = [];
+    return;
+  }
+  const t = v.indexOf(e);
+  v = t === -1 ? [...v, e] : v.slice(0, t + 1), queueMicrotask(() => {
+    v = [];
+  });
+}
+function Q() {
+  return v;
+}
+let w;
+function fe(e) {
+  w !== e && (w = e, queueMicrotask(() => {
+    w === e && (w = void 0);
+  }));
+}
+function ue() {
+  const e = w;
+  return w = void 0, e;
+}
+const pe = async (e, t) => {
+  const o = M(e);
+  if (o === void 0) {
+    if (process.env.NODE_ENV !== "production" && u() && typeof t == "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 e;
+  }
+  if (await o.ready, typeof t == "function") {
+    if (process.env.NODE_ENV !== "production" && u() && o.watchExports === void 0)
+      throw new Error("The controller must implement watchExports method to support watching exports");
+    const n = o.watchExports(
+      (s) => t(s, n)
+    );
+  }
+  return o.exports;
+}, me = async (e) => {
+  const t = M(e);
+  if (process.env.NODE_ENV !== "production" && u() && t === 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 t.ready, t;
+}, M = (e) => {
+  const o = j().manager.internals.resolveExports(e);
+  if (o !== void 0)
+    return o;
+  if (le(e))
+    return e;
+  const n = ue();
+  if (n !== void 0)
+    return n;
+}, $ = {
+  readOnly: !1
+}, O = /* @__PURE__ */ new WeakMap();
+var X;
+X = P;
+class Z {
+  constructor(t) {
+    this._callbacks = {
+      hostConnected: [],
+      hostDisconnected: [],
+      hostLoad: [],
+      hostLoaded: [],
+      hostUpdate: [],
+      hostUpdated: [],
+      hostDestroy: [],
+      hostLifecycle: []
+    }, this._ready = new U(), this._lifecycleCleanups = [], this.connectedCalled = !1, this._loadCalled = !1, this.loadedCalled = !1, this[X] = !0, this.ready = this._ready.promise, this._exports = G(this), this._exportWatchers = /* @__PURE__ */ new Set();
+    const o = _e(t ?? j(new.target.name));
+    process.env.NODE_ENV !== "production" ? (Object.defineProperty(this, "component", {
+      writable: !1,
+      enumerable: !1,
+      configurable: !0,
+      value: o
+    }), "hostDestroy" in this && this.component.manager.ensureHasDestroy?.()) : this.component = o, this.component.addController(this), this.component.manager === void 0 || (z(this), queueMicrotask(() => this.catchUpLifecycle()));
+  }
+  /**
+   * If controller is being added dynamically, after the component
+   * construction, then trigger connected and load right away
+   */
+  catchUpLifecycle() {
+    const { manager: t } = this.component;
+    t.connectedCalled && !this.connectedCalled && this.triggerConnected(), t._loadCalled && this.triggerLoad().then(() => {
+      t.loadedCalled && this.triggerLoaded();
+    }).catch(console.error);
+  }
+  get exports() {
+    return this._exports;
+  }
+  /**
+   * 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(t) {
+    const o = this._exports;
+    o !== t && (this._exports = t, this._exportWatchers.forEach(d), this.connectedCalled && this.assignedProperty !== !1 && this.component.requestUpdate(this.assignedProperty, o)), this._ready.resolve(t);
+  }
+  setProvisionalExports(t, o = !0) {
+    this._exports = o ? G(t) : t, this._exportWatchers.forEach(d);
+  }
+  watchExports(t) {
+    const o = () => t(this._exports);
+    return this._exportWatchers.add(o), () => void this._exportWatchers.delete(o);
+  }
+  /**
+   * 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 k(this.component), pe;
+  }
+  /**
+   * 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 k(this.component), me;
+  }
+  /**
+   * Like useRef, but doesn't wait for the controller to get ready
+   *
+   * @internal
+   */
+  get useRefSync() {
+    return k(this.component), M;
+  }
+  controllerRemoved() {
+    this.component.el.isConnected && this.triggerDisconnected(), this.triggerDestroy();
+  }
+  // Register a lifecycle callback
+  onConnected(t) {
+    this._callbacks.hostConnected.push(t);
+  }
+  onDisconnected(t) {
+    this._callbacks.hostDisconnected.push(t);
+  }
+  onLoad(t) {
+    this._callbacks.hostLoad.push(t);
+  }
+  onLoaded(t) {
+    this._callbacks.hostLoaded.push(t);
+  }
+  onUpdate(t) {
+    this._callbacks.hostUpdate.push(t);
+  }
+  onUpdated(t) {
+    this._callbacks.hostUpdated.push(t);
+  }
+  onDestroy(t) {
+    process.env.NODE_ENV !== "production" && u() && this.component.manager.ensureHasDestroy?.(), this._callbacks.hostDestroy.push(t);
+  }
+  onLifecycle(t) {
+    this._callbacks.hostLifecycle.push(t), this.connectedCalled && this.component.el.isConnected && this._callLifecycle(t);
+  }
+  // Call each lifecycle hook
+  /** @internal */
+  triggerConnected() {
+    const t = this;
+    t.hostConnected && d(t.hostConnected, t), this._callbacks.hostConnected.forEach(d), this.triggerLifecycle(), this.connectedCalled = !0;
+  }
+  /** @internal */
+  triggerDisconnected() {
+    const t = this;
+    t.hostDisconnected && d(t.hostDisconnected, t), this._callbacks.hostDisconnected.forEach(d), this._lifecycleCleanups.forEach(d), this._lifecycleCleanups = [];
+  }
+  /** @internal */
+  async triggerLoad() {
+    if (this._loadCalled)
+      return;
+    this._loadCalled = !0;
+    const t = this;
+    t.hostLoad && await S(t.hostLoad, t), this._callbacks.hostLoad.length > 0 && await Promise.allSettled(this._callbacks.hostLoad.map(S)), this._ready.resolve(this._exports);
+  }
+  /** @internal */
+  triggerLoaded() {
+    if (this.loadedCalled)
+      return;
+    const t = this;
+    t.hostLoaded && d(t.hostLoaded, t), this._callbacks.hostLoaded.forEach(d), this.loadedCalled = !0;
+  }
+  /** @internal */
+  triggerUpdate(t) {
+    const o = this;
+    o.hostUpdate && d(o.hostUpdate, o, t), this._callbacks.hostUpdate.forEach(I, t);
+  }
+  /** @internal */
+  triggerUpdated(t) {
+    const o = this;
+    o.hostUpdated && d(o.hostUpdated, o, t), this._callbacks.hostUpdated.forEach(I, t);
+  }
+  /** @internal */
+  triggerDestroy() {
+    const t = this;
+    t.hostDestroy && d(t.hostDestroy, t), this._callbacks.hostDestroy.forEach(d);
+  }
+  /** @internal */
+  triggerLifecycle() {
+    const t = this;
+    t.hostLifecycle && this._callLifecycle(() => t.hostLifecycle()), this._callbacks.hostLifecycle.forEach(this._callLifecycle, this);
+  }
+  _callLifecycle(t) {
+    k(this.component);
+    const o = d(t);
+    (Array.isArray(o) ? o : [o]).forEach((s) => {
+      typeof s == "function" ? this._lifecycleCleanups.push(s) : typeof s == "object" && typeof s.remove == "function" && this._lifecycleCleanups.push(s.remove);
+    });
+  }
+}
+function I(e) {
+  d(e, void 0, this);
+}
+const ye = Z;
+function G(e) {
+  if (typeof e != "object" && typeof e != "function" || e === null)
+    return e;
+  const t = new Proxy(e, {
+    get(o, n, s) {
+      if (!(ge.has(n) && n in o && o[n] === t)) {
+        if (n in o || n in Promise.prototype || typeof n == "symbol")
+          return typeof o == "function" ? o[n] : Reflect.get(o, n, s);
+        if (process.env.NODE_ENV !== "production" && u()) {
+          if (process.env.NODE_ENV === "test" && (n.startsWith("$$") || n.startsWith("@@") || n === "nodeType" || n === "tagName" || n === "toJSON" || n === "hasAttribute"))
+            return;
+          console.error(
+            `Trying to access "${n.toString()}" on the controller before it's loaded. ${q}`
+          );
+        }
+      }
+    },
+    set: (o, n, s, r) => (process.env.NODE_ENV !== "production" && u() && console.error(`Trying to set "${n.toString()}" on the controller before it's loaded. ${q}`), Reflect.set(o, n, s, r))
+  });
+  return t;
+}
+const ge = /* @__PURE__ */ new Set(["exports", "_exports"]), q = 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;
+function _e(e) {
+  if (process.env.NODE_ENV !== "production" && u()) {
+    if ("addController" in e)
+      return e;
+    throw new Error(
+      "Component does not implement ControllerHost. This might be because you forgot to add 'manager: Controller<this> = useControllerManager(this);' in your component, or you tried to use some controller before that line"
+    );
+  } else
+    return e;
+}
+function ve(e, t, o) {
+  const n = Object.keys(e), s = n.length;
+  b === void 0 && queueMicrotask(ee), b ?? (b = /* @__PURE__ */ new Map());
+  let r = b.get(e);
+  return r === void 0 && (r = { callbacks: [], keyCount: s }, b.set(e, r)), r.keyCount !== s && (r.callbacks.forEach((c) => c(n)), r.callbacks = [], r.keyCount = s), r.callbacks.push((c) => {
+    const i = (a) => d(t, null, a), l = c[s];
+    l === void 0 ? i(void 0) : e[l] === o ? i(l) : i(void 0);
+  }), o;
+}
+let b;
+function ee() {
+  Array.from(b?.entries() ?? []).forEach(([e, { callbacks: t }]) => {
+    const o = Object.keys(e);
+    t.forEach((n) => n(o));
+  }), b = void 0;
+}
+class be {
+  constructor(t) {
+    this.enabledWatchers = {}, this.allWatchers = {}, this.enableReadonly = () => {
+      if (this.enableReadonly = void 0, !this.component.manager.isLit)
+        return;
+      const o = this.component.manager.internals;
+      Object.entries(o.members).forEach(([n, [s]]) => {
+        var r;
+        s & Y.ReadOnly && ((r = o.setters)[n] ?? (r[n] = []), o.setters[n].push(o.readonlySetter));
+      });
+    }, this.trackedValue = W, this.keyTrackers = [], this.getters = {}, this.setters = {}, this.accessorGetter = {}, this.accessorSetter = {}, this._exports = /* @__PURE__ */ new WeakMap(), this.readonlySetter = (o, n, s) => {
+      if ($.readOnly)
+        return o;
+      throw new Error(
+        `Cannot assign to read-only property "${s}" of ${this.component.el.localName}. Trying to assign "${String(
+          o
+        )}"`
+      );
+    }, process.env.NODE_ENV !== "production" ? Object.defineProperty(this, "component", {
+      writable: !1,
+      enumerable: !1,
+      configurable: !0,
+      value: t
+    }) : this.component = t;
+  }
+  firePropTrackers(t, o) {
+    const n = this.keyTrackers;
+    this.trackedValue = W, this.keyTrackers = [], n.forEach((s) => s(t, o));
+  }
+  // REFACTOR: once Stencil is no longer supported, simplify this with Lit's getPropertyDescriptor(), or https://github.com/shoelace-style/shoelace/issues/1990
+  /**
+   * Configure a getter or setter for a given \@Prop/\@State
+   *
+   * Since props are defined on the prototype, they are shared between all
+   * instances of a component. Thus, instead of passing a reference to the
+   * getter/setter function, you should update the
+   * ComponentInternals.getters/setters properties, and then call getSetProxy
+   * to apply the changes to the prototype
+   */
+  getSetProxy(t) {
+    const o = this.component, n = o.constructor.prototype;
+    if (this._getSetProxy(n, t, "class"), o.manager.isLit)
+      return;
+    const s = o.el.constructor.prototype;
+    n !== s && this._getSetProxy(s, t, "html");
+  }
+  _getSetProxy(t, o, n) {
+    const s = this.component, r = J(s, o);
+    let c;
+    do
+      c = Object.getOwnPropertyDescriptor(t, o);
+    while (!c && (t = Object.getPrototypeOf(t)));
+    if (process.env.NODE_ENV !== "production" && u()) {
+      const N = n === "html";
+      if (c?.set === void 0 || c.get === void 0) {
+        if (c !== void 0 && "value" in c)
+          throw new Error(
+            `getSet() should only be used on @Prop/@property/@State/@state properties. For internal component properties, use regular get/set syntax. Tried to use it on "${o}" in ${s.el.localName}`
+          );
+        if (N)
+          return;
+        throw new Error(`Unable to find "${o}" property on the ${s.el.localName} component`);
+      }
+      if (r === void 0)
+        throw new Error("Unable to retrieve prop type");
+    } else if (!c)
+      return;
+    const i = c.get, l = c.set, a = L in i, h = L in l;
+    if (a && h)
+      return;
+    const f = !a, y = !h, V = f ? function() {
+      let m = i.call(this);
+      const g = O.get(this);
+      if (g === void 0)
+        return m;
+      const C = g.manager.internals;
+      m = C.accessorGetter[o](m, o);
+      const p = C.getters[o] ?? F;
+      for (let _ = 0; _ < p.length; _++)
+        m = p[_](m, o);
+      return m;
+    } : i, T = y ? function(m) {
+      const g = i.call(this), C = O.get(this);
+      if (C === void 0) {
+        l.call(this, m);
+        return;
+      }
+      let p = C.manager.isLit ? (
+        /*
+         * Cast `null` to `undefined`.
+         * See https://devtopia.esri.com/WebGIS/arcgis-web-components/discussions/1299
+         */
+        m ?? void 0
+      ) : ae(m, r);
+      const _ = C.manager.internals;
+      if (p === g)
+        l.call(this, p);
+      else {
+        const H = _.setters[o] ?? F;
+        for (let D = 0; D < H.length && (p = H[D](p, g, o), p !== g); D++)
+          ;
+        p = _.accessorSetter[o](p, g, o), l.call(this, p), p !== g && _.enabledWatchers[o]?.forEach((D) => D(p, g, o));
+      }
+      _.keyTrackers.length > 0 && _?.firePropTrackers(o, m);
+    } : l;
+    f && (V[L] = !0), y && (T[L] = !0), Object.defineProperty(t, o, {
+      ...c,
+      get: V,
+      set: T
+    });
+  }
+  /**
+   * Associate an exports object with a controller for reverse lookup in
+   * controller.use
+   */
+  markExports(t, o) {
+    (typeof o == "object" && o !== null || typeof o == "function") && this._exports.set(o, t);
+  }
+  resolveExports(t) {
+    if (typeof t == "object" && t !== null || typeof t == "function")
+      return this._exports.get(t);
+  }
+}
+const F = [], L = Symbol(), W = process.env.NODE_ENV !== "production" ? Symbol.for(
+  // Use Symbol.for in dev mode to make it easier to maintain state when doing HMR.
+  `${R}: nothing`
+) : (
+  // eslint-disable-next-line symbol-description
+  Symbol()
+);
+function A(e, t, o) {
+  var n;
+  const s = t;
+  if (process.env.NODE_ENV !== "production" && u() && J(e, s) === void 0)
+    throw new Error(
+      e.manager.isLit ? `Trying to watch a non-@property, non-@state property "${s}". Either convert it into a @state() to be able to use watch() on it, or use the get/set syntax` : `Trying to watch a non-@Prop, non-@State property "${s}". Convert it into a @State() or @Prop property if you need to use watch() on it`
+    );
+  const r = e.manager.internals;
+  (n = r.allWatchers)[s] ?? (n[s] = []);
+  const c = r.allWatchers[s], i = o, l = (a, h, f) => d(i, null, a, h, f);
+  return c.push(l), () => {
+    const a = c.indexOf(l);
+    a !== -1 && c.splice(a, 1);
+  };
+}
+function Ce(e, t, o) {
+  const n = e.manager.internals;
+  return n.trackedValue !== W && n.trackedValue !== o && n.firePropTrackers(void 0, void 0), n.keyTrackers.length === 0 && queueMicrotask(() => n.firePropTrackers(void 0, void 0)), n.trackedValue = o, n.keyTrackers.push((s, r) => d(t, void 0, o === r ? s : void 0)), o;
+}
+function Ee(e = [
+  j(),
+  ...Q()
+], t, o) {
+  const n = Array.isArray(e) ? e : [e];
+  let s = n.length + 1;
+  const r = (i) => {
+    s -= 1, i !== void 0 && (s = Math.min(s, 0)), s === 0 && t(i);
+  };
+  n.forEach(
+    (i) => ve(
+      i,
+      (l) => r(
+        l === void 0 ? void 0 : {
+          key: l,
+          host: i,
+          isReactive: !1
+        }
+      ),
+      o
+    )
+  );
+  const c = n.find(
+    (i) => "manager" in i && typeof i.manager == "object" && i.manager.component === i
+  );
+  return c && Ce(
+    c,
+    (i) => r(
+      i === void 0 ? void 0 : {
+        key: i,
+        host: c,
+        isReactive: !0
+      }
+    ),
+    o
+  ), o;
+}
+function ke(e) {
+  $.readOnly = !0;
+  try {
+    return e();
+  } finally {
+    $.readOnly = !1;
+  }
+}
+const we = (e) => (...t) => {
+  const o = Q(), n = new e(...t), s = n.exports;
+  z(o.at(-1));
+  const r = n.component.manager.internals;
+  r.markExports(n, s), n.watchExports((i) => r.markExports(n, i)), fe(n);
+  const c = [n.component, ...o].reverse();
+  return Ee(
+    c,
+    (i) => i === void 0 ? void 0 : De(n, i, s),
+    s
+  );
+};
+function De(e, { host: t, key: o, isReactive: n }, s) {
+  const r = t, c = r[o] !== e.exports, i = r[o] !== s, l = s !== e.exports;
+  if (c && !i && l && (r[o] = e.exports), t === e.component) {
+    if (n) {
+      const h = e.component.manager.internals;
+      i && h.markExports(e, r[o]), A(e.component, o, (f) => {
+        f !== e.exports && h.markExports(e, f);
+      });
+    }
+    e.assignedProperty = n ? void 0 : o;
+  }
+  e.watchExports(() => {
+    if (r[o] === e.exports)
+      return;
+    const h = e.component.manager;
+    h.internals.setters[o]?.includes(h.internals.readonlySetter) ? ke(() => {
+      r[o] = e.exports;
+    }) : r[o] = e.exports;
+  });
+}
+class Le extends ye {
+  constructor(t, o) {
+    const n = "addController" in t;
+    process.env.NODE_ENV !== "production" && u() && !n && Object.defineProperty(t.el, "__component", {
+      value: t
+    });
+    const s = /* @__PURE__ */ new Set();
+    function r(a) {
+      s.add(a), !(P in a) && t.renderRoot && t.el.isConnected && a.hostConnected?.();
+    }
+    function c(a) {
+      s.delete(a), a.controllerRemoved?.();
+    }
+    const i = t;
+    if (i.addController = r, i.removeController = c, !n) {
+      const a = o ?? t.constructor.__forceUpdate;
+      i.requestUpdate = () => a(t);
+    }
+    if (process.env.NODE_ENV !== "production" && u() && (Object.entries({
+      componentDidLoad: "loaded",
+      componentDidRender: "updated",
+      componentDidUpdate: "updated",
+      componentShouldUpdate: "shouldUpdate",
+      componentWillLoad: "load",
+      componentWillRender: "willUpdate",
+      componentWillUpdate: "willUpdate"
+    }).forEach(([h, f]) => {
+      if (n && h in t)
+        throw new Error(
+          `Unexpected ${h}() in a Lit component ${t.el.localName}. In Lit, you should use ${f}() instead`
+        );
+      if (!n && f in t)
+        throw new Error(
+          `Unexpected ${f}() in a Stencil component ${t.el.localName}. In Stencil, you should use ${f}() instead`
+        );
+    }), n)) {
+      let h = 0, f = !1;
+      for (let y = t; !f; h++) {
+        if (y === null)
+          throw new Error("Expected controllers to be used in a LitElement class");
+        if (Object.hasOwn(y, "_load")) {
+          f = !0;
+          break;
+        }
+        y = Object.getPrototypeOf(y);
+      }
+      if (h < 1)
+        throw new Error(
+          "It looks like you are trying to call useControllerManager in a component that uses LitElement imported from 'lit'. useControllerManager should only be used in the LitElement coming from `@arcgis/lumina`"
+        );
+    }
+    super(t), this.internals = new be(this.component), this.destroyed = !1, this._updatePromise = new U(), this._originalLifecycles = {}, this.isLit = n, this.component.manager = this, ce(t, n), this._controllers = s, this.exports = void 0, this.hasDestroy = x in this.component && typeof this.component.destroy == "function", this._bindLifecycleMethods();
+    const l = this.internals;
+    Object.keys(l.members).forEach((a) => {
+      l.accessorGetter[a] = K, l.accessorSetter[a] = K, l.getSetProxy(a);
+    }), n ? this.internals.enabledWatchers = this.internals.allWatchers : Object.defineProperty(t, "updateComplete", {
+      get: async () => await this._updatePromise.promise
+    }), queueMicrotask(l.enableReadonly), k(t), O.set(t.el, t), O.set(t, t);
+  }
+  _bindLifecycleMethods() {
+    const t = this.component, o = this.isLit, n = t.el === t;
+    this._originalLifecycles = {
+      // These component's callbacks will be called by Lit, so we don't have to
+      _connectedCallback: o || n ? void 0 : t.connectedCallback,
+      _disconnectedCallback: o || n ? void 0 : t.disconnectedCallback,
+      _load: o ? t.load : t.componentWillLoad,
+      _loaded: o ? t.loaded : t.componentDidLoad,
+      _willUpdate: o ? void 0 : t.componentWillUpdate,
+      _updated: o ? void 0 : t.componentDidUpdate,
+      _destroy: t.destroy
+    };
+    const s = this._connectedCallback.bind(this), r = this._disconnectedCallback.bind(this), c = this._update.bind(this), i = this._updated.bind(this);
+    o ? t.constructor.prototype.addController.call(t, {
+      // Lit will call these callbacks
+      hostConnected: s,
+      hostDisconnected: r,
+      hostUpdate: c,
+      hostUpdated: i
+    }) : (t.connectedCallback = s, t.disconnectedCallback = r, t.componentWillLoad = this._load.bind(this), t.componentDidLoad = this._loaded.bind(this), t.componentWillUpdate = c, t.componentDidUpdate = i), this.hasDestroy && (t.destroy = this.destroy.bind(this));
+  }
+  /**
+   * Private because this is not supposed to be called by Component directly.
+   * Instead, _bindLifecycleMethods will take care of that. Otherwise, you risk
+   * calling lifecycle methods twice.
+   *
+   * @internal
+   */
+  _connectedCallback() {
+    if (this.destroyed) {
+      const o = this.component.el.localName;
+      throw this.component.el.remove(), new Error(
+        `The ${o} component has already been destroyed. It cannot be used again. If you meant to disconnect and reconnect a component without automatic destroy, set the ${x} prop.`
+      );
+    }
+    this._autoDestroyTimeout !== void 0 && clearTimeout(this._autoDestroyTimeout);
+    const t = this.internals;
+    t.enabledWatchers = t.allWatchers, ee(), t.enableReadonly?.(), this._controllers.forEach(xe), this._originalLifecycles._connectedCallback?.call(this.component), process.env.NODE_ENV !== "production" && u() && de?.(this, !0);
+  }
+  /** @internal */
+  _disconnectedCallback() {
+    this.destroyed || (this._controllers.forEach(Oe), this._originalLifecycles._disconnectedCallback?.call(this.component), this.hasDestroy && this._setAutoDestroyTimeout());
+  }
+  /** @internal */
+  async _load() {
+    await Promise.allSettled(Array.from(this._controllers, Ne)), await this._originalLifecycles._load?.call(this.component), this.hasDestroy && A(this.component, x, () => this._setAutoDestroyTimeout());
+  }
+  /** @internal */
+  _loaded() {
+    this._controllers.forEach(Ue), this._originalLifecycles._loaded?.call(this.component);
+  }
+  _update() {
+    const t = this.component;
+    return this._controllers.forEach(Se, t.$changes), this._originalLifecycles._willUpdate?.call(this.component);
+  }
+  _updated() {
+    const t = this.component;
+    if (this._controllers.forEach($e, t.$changes), this._originalLifecycles._updated?.call(this.component), this.isLit)
+      t.$changes = /* @__PURE__ */ new Map();
+    else {
+      const o = this._updatePromise;
+      this._updatePromise = new U(), o.resolve(!0);
+    }
+  }
+  async destroy() {
+    if (process.env.NODE_ENV !== "production" && u() && this.ensureHasDestroy?.(), !this.destroyed) {
+      if (this.component.el.isConnected) {
+        this.hasDestroy = !1;
+        try {
+          this.component.el.remove();
+        } finally {
+          this.hasDestroy = !0;
+        }
+      }
+      this._autoDestroyTimeout = void 0, this.destroyed = !0, this._controllers.forEach(We), this._controllers.clear(), await this._originalLifecycles._destroy?.call(this.component);
+    }
+  }
+  _setAutoDestroyTimeout() {
+    if (this._autoDestroyTimeout !== void 0 && clearTimeout(this._autoDestroyTimeout), !this.component.el.isConnected && !this.component.autoDestroyDisabled) {
+      const t = () => void this.destroy().catch(console.error);
+      process.env.NODE_ENV !== "production" && u() && B === 0 || (this._autoDestroyTimeout = re(t, B));
+    }
+  }
+}
+process.env.NODE_ENV !== "production" && u() && (Le.prototype.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.
+           */
+          @${this.isLit ? "property" : "Prop"}() ${x} = false;
+          
+          /** Permanently destroy the component */
+          @${this.isLit ? "method" : "Method"}()
+          async destroy(): Promise<void> {
+            await this.manager.destroy();
+          }
+          `.trim().split(`
+`).map((t) => t.trim()).join(`
+`)
+    );
+});
+const x = "autoDestroyDisabled";
+let B = 1e3;
+process.env.NODE_ENV !== "production" && u();
+const K = (e) => e;
+function xe(e) {
+  "triggerConnected" in e ? e.triggerConnected() : d(e.hostConnected, e);
+}
+function Oe(e) {
+  "triggerDisconnected" in e ? e.triggerDisconnected() : d(e.hostDisconnected, e);
+}
+async function Ne(e) {
+  "triggerLoad" in e ? await e.triggerLoad() : await S(e.hostLoad, e);
+}
+function Ue(e) {
+  "triggerLoaded" in e ? e.triggerLoaded() : d(e.hostLoaded, e);
+}
+function Se(e) {
+  "triggerUpdate" in e ? e.triggerUpdate(this) : d(e.hostUpdate, e, this);
+}
+function $e(e) {
+  "triggerUpdated" in e ? e.triggerUpdated(this) : d(e.hostUpdated, e, this);
+}
+function We(e) {
+  "triggerDestroy" in e ? e.triggerDestroy() : d(e.hostDestroy, e);
+}
+const Pe = (e) => je(void 0, e);
+class Re extends Z {
+  constructor(t, o) {
+    super(t);
+    const n = this.exports;
+    try {
+      k(this.component);
+      const s = o(this.component, this), r = this.exports !== n;
+      if (he(s)) {
+        r || this.setProvisionalExports(s);
+        const c = s.then((i) => {
+          this.exports = i, super.catchUpLifecycle();
+        }).catch((i) => {
+          this._ready.reject(i), console.error(i);
+        });
+        this.onLoad(async () => await c);
+      } else
+        (!r || s !== void 0) && (this.exports = s), queueMicrotask(() => super.catchUpLifecycle());
+    } catch (s) {
+      this._ready.reject(s), console.error(s);
+    }
+  }
+  /** Noop - will be called in the constructor instead */
+  catchUpLifecycle() {
+  }
+}
+const je = we(Re), Me = (e) => (t = {}) => (
+  // eslint-disable-next-line @typescript-eslint/promise-function-async
+  Pe((o, n) => {
+    const s = ne(o.el), r = {
+      _lang: s.lang,
+      _t9nLocale: s.t9nLocale,
+      _loading: !0
+    }, c = o;
+    n.onLifecycle(
+      () => se(
+        o.el,
+        () => e("./assets"),
+        ({ t9nLocale: l, t9nStrings: a, lang: h }) => {
+          const f = {
+            ...a,
+            _lang: h,
+            _t9nLocale: l,
+            _loading: !1
+          };
+          n.exports = f;
+          const y = a.componentLabel;
+          typeof y == "string" && "label" in o && o.label == null && (o.label ?? (o.label = y)), i(c.messageOverrides);
+        },
+        t.name
+      )
+    );
+    function i(l) {
+      const a = n.exports, h = a._original ?? a, f = te(h, l);
+      l && (f._original = h), n.exports = f;
+    }
+    return "messageOverrides" in c && n.onLifecycle(() => A(c, "messageOverrides", i)), t.blocking ? (n.setProvisionalExports(r, !1), n.ready) : r;
+  })
+);
+function te(e, t) {
+  if (!t)
+    return e;
+  const o = { ...e };
+  return Object.entries(t).forEach(([n, s]) => {
+    typeof s == "object" ? o[n] = te(e[n], s) : o[n] = s ?? e[n];
+  }), o;
+}
+const Te = Me(ie);
 export {
-  s as u
+  Te as u
 };