@arcgis/map-components 4.32.0-next.1 → 4.32.0-next.3

package/dist/esm/index-d8e1295e.js

@@ -1,1453 +0,0 @@
-/*!
- * All material copyright Esri, All Rights Reserved, unless otherwise specified.
- * See https://js.arcgis.com/4.32/esri/copyright.txt for details.
- * v4.32.0-next.1
- */
-import { c as isNotUndefined, d as safeCall, D as Deferred, e as safeAsyncCall, f as devToolsAwareTimeout, h as importCoreAccessor, j as importCoreAccessorSupportDecorators, k as camelToKebab, i as importCoreReactiveUtils } from './index-c52668d4.js';
-
-// src/framework.ts
-function retrieveComponentMembers(component, isLit) {
-  if (isLit) {
-    const elementProperties = component.constructor.elementProperties;
-    component.manager.internals.members = Object.fromEntries(
-      Array.from(
-        elementProperties,
-        ([name, descriptor]) => descriptor.noAccessor ? void 0 : [
-          name,
-          [
-            (descriptor.readOnly ? 2048 /* ReadOnly */ : 0) | (descriptor.state ? 32 /* State */ : 16 /* Unknown */)
-          ]
-        ]
-      ).filter(isNotUndefined)
-    );
-  } else {
-    const constructor = component.constructor;
-    const members = constructor.__registerControllers?.(component) ?? void 0;
-    constructor.__registerControllers = void 0;
-    if (typeof members !== "object") {
-      throw new Error(
-        "Failed to retrieve component meta" 
-      );
-    }
-    component.manager.internals.members = Object.fromEntries(
-      Object.entries(members).filter(([_name, [propType]]) => (propType & 63 /* PropLike */) !== 0)
-    );
-  }
-}
-function parsePropertyValue(value, type = 8 /* Any */) {
-  const isComplex = value == null || typeof value === "object" || typeof value === "function";
-  if (isComplex) {
-    return value;
-  }
-  if ((type & 4 /* Boolean */) !== 0) {
-    return value === "false" ? false : value === "" || !!value;
-  } else if ((type & 2 /* Number */) !== 0) {
-    return Number.parseFloat(value);
-  } else if ((type & 1 /* String */) !== 0) {
-    return String(value);
-  } else {
-    return value;
-  }
-}
-var getMemberType = (component, name) => component.manager.internals.members?.[name]?.[0];
-
-// src/types.ts
-var controllerSymbol = Symbol.for("controller");
-
-// src/utils.ts
-var isController = (value) => typeof value === "object" && value !== null && (controllerSymbol in value || "hostConnected" in value || "hostDisconnected" in value || "hostUpdate" in value || "hostUpdated" in value);
-
-// src/ControllerInternals.ts
-var ambientComponent;
-function setAmbientComponent(component) {
-  if (ambientComponent === component) {
-    return;
-  }
-  ambientComponent = component;
-  queueMicrotask(() => {
-    if (ambientComponent === component) {
-      ambientComponent = void 0;
-    }
-  });
-}
-function retrieveComponent(name2) {
-  return ambientComponent;
-}
-var ambientControllers = [];
-function setParentController(controller) {
-  if (controller === void 0) {
-    ambientControllers = [];
-    return;
-  }
-  const index = ambientControllers.indexOf(controller);
-  ambientControllers = index === -1 ? [...ambientControllers, controller] : ambientControllers.slice(0, index + 1);
-  queueMicrotask(() => {
-    ambientControllers = [];
-  });
-}
-function retrieveParentControllers() {
-  return ambientControllers;
-}
-var ambientChildController;
-function setAmbientChildController(controller) {
-  if (ambientChildController === controller) {
-    return;
-  }
-  ambientChildController = controller;
-  queueMicrotask(() => {
-    if (ambientChildController === controller) {
-      ambientChildController = void 0;
-    }
-  });
-}
-function retrieveAmbientChildController() {
-  const controller = ambientChildController;
-  ambientChildController = void 0;
-  return controller;
-}
-var use = async (value, watchExports) => {
-  const controller = useRefSync(value);
-  if (controller === void 0) {
-    return value;
-  }
-  await controller.ready;
-  if (typeof watchExports === "function") {
-    const unsubscribe = controller.watchExports(
-      (exports) => watchExports(exports, unsubscribe)
-    );
-  }
-  return controller.exports;
-};
-var useRef = async (value) => {
-  const controller = useRefSync(value);
-  await controller.ready;
-  return controller;
-};
-var useRefSync = (value) => {
-  const ambientChildController2 = retrieveAmbientChildController();
-  if (ambientChildController2 !== void 0) {
-    return ambientChildController2;
-  }
-  const component = retrieveComponent();
-  const controller = component.manager.internals.resolveExports(value);
-  if (controller !== void 0) {
-    return controller;
-  }
-  if (isController(value)) {
-    return value;
-  }
-  return void 0;
-};
-var shouldBypass = {
-  setter: false,
-  getter: false,
-  readOnly: false
-};
-var elementToInstance = /* @__PURE__ */ new WeakMap();
-var _a;
-_a = controllerSymbol;
-var Controller = class {
-  constructor(component) {
-    this._callbacks = {
-      hostConnected: [],
-      hostDisconnected: [],
-      hostLoad: [],
-      hostLoaded: [],
-      hostUpdate: [],
-      hostUpdated: [],
-      hostDestroy: [],
-      hostLifecycle: []
-    };
-    this._ready = new Deferred();
-    this._lifecycleCleanups = [];
-    this.connectedCalled = false;
-    this._loadCalled = false;
-    this.loadedCalled = false;
-    this[_a] = true;
-    this.ready = this._ready.promise;
-    /*
-     * Setting default exports to "this" so that controllers that don't use
-     * exports/proxyExports(), could still be used as if they did
-     * (i.e with controller.use)
-     */
-    this._exports = makeProvisionalValue(this);
-    this._exportWatchers = /* @__PURE__ */ new Set();
-    const resolvedComponent = toControllerHost(component ?? retrieveComponent());
-    {
-      this.component = resolvedComponent;
-    }
-    this.component.addController(this);
-    setParentController(this);
-    const manager = this.component.manager;
-    const isInControllerManager = manager === void 0;
-    if (!isInControllerManager) {
-      queueMicrotask(() => this.catchUpLifecycle());
-    }
-  }
-  /**
-   * If controller is being added dynamically, after the component
-   * construction, then trigger connected and load right away
-   */
-  catchUpLifecycle() {
-    const { manager } = this.component;
-    const connectedWillStillHappen = !manager.connectedCalled;
-    if (!connectedWillStillHappen && !this.connectedCalled) {
-      this.triggerConnected();
-    }
-    const loadWillStillHappen = !manager._loadCalled;
-    if (loadWillStillHappen) {
-      return;
-    }
-    this.triggerLoad().then(() => {
-      const loadedWillStillHappen = !manager.loadedCalled;
-      if (loadedWillStillHappen) {
-        return;
-      }
-      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(exports) {
-    const oldExports = this._exports;
-    if (oldExports !== exports) {
-      this._exports = exports;
-      this._exportWatchers.forEach(safeCall);
-      if (this.connectedCalled && this.assignedProperty !== false) {
-        this.component.requestUpdate(this.assignedProperty, oldExports);
-      }
-    }
-    this._ready.resolve(exports);
-  }
-  setProvisionalExports(exports) {
-    this._exports = makeProvisionalValue(exports);
-    this._exportWatchers.forEach(safeCall);
-  }
-  watchExports(callback) {
-    const safeCallback = () => callback(this._exports);
-    this._exportWatchers.add(safeCallback);
-    return () => void this._exportWatchers.delete(safeCallback);
-  }
-  /**
-   * 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() {
-    setAmbientComponent(this.component);
-    return use;
-  }
-  /**
-   * 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() {
-    setAmbientComponent(this.component);
-    return useRef;
-  }
-  /**
-   * Like useRef, but doesn't wait for the controller to get ready
-   *
-   * @internal
-   */
-  get useRefSync() {
-    setAmbientComponent(this.component);
-    return useRefSync;
-  }
-  controllerRemoved() {
-    if (this.component.el.isConnected) {
-      this.triggerDisconnected();
-    }
-    this.triggerDestroy();
-  }
-  // Register a lifecycle callback
-  onConnected(callback) {
-    this._callbacks.hostConnected.push(callback);
-  }
-  onDisconnected(callback) {
-    this._callbacks.hostDisconnected.push(callback);
-  }
-  onLoad(callback) {
-    this._callbacks.hostLoad.push(callback);
-  }
-  onLoaded(callback) {
-    this._callbacks.hostLoaded.push(callback);
-  }
-  onUpdate(callback) {
-    this._callbacks.hostUpdate.push(callback);
-  }
-  onUpdated(callback) {
-    this._callbacks.hostUpdated.push(callback);
-  }
-  onDestroy(callback) {
-    this._callbacks.hostDestroy.push(callback);
-  }
-  onLifecycle(callback) {
-    this._callbacks.hostLifecycle.push(callback);
-    if (this.connectedCalled && this.component.el.isConnected) {
-      this._callLifecycle(callback);
-    }
-  }
-  // Call each lifecycle hook
-  /** @internal */
-  triggerConnected() {
-    const genericController = this;
-    if (genericController.hostConnected) {
-      safeCall(genericController.hostConnected, genericController);
-    }
-    this._callbacks.hostConnected.forEach(safeCall);
-    this.triggerLifecycle();
-    this.connectedCalled = true;
-  }
-  /** @internal */
-  triggerDisconnected() {
-    const genericController = this;
-    if (genericController.hostDisconnected) {
-      safeCall(genericController.hostDisconnected, genericController);
-    }
-    this._callbacks.hostDisconnected.forEach(safeCall);
-    this._lifecycleCleanups.forEach(safeCall);
-    this._lifecycleCleanups = [];
-  }
-  /** @internal */
-  async triggerLoad() {
-    if (this._loadCalled) {
-      return;
-    }
-    this._loadCalled = true;
-    const genericController = this;
-    if (genericController.hostLoad) {
-      await safeAsyncCall(genericController.hostLoad, genericController);
-    }
-    if (this._callbacks.hostLoad.length > 0) {
-      await Promise.allSettled(this._callbacks.hostLoad.map(safeAsyncCall));
-    }
-    this._ready.resolve(this._exports);
-  }
-  /** @internal */
-  triggerLoaded() {
-    if (this.loadedCalled) {
-      return;
-    }
-    const genericController = this;
-    if (genericController.hostLoaded) {
-      safeCall(genericController.hostLoaded, genericController);
-    }
-    this._callbacks.hostLoaded.forEach(safeCall);
-    this.loadedCalled = true;
-  }
-  /** @internal */
-  triggerUpdate(changedProperties) {
-    const genericController = this;
-    if (genericController.hostUpdate) {
-      safeCall(genericController.hostUpdate, genericController, changedProperties);
-    }
-    this._callbacks.hostUpdate.forEach(callUpdate, changedProperties);
-  }
-  /** @internal */
-  triggerUpdated(changedProperties) {
-    const genericController = this;
-    if (genericController.hostUpdated) {
-      safeCall(genericController.hostUpdated, genericController, changedProperties);
-    }
-    this._callbacks.hostUpdated.forEach(callUpdate, changedProperties);
-  }
-  /** @internal */
-  triggerDestroy() {
-    const genericController = this;
-    if (genericController.hostDestroy) {
-      safeCall(genericController.hostDestroy, genericController);
-    }
-    this._callbacks.hostDestroy.forEach(safeCall);
-  }
-  /** @internal */
-  triggerLifecycle() {
-    const genericController = this;
-    if (genericController.hostLifecycle) {
-      this._callLifecycle(() => genericController.hostLifecycle());
-    }
-    this._callbacks.hostLifecycle.forEach(this._callLifecycle, this);
-  }
-  _callLifecycle(callback) {
-    setAmbientComponent(this.component);
-    const cleanupRaw = safeCall(callback);
-    const cleanup = Array.isArray(cleanupRaw) ? cleanupRaw : [cleanupRaw];
-    cleanup.forEach((cleanup2) => {
-      if (typeof cleanup2 === "function") {
-        this._lifecycleCleanups.push(cleanup2);
-      } else if (typeof cleanup2 === "object" && typeof cleanup2.remove === "function") {
-        this._lifecycleCleanups.push(cleanup2.remove);
-      }
-    });
-  }
-};
-function callUpdate(callback) {
-  safeCall(callback, void 0, this);
-}
-var GenericController = Controller;
-function makeProvisionalValue(base) {
-  if (typeof base !== "object" && typeof base !== "function" || base === null) {
-    return base;
-  }
-  const proxy = new Proxy(base, {
-    get(target, prop, receiver) {
-      if (cyclical.has(prop) && prop in target && target[prop] === proxy) {
-        return void 0;
-      }
-      if (prop in target || prop in Promise.prototype || typeof prop === "symbol") {
-        return typeof target === "function" ? target[prop] : Reflect.get(target, prop, receiver);
-      }
-      return void 0;
-    },
-    set: (target, prop, newValue, receiver) => {
-      return Reflect.set(target, prop, newValue, receiver);
-    }
-  });
-  return proxy;
-}
-var cyclical = /* @__PURE__ */ new Set(["exports", "_exports"]);
-function toControllerHost(component) {
-  {
-    return component;
-  }
-}
-function trackPropertyKey(object, onResolved, defaultValue) {
-  const keys = Object.keys(object);
-  const keyCount = keys.length;
-  if (keyTrackMap === void 0) {
-    queueMicrotask(keyTrackResolve);
-  }
-  keyTrackMap ?? (keyTrackMap = /* @__PURE__ */ new Map());
-  let pendingTrackers = keyTrackMap.get(object);
-  if (pendingTrackers === void 0) {
-    pendingTrackers = { callbacks: [], keyCount };
-    keyTrackMap.set(object, pendingTrackers);
-  }
-  if (pendingTrackers.keyCount !== keyCount) {
-    pendingTrackers.callbacks.forEach((resolve) => resolve(keys));
-    pendingTrackers.callbacks = [];
-    pendingTrackers.keyCount = keyCount;
-  }
-  pendingTrackers.callbacks.push((keys2) => {
-    const callback = (key2) => safeCall(onResolved, null, key2);
-    const key = keys2[keyCount];
-    if (key === void 0) {
-      callback(void 0);
-    } else if (object[key] === defaultValue) {
-      callback(key);
-    } else {
-      callback(void 0);
-    }
-  });
-  return defaultValue;
-}
-var keyTrackMap = void 0;
-function keyTrackResolve() {
-  Array.from(keyTrackMap?.entries() ?? []).forEach(([object, { callbacks }]) => {
-    const keys = Object.keys(object);
-    callbacks.forEach((commit) => commit(keys));
-  });
-  keyTrackMap = void 0;
-}
-function watch(component, property, callback) {
-  var _a2;
-  const genericProperty = property;
-  const internals = component.manager.internals;
-  (_a2 = internals.allWatchers)[genericProperty] ?? (_a2[genericProperty] = []);
-  const watchers = internals.allWatchers[genericProperty];
-  const genericCallback = callback;
-  const safeCallback = (newValue, oldValue, propertyName) => safeCall(genericCallback, null, newValue, oldValue, propertyName);
-  watchers.push(safeCallback);
-  return () => {
-    const index = watchers.indexOf(safeCallback);
-    if (index !== -1) {
-      watchers.splice(index, 1);
-    }
-  };
-}
-
-// src/ComponentInternals.ts
-var ComponentInternals = class {
-  constructor(component) {
-    /**
-     * When watchers are set, they are set into `allWatchers`. When watchers are
-     * read in the setter, they are read from `enabledWatchers`.
-     *
-     * In Stencil, on connectedCallback(), controller manager does
-     * `enabledWatchers=allWatchers`. Reasoning:
-     * - This disables watchers until connected callback (matches behavior of
-     *   Stencil's watchers)
-     * - This removes the need for a check in the setter for whether the watchers
-     *   were enabled already or not (as getters/setters are hot path, and should
-     *   be streamlined)
-     *
-     * In Lit, we set enabledWatchers to allWatchers in the constructor.
-     * Reasoning:
-     * - While in Stencil all user provided properties are either set before the
-     *   component constructor (this is possible since Stencil's props store is
-     *   externalized) or after connectedCallback, in Lit the properties may be
-     *   set by attributeChangedCallback before connectedCallback. Thus, we need
-     *   to enable watchers even before connectedCallback.
-     * - This means, that a watcher set for some prop before your component got
-     *   a chance to set the default value will trigger the watcher when the
-     *   default value is set - but, that is inline with Lit's willUpdate behavior
-     *   of triggering for default values AND, the only way to set a watcher
-     *   before default value is if you called watcher inside a controller. For
-     *   now, there are no controllers written outside of arcgis-map-components
-     *   package, so I was able to verify that this change would have no
-     *   negative impact.
-     *
-     * In either way, I plan to remove watchers from controllers once Stencil
-     * support is removed.
-     */
-    this.enabledWatchers = {};
-    this.allWatchers = {};
-    /**
-     * "readOnly" is not enabled initially since we need to allow to set property
-     * default values in the constructor.
-     * For Stencil, readonly is enabled by the `readonly()` controller.
-     * For Lit, we have the following logic:
-     */
-    this.enableReadonly = () => {
-      this.enableReadonly = void 0;
-      if (!this.component.manager.isLit) {
-        return;
-      }
-      const internals = this.component.manager.internals;
-      Object.entries(internals.members).forEach(([name2, [type]]) => {
-        var _a2;
-        const isReadOnly = type & 2048 /* ReadOnly */;
-        if (isReadOnly) {
-          (_a2 = internals.setters)[name2] ?? (_a2[name2] = []);
-          internals.setters[name2].push(internals.readonlySetter);
-        }
-      });
-    };
-    this.trackedValue = nothing;
-    this.keyTrackers = [];
-    this.getters = {};
-    this.setters = {};
-    this.accessorGetter = {};
-    this.accessorSetter = {};
-    this.reactiveUtilsIntegrations = /* @__PURE__ */ new Set();
-    this._exports = /* @__PURE__ */ new WeakMap();
-    this.readonlySetter = (newValue, _oldValue, property) => {
-      if (shouldBypass.readOnly) {
-        return newValue;
-      }
-      throw new Error(
-        `Cannot assign to read-only property "${property}" of ${this.component.el.tagName.toLowerCase()}. Trying to assign "${String(
-          newValue
-        )}"`
-      );
-    };
-    {
-      this.component = component;
-    }
-  }
-  firePropTrackers(key, value) {
-    const trackers = this.keyTrackers;
-    this.trackedValue = nothing;
-    this.keyTrackers = [];
-    trackers.forEach((tracker) => tracker(key, value));
-  }
-  // 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(property) {
-    const component = this.component;
-    const classPrototype = component.constructor.prototype;
-    this._getSetProxy(classPrototype, property, "class");
-    if (component.manager.isLit) {
-      return;
-    }
-    const htmlPrototype = component.el.constructor.prototype;
-    if (classPrototype !== htmlPrototype) {
-      this._getSetProxy(htmlPrototype, property, "html");
-    }
-  }
-  _getSetProxy(prototype, name2, type) {
-    const component = this.component;
-    const propType = getMemberType(component, name2);
-    let descriptor;
-    do {
-      descriptor = Object.getOwnPropertyDescriptor(prototype, name2);
-    } while (!descriptor && (prototype = Object.getPrototypeOf(prototype)));
-    if (!descriptor) {
-      return void 0;
-    }
-    const originalGet = descriptor.get;
-    const originalSet = descriptor.set;
-    const isGetterAlreadyOverwritten = customAccessor in originalGet;
-    const isSetterAlreadyOverwritten = customAccessor in originalSet;
-    if (isGetterAlreadyOverwritten && isSetterAlreadyOverwritten) {
-      return;
-    }
-    const shouldOverwriteGet = !isGetterAlreadyOverwritten;
-    const shouldOverwriteSet = !isSetterAlreadyOverwritten;
-    const finalGetter = shouldOverwriteGet ? function getter() {
-      let value = originalGet.call(this);
-      const component2 = elementToInstance.get(this);
-      if (shouldBypass.getter || component2 === void 0) {
-        return value;
-      }
-      const internals = component2.manager.internals;
-      value = internals.accessorGetter[name2](value, name2);
-      const getters = internals.getters[name2] ?? emptyArray;
-      for (let i = 0; i < getters.length; i++) {
-        value = getters[i](value, name2);
-      }
-      return value;
-    } : originalGet;
-    const finalSetter = shouldOverwriteSet ? function setter(rawNewValue) {
-      const oldValue = originalGet.call(this);
-      const component2 = elementToInstance.get(this);
-      if (component2 === void 0) {
-        originalSet.call(this, rawNewValue);
-        return;
-      }
-      let newValue = component2.manager.isLit ? (
-        /*
-         * Cast `null` to `undefined`.
-         * See https://devtopia.esri.com/WebGIS/arcgis-web-components/discussions/1299
-         */
-        rawNewValue ?? void 0
-      ) : parsePropertyValue(rawNewValue, propType);
-      const internals = component2.manager.internals;
-      if (newValue === oldValue) {
-        originalSet.call(this, newValue);
-      } else {
-        const setters = shouldBypass.setter ? emptyArray : internals.setters[name2] ?? emptyArray;
-        for (let i = 0; i < setters.length; i++) {
-          newValue = setters[i](newValue, oldValue, name2);
-          if (newValue === oldValue) {
-            break;
-          }
-        }
-        newValue = internals.accessorSetter[name2](newValue, oldValue, name2);
-        originalSet.call(this, newValue);
-        if (newValue !== oldValue) {
-          internals.enabledWatchers[name2]?.forEach((watcher) => watcher(newValue, oldValue, name2));
-        }
-      }
-      if (internals.keyTrackers.length > 0) {
-        internals?.firePropTrackers(name2, rawNewValue);
-      }
-    } : originalSet;
-    if (shouldOverwriteGet) {
-      finalGetter[customAccessor] = true;
-    }
-    if (shouldOverwriteSet) {
-      finalSetter[customAccessor] = true;
-    }
-    Object.defineProperty(prototype, name2, {
-      ...descriptor,
-      get: finalGetter,
-      set: finalSetter
-    });
-  }
-  /**
-   * Associate an exports object with a controller for reverse lookup in
-   * controller.use
-   */
-  markExports(controller, exports) {
-    if (typeof exports === "object" && exports !== null || typeof exports === "function") {
-      this._exports.set(exports, controller);
-    }
-  }
-  resolveExports(exports) {
-    if (typeof exports === "object" && exports !== null || typeof exports === "function") {
-      return this._exports.get(exports);
-    } else {
-      return void 0;
-    }
-  }
-};
-var emptyArray = [];
-var customAccessor = Symbol();
-var nothing = Symbol() ;
-var useControllerManager = (component, forceUpdate) => new ControllerManager(component, forceUpdate);
-var ControllerManager = class extends GenericController {
-  constructor(component, forceUpdate) {
-    const isLit = "addController" in component;
-    const controllers = /* @__PURE__ */ new Set();
-    function addController(controller) {
-      controllers.add(controller);
-      if (!(controllerSymbol in controller) && component.renderRoot && component.el.isConnected) {
-        controller.hostConnected?.();
-      }
-    }
-    function removeController(controller) {
-      void controllers.delete(controller);
-      controller.controllerRemoved?.();
-    }
-    const controllerHost = component;
-    controllerHost.addController = addController;
-    controllerHost.removeController = removeController;
-    if (!isLit) {
-      const update = forceUpdate ?? component.constructor.__forceUpdate;
-      controllerHost.requestUpdate = () => update(component);
-    }
-    super(component);
-    /** @internal */
-    this.internals = new ComponentInternals(this.component);
-    this.destroyed = false;
-    this._updatePromise = new Deferred();
-    this._originalLifecycles = {};
-    this.isLit = isLit;
-    this.component.manager = this;
-    retrieveComponentMembers(component, isLit);
-    this._controllers = controllers;
-    this.exports = void 0;
-    this.hasDestroy = autoDestroyDisabledPropName in this.component && typeof this.component.destroy === "function";
-    this._bindLifecycleMethods();
-    const internals = this.internals;
-    Object.keys(internals.members).forEach((name2) => {
-      internals.accessorGetter[name2] = defaultGetterSetter;
-      internals.accessorSetter[name2] = defaultGetterSetter;
-      internals.getSetProxy(name2);
-    });
-    if (isLit) {
-      this.internals.enabledWatchers = this.internals.allWatchers;
-    } else {
-      Object.defineProperty(component, "updateComplete", {
-        get: async () => await this._updatePromise.promise
-      });
-    }
-    queueMicrotask(internals.enableReadonly);
-    setParentController(void 0);
-    setAmbientComponent(component);
-    elementToInstance.set(component.el, component);
-    elementToInstance.set(component, component);
-  }
-  _bindLifecycleMethods() {
-    const component = this.component;
-    const isLit = this.isLit;
-    const isStencilDistBuild = component.el === component;
-    this._originalLifecycles = {
-      // These component's callbacks will be called by Lit, so we don't have to
-      _connectedCallback: isLit || isStencilDistBuild ? void 0 : component.connectedCallback,
-      _disconnectedCallback: isLit || isStencilDistBuild ? void 0 : component.disconnectedCallback,
-      _load: isLit ? component.load : component.componentWillLoad,
-      _loaded: isLit ? component.loaded : component.componentDidLoad,
-      _willUpdate: isLit ? void 0 : component.componentWillUpdate,
-      _updated: isLit ? void 0 : component.componentDidUpdate,
-      _destroy: component.destroy
-    };
-    const hostConnected = this._connectedCallback.bind(this);
-    const hostDisconnected = this._disconnectedCallback.bind(this);
-    const hostUpdate = this._update.bind(this);
-    const hostUpdated = this._updated.bind(this);
-    if (isLit) {
-      component.constructor.prototype.addController.call(component, {
-        // Lit will call these callbacks
-        hostConnected,
-        hostDisconnected,
-        hostUpdate,
-        hostUpdated
-      });
-    } else {
-      component.connectedCallback = hostConnected;
-      component.disconnectedCallback = hostDisconnected;
-      component.componentWillLoad = this._load.bind(this);
-      component.componentDidLoad = this._loaded.bind(this);
-      component.componentWillUpdate = hostUpdate;
-      component.componentDidUpdate = hostUpdated;
-    }
-    if (this.hasDestroy) {
-      component.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 tagName = this.component.el.tagName.toLowerCase();
-      this.component.el.remove();
-      throw new Error(
-        `The ${tagName} component has already been destroyed. It cannot be used again. If you meant to disconnect and reconnect a component without automatic destroy, set the ${autoDestroyDisabledPropName} prop.`
-      );
-    }
-    if (this._autoDestroyTimeout !== void 0) {
-      clearTimeout(this._autoDestroyTimeout);
-    }
-    const internals = this.internals;
-    internals.enabledWatchers = internals.allWatchers;
-    keyTrackResolve();
-    internals.enableReadonly?.();
-    this._controllers.forEach(callConnected);
-    this._originalLifecycles._connectedCallback?.call(this.component);
-  }
-  /** @internal */
-  _disconnectedCallback() {
-    if (this.destroyed) {
-      return;
-    }
-    this._controllers.forEach(callDisconnected);
-    this._originalLifecycles._disconnectedCallback?.call(this.component);
-    if (this.hasDestroy) {
-      this._setAutoDestroyTimeout();
-    }
-  }
-  /** @internal */
-  async _load() {
-    const integrations = this.internals.reactiveUtilsIntegrations;
-    if (integrations.size > 0) {
-      for (const controller of integrations) {
-        if ("triggerLoad" in controller) {
-          await controller.triggerLoad();
-        } else {
-          await safeAsyncCall(controller.hostLoad, controller);
-        }
-      }
-    }
-    await Promise.allSettled(Array.from(this._controllers, callLoad, integrations));
-    await this._originalLifecycles._load?.call(this.component);
-    if (this.hasDestroy) {
-      watch(this.component, autoDestroyDisabledPropName, () => this._setAutoDestroyTimeout());
-    }
-  }
-  /** @internal */
-  _loaded() {
-    this._controllers.forEach(callLoaded);
-    this._originalLifecycles._loaded?.call(this.component);
-  }
-  _update() {
-    const maybeLitComponent = this.component;
-    this._controllers.forEach(callUpdate2, maybeLitComponent.$changes);
-    this._originalLifecycles._willUpdate?.call(this.component);
-  }
-  _updated() {
-    const maybeLitComponent = this.component;
-    this._controllers.forEach(callUpdated, maybeLitComponent.$changes);
-    this._originalLifecycles._updated?.call(this.component);
-    if (this.isLit) {
-      maybeLitComponent.$changes = /* @__PURE__ */ new Map();
-    } else {
-      const updatePromise = this._updatePromise;
-      this._updatePromise = new Deferred();
-      updatePromise.resolve(true);
-    }
-  }
-  async destroy() {
-    if (this.destroyed) {
-      return;
-    }
-    if (this.component.el.isConnected) {
-      this.hasDestroy = false;
-      try {
-        this.component.el.remove();
-      } finally {
-        this.hasDestroy = true;
-      }
-    }
-    this._autoDestroyTimeout = void 0;
-    this.destroyed = true;
-    this._controllers.forEach(callDestroy);
-    this._controllers.clear();
-    await this._originalLifecycles._destroy?.call(this.component);
-  }
-  _setAutoDestroyTimeout() {
-    if (this._autoDestroyTimeout !== void 0) {
-      clearTimeout(this._autoDestroyTimeout);
-    }
-    if (!this.component.el.isConnected && !this.component.autoDestroyDisabled) {
-      const destroy = () => void this.destroy().catch(console.error);
-      {
-        this._autoDestroyTimeout = devToolsAwareTimeout(destroy, autoDestroyOnDisconnectTimeout);
-      }
-    }
-  }
-};
-var autoDestroyDisabledPropName = "autoDestroyDisabled";
-var autoDestroyOnDisconnectTimeout = 1e3;
-var defaultGetterSetter = (value) => value;
-function callConnected(controller) {
-  if ("triggerConnected" in controller) {
-    controller.triggerConnected();
-  } else {
-    safeCall(controller.hostConnected, controller);
-  }
-}
-function callDisconnected(controller) {
-  if ("triggerDisconnected" in controller) {
-    controller.triggerDisconnected();
-  } else {
-    safeCall(controller.hostDisconnected, controller);
-  }
-}
-async function callLoad(controller) {
-  if (!this.has(controller)) {
-    if ("triggerLoad" in controller) {
-      await controller.triggerLoad();
-    } else {
-      await safeAsyncCall(controller.hostLoad, controller);
-    }
-  }
-}
-function callLoaded(controller) {
-  if ("triggerLoaded" in controller) {
-    controller.triggerLoaded();
-  } else {
-    safeCall(controller.hostLoaded, controller);
-  }
-}
-function callUpdate2(controller) {
-  if ("triggerUpdate" in controller) {
-    controller.triggerUpdate(this);
-  } else {
-    safeCall(controller.hostUpdate, controller, this);
-  }
-}
-function callUpdated(controller) {
-  if ("triggerUpdated" in controller) {
-    controller.triggerUpdated(this);
-  } else {
-    safeCall(controller.hostUpdated, controller, this);
-  }
-}
-function callDestroy(controller) {
-  if ("triggerDestroy" in controller) {
-    controller.triggerDestroy();
-  } else {
-    safeCall(controller.hostDestroy, controller);
-  }
-}
-function trackPropKey(component, onResolved, defaultValue) {
-  const internals = component.manager.internals;
-  if (internals.trackedValue !== nothing && internals.trackedValue !== defaultValue) {
-    internals.firePropTrackers(void 0, void 0);
-  }
-  if (internals.keyTrackers.length === 0) {
-    queueMicrotask(() => internals.firePropTrackers(void 0, void 0));
-  }
-  internals.trackedValue = defaultValue;
-  internals.keyTrackers.push((key, value) => safeCall(onResolved, void 0, defaultValue === value ? key : void 0));
-  return defaultValue;
-}
-
-// src/trackKey.ts
-function trackKey(hostsCandidates, onResolved, defaultValue) {
-  const candidateHosts = Array.isArray(hostsCandidates) ? hostsCandidates : [hostsCandidates];
-  let leftToResolve = candidateHosts.length + 1;
-  const resolved = (resolution) => {
-    leftToResolve -= 1;
-    if (resolution !== void 0) {
-      leftToResolve = Math.min(leftToResolve, 0);
-    }
-    if (leftToResolve === 0) {
-      onResolved(resolution);
-    }
-  };
-  candidateHosts.forEach(
-    (host) => trackPropertyKey(
-      host,
-      (key) => resolved(
-        key === void 0 ? void 0 : {
-          key,
-          host,
-          isReactive: false
-        }
-      ),
-      defaultValue
-    )
-  );
-  const component = candidateHosts.find(
-    (host) => "manager" in host && typeof host.manager === "object" && host.manager.component === host
-  );
-  if (component) {
-    trackPropKey(
-      component,
-      (key) => resolved(
-        key === void 0 ? void 0 : {
-          key,
-          host: component,
-          isReactive: getMemberType(component, key) !== void 0
-        }
-      ),
-      defaultValue
-    );
-  }
-  return defaultValue;
-}
-
-// src/getSet.ts
-function getSet(defaultValue, getSet2) {
-  const component = retrieveComponent();
-  return trackPropKey(
-    component,
-    (rawName) => {
-      const name2 = rawName;
-      const manager = component.manager;
-      const genericComponent = component;
-      const value = genericComponent[name2];
-      const isStencilHotReload = "production" !== "production"  ;
-      if (value != null && value !== defaultValue && typeof getSet2.set === "function" && !isStencilHotReload) {
-        const newValue = getSet2.set(value, defaultValue, name2);
-        if (newValue !== value) {
-          if (manager.isLit) {
-            genericComponent[name2] = newValue;
-          } else {
-            let firstConnected = true;
-            manager.onConnected(() => {
-              if (!firstConnected) {
-                return;
-              }
-              firstConnected = true;
-              bypassSetter(() => {
-                genericComponent[name2] = newValue;
-              });
-            });
-          }
-        }
-      }
-      genericGetSet(component, name2, getSet2);
-    },
-    defaultValue
-  );
-}
-function bypassSetter(callback) {
-  shouldBypass.setter = true;
-  try {
-    return callback();
-  } finally {
-    shouldBypass.setter = false;
-  }
-}
-function bypassGetter(callback) {
-  shouldBypass.getter = true;
-  try {
-    return callback();
-  } finally {
-    shouldBypass.getter = false;
-  }
-}
-function genericGetSet(component, property, getSet2) {
-  var _a2, _b;
-  const genericGetSet2 = getSet2;
-  const internals = component.manager.internals;
-  const get = typeof genericGetSet2.get === "function" ? genericGetSet2.get : void 0;
-  if (get) {
-    (_a2 = internals.getters)[property] ?? (_a2[property] = []);
-    internals.getters[property].unshift(get);
-  }
-  const set = genericGetSet2.set === "ignore" ? ignoreSet : genericGetSet2.set;
-  if (set) {
-    (_b = internals.setters)[property] ?? (_b[property] = []);
-    internals.setters[property].unshift(
-      set
-    );
-  }
-}
-var ignoreSet = (_, value) => value;
-
-// src/readonly.ts
-function readonly(value) {
-  const component = retrieveComponent();
-  return getSet(value, { set: component.manager.internals.readonlySetter });
-}
-function bypassReadOnly(callback) {
-  shouldBypass.readOnly = true;
-  try {
-    return callback();
-  } finally {
-    shouldBypass.readOnly = false;
-  }
-}
-
-// src/proxyExports.ts
-var proxyExports = (Class) => (...args) => {
-  const ambientControllers2 = retrieveParentControllers();
-  const instance = new Class(...args);
-  const initialExports = instance.exports;
-  setParentController(ambientControllers2.at(-1));
-  const internals = instance.component.manager.internals;
-  internals.markExports(instance, initialExports);
-  instance.watchExports((exports) => internals.markExports(instance, exports));
-  setAmbientChildController(instance);
-  const hostCandidates = [instance.component, ...ambientControllers2].reverse();
-  return trackKey(
-    hostCandidates,
-    (resolution) => resolution === void 0 ? void 0 : setProxy(instance, resolution, initialExports),
-    initialExports
-  );
-};
-function setProxy(controller, { host, key, isReactive: assignedToProp }, initialExports) {
-  const genericHost = host;
-  const controllerValueChanged = genericHost[key] !== controller.exports;
-  const hostValueChanged = genericHost[key] !== initialExports;
-  const controllerUpdatedExports = initialExports !== controller.exports;
-  if (controllerValueChanged && !hostValueChanged && controllerUpdatedExports) {
-    genericHost[key] = controller.exports;
-  }
-  const isProxyExportsOnComponent = host === controller.component;
-  if (isProxyExportsOnComponent) {
-    if (assignedToProp) {
-      const internals = controller.component.manager.internals;
-      if (hostValueChanged) {
-        internals.markExports(controller, genericHost[key]);
-      }
-      watch(controller.component, key, (value) => {
-        if (value !== controller.exports) {
-          internals.markExports(controller, value);
-        }
-      });
-    }
-    controller.assignedProperty = assignedToProp ? void 0 : key;
-  }
-  controller.watchExports(() => {
-    if (genericHost[key] === controller.exports) {
-      return;
-    }
-    const manager = controller.component.manager;
-    const isReadOnly = manager.internals.setters[key]?.includes(manager.internals.readonlySetter);
-    if (isReadOnly) {
-      bypassReadOnly(() => {
-        genericHost[key] = controller.exports;
-      });
-    } else {
-      genericHost[key] = controller.exports;
-    }
-  });
-}
-
-var reactiveUtils;
-async function loadReactiveUtils() {
-  reactiveUtils ?? (reactiveUtils = importCoreReactiveUtils());
-  return await reactiveUtils;
-}
-var accessorPromise = Promise.all([importCoreAccessor(), importCoreAccessorSupportDecorators()]);
-var ReactiveUtilsIntegration = class extends Controller {
-  async hostLoad() {
-    const [Accessor, { subclass, property }] = await accessorPromise;
-    class AccessorSubclass extends Accessor {
-    }
-    const getter = (_value, propertyName) => accessor[propertyName];
-    function setter(newValue, _oldValue, propertyName) {
-      if (accessor !== void 0) {
-        accessor[propertyName] = newValue;
-      }
-      return newValue;
-    }
-    const component = this.component;
-    const internals = component.manager.internals;
-    const enabledMembers = [];
-    bypassGetter(
-      () => Object.keys(internals.members).forEach((name) => {
-        const alreadyIntegrated = internals.accessorSetter[name] !== defaultGetterSetter;
-        if (alreadyIntegrated) {
-          return;
-        }
-        enabledMembers.push(name);
-        internals.accessorGetter[name] = getter;
-        internals.accessorSetter[name] = setter;
-        property({
-          value: component[name]
-        })(AccessorSubclass.prototype, name);
-      })
-    );
-    this._enabledMembers = enabledMembers;
-    if (enabledMembers.length === 0) {
-      return;
-    }
-    const Subclass = subclass(component.el.tagName)(AccessorSubclass);
-    const accessor = new Subclass();
-    this._instance = accessor;
-  }
-  controllerRemoved() {
-    super.controllerRemoved();
-    const internals = this.component.manager.internals;
-    this._instance?.destroy();
-    this._enabledMembers?.forEach((name) => {
-      internals.accessorGetter[name] = defaultGetterSetter;
-      internals.accessorSetter[name] = defaultGetterSetter;
-    });
-  }
-};
-
-// src/accessor/useAccessor.ts
-var makeAccessorController = (loadAccessor, _options) => (component, options) => proxy(component, loadAccessor, options);
-var AccessorController = class extends GenericController {
-  constructor(component, _loadAccessor, _options) {
-    super(component);
-    this._loadAccessor = _loadAccessor;
-    this._options = _options;
-    // A mapping from bound component's "prop" name to Accessor instance's "property"
-    this._watchedProperties = /* @__PURE__ */ new Map();
-    this._isBinding = { value: true };
-    this.setProvisionalExports(
-      accessorSupport.makeGetterProxy(
-        component,
-        this._watchedProperties,
-        this._isBinding,
-        this.constructor.allowedPropNameMismatches
-      )
-    );
-    const integrations = component.manager.internals.reactiveUtilsIntegrations;
-    integrations.add(this);
-    const reactiveUtilsIntegration = Array.from(integrations).find(
-      (integration) => integration instanceof ReactiveUtilsIntegration
-    );
-    if (reactiveUtilsIntegration) {
-      integrations.delete(reactiveUtilsIntegration);
-    }
-    integrations.add(reactiveUtilsIntegration ?? new ReactiveUtilsIntegration(this.component));
-    trackPropKey(
-      component,
-      (resolved) => {
-        if (resolved) {
-          this._instancePropName = resolved;
-        }
-      },
-      this.exports
-    );
-  }
-  hostConnected() {
-    this._isBinding.value = false;
-  }
-  async hostLoad() {
-    this.reactiveUtils = await loadReactiveUtils();
-    const component = this.component;
-    const parameters = this._gatherParameters();
-    const finalParameters = this._options?.editConstructorProperties?.call(component, parameters) ?? parameters;
-    const awaitedParameters = finalParameters instanceof Promise ? await finalParameters : finalParameters;
-    const genericComponent = component;
-    const existingInstance = typeof this._instancePropName === "string" ? genericComponent[this._instancePropName] : void 0;
-    const hasInstance = existingInstance != null && existingInstance !== this.exports;
-    if (hasInstance) {
-      this._instance = existingInstance;
-      existingInstance.set(awaitedParameters);
-    } else {
-      this._instance = await this._createInstance(awaitedParameters);
-    }
-    if (component.manager.destroyed) {
-      return;
-    }
-    accessorSupport.watchComponentUpdates(this, this._instance, this._watchedProperties);
-    accessorSupport.watchAccessorUpdates(this, this._instance, this._watchedProperties);
-    this.exports = this._instance;
-  }
-  _gatherParameters() {
-    const data = Object.fromEntries(
-      Array.from(
-        this._watchedProperties,
-        ([prop, property]) => [property, this.component[prop]]
-      ).filter(([, value]) => value !== void 0)
-    );
-    const props = data ;
-    return props;
-  }
-  async _createInstance(parameters) {
-    if (this._isAccessorConstructor(this._loadAccessor)) {
-      return new this._loadAccessor(parameters);
-    } else {
-      return await this._loadAccessor(parameters);
-    }
-  }
-  _isAccessorConstructor(loader) {
-    return "prototype" in loader && "declaredClass" in loader.prototype;
-  }
-  hostDestroy() {
-    if (this._instance) {
-      this._instance.destroy();
-    }
-  }
-  async reCreate() {
-    this.hostDestroy();
-    await this.hostLoad();
-  }
-};
-var proxy = proxyExports(AccessorController);
-var accessorSupport = {
-  makeGetterProxy: (component, watchedProperties, isBinding, allowedPropNameMismatches) => new Proxy(
-    {},
-    {
-      /*
-       * Without this, makeProvisionalValue() will throw on accessing
-       * non-existent prop
-       */
-      has: (target, prop) => typeof prop === "string" || prop in target,
-      get: (target, prop) => {
-        const value = Reflect.get(target, prop);
-        if (typeof prop === "symbol" || prop in Promise.prototype) {
-          return value;
-        }
-        const hasProp = prop in target;
-        const doBinding = isBinding?.value ?? true;
-        if (hasProp || !doBinding) {
-          return value;
-        }
-        return trackKey(
-          component,
-          (resolved) => {
-            if (resolved !== void 0) {
-              watchedProperties.set(resolved.key, prop);
-            }
-          },
-          value
-        );
-      }
-    }
-  ),
-  // Update Accessor on component prop change
-  watchComponentUpdates(controller, instance, watchedProperties) {
-    function getter(_value, propName) {
-      const propertyName = watchedProperties.get(propName);
-      const value = instance[propertyName];
-      const flipBoolean = typeof value === "boolean" && propertyName !== propName && propName.toLowerCase().includes("disable");
-      return flipBoolean ? !value : value;
-    }
-    const setter = (newValue, _oldValue, propName) => {
-      const propertyName = watchedProperties.get(propName);
-      const value = instance[propertyName];
-      const flipBoolean = typeof value === "boolean" && propertyName !== propName && propName.toLowerCase().includes("disable");
-      const currentValue = flipBoolean ? !value : component.manager.isLit ? value ?? void 0 : value;
-      if (currentValue === newValue) {
-        return newValue;
-      }
-      instance[propertyName] = flipBoolean ? !newValue : newValue;
-      const finalValue = instance[propertyName];
-      return flipBoolean ? !finalValue : finalValue;
-    };
-    const component = controller.component;
-    const internals = component.manager.internals;
-    watchedProperties.forEach((_propName, propertyName) => {
-      internals.accessorGetter[propertyName] = getter;
-      internals.accessorSetter[propertyName] = setter;
-    });
-  },
-  // Update component on Accessor prop change
-  watchAccessorUpdates(controller, instance, watchedProperties) {
-    const { component } = controller;
-    const genericComponent = component;
-    const genericInstance = instance;
-    const readonlyProps = findReadOnlyAccessorProps(instance);
-    bypassGetter(
-      () => (
-        // Careful: Map's forEach callback arguments are (value, key), not (key, value)
-        watchedProperties.forEach((propertyName, propName) => {
-          if (readonlyProps.has(propertyName)) {
-            return;
-          }
-          const domValue = genericComponent[propName];
-          let modelValue = genericInstance[propertyName];
-          if (component.manager.isLit) {
-            modelValue ?? (modelValue = void 0);
-          }
-          const flipBoolean = typeof domValue === "boolean" && propertyName !== propName && propName.toLowerCase().includes("disable");
-          const resolvedDomValue = flipBoolean ? !domValue : domValue;
-          if (resolvedDomValue != null && modelValue !== resolvedDomValue) {
-            genericInstance[propertyName] = resolvedDomValue;
-          }
-        })
-      )
-    );
-    controller.onLifecycle(() => {
-      if (instance.destroyed) {
-        return;
-      }
-      return Array.from(
-        watchedProperties,
-        ([propName, propertyName]) => controller.reactiveUtils.watch(
-          () => genericInstance[propertyName],
-          () => {
-            const newValue = genericInstance[propertyName];
-            const flipBoolean = typeof newValue === "boolean" && propertyName !== propName && propName.toLowerCase().includes("disable");
-            const resolvedNewValue = flipBoolean ? !newValue : newValue;
-            bypassSetter(() => {
-              genericComponent[propName] = resolvedNewValue;
-            });
-          },
-          { initial: true }
-        )
-      );
-    });
-  },
-  // REFACTOR: remove this once Stencil is no longer supported
-  reEmitAccessorEvents(controller, instance, reactiveUtils2, prefix) {
-    const isEvented = "on" in instance && typeof instance.on === "function";
-    if (!isEvented) {
-      return;
-    }
-    const toListen = Object.entries(controller.component).map(([key, unknown]) => {
-      const value = unknown;
-      if (!key.startsWith(prefix) || key === prefix || typeof value !== "object" || value === null || !("emit" in value) || typeof value.emit !== "function") {
-        return void 0;
-      }
-      const emit = value.emit;
-      const trimmedEventName = key.slice(prefix.length);
-      const camelCaseEventName = camelToKebab(trimmedEventName);
-      const eventName = camelCaseEventName.toLowerCase();
-      return [eventName, emit];
-    }).filter(isNotUndefined);
-    if (toListen.length === 0) {
-      return;
-    }
-    const eventTarget = instance;
-    const getEventTarget = () => eventTarget;
-    controller.onLifecycle(() => {
-      if (instance.destroyed) {
-        return;
-      }
-      return toListen.map(([eventName, emit]) => reactiveUtils2.on(getEventTarget, eventName, emit));
-    });
-  },
-  async reCreate(instance, component) {
-    const accessorController = component.manager.useRefSync(instance);
-    if (accessorController === void 0) {
-      return;
-    }
-    await accessorController.reCreate();
-  }
-};
-function findReadOnlyAccessorProps(instance) {
-  const accessor = instance;
-  const properties = Object.entries(accessor.__accessor__?.metadata ?? {});
-  return new Set(
-    properties.filter(([_property, descriptor]) => descriptor?.readOnly === true).map(([property]) => property)
-  );
-}
-
-export { AccessorController as A, Controller as C, accessorSupport as a, getSet as g, makeAccessorController as m, proxyExports as p, readonly as r, setAmbientComponent as s, trackPropKey as t, useControllerManager as u, watch as w };