@arcgis/lumina 4.33.0-next.124 → 4.33.0-next.126

package/dist/index.js

@@ -1,42 +1,41 @@
 import { ContextProvider, ContextConsumer } from "@lit/context";
-import { r as retrieveComponent, G as GenericController, k as keyTrackResolve, s as setAmbientComponent, a as shouldBypassGetter, b as shouldBypassReadOnly, c as controllerSymbol } from "./Controller-CZ8Djohh.js";
-import { d } from "./Controller-CZ8Djohh.js";
+import { r as retrieveComponent, G as GenericController, k as keyTrackResolve, q as queueMicroTask, s as setAmbientComponent, c as controllerSymbol, a as shouldBypassReadOnly } from "./Controller-B3mB4uaz.js";
+import { b } from "./Controller-B3mB4uaz.js";
 import { state } from "@lit/reactive-element/decorators/state.js";
 import { property as property$1 } from "@lit/reactive-element/decorators/property.js";
-import { n as noShadowRoot, a as attachToAncestor } from "./utils-BdB9g3GU.js";
-import { m } from "./utils-BdB9g3GU.js";
+import { e as emptyFunction, n as noShadowRoot, a as attachToAncestor } from "./lazyLoad-ByH-FaBP.js";
+import { d, m } from "./lazyLoad-ByH-FaBP.js";
 import { isEsriInternalEnv, safeCall, devToolsAwareTimeout, Deferred, camelToKebab, safeAsyncCall } from "@arcgis/components-utils";
-import { nothing as nothing$1, LitElement as LitElement$1, isServer, noChange as noChange$1 } from "lit";
-import { PropertyFlags } from "./config.js";
+import { nothing as nothing$1, LitElement as LitElement$1, isServer, notEqual, noChange as noChange$1 } from "lit";
+import { propertyFlagAttribute, propertyFlagNoAccessor, propertyFlagReadOnly, propertyFlagState, propertyFlagBoolean, propertyFlagNumber, propertyFlagReflect } from "./config.js";
 import { classMap } from "lit-html/directives/class-map.js";
 import { styleMap } from "lit/directives/style-map.js";
 import { directive as directive$1, Directive } from "lit-html/directive.js";
 import { live as live$1 } from "lit-html/directives/live.js";
 import { nothing as nothing$2, noChange as noChange$2, render } from "lit-html";
