@arcgis/lumina 5.1.0-next.8 → 5.1.0-next.80

package/dist/{Controller-DQnXLHsP.js → Controller-4XBxysPn.js}

@@ -1,5 +1,5 @@
 import { safeCall, isEsriInternalEnv, safeAsyncCall } from "@arcgis/toolkit/error";
-import { r as retrieveComponent, d as retrieveParentControllers, b as setParentController, a as setAmbientComponent, u as use, k as useRef, l as useRefSync, c as controllerSymbol } from "./ControllerInternals-By6dhpY-.js";
+import { r as retrieveComponent, d as retrieveParentControllers, b as setParentController, a as setAmbientComponent, u as use, k as useRef, l as useRefSync, c as controllerSymbol } from "./ControllerInternals-D2JYGiUO.js";
 import { nothing } from "lit";
 import { Deferred } from "@arcgis/toolkit/promise";
 import { rethrowError } from "@arcgis/toolkit/log";
@@ -211,19 +211,19 @@ class Controller {
    * controller as ready (for usage in other controllers). Also, triggers
    * re-render of the component
    */
-  set exports(exports) {
+  set exports(exports$1) {
     const oldExports = this.#exports;
-    if (oldExports !== exports) {
-      this.#exports = exports;
+    if (oldExports !== exports$1) {
+      this.#exports = exports$1;
       this.#exportWatchers.forEach(safeCall);
       if (this.connectedCalled && this.O !== false) {
         this.#component.requestUpdate(this.O, oldExports);
       }
     }
-    this.P.resolve(exports);
+    this.P.resolve(exports$1);
   }
-  setProvisionalExports(exports, proxy = true) {
-    this.#exports = proxy ? makeProvisionalValue(exports) : exports;
+  setProvisionalExports(exports$1, proxy = true) {
+    this.#exports = proxy ? makeProvisionalValue(exports$1) : exports$1;
     this.#exportWatchers.forEach(safeCall);
   }
   #exportWatchers;
@@ -454,9 +454,9 @@ export {
   Controller as C,
   GenericController as G,
   createEventFactory as a,
-  trackPropertyKey as b,
+  trackPropKey as b,
   createEvent as c,
-  trackPropKey as d,
+  trackPropertyKey as d,
   propertyTrackResolve as p,
   trackKey as t
 };

package/dist/{ControllerInternals-By6dhpY-.js → ControllerInternals-D2JYGiUO.js}

@@ -1,5 +1,5 @@
 import { isEsriInternalEnv } from "@arcgis/toolkit/error";
-const controllerSymbol = Symbol.for("controller");
+const controllerSymbol = /* @__PURE__ */ Symbol.for("controller");
 const isController = (value) => typeof value === "object" && value !== null && (controllerSymbol in value || "hostConnected" in value || "hostDisconnected" in value || "hostUpdate" in value || "hostUpdated" in value);
 const isPromise = (arg) => typeof arg?.then === "function";
 const getControllersCount = (component) => component.M.length;
@@ -74,7 +74,7 @@ const use = async (value, watchExports) => {
       throw new Error(`The controller must implement watchExports method to support watching exports`);
     }
     const unsubscribe = controller.watchExports(
-      (exports) => watchExports(exports, unsubscribe)
+      (exports$1) => watchExports(exports$1, unsubscribe)
     );
   }
   return controller.exports;
@@ -119,10 +119,10 @@ export {
   setParentController as b,
   controllerSymbol as c,
   retrieveParentControllers as d,
-  bypassSetter as e,
-  bypassReadOnly as f,
-  isController as g,
-  getControllersCount as h,
+  bypassReadOnly as e,
+  bypassSetter as f,
+  getControllersCount as g,
+  isController as h,
   isPromise as i,
   setAmbientChildController as j,
   useRef as k,

package/dist/{ControllerManager-eFkqujn9.js → ControllerManager-DFn8sm5s.js}

@@ -1,8 +1,8 @@
 import { safeCall, isEsriInternalEnv } from "@arcgis/toolkit/error";
-import { G as GenericController, p as propertyTrackResolve } from "./Controller-DQnXLHsP.js";
+import { G as GenericController, p as propertyTrackResolve } from "./Controller-4XBxysPn.js";
 import { nothing, LitElement as LitElement$1 } from "lit";
 import { devToolsAwareTimeout } from "@arcgis/toolkit/promise";
-import { a as setAmbientComponent } from "./ControllerInternals-By6dhpY-.js";
+import { a as setAmbientComponent } from "./ControllerInternals-D2JYGiUO.js";
 class ControllerManager extends GenericController {
   constructor(component) {
     super(component);
@@ -83,12 +83,12 @@ class ControllerManager extends GenericController {
   // 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.devOnly$ensureHasDestroy?.();
-    }
     if (this.destroyed) {
       return;
     }
+    if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
+      this.devOnly$ensureHasDestroy?.();
+    }
     if (this.#component.el.isConnected) {
       this.hasDestroy = false;
       this.#component.el.remove();
@@ -132,15 +132,15 @@ class ControllerManager extends GenericController {
    *
    * @private
    */
-  W(controller, exports) {
-    if (typeof exports === "object" && exports !== null || typeof exports === "function") {
-      this.#exportsStore.set(exports, controller);
+  W(controller, exports$1) {
+    if (typeof exports$1 === "object" && exports$1 !== null || typeof exports$1 === "function") {
+      this.#exportsStore.set(exports$1, controller);
     }
   }
   /** @private */
-  X(exports) {
-    if (typeof exports === "object" && exports !== null || typeof exports === "function") {
-      return this.#exportsStore.get(exports);
+  X(exports$1) {
+    if (typeof exports$1 === "object" && exports$1 !== null || typeof exports$1 === "function") {
+      return this.#exportsStore.get(exports$1);
     } else {
       return void 0;
     }

package/dist/LitElement.d.ts

@@ -5,6 +5,7 @@ import { ToElement } from './jsx/types.ts';
 import { BaseController, LuminaPropertyDeclaration } from './controllers/types.ts';
 import { ControllerManager } from './controllers/ControllerManager.ts';
 import { Controller } from './controllers/Controller.ts';
+import { FormAssociatedEvents } from './formAssociatedUtils.ts';
 type ComponentLifecycle = {
     connectedCallback?: () => void;
     disconnectedCallback?: () => void;
@@ -117,6 +118,19 @@ export declare class LitElement extends OriginalLitElement implements ComponentL
      * @private
      */
     __offspringComponents: ProxyComponent["__offspringComponents"];
+    /**
+     * For HMR, if the .elementInternals was created, preserve that element
+     * internals instance across hot reloads. This method lets HMR get a reference
+     * to element internals in a side-effect free way and without adding production
+     * bytes.
+     *
+     * @private
+     */
+    devOnly$PureGetElementInternals?: () => ElementInternals | undefined;
+    /**
+     * @see [MDN ElementInternals](https://developer.mozilla.org/en-US/docs/Web/API/ElementInternals)
+     */
+    get elementInternals(): ElementInternals;
     constructor();
     connectedCallback(): void;
     disconnectedCallback(): void;
@@ -157,6 +171,7 @@ export declare class LitElement extends OriginalLitElement implements ComponentL
      * ```
      */
     listen<K extends keyof HTMLElementEventMap>(name: K, listener: (this: this, event: HTMLElementEventMap[K]) => unknown, options?: AddEventListenerOptions | boolean): void;
+    listen<K extends keyof FormAssociatedEvents>(name: K, listener: (this: this, event: FormAssociatedEvents[K]) => unknown, options?: Omit<AddEventListenerOptions, "capture" | "passive"> | boolean): void;
     listen(name: string, listener: (this: this, event: Event) => unknown, options?: AddEventListenerOptions | boolean): void;
     listen<EventType extends Event = CustomEvent<"Provide type like this.listenOn<ToEvents<ArcgisCounter>['arcgisClick']>() to get type-checked payload type">>(name: string, 
     /**

package/dist/config.d.ts

@@ -19,3 +19,4 @@ export declare const propertyFlagNumber: number;
 export declare const propertyFlagState: number;
 export declare const propertyFlagReadOnly: number;
 export declare const propertyFlagNoAccessor: number;
+export declare const propertyFlagUseDefault: number;

package/dist/config.js

@@ -8,6 +8,7 @@ const propertyFlagNumber = 1 << 3;
 const propertyFlagState = 1 << 4;
 const propertyFlagReadOnly = 1 << 5;
 const propertyFlagNoAccessor = 1 << 6;
+const propertyFlagUseDefault = 1 << 7;
 export {
   lazyMetaGroupJoiner,
   lazyMetaItemJoiner,
@@ -18,5 +19,6 @@ export {
   propertyFlagNumber,
   propertyFlagReadOnly,
   propertyFlagReflect,
-  propertyFlagState
+  propertyFlagState,
+  propertyFlagUseDefault
 };

package/dist/context.js

@@ -1,5 +1,5 @@
-import { ContextProvider, ContextConsumer } from "@lit/context";
-import { r as retrieveComponent } from "./ControllerInternals-By6dhpY-.js";
+import { ContextConsumer, ContextProvider } from "@lit/context";
+import { r as retrieveComponent } from "./ControllerInternals-D2JYGiUO.js";
 const useContextProvider = (options) => {
   const component = retrieveComponent();
   const controller = new ContextProvider(component.el, options);

package/dist/controllers/accessor/index.js

@@ -1,8 +1,8 @@
 import { isEsriInternalEnv } from "@arcgis/toolkit/error";
-import { r as retrieveComponent } from "../../ControllerInternals-By6dhpY-.js";
+import { r as retrieveComponent } from "../../ControllerInternals-D2JYGiUO.js";
 import { on, watch } from "@arcgis/core/core/reactiveUtils.js";
-import { a as createEventFactory, G as GenericController, d as trackPropKey, t as trackKey } from "../../Controller-DQnXLHsP.js";
-import { p as proxyExports } from "../../proxyExports-CXEnG2Az.js";
+import { a as createEventFactory, G as GenericController, b as trackPropKey, t as trackKey } from "../../Controller-4XBxysPn.js";
+import { p as proxyExports } from "../../proxyExports-DqN4TWBr.js";
 import { createObservable, trackAccess } from "@arcgis/core/applications/Components/reactiveUtils.js";
 import { property, subclass } from "@arcgis/core/core/accessorSupport/decorators.js";
 import Accessor from "@arcgis/core/core/Accessor.js";

package/dist/controllers/accessor/reEmitEvent.d.ts

@@ -1,10 +1,11 @@
 import { EventEmitter } from '../../createEvent.ts';
+import { Evented } from '@arcgis/core/core/Evented.js';
 /**
  * Re-emit an event from the accessor instance on the component
  *
  * @example
  * ```tsx
- * arcgisGo = reEmitEvent<__esri.HomeViewModelGoEvent>(() => this.viewModel, "go");
+ * arcgisGo = reEmitEvent<HomeViewModelGoEvent>(() => this.viewModel, "go");
  * ```
  */
-export declare const reEmitEvent: <T>(getEventedAccessor: () => __esri.Evented, eventName: string) => EventEmitter<T>;
+export declare const reEmitEvent: <T>(getEventedAccessor: () => Evented, eventName: string) => EventEmitter<T>;

package/dist/controllers/accessor/store.d.ts

@@ -2,7 +2,7 @@ import { default as Accessor } from '@arcgis/core/core/Accessor.js';
 /**
  * See https://webgis.esri.com/references/lumina/controllers/useAccessor#createstore-utility
  */
-export declare const createStore: <T extends object>(initializer: T | (() => T)) => __esri.Accessor & T;
+export declare const createStore: <T extends object>(initializer: T | (() => T)) => Accessor & T;
 /** @deprecated Use {@link createStore} instead */
 export declare const createLegacyStore: <T extends object>(defaultState: T | (() => T)) => ObservableMap<T>;
 /** @deprecated Use {@link createStore} instead */

package/dist/controllers/accessor/useAccessor.d.ts

@@ -1,6 +1,7 @@
 import { GenericController } from '../Controller.ts';
 import { LitElement } from '../../LitElement.ts';
-type Requires<Props, Accessor extends __esri.Accessor, OmitProps extends string = never> = LitElement & Omit<Pick<Accessor, keyof Accessor & keyof Props>, AlwaysOmit | OmitProps> & {
+import { default as coreAccessor } from '@arcgis/core/core/Accessor.js';
+type Requires<Props, Accessor extends coreAccessor, OmitProps extends string = never> = LitElement & Omit<Pick<Accessor, keyof Accessor & keyof Props>, AlwaysOmit | OmitProps> & {
     autoDestroyDisabled: boolean;
     destroy: () => Promise<void>;
 };
@@ -12,7 +13,7 @@ type AlwaysOmit = "addHandles" | "declaredClass" | "destroyed" | "hasHandles" |
  * See https://webgis.esri.com/references/lumina/controllers/useAccessor for
  * documentation & examples.
  */
-export declare const makeAccessorController: <Props, Accessor extends __esri.Accessor, OmitProps extends string = never>(createInstance: ((props?: Props) => Accessor) | (new (props?: Props) => Accessor), _options?: {
+export declare const makeAccessorController: <Props, Accessor extends coreAccessor, OmitProps extends string = never>(createInstance: ((props?: Props) => Accessor) | (new (props?: Props) => Accessor), _options?: {
     /**
      * By default, to ensure that you didn't accidentally forget to bind any
      * of the Accessor's properties on your component, every property that
@@ -38,7 +39,7 @@ export declare const makeAccessorController: <Props, Accessor extends __esri.Acc
      */
     omitProps: OmitProps[];
 }) => (component: Requires<Props, Accessor, OmitProps>) => Accessor;
-export declare class AccessorController<Props, Accessor extends __esri.Accessor, ExtraRequires = Record<never, never>> extends GenericController<Accessor, ExtraRequires & Requires<Props, Accessor>> {
+export declare class AccessorController<Props, Accessor extends coreAccessor, ExtraRequires = Record<never, never>> extends GenericController<Accessor, ExtraRequires & Requires<Props, Accessor>> {
     #private;
     protected instance: Accessor;
     /**
@@ -63,14 +64,14 @@ export declare class AccessorController<Props, Accessor extends __esri.Accessor,
     hostConnected(): void;
     hostDestroy(): void;
 }
-type MinimalAccessorController = Pick<AccessorController<never, __esri.Accessor>, "_currentlyBindingPropertyName" | "exports"> & {
+type MinimalAccessorController = Pick<AccessorController<never, coreAccessor>, "_currentlyBindingPropertyName" | "exports"> & {
     component: LitElement;
 };
 export declare const makeBinderProxy: (component: LitElement, accessorControllerRef: WeakRef<MinimalAccessorController & {
     constructor: MinimalAccessorController["constructor"] & {
         devOnly$allowedPropNameMismatches?: ReadonlySet<string>;
     };
-}>, accessorControllerIndex: number, instance: __esri.Accessor, boundProperties: Map<string, string>) => unknown;
-export declare const getAccessorControllerBoundProperties: <Accessor extends __esri.Accessor>(controller: AccessorController<unknown, Accessor>) => Map<string & keyof Accessor, string>;
-export declare const reCreateAccessor: (instance: __esri.Accessor, component: LitElement) => void;
+}>, accessorControllerIndex: number, instance: coreAccessor, boundProperties: Map<string, string>) => unknown;
+export declare const getAccessorControllerBoundProperties: <Accessor extends coreAccessor>(controller: AccessorController<unknown, Accessor>) => Map<string & keyof Accessor, string>;
+export declare const reCreateAccessor: (instance: coreAccessor, component: LitElement) => void;
 export {};

package/dist/controllers/index.js

@@ -1,13 +1,13 @@
-import { C as Controller, t as trackKey, a as createEventFactory, p as propertyTrackResolve } from "../Controller-DQnXLHsP.js";
-import { G, d, b } from "../Controller-DQnXLHsP.js";
-import { a as setAmbientComponent, i as isPromise, b as setParentController, d as retrieveParentControllers, r as retrieveComponent } from "../ControllerInternals-By6dhpY-.js";
-import { f, e, c, h, g } from "../ControllerInternals-By6dhpY-.js";
-import { p as proxyExports } from "../proxyExports-CXEnG2Az.js";
+import { C as Controller, t as trackKey, a as createEventFactory, p as propertyTrackResolve } from "../Controller-4XBxysPn.js";
+import { G, b, d } from "../Controller-4XBxysPn.js";
+import { a as setAmbientComponent, i as isPromise, b as setParentController, d as retrieveParentControllers, r as retrieveComponent } from "../ControllerInternals-D2JYGiUO.js";
+import { e, f, c, g, h } from "../ControllerInternals-D2JYGiUO.js";
+import { p as proxyExports } from "../proxyExports-DqN4TWBr.js";
 import { isServer } from "lit";
 import { isEsriInternalEnv } from "@arcgis/toolkit/error";
 import { observeAncestorsMutation, getElementAttribute } from "@arcgis/toolkit/dom";
 import { getElementLocale, startLocaleObserver } from "@arcgis/toolkit/intl";
-import { s as setAutoDestroyOnDisconnectTimeout, b as autoDestroyOnDisconnectTimeout } from "../ControllerManager-eFkqujn9.js";
+import { s as setAutoDestroyOnDisconnectTimeout, b as autoDestroyOnDisconnectTimeout } from "../ControllerManager-DFn8sm5s.js";
 const makeController = (constructor) => proxy(void 0, constructor);
 const makeGenericController = (constructor) => (component) => proxy(
   component,
@@ -258,12 +258,12 @@ const exportsForTests = {
 export {
   Controller,
   G as GenericController,
-  f as bypassReadOnly,
-  e as bypassSetter,
+  e as bypassReadOnly,
+  f as bypassSetter,
   c as controllerSymbol,
   exportsForTests,
-  h as getControllersCount,
-  g as isController,
+  g as getControllersCount,
+  h as isController,
   keyTrackResolve,
   load,
   makeController,
@@ -274,8 +274,8 @@ export {
   retrieveComponent,
   toFunction,
   trackKey,
-  d as trackPropKey,
-  b as trackPropertyKey,
+  b as trackPropKey,
+  d as trackPropertyKey,
   useDirection,
   useMedia,
   usePropertyChange,

package/dist/formAssociatedUtils.d.ts

@@ -0,0 +1,48 @@
+import { ProxyComponent } from './lazyLoad.ts';
+import { LitElement } from './LitElement.ts';
+/**
+ * Web platform allows custom elements to define these methods to handle the
+ * corresponding form events. For performance reasons, the engines require that
+ * these methods are present when the customElements.define() is called - it
+ * means that we need to include them in the lazy proxy as well.
+ *
+ * The lazy proxy today only creates the methods proxies the first time a proxy
+ * element of that tag name is created, which is too late.
+ *
+ * We could update the proxy to define the method proxies right away. Some cons
+ * with that:
+ * - In lazy builds, most components are never loaded, so I want to keep the
+ *   per-proxy overhead minimal.
+ * - To handle this form event, the component would need to define a
+ *   corresponding method with a \@method() decorator (to ensure it is present
+ *   on the proxy), and the method needs to be async (so that the lazy proxy
+ *   knows to await component loading before calling the method)
+ *   - If you forget to add \@method(), lazy proxy won't proxy this method. If
+ *     you forget to make it async, lazy proxy will error if the component is
+ *     not loaded yet. These are not obvious constraints from lazy-loading, and
+ *     do not match the examples online/copilot. We may need lint rules about
+ *     this.
+ * - Such API is not composable - if the method needs to be present on the
+ *   component, it is hard for a controller to handle it, creating wiring
+ *   boilerplate.
+ *
+ * To address these concerns, the proxy does the following:
+ * - Always define these methods on the prototype (harmless for
+ *   non-form-associated components). The methods are created once, so no
+ *   per-proxy overhead.
+ * - The proxy waits for component to be loaded. This avoids a race condition of
+ *   event being emitted before the constructor is lazy-loaded, and keeps timing
+ *   consistent with non-lazy builds.
+ * - The proxy will emit a corresponding event on itself. The component or any
+ *   controller can choose to listen to these events. The event does not bubble
+ *   and does not compose, so will have minimum visibility outside the component.
+ * - To keep the non-lazy behavior aligned, we also emit such events on itself
+ *   in non-lazy builds.
+ */
+export interface FormAssociatedEvents {
+    luminaFormAssociatedCallback: CustomEvent<readonly [form: HTMLFormElement | null]>;
+    luminaFormDisabledCallback: CustomEvent<readonly [disabled: boolean]>;
+    luminaFormResetCallback: CustomEvent<readonly []>;
+    luminaFormStateRestoreCallback: CustomEvent<readonly [state: unknown, mode: "autocomplete" | "restore"]>;
+}
+export declare function proxyFormMethodsToEvents(constructor: typeof LitElement | typeof ProxyComponent): void;

package/dist/hmrSupport.d.ts

@@ -21,6 +21,7 @@ export type HmrComponentMeta = {
     readonly properties: (readonly [property: string, attribute: string] | readonly [property: string])[];
     readonly asyncMethods: readonly string[];
     readonly syncMethods: readonly string[];
+    readonly formAssociated: boolean;
 };
 /**
  * Update lazy component meta

package/dist/hmrSupport.js

@@ -1,4 +1,4 @@
-import { n as noShadowRoot, P as ProxyComponent } from "./lazyLoad-DJM-hmfq.js";
+import { P as ProxyComponent, n as noShadowRoot } from "./lazyLoad-B5Rj3U_I.js";
 import { camelToKebab } from "@arcgis/toolkit/string";
 function handleHmrUpdate(newModules) {
   newModules.forEach((newModule) => {
@@ -56,6 +56,8 @@ function reInitialize(instance, newModule) {
     ([propertyName, descriptor]) => typeof propertyName === "string" && (instance.devOnly$hmrSetProps.has(propertyName) || typeof descriptor.attribute === "string" && instance.devOnly$hmrSetAttributes.has(descriptor.attribute))
   ).map(([key]) => [key, instance[key]]);
   instance.devOnly$hmrResetStore(Object.fromEntries(preservedProperties));
+  const elementInternals = instance.$component.devOnly$PureGetElementInternals();
+  instance.devOnly$elementInternals = elementInternals;
   if (instance.isConnected) {
     instance.$component.disconnectedCallback();
   }
@@ -91,7 +93,7 @@ function handleComponentMetaUpdate(meta) {
   ProxyClass.observedAttributes = attributes;
 }
 function initializeAttributeObserver() {
-  const observedAttributesSymbol = Symbol.for("@arcgis/lumina:observedAttributes");
+  const observedAttributesSymbol = /* @__PURE__ */ Symbol.for("@arcgis/lumina:observedAttributes");
   const globalThisWithObservedAttributes = globalThis;
   const alreadyHadObservers = observedAttributesSymbol in globalThisWithObservedAttributes;
   globalThisWithObservedAttributes[observedAttributesSymbol] ??= {};

package/dist/index.js

@@ -1,16 +1,16 @@
-import { p as propertyTrackResolve } from "./Controller-DQnXLHsP.js";
-import { c } from "./Controller-DQnXLHsP.js";
+import { p as propertyTrackResolve } from "./Controller-4XBxysPn.js";
+import { c } from "./Controller-4XBxysPn.js";
 import { state } from "lit/decorators/state.js";
 import { property as property$1 } from "lit/decorators/property.js";
-import { e as emptyFunction, n as noShadowRoot, a as attachToAncestor } from "./lazyLoad-DJM-hmfq.js";
-import { d, m } from "./lazyLoad-DJM-hmfq.js";
+import { e as emptyFunction, n as noShadowRoot, p as proxyFormMethodsToEvents, a as attachToAncestor } from "./lazyLoad-B5Rj3U_I.js";
+import { d, m } from "./lazyLoad-B5Rj3U_I.js";
 import { isEsriInternalEnv, safeAsyncCall, safeCall } from "@arcgis/toolkit/error";
 import { camelToKebab } from "@arcgis/toolkit/string";
 import { Deferred } from "@arcgis/toolkit/promise";
 import { LitElement as LitElement$1, isServer, notEqual, noChange as noChange$1, nothing as nothing$1, render } from "lit";
-import { c as controllerSymbol, s as shouldBypassReadOnly } from "./ControllerInternals-By6dhpY-.js";
-import { C as ControllerManager, a as autoDestroyDisabledPropName } from "./ControllerManager-eFkqujn9.js";
-import { propertyFlagAttribute, propertyFlagNoAccessor, propertyFlagReadOnly, propertyFlagState, propertyFlagBoolean, propertyFlagNumber, propertyFlagReflect } from "./config.js";
+import { c as controllerSymbol, s as shouldBypassReadOnly } from "./ControllerInternals-D2JYGiUO.js";
+import { C as ControllerManager, a as autoDestroyDisabledPropName } from "./ControllerManager-DFn8sm5s.js";
+import { propertyFlagAttribute, propertyFlagUseDefault, propertyFlagNoAccessor, propertyFlagReadOnly, propertyFlagState, propertyFlagBoolean, propertyFlagNumber, propertyFlagReflect } from "./config.js";
 import { classMap } from "lit/directives/class-map.js";
 import { styleMap } from "lit/directives/style-map.js";
 import { directive as directive$1, Directive } from "lit/directive.js";
@@ -65,6 +65,10 @@ class LitElement extends LitElement$1 {
             );
           }
         });
+        this.devOnly$PureGetElementInternals = () => this.#elementInternals;
+        if (lazy?.devOnly$elementInternals !== void 0) {
+          this.#elementInternals = lazy.devOnly$elementInternals;
+        }
       }
     }
     if (createObservable) {
@@ -119,6 +123,7 @@ class LitElement extends LitElement$1 {
       // Controllers add this option to Lit
       readOnly: !!(flags & propertyFlagReadOnly),
       noAccessor: !!(flags & propertyFlagNoAccessor),
+      useDefault: !!(flags & propertyFlagUseDefault),
       c: false,
       ...rest,
       hasChanged(newValue, oldValue) {
@@ -160,6 +165,9 @@ class LitElement extends LitElement$1 {
   static {
     this.lumina = true;
   }
+  static {
+    proxyFormMethodsToEvents(this);
+  }
   /**
    * The JS API's Accessor observables. This is used to integrate with the JS
    * API's reactivity system.
@@ -171,14 +179,26 @@ class LitElement extends LitElement$1 {
   #enableUpdating;
   #postLoadedDeferred;
   #trackingTarget;
+  #elementInternals;
+  /**
+   * @see [MDN ElementInternals](https://developer.mozilla.org/en-US/docs/Web/API/ElementInternals)
+   */
+  get elementInternals() {
+    this.#elementInternals ??= this.el.attachInternals();
+    return this.#elementInternals;
+  }
   connectedCallback() {
-    if (this.el.hasAttribute("defer-hydration")) {
-      return;
+    if (!this.hasAttribute("defer-hydration")) {
+      this.#connectedCallback(true);
     }
+  }
+  #connectedCallback(callSuper) {
     const trackingTarget = this.constructor.K.c?.(() => this.requestUpdate());
     this.#trackingTarget = trackingTarget;
     const isFirstCall = !this.manager.connectedCalled;
-    super.connectedCallback();
+    if (callSuper) {
+      super.connectedCallback();
+    }
     if (isFirstCall) {
       queueMicrotask(
         // eslint-disable-next-line @typescript-eslint/promise-function-async, @typescript-eslint/no-misused-promises
@@ -222,9 +242,13 @@ class LitElement extends LitElement$1 {
     const options = Class.shadowRootOptions;
     const useLightDom = options === noShadowRoot;
     const renderRoot = existingShadowRoot ?? (useLightDom ? this.el : this.el.attachShadow(options));
-    if (existingShadowRoot && // The shadow root may already exist if we are doing HMR - such case is not
-    // SSR so ignore it
-    process.env.NODE_ENV !== "production" && (this.el.constructor.devOnly$hmrIndex ?? 0) === 0) {
+    if (existingShadowRoot && // If we are in production, we are not in HMR, so assume SSR.
+    // If we are not in production, we might still be in SSR, as long as we
+    // are not in HMR
+    (process.env.NODE_ENV === "production" || this.el.constructor.devOnly$hmrIndex === void 0)) {
+      if (!this.manager.connectedCalled) {
+        this.#connectedCallback(false);
+      }
       LitElement$1.prototype.createRenderRoot.call(this);
       return existingShadowRoot;
     }
@@ -264,7 +288,7 @@ class LitElement extends LitElement$1 {
     this.#enableUpdating(true);
     this.performUpdate();
     this.I.resolve();
-    await Promise.resolve();
+    await 0;
     const pendingChildren = this.J.filter((loaded) => !loaded.manager?.loadedCalled);
     if (pendingChildren.length) {
       await Promise.allSettled(pendingChildren.map(async (child) => await child.componentOnReady()));
@@ -386,7 +410,15 @@ const makeRuntime = (options) => {
     customElement(tagName, component) {
       component.K = runtime;
       component.L = tagName;
-      if (!customElements.get(tagName)) {
+      if (isServer) {
+        let define = function() {
+          try {
+            customElements.define(tagName, component);
+          } catch {
+          }
+        };
+        define();
+      } else if (!customElements.get(tagName)) {
         customElements.define(tagName, component);
       }
     }