@arcgis/lumina 4.33.0-next.12 → 4.33.0-next.120

package/dist/jsx/types.d.ts

@@ -1,15 +1,7 @@
-/**
- * This reference directive is removed by tsup at compile time. It is only
- * needed to correctly type-check this package. For consumers of this package,
- * they should have an `./src/lumina.ts` file like so:
- * ```ts
- * /// <reference types="@arcgis/lumina/typings" />
- * ```
- */
-import type { TemplateResult } from "lit-html";
-import type { DirectiveResult } from "lit-html/directive.js";
-import type { HTMLElementTags, HTMLAttributes, GlobalEventHandlersCamelCase, SvgElementTags, DOMAttributes, AriaAttributes } from "./generatedTypes";
-import type { CustomAttributes } from "./baseTypes";
+import { TemplateResult } from 'lit-html';
+import { DirectiveResult } from 'lit-html/directive.js';
+import { HTMLElementTags, HTMLAttributes, GlobalEventHandlersCamelCase, SvgElementTags, DOMAttributes, AriaAttributes } from './generatedTypes';
+import { CustomAttributes } from './baseTypes';
 /**
  * The "h" namespace is used to import JSX types for elements and attributes.
  * It is imported in order to avoid conflicting global JSX issues.
@@ -372,27 +364,8 @@ type FixupStencilEventCasing<PropertyName extends PropertyKey> = PropertyName ex
  * https://www.typescriptlang.org/docs/handbook/jsx.html
  */
 export declare namespace LuminaJsx {
-    /**
-     * Whether to pick TemplateResult or JsxNode here is a compromise.
-     *
-     * - If I tell it Lit JSX type is JsxNode, then even <a /> expression will
-     *   have a very broad JsxNode type (union of template results, null,
-     *   undefined, false, and more). This may slow down type-checking and may be
-     *   too-broad for certain use cases.
-     *   - Since <a /> would be typed very broad, you won't be able to declare
-     *     your function as receiving just TemplateResult
-     *   - Also, this makes TypeScript not allow you to return undefined from
-     *     your functional component
-     *   - This is what React did and what I am going with
-     * - If I tell TypeScript that JSX type is TemplateResult, then my function
-     *   component is no longer allowed to return undefined or string or etc.
-     *
-     * This is mainly a TypeScript limitation. Issues tracking this:
-     * - https://github.com/microsoft/TypeScript/issues/21699
-     * - https://github.com/DefinitelyTyped/DefinitelyTyped/issues/18912
-     *
-     */
     export type Element = TemplateResult;
+    export type ElementType = JsxNode;
     export interface ElementClass {
     }
     export interface ElementAttributesProperty {

package/dist/lazyLoad.d.ts

@@ -1,7 +1,7 @@
-import { Deferred } from "@arcgis/components-utils";
-import type { LitElement } from "./LitElement";
-import type { Runtime } from "./runtime";
-import type { ControllerManager } from "@arcgis/components-controllers";
+import { Deferred } from '@arcgis/components-utils';
+import { LitElement } from './LitElement';
+import { Runtime } from './makeRuntime';
+import { ControllerManager } from './controllers/ControllerManager';
 /**
  * Defines lazy-loading proxy components for all web components in this package.
  *
@@ -47,32 +47,32 @@ declare const HtmlElement: {
  * component, so as to have identical DOM structure for lazy vs non-lazy builds
  * (otherwise, css selectors may break)
  *
- * @internal
+ * @private
  */
 export declare abstract class ProxyComponent extends HtmlElement {
     static observedAttributes?: readonly string[];
-    /** @internal */
+    /** @private */
     static _loadPromise: Promise<Record<string, typeof LitElement>> | undefined;
-    /** @internal */
+    /** private */
     static _LitConstructor?: typeof LitElement;
     /**
      * A list of instances of this component. This allows hot module replacement
      * to update all proxy component to use a new LitElement instance.
      *
-     * @internal
+     * private
      */
     static _hmrInstances: WeakRef<ProxyComponent>[] | undefined;
-    /** @internal */
+    /** private */
     static _hmrIndex: number | undefined;
-    /** @internal */
+    /** private */
     static _properties?: readonly string[];
-    /** @internal */
+    /** private */
     static _asyncMethods?: readonly string[];
-    /** @internal */
+    /** private */
     static _syncMethods?: readonly string[];
     protected static _name: string;
     static readonly lumina = true;
-    /** @internal */
+    /** private */
     static _initializePrototype(): void;
     private static _bindProp;
     private static _bindAsync;
@@ -81,14 +81,14 @@ export declare abstract class ProxyComponent extends HtmlElement {
      * On HMR, preserve the values of all properties that at least once were set
      * by someone other than component itself.
      *
-     * @internal
+     * private
      */
     _hmrSetProps: Set<PropertyKey>;
-    /** @internal */
+    /** private */
     _hmrSetAttributes: Set<string>;
-    /** @internal */
+    /** private */
     _litElement: LitElement | undefined;
-    /** @internal */
+    /** private */
     _store: LitElement | Record<string, unknown>;
     /**
      * If attributeChangedCallback() is called before the LitElement is loaded,
@@ -153,7 +153,7 @@ export declare abstract class ProxyComponent extends HtmlElement {
      * Create a promise that resolves once component is fully loaded
      */
     componentOnReady(): Promise<this>;
-    /** @internal */
+    /** private */
     _initializeComponent(module: Record<string, typeof LitElement>): void;
     /**
      * Implemented on the proxy for compatibility with Lit Context.

package/dist/lifecycleSupport.d.ts

@@ -1,4 +1,4 @@
-import type { ProxyComponent } from "./lazyLoad";
+import { ProxyComponent } from './lazyLoad';
 /**
  * If there is a parent component, tell it to await it's loaded() until we
  * completed load().

package/dist/makeRuntime.d.ts

@@ -0,0 +1,109 @@
+import { CSSResult } from 'lit';
+import { LitElement } from './LitElement';
+/**
+ * `@arcgis/lumina` package may be bundled once but used by multiple packages with
+ * different configuration options. For that reason, the configuration options
+ * cannot be a global object, but has to be an object that you pass around.
+ */
+export type Runtime = RuntimeOptions & {
+    /**
+     * Get the base path to where the package assets can be found.
+     * By default, the package asset path is set to `https://js.arcgis.com/<simplified-package-name>/<released-verion>/`.
+     * We are hosting our assets on a CDN (Content Delivery Network) to ensure fast and reliable access.
+     * It is CORS-enabled, so you can load the assets from any domain.
+     * Use "setAssetPath(path)" if the path needs to be customized.
+     */
+    readonly getAssetPath: (suffix: string) => string;
+    /**
+     * Used to manually set the base path where package assets (like localization
+     * and icons) can be found.
+     *
+     * By default, the package asset path is set to `https://js.arcgis.com/<simplified-package-name>/<released-verion>/`.
+     * For example, `https://js.arcgis.com/map-components/4.30/`.
+     * We are hosting our assets on a CDN (Content Delivery Network) to ensure fast and reliable access.
+     * It is CORS-enabled, so you can load the assets from any domain.
+     * This is the recommended way to load the assets and avoid bundling them with your application.
+     * It means that by default, you don't need to use "setAssetPath" since the path is already set.
+     *
+     * However, if you need to host the assets locally, you can use "setAssetPath" to set the base path.
+     * If the script is used as "module", it's recommended to use "import.meta.url",
+     * such as "setAssetPath(import.meta.url)". Other options include
+     * "setAssetPath(document.currentScript.src)", or using a bundler's replace plugin to
+     * dynamically set the path at build time, such as "setAssetPath(process.env.ASSET_PATH)".
+     * But do note that this configuration depends on how your script is bundled, or lack of
+     * bundling, and where your assets can be loaded from. Additionally custom bundling
+     * will have to ensure the static assets are copied to its build directory.
+     */
+    readonly setAssetPath: (path: URL | string) => void;
+    /**
+     * The customElement decorator. Unlike default Lit's decorator this one
+     * provides runtime instance to the LitElement class
+     *
+     * @remarks
+     * You do not need to call this decorator in your component.
+     * It will be added automatically at build time.
+     *
+     * Instead, make sure your component file has the following:
+     * ```ts
+     * declare global {
+     *  interface DeclareElements {
+     *      "arcgis-your-component": ArcgisYourComponent;
+     *   }
+     * }
+     * ```
+     */
+    readonly customElement: (tagName: string, component: typeof LitElement) => void;
+};
+export type RuntimeOptions = {
+    /**
+     * The default asset path to use in NPM and CDN builds.
+     *
+     * This option will be set by Lumina compiler based on the value of the
+     * `assets.defaultPath` option in the `useLumina()` plugin.
+     */
+    readonly defaultAssetPath: string;
+    /**
+     * The attribute that indicates a component has rendered it's content.
+     * Usually this attribute is added after your component's `loaded()` lifecycle
+     * happened. However, during SSR, "hydrated" is added right away on the
+     * server.
+     *
+     * Until element has this attribute, it will have `visibility:hidden` style
+     * applied.
+     *
+     * This option will be set by the Lumina compiler based on the value of
+     * the `css.hydratedAttribute` option in the `useLumina()` plugin.
+     */
+    readonly hydratedAttribute: string;
+    /**
+     * Styles that you wish to make available in each component's shadow root, but
+     * to not apply outside the shadow root
+     *
+     * This option will be set by Lumina compiler based on the value of the
+     * `css.commonStylesPath` option in the `useLumina()` plugin.
+     */
+    readonly commonStyles?: CSSResult;
+};
+/**
+ * The options object will be provided by Lumina compiler at build-time.
+ * It should not be specified in the source code.
+ */
+export declare function makeRuntime(options?: RuntimeOptions): Runtime;
+/**
+ * Exposing the reference to the runtime globally when in tests or development.
+ * This is primarily for usage by dynamically created components in tests
+ *
+ * @private
+ */
+export type DevOnlyGlobalRuntime = typeof globalThis & {
+    devOnly$luminaRuntime?: Runtime;
+};
+/**
+ * Called from the component constructor when in development or test mode.
+ * Used primarily by mount to get a reference to the rendered component.
+ *
+ * @private
+ */
+export type DevOnlyGlobalComponentRefCallback = typeof globalThis & {
+    devOnly$luminaComponentRefCallback?: (component: LitElement) => void;
+};

package/dist/proxyExports-CK5BLFLO.js

@@ -0,0 +1,60 @@
+import { e as setParentController, f as retrieveParentControllers, u as setAmbientChildController, t as trackKey, l as bypassReadOnly } from "./Controller-CZ8Djohh.js";
+const proxyExports = (Class) => (...args) => {
+  const ambientControllers = retrieveParentControllers();
+  const instance = new Class(...args);
+  const initialExports = instance.exports;
+  setParentController(ambientControllers.at(-1));
+  const manager = instance.component.manager;
+  manager._markExports(instance, initialExports);
+  instance.watchExports((exports) => manager._markExports(instance, exports));
+  setAmbientChildController(instance);
+  const hostCandidates = [instance.component, ...ambientControllers].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 manager = controller.component.manager;
+      if (hostValueChanged) {
+        manager._markExports(controller, genericHost[key]);
+      }
+      controller.onUpdate((changes) => {
+        if (changes.has(key)) {
+          const value = genericHost[key];
+          if (value !== controller.exports) {
+            manager._markExports(controller, value);
+          }
+        }
+      });
+    }
+    controller.assignedProperty = assignedToProp ? void 0 : key;
+  }
+  const isReadOnly = controller.component.constructor.elementProperties.get(key)?.readOnly;
+  controller.watchExports(() => {
+    if (genericHost[key] === controller.exports) {
+      return;
+    }
+    if (isReadOnly) {
+      bypassReadOnly(() => {
+        genericHost[key] = controller.exports;
+      });
+    } else {
+      genericHost[key] = controller.exports;
+    }
+  });
+}
+export {
+  proxyExports as p
+};

package/dist/render.d.ts

@@ -0,0 +1,5 @@
+import { JsxNode } from './jsx/types';
+/**
+ * Retrieve an HTML element to be manually appended to an existing component.
+ */
+export declare function renderElement<Element extends HTMLElement = HTMLElement>(element: JsxNode): Element;

package/dist/runtime.d.ts

@@ -1,109 +1,6 @@
-import type { CSSResult } from "lit";
-import type { LitElement } from "./LitElement";
+export declare const runtime: import('./makeRuntime').Runtime;
 /**
- * `@arcgis/lumina` package may be bundled once but used by multiple packages with
- * different configuration options. For that reason, the configuration options
- * cannot be a global object, but has to be an object that you pass around.
+ * "customElement" needs to be exported - it will be used by the build system.
+ * You should not call it directly.
  */
-export type Runtime = RuntimeOptions & {
-    /**
-     * Get the base path to where the package assets can be found.
-     * By default, the package asset path is set to `https://js.arcgis.com/<simplified-package-name>/<released-verion>/`.
-     * We are hosting our assets on a CDN (Content Delivery Network) to ensure fast and reliable access.
-     * It is CORS-enabled, so you can load the assets from any domain.
-     * Use "setAssetPath(path)" if the path needs to be customized.
-     */
-    readonly getAssetPath: (suffix: string) => string;
-    /**
-     * Used to manually set the base path where package assets (like localization
-     * and icons) can be found.
-     *
-     * By default, the package asset path is set to `https://js.arcgis.com/<simplified-package-name>/<released-verion>/`.
-     * For example, `https://js.arcgis.com/map-components/4.30/`.
-     * We are hosting our assets on a CDN (Content Delivery Network) to ensure fast and reliable access.
-     * It is CORS-enabled, so you can load the assets from any domain.
-     * This is the recommended way to load the assets and avoid bundling them with your application.
-     * It means that by default, you don't need to use "setAssetPath" since the path is already set.
-     *
-     * However, if you need to host the assets locally, you can use "setAssetPath" to set the base path.
-     * If the script is used as "module", it's recommended to use "import.meta.url",
-     * such as "setAssetPath(import.meta.url)". Other options include
-     * "setAssetPath(document.currentScript.src)", or using a bundler's replace plugin to
-     * dynamically set the path at build time, such as "setAssetPath(process.env.ASSET_PATH)".
-     * But do note that this configuration depends on how your script is bundled, or lack of
-     * bundling, and where your assets can be loaded from. Additionally custom bundling
-     * will have to ensure the static assets are copied to its build directory.
-     */
-    readonly setAssetPath: (path: URL | string) => void;
-    /**
-     * The customElement decorator. Unlike default Lit's decorator this one
-     * provides runtime instance to the LitElement class
-     *
-     * @remarks
-     * You do not need to call this decorator in your component.
-     * It will be added automatically at build time.
-     *
-     * Instead, make sure your component file has the following:
-     * ```ts
-     * declare global {
-     *  interface DeclareElements {
-     *      "arcgis-your-component": ArcgisYourComponent;
-     *   }
-     * }
-     * ```
-     */
-    readonly customElement: (tagName: string, component: typeof LitElement) => void;
-};
-export type RuntimeOptions = {
-    /**
-     * The default asset path to use in NPM and CDN builds.
-     *
-     * This option will be set by Lumina compiler based on the value of the
-     * `assets.defaultPath` option in the `useLumina()` plugin.
-     */
-    readonly defaultAssetPath: string;
-    /**
-     * The attribute that indicates a component has rendered it's content.
-     * Usually this attribute is added after your component's `loaded()` lifecycle
-     * happened. However, during SSR, "hydrated" is added right away on the
-     * server.
-     *
-     * Until element has this attribute, it will have `visibility:hidden` style
-     * applied.
-     *
-     * This option will be set by the Lumina compiler based on the value of
-     * the `css.hydratedAttribute` option in the `useLumina()` plugin.
-     */
-    readonly hydratedAttribute: string;
-    /**
-     * Styles that you wish to make available in each component's shadow root, but
-     * to not apply outside the shadow root
-     *
-     * This option will be set by Lumina compiler based on the value of the
-     * `css.commonStylesPath` option in the `useLumina()` plugin.
-     */
-    readonly commonStyles?: CSSResult;
-};
-/**
- * The options object will be provided by Lumina compiler at build-time.
- * It should not be specified in the source code.
- */
-export declare function makeRuntime(options?: RuntimeOptions): Runtime;
-/**
- * Exposing the reference to the runtime globally when in tests or development.
- * This is primarily for usage by dynamically created components in tests
- *
- * @private
- */
-export type DevOnlyGlobalRuntime = typeof globalThis & {
-    devOnly$luminaRuntime?: Runtime;
-};
-/**
- * Called from the component constructor when in development or test mode.
- * Used primarily by mount to get a reference to the rendered component.
- *
- * @private
- */
-export type DevOnlyGlobalComponentRefCallback = typeof globalThis & {
-    devOnly$luminaComponentRefCallback?: (component: LitElement) => void;
-};
+export declare const customElement: (tagName: string, component: typeof import('./LitElement').LitElement) => void;

package/dist/stencilSsrCompatibility/index.d.ts

@@ -1,9 +1,5 @@
-/**
- * Lots of silencing of ESLint in this file to be compatible with Stencil's
- * unsafe typings.
- */
-import { type RenderInfo } from "@lit-labs/ssr/lib/render.js";
-import type { Readable } from "node:stream";
+import { RenderInfo } from '@lit-labs/ssr/lib/render.js';
+import { Readable } from 'node:stream';
 /**
  * @deprecated
  * Use `render` from `@lit-labs/ssr` instead.

package/dist/stencilSsrCompatibility/index.js

@@ -1,11 +1,10 @@
-// src/stencilSsrCompatibility/index.ts
 import { getWindow } from "@lit-labs/ssr/lib/dom-shim.js";
 import { render } from "@lit-labs/ssr/lib/render.js";
 import { html } from "@lit-labs/ssr/lib/server-template.js";
-import { unsafeStatic, withStatic } from "lit-html/static.js";
+import { withStatic, unsafeStatic } from "lit-html/static.js";
 import { collectResult } from "@lit-labs/ssr/lib/render-result.js";
 import { RenderResultReadable } from "@lit-labs/ssr/lib/render-result-readable.js";
-var staticHtml = withStatic(html);
+const staticHtml = withStatic(html);
 function createWindowFromHtml(templateHtml, uniqueId = Math.random().toString()) {
   const window = getWindow({ includeJSBuiltIns: true });
   window.document.defaultView = window;

package/dist/typings/importMeta.d.ts

@@ -7,7 +7,7 @@ interface ImportMetaEnv {
 }
 interface ImportMeta {
     url: string;
-    readonly hot?: import("vite/types/hot.d.ts").ViteHotContext;
+    readonly hot?: import('vite/types/hot.d.ts').ViteHotContext;
     readonly env: ImportMetaEnv;
-    glob: import("vite/types/importGlob.d.ts").ImportGlobFunction;
+    glob: import('vite/types/importGlob.d.ts').ImportGlobFunction;
 }

package/dist/{chunk-NO7HOBNA.js → utils-CwiifsrO.js}

@@ -1,17 +1,9 @@
-import {
-  lazyMetaGroupJoiner,
-  lazyMetaItemJoiner,
-  lazyMetaSubItemJoiner
-} from "./chunk-PGHUBTOM.js";
-
-// src/lazyLoad.ts
-import { Deferred, camelToKebab, isEsriInternalEnv } from "@arcgis/components-utils";
-
-// src/devOnlyDetectIncorrectLazyUsages.ts
+import { Deferred, isEsriInternalEnv, camelToKebab } from "@arcgis/components-utils";
+import { lazyMetaSubItemJoiner, lazyMetaGroupJoiner, lazyMetaItemJoiner } from "./config.js";
 function devOnlyDetectIncorrectLazyUsages(LitClass) {
   const genericPrototype = LitClass.prototype;
   const descriptor = Object.getOwnPropertyDescriptor(genericPrototype, "innerText");
-  if (descriptor !== void 0 && descriptor.get === descriptor.set) {
+  if (descriptor !== void 0 && descriptor.set?.name === "setWrapper") {
     return;
   }
   const allowList = /* @__PURE__ */ new Set([
@@ -41,23 +33,40 @@ function devOnlyDetectIncorrectLazyUsages(LitClass) {
     if (allowList.has(key)) {
       return;
     }
-    const callback = (...args) => {
+    function validateUsage(...args) {
+      const isDynamicallyCreatedComponentInTest = this === this.el;
+      if (isDynamicallyCreatedComponentInTest) {
+        return;
+      }
       if (key === "hasAttribute" && args[0] === "defer-hydration") {
         return false;
       }
       throw new Error(
         `You should not be trying to access this.${key} directly as it won't work correctly in lazy-builds. Instead, ${customErrorMessages[key] ?? `use this.el.${key}`}`
       );
-    };
+    }
     if (typeof value.value === "function") {
-      genericPrototype[key] = callback;
+      genericPrototype[key] = function functionWrapper(...args) {
+        return validateUsage.call(this, ...args) ?? value.value.call(this, ...args);
+      };
+    } else if (typeof value.get === "function") {
+      Object.defineProperty(genericPrototype, key, {
+        get() {
+          validateUsage.call(this);
+          return value.get.call(this);
+        },
+        set: typeof value.set === "function" ? function setWrapper(setValue) {
+          validateUsage.call(this);
+          value.set.call(this, setValue);
+        } : void 0
+      });
+    } else if (key === key.toUpperCase() && typeof value.value === "number") {
+      return;
     } else {
-      Object.defineProperty(genericPrototype, key, { get: callback, set: callback });
+      throw new Error(`Unexpected value type for ${key}: ${value}`);
     }
   });
 }
-
-// src/lifecycleSupport.ts
 function attachToAncestor(child) {
   let ancestor = child;
   while (ancestor = ancestor.parentNode ?? ancestor.host) {
@@ -71,9 +80,7 @@ function attachToAncestor(child) {
   }
   return false;
 }
-
-// src/lazyLoad.ts
-var makeDefineCustomElements = (runtime, structure) => function defineCustomElements(windowOrOptions, options) {
+const makeDefineCustomElements = (runtime, structure) => function defineCustomElements(windowOrOptions, options) {
   if (!globalThis.customElements) {
     return;
   }
@@ -121,35 +128,19 @@ function createLazyElement([tagName, [load, compactMeta = ""]]) {
     globalThis.devOnly$ownTagNames?.add(tagName);
   }
 }
-var defineProperty = Object.defineProperty;
+const defineProperty = Object.defineProperty;
 function parseCondensedProp(propAndAttribute) {
   const name = propAndAttribute.split(lazyMetaSubItemJoiner);
   return name.length === 1 ? [name[0], camelToKebab(name[0])] : name;
 }
-var HtmlElement = globalThis.HTMLElement ?? parseCondensedProp;
-var ProxyComponent = class extends HtmlElement {
+const HtmlElement = globalThis.HTMLElement ?? parseCondensedProp;
+class ProxyComponent extends HtmlElement {
   constructor() {
     super();
-    /** @internal */
     this._store = {};
-    /**
-     * If attributeChangedCallback() is called before the LitElement is loaded,
-     * store the attributes here, and replay later
-     */
     this._pendingAttributes = [];
-    /**
-     * Resolved once LitElement's load() is complete.
-     * Not read inside of this class, but needed for LitElement to determine if
-     * it's closest ancestor finished load()
-     */
     this._postLoad = new Deferred();
-    /**
-     * Resolved once LitElement's loaded() is complete
-     */
     this._postLoaded = new Deferred();
-    /**
-     * Direct offspring that should be awaited before loaded() is emitted
-     */
     this._offspring = [];
     if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
       this._hmrSetProps = /* @__PURE__ */ new Set();
@@ -162,7 +153,7 @@ var ProxyComponent = class extends HtmlElement {
     if (ProxyClass._LitConstructor) {
       this._initializeComponent({ a: ProxyClass._LitConstructor });
     } else {
-      void ProxyClass._loadPromise.then(this._initializeComponent.bind(this)).catch((error) => {
+      void ProxyClass._loadPromise.then(awaitTopLevelPolyfill).then(this._initializeComponent.bind(this)).catch((error) => {
         this._postLoaded.reject(error);
         setTimeout(() => {
           throw error;
@@ -172,17 +163,13 @@ var ProxyComponent = class extends HtmlElement {
     if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
       ProxyClass._hmrInstances ??= [];
       ProxyClass._hmrInstances.push(new WeakRef(this));
-      Object.defineProperty(this, "_store", {
-        value: this._store,
-        enumerable: false,
-        configurable: true
-      });
+      Object.defineProperty(this, "_store", { value: this._store, enumerable: false, configurable: true });
     }
   }
   static {
     this.lumina = true;
   }
-  /** @internal */
+  /** private */
   static _initializePrototype() {
     this._properties?.forEach(this._bindProp, this);
     this._asyncMethods?.forEach(this._bindAsync, this);
@@ -302,7 +289,7 @@ var ProxyComponent = class extends HtmlElement {
     await this._postLoaded.promise;
     return this;
   }
-  /** @internal */
+  /** private */
   _initializeComponent(module) {
     const ProxyClass = this.constructor;
     const tagName = ProxyClass._name;
@@ -330,11 +317,7 @@ var ProxyComponent = class extends HtmlElement {
     const litElement = document.createElement(lazyTagName);
     LitConstructor.lazy = void 0;
     if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
-      Object.defineProperty(this, "_litElement", {
-        value: litElement,
-        configurable: true,
-        enumerable: false
-      });
+      Object.defineProperty(this, "_litElement", { value: litElement, configurable: true, enumerable: false });
     } else {
       this._litElement = litElement;
     }
@@ -384,7 +367,7 @@ var ProxyComponent = class extends HtmlElement {
   requestUpdate() {
     this._litElement?.requestUpdate();
   }
-};
+}
 function syncLitElement([key, value]) {
   this[key] = value;
 }
@@ -409,13 +392,13 @@ function patchLitElement(parentClass) {
     devOnlyDetectIncorrectLazyUsages(parentClass);
   }
 }
-
-// src/utils.ts
-var noShadowRoot = {};
-
+const awaitTopLevelPolyfill = async (module) => await (module.default?.then(
+  (module2) => typeof module2 === "function" ? { a: module2 } : module2
+) ?? module);
+const noShadowRoot = {};
 export {
-  attachToAncestor,
-  makeDefineCustomElements,
-  ProxyComponent,
-  noShadowRoot
+  ProxyComponent as P,
+  attachToAncestor as a,
+  makeDefineCustomElements as m,
+  noShadowRoot as n
 };