-function useContextProvider(options) {
+const useContextProvider = (options) => {
   const component = retrieveComponent();
   const controller = new ContextProvider(component.el, options);
   component.addController(controller);
   return controller;
-}
-function useContextConsumer(options) {
+};
+const useContextConsumer = (options) => {
   const component = retrieveComponent();
   const controller = new ContextConsumer(component.el, options);
   component.addController(controller);
   return controller;
-}
+};
 const property = property$1;
 const method = void 0;
 class ControllerManager extends GenericController {
   constructor(component) {
     super(component);
     this.destroyed = false;
-    this._enforceReadonly = false;
-    this._trackedValue = nothing$1;
-    this._keyTrackers = [];
-    this._accessorGetter = {};
-    this._accessorSetter = {};
-    this._exportsStore = /* @__PURE__ */ new WeakMap();
+    this.R = false;
+    this.V = nothing$1;
+    this.T = [];
+    this.#exportsStore = /* @__PURE__ */ new WeakMap();
+    this.#component = component;
     this.exports = void 0;
     this.hasDestroy = autoDestroyDisabledPropName in component && typeof component.destroy === "function";
     LitElement$1.prototype.addController.call(component, {
@@ -55,11 +54,11 @@ class ControllerManager extends GenericController {
             `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);
+        if (this.#autoDestroyTimeout !== void 0) {
+          clearTimeout(this.#autoDestroyTimeout);
         }
         keyTrackResolve();
-        for (const controller of component._controllers) {
+        for (const controller of component.M) {
           if ("triggerConnected" in controller) {
             controller.triggerConnected();
           } else {
@@ -68,7 +67,7 @@ class ControllerManager extends GenericController {
         }
       },
       hostDisconnected: () => {
-        for (const controller of component._controllers) {
+        for (const controller of component.M) {
           if ("triggerDisconnected" in controller) {
             controller.triggerDisconnected();
           } else {
@@ -76,186 +75,102 @@ class ControllerManager extends GenericController {
           }
         }
         if (this.hasDestroy && !this.destroyed) {
-          this._setAutoDestroyTimeout();
+          this.U();
         }
       },
       hostUpdate: () => {
-        for (const controller of component._controllers) {
+        for (const controller of component.M) {
           if ("triggerUpdate" in controller) {
-            controller.triggerUpdate(this._changes);
+            controller.triggerUpdate(this.Q);
           } else {
-            safeCall(controller.hostUpdate, controller, this._changes);
+            safeCall(controller.hostUpdate, controller, this.Q);
           }
         }
       },
       hostUpdated: () => {
-        for (const controller of component._controllers) {
+        for (const controller of component.M) {
           if ("triggerUpdated" in controller) {
-            controller.triggerUpdated(this._changes);
+            controller.triggerUpdated(this.Q);
           } else {
-            safeCall(controller.hostUpdated, controller, this._changes);
+            safeCall(controller.hostUpdated, controller, this.Q);
           }
         }
-        this._changes = void 0;
+        this.Q = void 0;
       }
     });
-    component.constructor.elementProperties.forEach((descriptor, name) => {
-      if (!descriptor.noAccessor) {
-        this._accessorGetter[name] = defaultGetterSetter;
-        this._accessorSetter[name] = defaultGetterSetter;
-        this._getSetProxy(name, descriptor.readOnly);
-      }
-    });
-    queueMicrotask(() => {
-      this._enforceReadonly = true;
-    });
+    queueMicroTask(() => this.R = true);
     setAmbientComponent(component);
   }
+  #autoDestroyTimeout;
+  #component;
   // Keep this method async needlessly for now to avoid a breaking change if we
   // would need to make it async in the future
   // eslint-disable-next-line @typescript-eslint/require-await
   async destroy() {
     if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
-      this._ensureHasDestroy?.();
+      this.devOnly$ensureHasDestroy?.();
     }
     if (this.destroyed) {
       return;
     }
-    if (this.component.el.isConnected) {
+    if (this.#component.el.isConnected) {
       this.hasDestroy = false;
-      try {
-        this.component.el.remove();
-      } finally {
-        this.hasDestroy = true;
-      }
+      this.#component.el.remove();
     }
-    this._autoDestroyTimeout = void 0;
+    this.#autoDestroyTimeout = void 0;
     this.destroyed = true;
-    for (const controller of this.component._controllers) {
+    for (const controller of this.#component.M) {
       if ("triggerDestroy" in controller) {
         controller.triggerDestroy();
       } else {
         safeCall(controller.hostDestroy, controller);
       }
     }
-    this.component._controllers.clear();
+    this.#component.M.splice(0);
   }
   /** @private */
-  _setAutoDestroyTimeout() {
-    if (this._autoDestroyTimeout !== void 0) {
-      clearTimeout(this._autoDestroyTimeout);
+  U() {
+    if (this.#autoDestroyTimeout !== void 0) {
+      clearTimeout(this.#autoDestroyTimeout);
     }
-    if (!this.component.el.isConnected && !this.component.autoDestroyDisabled) {
-      const destroy = () => void this.component.destroy();
+    if (!this.#component.el.isConnected && !this.#component.autoDestroyDisabled) {
+      const destroy = () => void this.#component.destroy();
       if (process.env.NODE_ENV !== "production" && isEsriInternalEnv() && autoDestroyOnDisconnectTimeout === 0) ;
       else {
-        this._autoDestroyTimeout = devToolsAwareTimeout(destroy, autoDestroyOnDisconnectTimeout);
+        this.#autoDestroyTimeout = devToolsAwareTimeout(destroy, autoDestroyOnDisconnectTimeout);
       }
     }
   }
   /** @private */
-  _firePropTrackers(key, value) {
-    const trackers = this._keyTrackers;
-    this._trackedValue = nothing$1;
-    this._keyTrackers = [];
+  S(key, value) {
+    const trackers = this.T;
+    this.V = nothing$1;
+    this.T = [];
     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 \@property/\@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
-   *
-   * @deprecated
-   */
-  _getSetProxy(name, isReadOnly) {
-    let prototype = this.component.constructor.prototype;
-    let descriptor;
-    do {
-      descriptor = Object.getOwnPropertyDescriptor(prototype, name);
-    } while (!descriptor && (prototype = Object.getPrototypeOf(prototype)));
-    if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
-      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 @property/@state properties. For internal component properties, use regular get/set syntax. Tried to use it on "${name}" in ${this.component.el.localName}`
-          );
-        } else {
-          throw new Error(`Unable to find "${name}" property on the ${this.component.el.localName} component`);
-        }
-      }
-    } else if (!descriptor) {
-      return;
-    }
-    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() {
-      const value = originalGet.call(this);
-      if (shouldBypassGetter) {
-        return value;
-      }
-      return this.manager._accessorGetter[name](value, name);
-    } : originalGet;
-    const finalSetter = shouldOverwriteSet ? function setter(rawNewValue) {
-      const oldValue = originalGet.call(this);
-      let newValue = rawNewValue ?? void 0;
-      const manager = this.manager;
-      if (newValue !== oldValue) {
-        if (isReadOnly && !shouldBypassReadOnly && (manager._enforceReadonly || manager.connectedCalled)) {
-          throw new Error(
-            `Cannot assign to read-only property "${name}" of ${this.el.localName}. Trying to assign "${String(
-              newValue
-            )}"`
-          );
-        }
-        newValue = manager._accessorSetter[name](newValue, oldValue, name);
-      }
-      originalSet.call(this, newValue);
-      if (manager._keyTrackers.length > 0) {
-        manager?._firePropTrackers(name, rawNewValue);
-      }
-    } : originalSet;
-    if (shouldOverwriteGet) {
-      finalGetter[customAccessor] = true;
-    }
-    if (shouldOverwriteSet) {
-      finalSetter[customAccessor] = true;
-    }
-    Object.defineProperty(prototype, name, { ...descriptor, get: finalGetter, set: finalSetter });
-  }
+  #exportsStore;
   /**
    * Associate an exports object with a controller for reverse lookup in
    * controller.use
    *
    * @private
    */
