@arcgis/coding-components 4.30.0-next.86 → 4.30.0-next.88

package/dist/components/{chunk-63RMNUHL.js → chunk-IHYYRFLQ.js}

@@ -1,7 +1,7 @@
 /*!
  * All material copyright Esri, All Rights Reserved, unless otherwise specified.
  * See https://js.arcgis.com/4.30/esri/copyright.txt for details.
- * v4.30.0-next.86
+ * v4.30.0-next.88
  */
 import { D as Deferred, g as camelToKebab, h as safeCall, j as safeAsyncCall, k as devToolsAwareTimeout } from './index2.js';
 
@@ -21,26 +21,29 @@ function retrieveComponentMembers(component, isLit) {
     const constructor = component.constructor;
     const members = constructor.__registerControllers?.(component) ?? void 0;
     constructor.__registerControllers = void 0;
-    if (typeof members !== "object")
+    if (typeof members !== "object") {
       throw new Error(
         "Failed to retrieve internal component meta. Make sure you have the useComponentsControllers() Rollup Plugin for Stencil Controllers configured in your Stencil config."
       );
+    }
     component.manager.internals.members = members;
   }
 }
 var getLitProperties = (component) => component.constructor.elementProperties;
 function parsePropertyValue(value, type = 8 /* Any */) {
   const isComplex = value == null || typeof value === "object" || typeof value === "function";
-  if (isComplex)
+  if (isComplex) {
     return value;
-  if ((type & 4 /* Boolean */) !== 0)
+  }
+  if ((type & 4 /* Boolean */) !== 0) {
     return value === "false" ? false : value === "" || !!value;
-  else if ((type & 2 /* Number */) !== 0)
+  } else if ((type & 2 /* Number */) !== 0) {
     return Number.parseFloat(value);
-  else if ((type & 1 /* String */) !== 0)
+  } else if ((type & 1 /* String */) !== 0) {
     return String(value);
-  else
+  } else {
     return value;
+  }
 }
 var makeMemberFilter = (filter) => (component) => {
   const members = component.manager.internals.members;
@@ -50,12 +53,13 @@ var getPropLikeMembers = makeMemberFilter(63 /* PropLike */);
 var getMemberType = (component, name) => component.manager.internals.members?.[name]?.[0];
 function getPropType(component, name) {
   const type = getMemberType(component, name);
-  if (type === void 0)
+  if (type === void 0) {
     return void 0;
-  else if (type & 32 /* State */)
+  } else if (type & 32 /* State */) {
     return "state";
-  else
+  } else {
     return "prop";
+  }
 }
 
 // src/types.ts
@@ -80,14 +84,17 @@ var ControllerInternals = class {
           const error = new Error(
             `Unable to resolve a controller from the provided value, so can't watch it's exports. ${unresolvableExports}`
           );
-          console.error(error);
+          {
+            console.error(error);
+          }
         }
         return value;
       }
       await controller.ready;
       if (typeof watchExports === "function") {
-        if (controller.watchExports === void 0)
+        if (controller.watchExports === void 0) {
           throw new Error(`The controller must implement watchExports method to support watching exports`);
+        }
         const unsubscribe = controller.watchExports(
           (exports) => watchExports(exports, unsubscribe)
         );
@@ -96,21 +103,25 @@ var ControllerInternals = class {
     };
     this.useRef = async (value) => {
       const controller = this.useRefSync(value);
-      if (controller === void 0)
+      if (controller === void 0) {
         throw new Error(`Unable to resolve a controller from the provided value. ${unresolvableExports}`);
+      }
       await controller.ready;
       return controller;
     };
     this.useRefSync = (value) => {
       const ambientChildController = this.retrieveAmbientChildController();
-      if (ambientChildController !== void 0)
+      if (ambientChildController !== void 0) {
         return ambientChildController;
+      }
       const component = Controller.internals.retrieveComponent();
       const controller = component.manager.internals.resolveExports(value);
-      if (controller !== void 0)
+      if (controller !== void 0) {
         return controller;
-      if (isController(value))
+      }
+      if (isController(value)) {
         return value;
+      }
       return void 0;
     };
     this.shouldBypassSetter = false;
@@ -128,16 +139,18 @@ var ControllerInternals = class {
    * improve DX (avoids the need to pass "this" explicitly for each controller)
    */
   setAmbientComponent(component) {
-    if (this._ambientComponent === component)
+    if (this._ambientComponent === component) {
       return;
+    }
     this._ambientComponent = component;
     queueMicrotask(() => {
-      if (this._ambientComponent === component)
+      if (this._ambientComponent === component) {
         this._ambientComponent = void 0;
+      }
     });
   }
   retrieveComponent(name) {
-    if (this._ambientComponent === void 0)
+    if (this._ambientComponent === void 0) {
       throw new Error(
         [
           `Unable to find out which component ${name || "this"} controller `,
@@ -153,6 +166,7 @@ var ControllerInternals = class {
           "You might also have multiple instances of Controllers loaded"
         ].join("\n")
       );
+    }
     return this._ambientComponent;
   }
   /*
@@ -177,12 +191,14 @@ var ControllerInternals = class {
    * controller exports, rather than the controller itself
    */
   setAmbientChildController(controller) {
-    if (this._ambientChildController === controller)
+    if (this._ambientChildController === controller) {
       return;
+    }
     this._ambientChildController = controller;
     queueMicrotask(() => {
-      if (this._ambientChildController === controller)
+      if (this._ambientChildController === controller) {
         this._ambientChildController = void 0;
+      }
     });
   }
   retrieveAmbientChildController() {
@@ -236,12 +252,14 @@ var _Controller = class _Controller {
     });
     this.component.addController(this);
     _Controller.internals.setParentController(this);
-    if ("hostDestroy" in this)
+    if ("hostDestroy" in this) {
       this.component.manager.ensureHasDestroy();
+    }
     const manager = this.component.manager;
     const isInControllerManager = manager === void 0;
-    if (!isInControllerManager)
+    if (!isInControllerManager) {
       queueMicrotask(() => this.catchUpLifecycle());
+    }
   }
   /**
    * If controller is being added dynamically, after the component
@@ -250,15 +268,18 @@ var _Controller = class _Controller {
   catchUpLifecycle() {
     const { manager } = this.component;
     const connectedWillStillHappen = !manager.connectedCalled;
-    if (!connectedWillStillHappen && !this.connectedCalled)
+    if (!connectedWillStillHappen && !this.connectedCalled) {
       this.triggerConnected();
+    }
     const loadWillStillHappen = !manager.willLoadCalled;
-    if (loadWillStillHappen)
+    if (loadWillStillHappen) {
       return;
+    }
     this.triggerLoad().then(() => {
       const loadedWillStillHappen = !manager.didLoadCalled;
-      if (loadedWillStillHappen)
+      if (loadedWillStillHappen) {
         return;
+      }
       this.triggerLoaded();
     }).catch(console.error);
   }
@@ -273,8 +294,9 @@ var _Controller = class _Controller {
   set exports(exports) {
     if (this._exports !== exports) {
       this._exports = exports;
-      if (this.connectedCalled)
+      if (this.connectedCalled) {
         this.component.requestUpdate();
+      }
       this._exportWatchers.forEach(safeCall);
     }
     this._ready.resolve(exports);
@@ -430,10 +452,11 @@ var _Controller = class _Controller {
   watch(property, callback) {
     var _a2;
     const type = getMemberType(this.component, property);
-    if (type === void 0)
+    if (type === void 0) {
       throw new Error(
         `Trying to watch a non-@property, non-@state property "${property}". Either convert it into a @state() or use get/set syntax`
       );
+    }
     const internals = this.component.manager.internals;
     (_a2 = internals.allWatchers)[property] ?? (_a2[property] = []);
     const watchers = internals.allWatchers[property];
@@ -442,13 +465,15 @@ var _Controller = class _Controller {
     watchers.push(safeCallback);
     return () => {
       const index = watchers.indexOf(safeCallback);
-      if (index !== -1)
+      if (index !== -1) {
         watchers.splice(index, 1);
+      }
     };
   }
   controllerRemoved() {
-    if (this.component.el.isConnected)
+    if (this.component.el.isConnected) {
       this.triggerDisconnected();
+    }
     this.triggerDestroy();
   }
   // Register a lifecycle callback
@@ -476,68 +501,80 @@ var _Controller = class _Controller {
   }
   onLifecycle(callback) {
     this._callbacks.hostLifecycle.push(callback);
-    if (this.connectedCalled && this.component.el.isConnected)
+    if (this.connectedCalled && this.component.el.isConnected) {
       this._callLifecycle(callback);
+    }
   }
   // Call each lifecycle hook
   triggerConnected() {
     const genericController = this;
-    if (genericController.hostConnected)
+    if (genericController.hostConnected) {
       safeCall(genericController.hostConnected, genericController);
+    }
     this._callbacks.hostConnected.forEach(safeCall);
     this.triggerLifecycle();
     this.connectedCalled = true;
   }
   triggerDisconnected() {
     const genericController = this;
-    if (genericController.hostDisconnected)
+    if (genericController.hostDisconnected) {
       safeCall(genericController.hostDisconnected, genericController);
+    }
     this._callbacks.hostDisconnected.forEach(safeCall);
     this._lifecycleDisconnected.forEach(safeCall);
     this._lifecycleDisconnected = [];
   }
   async triggerLoad() {
-    if (this.willLoadCalled)
+    if (this.willLoadCalled) {
       return;
+    }
     this.willLoadCalled = true;
     const genericController = this;
-    if (genericController.hostLoad)
+    if (genericController.hostLoad) {
       await safeAsyncCall(genericController.hostLoad, genericController);
-    if (this._callbacks.hostLoad.length > 0)
+    }
+    if (this._callbacks.hostLoad.length > 0) {
       await Promise.allSettled(this._callbacks.hostLoad.map(safeAsyncCall));
+    }
     this._ready.resolve(this._exports);
   }
   triggerLoaded() {
-    if (this.didLoadCalled)
+    if (this.didLoadCalled) {
       return;
+    }
     const genericController = this;
-    if (genericController.hostLoaded)
+    if (genericController.hostLoaded) {
       safeCall(genericController.hostLoaded, genericController);
+    }
     this._callbacks.hostLoaded.forEach(safeCall);
     this.didLoadCalled = true;
   }
   triggerUpdate() {
     const genericController = this;
-    if (genericController.hostUpdate)
+    if (genericController.hostUpdate) {
       safeCall(genericController.hostUpdate, genericController);
+    }
     this._callbacks.hostUpdate.forEach(safeCall);
   }
   triggerUpdated() {
     const genericController = this;
-    if (genericController.hostUpdated)
+    if (genericController.hostUpdated) {
       safeCall(genericController.hostUpdated, genericController);
+    }
     this._callbacks.hostUpdated.forEach(safeCall);
   }
   triggerDestroy() {
     const genericController = this;
-    if (genericController.hostDestroy)
+    if (genericController.hostDestroy) {
       safeCall(genericController.hostDestroy, genericController);
+    }
     this._callbacks.hostDestroy.forEach(safeCall);
   }
   triggerLifecycle() {
     const genericController = this;
-    if (genericController.hostLifecycle)
+    if (genericController.hostLifecycle) {
       this._callLifecycle(() => genericController.hostLifecycle());
+    }
     this._callbacks.hostLifecycle.forEach((callback) => this._callLifecycle(callback));
   }
   _callLifecycle(callback) {
@@ -545,10 +582,11 @@ var _Controller = class _Controller {
     const cleanupRaw = safeCall(callback);
     const cleanup = Array.isArray(cleanupRaw) ? cleanupRaw : [cleanupRaw];
     cleanup.forEach((cleanup2) => {
-      if (typeof cleanup2 === "function")
+      if (typeof cleanup2 === "function") {
         this._lifecycleDisconnected.push(cleanup2);
-      else if (typeof cleanup2 === "object" && typeof cleanup2.remove === "function")
+      } else if (typeof cleanup2 === "object" && typeof cleanup2.remove === "function") {
         this._lifecycleDisconnected.push(cleanup2.remove);
+      }
     });
   }
 };
@@ -572,14 +610,17 @@ var GenericController = class extends Controller {
   }
 };
 function makeProvisionalValue(base) {
-  if (typeof base !== "object" && typeof base !== "function" || base === null)
+  if (typeof base !== "object" && typeof base !== "function" || base === null) {
     return base;
+  }
   const proxy2 = new Proxy(base, {
     get(target, prop, receiver) {
-      if (cyclical.has(prop) && prop in target && target[prop] === proxy2)
+      if (cyclical.has(prop) && prop in target && target[prop] === proxy2) {
         return void 0;
-      if (prop in target || prop in Promise.prototype || typeof prop === "symbol")
+      }
+      if (prop in target || prop in Promise.prototype || typeof prop === "symbol") {
         return typeof target === "function" ? target[prop] : Reflect.get(target, prop, receiver);
+      }
       console.error(`Trying to access "${prop.toString()}" on the controller before it's loaded. ${accessBeforeLoad}`);
       return void 0;
     },
@@ -593,19 +634,21 @@ function makeProvisionalValue(base) {
 var cyclical = /* @__PURE__ */ new Set(["exports", "_exports"]);
 var accessBeforeLoad = "" ;
 function toControllerHost(component) {
-  if ("addController" in component)
+  if ("addController" in component) {
     return component;
-  else
+  } else {
     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"
     );
+  }
 }
 var ignoreSet = (_, value) => value;
 function trackPropertyKey(object, onResolved, defaultValue) {
   const keys = Object.keys(object);
   const keyCount = keys.length;
-  if (keyTrackMap === void 0)
+  if (keyTrackMap === void 0) {
     queueMicrotask(keyTrackResolve);
+  }
   keyTrackMap ?? (keyTrackMap = /* @__PURE__ */ new Map());
   let pendingTrackers = keyTrackMap.get(object);
   if (pendingTrackers === void 0) {
@@ -620,12 +663,13 @@ function trackPropertyKey(object, onResolved, defaultValue) {
   pendingTrackers.callbacks.push((keys2) => {
     const callback = (key2) => safeCall(onResolved, null, key2);
     const key = keys2[keyCount];
-    if (key === void 0)
+    if (key === void 0) {
       callback(void 0);
-    else if (object[key] === defaultValue)
+    } else if (object[key] === defaultValue) {
       callback(key);
-    else
+    } else {
       callback(void 0);
+    }
   });
   return defaultValue;
 }
@@ -656,10 +700,12 @@ var ComponentInternals = class {
       let leftToResolve = candidateHosts.length + 1;
       const resolved = (resolution) => {
         leftToResolve -= 1;
-        if (resolution !== void 0)
+        if (resolution !== void 0) {
           leftToResolve = 0;
-        if (leftToResolve === 0)
+        }
+        if (leftToResolve === 0) {
           onResolved(resolution);
+        }
       };
       candidateHosts.forEach(
         (host) => this.component.manager.trackPropertyKey(
@@ -689,10 +735,12 @@ var ComponentInternals = class {
       return defaultValue;
     };
     this.trackPropKey = (onResolved, defaultValue) => {
-      if (this._trackedValue !== nothing && this._trackedValue !== defaultValue)
+      if (this._trackedValue !== nothing && this._trackedValue !== defaultValue) {
         this._firePropertyTrackers(void 0, void 0, void 0);
-      if (this._keyTrackers.length === 0)
+      }
+      if (this._keyTrackers.length === 0) {
         queueMicrotask(() => this._firePropertyTrackers(void 0, void 0, void 0));
+      }
       this._trackedValue = defaultValue;
       this._keyTrackers.push(
         (key, value, previousValue) => safeCall(onResolved, void 0, defaultValue === value ? key : void 0, previousValue)
@@ -733,43 +781,50 @@ var ComponentInternals = class {
     const component = this.component;
     const classPrototype = component.constructor.prototype;
     this._getSetProxy(classPrototype, property, hasGetter, hasSetter, "class");
-    if (component.manager.isLit)
+    if (component.manager.isLit) {
       return;
+    }
     const htmlPrototype = component.el.constructor.prototype;
-    if (classPrototype !== htmlPrototype)
+    if (classPrototype !== htmlPrototype) {
       this._getSetProxy(htmlPrototype, property, hasGetter, hasSetter, "html");
+    }
   }
   _getSetProxy(prototype, name, hasGetter, hasSetter, type) {
     const component = this.component;
     const propType = getMemberType(component, name);
     const descriptor = Object.getOwnPropertyDescriptor(prototype, name);
     const tolerateNotFound = type === "html";
-    if (descriptor?.set === void 0 || descriptor.get === void 0)
-      if (descriptor !== void 0 && "value" in descriptor)
+    if (descriptor?.set === void 0 || descriptor.get === void 0) {
+      if (descriptor !== void 0 && "value" in descriptor) {
         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 "${name}" in ${component.el.tagName}`
         );
-      else if (tolerateNotFound)
+      } else if (tolerateNotFound) {
         return;
-      else
+      } else {
         throw new Error(`Unable to find "${name}" property on the ${component.el.tagName} component`);
+      }
+    }
     const { get: originalGet, set: originalSet } = descriptor;
     const isGetterAlreadyOverwritten = customAccessor in originalGet;
     const isSetterAlreadyOverwritten = customAccessor in originalSet;
     const shouldOverwriteGet = !isGetterAlreadyOverwritten && hasGetter;
     const shouldOverwriteSet = !isSetterAlreadyOverwritten && hasSetter;
-    if (!shouldOverwriteGet && !shouldOverwriteSet)
+    if (!shouldOverwriteGet && !shouldOverwriteSet) {
       return;
+    }
     const finalGetter = shouldOverwriteGet ? function getter() {
       let value = originalGet.call(this);
       const component2 = Controller.internals.elementToInstance.get(this);
-      if (Controller.internals.shouldBypassGetter || component2 === void 0)
+      if (Controller.internals.shouldBypassGetter || component2 === void 0) {
         return value;
+      }
       const internals = component2.manager.internals;
       value = internals.accessorGetter[name](value, name);
       const getters = internals.getters[name] ?? emptyArray;
-      for (let i = 0; i < getters.length; i++)
+      for (let i = 0; i < getters.length; i++) {
         value = getters[i](value, name);
+      }
       return value;
     } : originalGet;
     const finalSetter = shouldOverwriteSet ? function setter(rawNewValue) {
@@ -781,27 +836,32 @@ var ComponentInternals = class {
       }
       let newValue = component2.manager.isLit ? rawNewValue : parsePropertyValue(rawNewValue, propType);
       const internals = component2.manager.internals;
-      if (newValue === oldValue)
+      if (newValue === oldValue) {
         originalSet.call(this, rawNewValue);
-      else {
+      } else {
         const setters = Controller.internals.shouldBypassSetter ? emptyArray : internals.setters[name] ?? emptyArray;
         for (let i = 0; i < setters.length; i++) {
           newValue = setters[i](newValue, oldValue, name);
-          if (newValue === oldValue)
+          if (newValue === oldValue) {
             break;
+          }
         }
         newValue = internals.accessorSetter[name](newValue, oldValue, name);
         originalSet.call(this, newValue);
-        if (newValue !== oldValue)
+        if (newValue !== oldValue) {
           internals.enabledWatchers[name]?.forEach((watcher) => watcher(newValue, oldValue, name));
+        }
       }
-      if (internals._keyTrackers.length > 0)
+      if (internals._keyTrackers.length > 0) {
         internals?._firePropertyTrackers(name, rawNewValue, oldValue);
+      }
     } : originalSet;
-    if (shouldOverwriteGet)
+    if (shouldOverwriteGet) {
       Object.defineProperty(finalGetter, customAccessor, { value: true });
-    if (shouldOverwriteSet)
+    }
+    if (shouldOverwriteSet) {
       Object.defineProperty(finalSetter, customAccessor, { value: true });
+    }
     Object.defineProperty(prototype, name, {
       ...descriptor,
       get: finalGetter,
@@ -813,14 +873,16 @@ var ComponentInternals = class {
    * controller.use
    */
   markExports(controller, exports) {
-    if (typeof exports === "object" && exports !== null || typeof exports === "function")
+    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")
+    if (typeof exports === "object" && exports !== null || typeof exports === "function") {
       return this._exports.get(exports);
-    else
+    } else {
       return void 0;
+    }
   }
 };
 var emptyArray = [];
@@ -833,8 +895,9 @@ var ControllerManager = class extends GenericController {
     const controllers = /* @__PURE__ */ new Set();
     function addController(controller) {
       controllers.add(controller);
-      if (isLit && !(controllerSymbol in controller) && component.el.isConnected)
+      if (isLit && !(controllerSymbol in controller) && component.el.isConnected) {
         controller.hostConnected?.();
+      }
     }
     function removeController(controller) {
       void controllers.delete(controller);
@@ -896,21 +959,24 @@ var ControllerManager = class extends GenericController {
      */
     this.trackKey = this.internals.trackKey;
     this._readonlySetter = (newValue, oldValue, property) => {
-      if (Controller.internals.shouldBypassReadonly)
+      if (Controller.internals.shouldBypassReadonly) {
         return newValue;
+      }
       const component = this.component;
       const isProp = getPropType(component, property) === "prop";
       if (isProp) {
         if (this.isLit) {
           const details = getLitProperties(component).get(property);
-          if (details && details?.attribute !== false)
+          if (details && details?.attribute !== false) {
             component.el.setAttribute(
               typeof details.attribute === "string" ? details.attribute : camelToKebab(property),
               // Not using converter.toAttribute to keep this unlikely case simpler
               String(oldValue)
             );
-        } else
+          }
+        } else {
           component.requestUpdate();
+        }
       }
       throw new Error(
         `Cannot assign to read-only property "${property}" of ${component.el.tagName.toLowerCase()}. Trying to assign "${String(
@@ -932,13 +998,15 @@ var ControllerManager = class extends GenericController {
     this._controllers = controllers;
     this.exports = void 0;
     this.hasDestroy = "autoDestroyDisabled" in this.component && typeof this.component.destroy === "function";
-    if (this.hasDestroy)
+    if (this.hasDestroy) {
       this.watch("autoDestroyDisabled", () => this._autoDestroyDisabledWatcher());
+    }
     this._bindLifecycleMethods();
-    if (!isLit)
+    if (!isLit) {
       Object.defineProperty(component, "updateComplete", {
         get: async () => await this._updatePromise.promise
       });
+    }
     const members = getPropLikeMembers(component);
     const internals = component.manager.internals;
     members.forEach((name) => {
@@ -968,7 +1036,7 @@ var ControllerManager = class extends GenericController {
     const hostDisconnected = this._disconnectedCallback.bind(this);
     const hostUpdate = this._update.bind(this);
     const hostUpdated = this._updated.bind(this);
-    if (isLit)
+    if (isLit) {
       component.constructor.prototype.addController.call(component, {
         // Lit will call these callbacks
         hostConnected,
@@ -976,7 +1044,7 @@ var ControllerManager = class extends GenericController {
         hostUpdate,
         hostUpdated
       });
-    else {
+    } else {
       component.connectedCallback = hostConnected;
       component.disconnectedCallback = hostDisconnected;
       component.componentWillLoad = this._load.bind(this);
@@ -984,16 +1052,18 @@ var ControllerManager = class extends GenericController {
       component.componentWillUpdate = hostUpdate;
       component.componentDidUpdate = hostUpdated;
     }
-    if (this.hasDestroy)
+    if (this.hasDestroy) {
       component.destroy = this.destroy.bind(this);
+    }
   }
   /**
    * Throws an error if component does not implement destroy() lifecycle, but
    * tries to use it.
    */
   ensureHasDestroy() {
-    if (!this.hasDestroy)
+    if (!this.hasDestroy) {
       throw new Error(destroyErrorMessage);
+    }
   }
   /**
    * Private because this is not supposed to be called by Component directly.
@@ -1008,8 +1078,9 @@ var ControllerManager = class extends GenericController {
         `The ${tagName} component has already been destroyed. It can not be used again. If you meant to disconnect and reconnect a component without automatic destroy, set the autoDestroyDisabled prop.`
       );
     }
-    if (this._autoDestroyTimeout !== void 0)
+    if (this._autoDestroyTimeout !== void 0) {
       clearTimeout(this._autoDestroyTimeout);
+    }
     this.internals.enabledWatchers = this.internals.allWatchers;
     keyTrackResolve();
     this._controllers.forEach(
@@ -1018,23 +1089,26 @@ var ControllerManager = class extends GenericController {
     this._originalLifecycles.connectedCallback?.call(this.component);
   }
   _disconnectedCallback() {
-    if (this.destroyed)
+    if (this.destroyed) {
       return;
+    }
     this._controllers.forEach(
       (controller) => "triggerDisconnected" in controller ? controller.triggerDisconnected() : safeCall(controller.hostDisconnected, controller)
     );
     this._originalLifecycles.disconnectedCallback?.call(this.component);
-    if (this.hasDestroy)
+    if (this.hasDestroy) {
       this._autoDestroyDisabledWatcher();
+    }
   }
   async _load() {
     const integrations = this.internals.reactiveUtilsIntegrations;
     if (integrations.size > 0) {
       for (const controller of integrations) {
-        if ("triggerLoad" in controller)
+        if ("triggerLoad" in controller) {
           await controller.triggerLoad();
-        else
+        } else {
           await safeAsyncCall(controller.hostLoad, controller);
+        }
       }
     }
     await Promise.allSettled(
@@ -1070,8 +1144,9 @@ var ControllerManager = class extends GenericController {
   }
   async destroy() {
     this.ensureHasDestroy();
-    if (this.destroyed)
+    if (this.destroyed) {
       return;
+    }
     if (this.component.el.isConnected) {
       this.hasDestroy = false;
       try {
@@ -1090,10 +1165,13 @@ var ControllerManager = class extends GenericController {
   }
   _autoDestroyDisabledWatcher() {
     if (!this.component.el.isConnected && !this.component.autoDestroyDisabled) {
-      if (this._autoDestroyTimeout !== void 0)
+      if (this._autoDestroyTimeout !== void 0) {
         clearTimeout(this._autoDestroyTimeout);
+      }
       const destroy = () => void this.destroy().catch(console.error);
-      this._autoDestroyTimeout = devToolsAwareTimeout(destroy, autoDestroyOnDisconnectTimeout);
+      {
+        this._autoDestroyTimeout = devToolsAwareTimeout(destroy, autoDestroyOnDisconnectTimeout);
+      }
     }
   }
   // REFACTOR: replace this with a readonly:true option in @property()
@@ -1144,10 +1222,11 @@ var ControllerManager = class extends GenericController {
   getSet(defaultValue, getSet) {
     return this.component.manager.trackPropKey((name) => {
       var _a2;
-      if (name === void 0)
+      if (name === void 0) {
         throw new Error(
           "Unable to resolve get/set's prop name. Make sure you are using it like @Prop() someProp = this.manager.getSet(defaultValue,{get,set})"
         );
+      }
       if (getSet.set === this._readonlySetter) {
         (_a2 = this.internals).readonlyProps ?? (_a2.readonlyProps = /* @__PURE__ */ new Set());
         this.internals.readonlyProps.add(name);
@@ -1158,20 +1237,22 @@ var ControllerManager = class extends GenericController {
       const initialSet = getSet.initialSet ?? true;
       if (value != null && value !== defaultValue && typeof getSet.set === "function" && initialSet && !isStencilHotReload) {
         const newValue = getSet.set(value, defaultValue, name);
-        if (newValue !== value)
-          if (this.isLit)
+        if (newValue !== value) {
+          if (this.isLit) {
             genericComponent[name] = newValue;
-          else {
+          } else {
             let firstConnected = true;
             this.onConnected(() => {
-              if (!firstConnected)
+              if (!firstConnected) {
                 return;
+              }
               firstConnected = true;
               this.bypassSetter(() => {
                 genericComponent[name] = newValue;
               });
             });
           }
+        }
       }
       this.genericGetSet(name, getSet);
     }, defaultValue);
@@ -1208,29 +1289,34 @@ function setProxy(controller, { host, key, type }, initialExports) {
   const controllerValueChanged = genericHost[key] !== controller.exports;
   const hostValueChanged = genericHost[key] !== initialExports;
   const controllerUpdatedExports = initialExports !== controller.exports;
-  if (controllerValueChanged && !hostValueChanged && controllerUpdatedExports)
+  if (controllerValueChanged && !hostValueChanged && controllerUpdatedExports) {
     genericHost[key] = controller.exports;
+  }
   const isProxyExportsOnComponent = host === controller.component;
   if (isProxyExportsOnComponent && type === "prop") {
     const internals = controller.component.manager.internals;
-    if (hostValueChanged)
+    if (hostValueChanged) {
       internals.markExports(controller, genericHost[key]);
+    }
     controller.component.manager.watch(key, (value) => {
-      if (value !== controller.exports)
+      if (value !== controller.exports) {
         internals.markExports(controller, value);
+      }
     });
   }
   controller.watchExports(() => {
-    if (genericHost[key] === controller.exports)
+    if (genericHost[key] === controller.exports) {
       return;
+    }
     const manager = controller.component.manager;
     const isReadOnly = manager.internals.readonlyProps?.has(key) === true;
-    if (isReadOnly)
+    if (isReadOnly) {
       manager.bypassReadonly(() => {
         genericHost[key] = controller.exports;
       });
-    else
+    } else {
       genericHost[key] = controller.exports;
+    }
   });
 }
 
@@ -1245,8 +1331,9 @@ var FunctionalController = class extends Controller {
       const value = constructor(this.component, this);
       const constructorChangedExports = this.exports !== originalExports;
       if (value instanceof Promise) {
-        if (!constructorChangedExports)
+        if (!constructorChangedExports) {
           this.setProvisionalExports(value);
+        }
         const resolved = value.then((result) => {
           this.exports = result;
           super.catchUpLifecycle();
@@ -1256,8 +1343,9 @@ var FunctionalController = class extends Controller {
         });
         this.onLoad(async () => await resolved);
       } else {
-        if (!constructorChangedExports || value !== void 0)
+        if (!constructorChangedExports || value !== void 0) {
           this.exports = value;
+        }
         queueMicrotask(() => super.catchUpLifecycle());
       }
     } catch (error) {