-  _markExports(controller, exports) {
+  W(controller, exports) {
     if (typeof exports === "object" && exports !== null || typeof exports === "function") {
-      this._exportsStore.set(exports, controller);
+      this.#exportsStore.set(exports, controller);
     }
   }
   /** @private */
-  _resolveExports(exports) {
+  X(exports) {
     if (typeof exports === "object" && exports !== null || typeof exports === "function") {
-      return this._exportsStore.get(exports);
+      return this.#exportsStore.get(exports);
     } else {
       return void 0;
     }
   }
 }
 if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
-  ControllerManager.prototype._ensureHasDestroy = function ensureHasDestroy() {
+  ControllerManager.prototype.devOnly$ensureHasDestroy = function ensureHasDestroy() {
     if (!this.hasDestroy) {
       throw new Error(
         `
@@ -283,31 +198,34 @@ if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
 let autoDestroyOnDisconnectTimeout = 1e3;
 const autoDestroyDisabledPropName = "autoDestroyDisabled";
 process.env.NODE_ENV !== "production" && isEsriInternalEnv() ? {} : void 0;
-const defaultGetterSetter = (value) => value;
-const customAccessor = Symbol();
-const emptyFunction = () => void 0;
 class LitElement extends LitElement$1 {
   constructor() {
     super();
-    this.el = this.constructor.lazy ?? this;
-    this._controllers = /* @__PURE__ */ new Set();
+    this.M = [];
     this.manager = new ControllerManager(this);
-    this._postLoad = this.constructor.lazy?._postLoad ?? new Deferred();
-    this._offspring = this.constructor.lazy?._offspring ?? [];
-    this._postLoaded = this.constructor.lazy?._postLoaded ?? new Deferred();
-    this._enableUpdating = this.enableUpdating;
-    this.enableUpdating = emptyFunction;
+    const that = this;
+    const constructor = that.constructor;
+    const lazy = constructor.N;
+    const createObservable = constructor.K.o;
     const ourShouldUpdate = LitElement.prototype.shouldUpdate;
-    if (this.shouldUpdate !== ourShouldUpdate) {
-      this._originalShouldUpdate = this.shouldUpdate;
-      this.shouldUpdate = ourShouldUpdate;
+    that.#postLoadedDeferred = lazy?.H ?? new Deferred();
+    that.I = lazy?.I ?? new Deferred();
+    that.J = lazy?.J ?? [];
+    that["_offspring"] = that.J;
+    that["_postLoad"] = that.I;
+    that.el = lazy ?? that;
+    that.#enableUpdating = that.enableUpdating;
+    that.enableUpdating = emptyFunction;
+    if (that.shouldUpdate !== ourShouldUpdate) {
+      that.#originalShouldUpdate = that.shouldUpdate;
+      that.shouldUpdate = ourShouldUpdate;
     }
     if (process.env.NODE_ENV !== "production") {
-      const isOwnComponent = globalThis.devOnly$ownTagNames?.has(this.el.localName);
-      const constructor = this.constructor;
-      const warningsWereCustomized = constructor.enabledWarnings !== LitElement$1.enabledWarnings;
+      const isOwnComponent = globalThis.devOnly$ownTagNames?.has(that.el.localName);
+      const constructor2 = this.constructor;
+      const warningsWereCustomized = constructor2.enabledWarnings !== LitElement$1.enabledWarnings;
       if (!isOwnComponent && !warningsWereCustomized) {
-        constructor.disableWarning?.("change-in-update");
+        constructor2.disableWarning?.("change-in-update");
       }
       if (isEsriInternalEnv()) {
         globalThis.devOnly$luminaComponentRefCallback?.(this);
@@ -329,8 +247,12 @@ class LitElement extends LitElement$1 {
         });
       }
     }
+    if (createObservable) {
+      that.#observables = /* @__PURE__ */ new Map();
+      constructor.elementProperties.forEach((_, name) => that.#observables.set(name, createObservable()));
+    }
     if (isServer) {
-      this.el.setAttribute(this.constructor.runtime.hydratedAttribute, "");
+      that.el.setAttribute(constructor.K.hydratedAttribute, "");
     }
   }
   /**
@@ -342,12 +264,13 @@ class LitElement extends LitElement$1 {
     }
     const finalizedStyles = super.finalizeStyles(styles);
     const useLightDom = this.shadowRootOptions === noShadowRoot;
-    return this.runtime?.commonStyles === void 0 || useLightDom ? finalizedStyles : [this.runtime.commonStyles, ...finalizedStyles];
+    return this.K?.commonStyles === void 0 || useLightDom ? finalizedStyles : [this.K.commonStyles, ...finalizedStyles];
   }
   static createProperty(name, options) {
     const flags = typeof options === "number" ? options : Array.isArray(options) ? options[0] : 0;
     const rest = Array.isArray(options) ? options[1] : void 0;
-    super.createProperty(name, {
+    const hasChanged = rest?.hasChanged ?? notEqual;
+    const normalizedOptions = {
       /**
        * By default to infer attribute name from property name, Lit just
        * converts property name to lowercase. That is consistent with
@@ -364,42 +287,105 @@ class LitElement extends LitElement$1 {
        *
        * Thus, overwriting Lit's default behavior to use kebab-case:
        */
-      attribute: !!(flags & PropertyFlags.ATTRIBUTE) && typeof name === "string" ? camelToKebab(name) : false,
-      reflect: !!(flags & PropertyFlags.REFLECT),
-      type: flags & PropertyFlags.BOOLEAN ? Boolean : flags & PropertyFlags.NUMBER ? Number : void 0,
+      attribute: !!(flags & propertyFlagAttribute) && typeof name === "string" ? camelToKebab(name) : false,
+      reflect: !!(flags & propertyFlagReflect),
+      type: flags & propertyFlagBoolean ? Boolean : flags & propertyFlagNumber ? Number : void 0,
       /**
        * At the moment in Lit, state:true just means attribute:false, so this
        * line is technically redundant, but let's keep it here just in case Lit
        * will add more meaning to state:true in the future.
        */
-      state: !!(flags & PropertyFlags.STATE),
+      state: !!(flags & propertyFlagState),
       // Controllers add this option to Lit
-      readOnly: !!(flags & PropertyFlags.READ_ONLY),
-      noAccessor: !!(flags & PropertyFlags.NO_ACCESSOR),
-      ...rest
-    });
+      readOnly: !!(flags & propertyFlagReadOnly),
+      noAccessor: !!(flags & propertyFlagNoAccessor),
+      c: false,
+      ...rest,
+      hasChanged(newValue, oldValue) {
+        const changed = hasChanged(newValue, oldValue);
+        normalizedOptions.c = changed;
+        return changed;
+      }
+    };
+    super.createProperty(name, normalizedOptions);
+  }
+  static getPropertyDescriptor(name, key, options) {
+    const runtime = this.K;
+    const accessor = super.getPropertyDescriptor(name, key, options);
+    options.d = accessor;
+    return {
+      ...accessor,
+      get() {
+        runtime.t?.(this.#observables.get(name));
+        return accessor.get?.call(this);
+      },
+      set(rawNewValue) {
+        const manager = this.manager;
+        if (options.readOnly && !shouldBypassReadOnly && (manager.R || manager.connectedCalled)) {
+          throw Error(
+            `Cannot assign to read-only property "${name}" of ${this.el.localName}. Trying to assign "${rawNewValue}"`
+          );
+        }
+        accessor.set.call(this, rawNewValue ?? void 0);
+        if (options.c) {
+          this.#observables?.get(name)?.notify();
+        }
+        if (manager.T.length > 0) {
+          manager?.S(name, rawNewValue);
+        }
+      }
+    };
   }
   static {
     this.lumina = true;
   }
+  /**
+   * The JS API's Accessor observables. This is used to integrate with the JS
+   * API's reactivity system.
+   *
+   * @private
+   */
+  #observables;
+  #originalShouldUpdate;
+  #enableUpdating;
+  #postLoadedDeferred;
+  #trackingTarget;
   connectedCallback() {
     if (this.el.hasAttribute("defer-hydration")) {
       return;
     }
+    const trackingTarget = this.manager.A?.(() => this.requestUpdate());
+    this.#trackingTarget = trackingTarget;
     const isFirstCall = !this.manager.connectedCalled;
     super.connectedCallback();
     if (isFirstCall) {
-      queueMicrotask(
-        // eslint-disable-next-line @typescript-eslint/no-misused-promises, @typescript-eslint/promise-function-async
-        () => this._load().catch((error) => {
-          this._postLoaded.reject(error);
+      queueMicroTask(
+        // eslint-disable-next-line @typescript-eslint/promise-function-async, @typescript-eslint/no-misused-promises
+        () => this.#load().catch((error) => {
+          this.#postLoadedDeferred.reject(error);
           setTimeout(() => {
             throw error;
           });
         })
       );
+    } else if (trackingTarget) {
+      this.requestUpdate();
     }
   }
+  #doTrackedUpdate(changedProperties) {
+    try {
+      this.#trackingTarget.clear();
+      this.manager.B(this.#trackingTarget, () => super.update(changedProperties));
+    } catch (error) {
+      this.#trackingTarget.clear();
+      throw error;
+    }
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    this.#trackingTarget?.destroy();
+    this.#trackingTarget = void 0;
+  }
   /**
    * Overwrite Lit's default behavior of attaching shadow root to the lit
    * element, and instead use this.el to support lazy builds.
@@ -431,13 +417,13 @@ class LitElement extends LitElement$1 {
     return renderRoot;
   }
   /** Do asynchronous component load */
-  async _load() {
-    const parentLoadPromise = this.el._ancestorLoad ?? attachToAncestor(this.el);
+  async #load() {
+    const parentLoadPromise = this.el.G ?? attachToAncestor(this.el);
     if (parentLoadPromise) {
       await parentLoadPromise;
     }
     const promises = [];
-    for (const controller of this._controllers) {
+    for (const controller of this.M) {
       if ("triggerLoad" in controller) {
         promises.push(controller.triggerLoad());
       } else {
@@ -448,20 +434,20 @@ class LitElement extends LitElement$1 {
     await this.load?.();
     if (this.manager.hasDestroy) {
       this.manager.onUpdate(
-        (changes) => changes.has(autoDestroyDisabledPropName) && this.manager._setAutoDestroyTimeout()
+        (changes) => changes.has(autoDestroyDisabledPropName) && this.manager.U()
       );
     }
-    this._enableUpdating(true);
+    this.#enableUpdating(true);
     this.performUpdate();
-    this._postLoad.resolve();
+    this.I.resolve();
     await Promise.resolve();
-    const pendingChildren = this._offspring.filter((loaded) => !loaded.manager?.loadedCalled);
+    const pendingChildren = this.J.filter((loaded) => !loaded.manager?.loadedCalled);
     if (pendingChildren.length) {
       await Promise.allSettled(pendingChildren.map(async (child) => await child.componentOnReady()));
     }
-    this._offspring.length = 0;
-    this.el.setAttribute(this.constructor.runtime.hydratedAttribute, "");
-    for (const controller of this._controllers) {
+    this.J.length = 0;
+    this.el.setAttribute(this.constructor.K.hydratedAttribute, "");
+    for (const controller of this.M) {
       if ("triggerLoaded" in controller) {
         controller.triggerLoaded();
       } else {
@@ -469,15 +455,22 @@ class LitElement extends LitElement$1 {
       }
     }
     this.loaded?.();
-    this._postLoaded.resolve();
+    this.#postLoadedDeferred.resolve();
   }
   /**
    * Overwriting default shouldUpdate simply to get access to
    * "changedProperties" so that we can later provide it to ControllerManager
    */
   shouldUpdate(_changedProperties) {
-    this.manager._changes = _changedProperties;
-    return this._originalShouldUpdate?.(_changedProperties) ?? true;
+    this.manager.Q = _changedProperties;
+    return this.#originalShouldUpdate?.(_changedProperties) ?? true;
+  }
+  update(changedProperties) {
+    if (this.#trackingTarget) {
+      this.#doTrackedUpdate(changedProperties);
+    } else {
+      super.update(changedProperties);
+    }
   }
   listen(name, listener, options) {
     const boundListener = listener?.bind(this) ?? listener;
@@ -504,7 +497,7 @@ class LitElement extends LitElement$1 {
    * });
    */
   async componentOnReady() {
-    await this._postLoaded.promise;
+    await this.#postLoadedDeferred.promise;
     return this;
   }
   /**
@@ -517,7 +510,7 @@ class LitElement extends LitElement$1 {
    * timing, and to add support for load/loaded lifecycle hooks.
    */
   addController(controller) {
-    this._controllers.add(controller);
+    this.M.push(controller);
     if (!(controllerSymbol in controller) && this.renderRoot && this.el.isConnected) {
       controller.hostConnected?.();
     }
@@ -526,11 +519,11 @@ class LitElement extends LitElement$1 {
    * Removes a controller from the host.
    */
   removeController(controller) {
-    this._controllers.delete(controller);
+    this.M.splice(this.M.indexOf(controller), 1);
     controller.controllerRemoved?.();
   }
 }
-function makeRuntime(options) {
+const makeRuntime = (options) => {
   let assetPath;
   const setAssetPath = (path) => {
     assetPath = new URL(
@@ -564,8 +557,8 @@ function makeRuntime(options) {
     },
     setAssetPath,
     customElement(tagName, component) {
-      component.runtime = runtime;
-      component.tagName = tagName;
+      component.K = runtime;
+      component.L = tagName;
       if (!customElements.get(tagName)) {
         customElements.define(tagName, component);
       }
@@ -576,7 +569,7 @@ function makeRuntime(options) {
     globalThis.devOnly$luminaRuntime = runtime;
   }
   return runtime;
-}
+};
 const Fragment = void 0;
 const bindAttribute = void 0;
 const bindBooleanAttribute = void 0;
@@ -651,11 +644,11 @@ const makeReactWrapperFactory = (react, createComponent) => (options) => {
   return result;
 };
 const getReactWrapperOptions = (tagNameAndElement, events) => ({ tagName: tagNameAndElement, events });
-function renderElement(element) {
+const renderElement = (element) => {
   const container = document.createElement("div");
   render(element, container);
   return container.firstElementChild;
-}
+};
 export {
   Fragment,
   LitElement,
@@ -663,9 +656,10 @@ export {
   bindBooleanAttribute,
   bindEvent,
   bindProperty,
-  d as createEvent,
+  b as createEvent,
   deferLoad,
   deferredLoaders,
+  d as devOnly$getLitElementTagNameAndRuntime,
   directive,
   getReactWrapperOptions,
   live,