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

package/dist/{Controller-BQOv8BAL.js → Controller-ftAEcdmI.js}

@@ -1,126 +1,12 @@
-import { isEsriInternalEnv, safeCall, Deferred, safeAsyncCall } from "@arcgis/components-utils";
+import { safeCall, isEsriInternalEnv, safeAsyncCall } from "@arcgis/toolkit/error";
+import { r as retrieveComponent, d as retrieveParentControllers, b as setParentController, s as setAmbientComponent, u as use, k as useRef, l as useRefSync, c as controllerSymbol } from "./ControllerInternals-CWQrfEA8.js";
 import { nothing } from "lit";
-const controllerSymbol = 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;
-let ambientComponent;
-const setAmbientComponent = (component) => {
-  if (ambientComponent === component) {
-    return;
-  }
-  ambientComponent = component;
-  queueMicrotask(() => ambientComponent === component ? ambientComponent = void 0 : 0);
-};
-const retrieveComponent = (name) => {
-  if (process.env.NODE_ENV !== "production" && ambientComponent === void 0) {
-    throw new Error(
-      [
-        `Unable to find out which component ${name || "this"} controller `,
-        "belongs to. Possible causes:\n",
-        "- You might have multiple versions of ",
-        "@arcgis/lumina package installed\n",
-        ...isEsriInternalEnv() ? [
-          "- You tried to create controller outside the component. If so, ",
-          "please wrap your controller definition in an arrow function (like",
-          "`const myController = ()=>makeController(...);`) and call that",
-          "function inside the component (`my = myController();`), or ",
-          "define your controller using makeGenericController/GenericController ",
-          "instead.\n",
-          "- You tried to create a controller inside an async function. ",
-          "This is allowed without calling controller.use(). Make sure you ",
-          "use it like `await controller.use(useController())`."
-        ] : []
-      ].join("")
-    );
-  }
-  return ambientComponent;
-};
-let ambientControllers = [];
-const setParentController = (controller) => {
-  if (controller === void 0) {
-    ambientControllers = [];
-    return;
-  }
-  const index = ambientControllers.indexOf(controller);
-  ambientControllers = index === -1 ? [...ambientControllers, controller] : ambientControllers.slice(0, index + 1);
-  queueMicrotask(() => ambientControllers = []);
-};
-const retrieveParentControllers = () => ambientControllers;
-let ambientChildController;
-const setAmbientChildController = (controller) => {
-  if (ambientChildController === controller) {
-    return;
-  }
-  ambientChildController = controller;
-  queueMicrotask(() => ambientChildController === controller ? ambientChildController = void 0 : 0);
-};
-const retrieveAmbientChildController = () => {
-  const controller = ambientChildController;
-  ambientChildController = void 0;
-  return controller;
-};
-const use = async (value, watchExports) => {
-  const controller = useRefSync(value);
-  if (controller === void 0) {
-    if (process.env.NODE_ENV !== "production" && isEsriInternalEnv() && typeof watchExports === "function") {
-      throw new Error(
-        `Unable to resolve a controller from the provided value, so can't watch it's exports. The value you passed is not a controller and not a controller exports. If your controller exports a literal value, try making your controller export an object instead`
-      );
-    }
-    return value;
-  }
-  await controller.ready;
-  if (typeof watchExports === "function") {
-    if (process.env.NODE_ENV !== "production" && isEsriInternalEnv() && 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)
-    );
-  }
-  return controller.exports;
-};
-const useRef = async (value) => {
-  const controller = useRefSync(value);
-  if (process.env.NODE_ENV !== "production" && isEsriInternalEnv() && controller === void 0) {
-    throw new Error(
-      `Unable to resolve a controller from the provided value. The value you passed is not a controller and not a controller exports. If your controller exports a literal value, try making your controller export an object instead`
-    );
-  }
-  await controller.ready;
-  return controller;
-};
-const useRefSync = (value) => {
-  const component = retrieveComponent();
-  const controller = component.manager.X(value);
-  if (controller !== void 0) {
-    return controller;
-  }
-  if (isController(value)) {
-    return value;
-  }
-  const ambientChildController2 = retrieveAmbientChildController();
-  if (ambientChildController2 !== void 0) {
-    return ambientChildController2;
-  }
-  return void 0;
-};
-let shouldBypassReadOnly = false;
-const bypassReadOnly = (callback) => {
-  shouldBypassReadOnly = true;
-  try {
-    return callback();
-  } finally {
-    shouldBypassReadOnly = false;
-  }
-};
-const bypassSetter = bypassReadOnly;
+import { Deferred } from "@arcgis/toolkit/promise";
 const trackPropertyKey = (object, onResolved, defaultValue) => {
   const keys = Object.keys(object);
   const keyCount = keys.length;
   if (keyTrackMap === void 0) {
-    queueMicrotask(keyTrackResolve);
+    queueMicrotask(propertyTrackResolve);
   }
   keyTrackMap ??= /* @__PURE__ */ new Map();
   let pendingTrackers = keyTrackMap.get(object);
@@ -147,7 +33,7 @@ const trackPropertyKey = (object, onResolved, defaultValue) => {
   return defaultValue;
 };
 let keyTrackMap = void 0;
-const keyTrackResolve = () => {
+const propertyTrackResolve = () => {
   keyTrackMap?.forEach(({ callbacks }, object) => {
     const keys = Object.keys(object);
     callbacks.forEach((commit) => commit(keys));
@@ -207,7 +93,7 @@ const createEventFactory = (eventName = "", options = {}, component = retrieveCo
         console.warn(`Trying to emit an ${eventName} event on a disconnected element ${component.el.localName}`);
       }
       if (eventName === "") {
-        keyTrackResolve();
+        propertyTrackResolve();
         if (process.env.NODE_ENV !== "production" && isEsriInternalEnv() && eventName === "") {
           throw new Error("Unable to resolve event name from property name");
         }
@@ -566,22 +452,10 @@ const accessBeforeLoad = process.env.NODE_ENV !== "production" && isEsriInternal
 export {
   Controller as C,
   GenericController as G,
-  shouldBypassReadOnly as a,
-  createEvent as b,
-  controllerSymbol as c,
-  setParentController as d,
-  retrieveParentControllers as e,
-  createEventFactory as f,
-  bypassSetter as g,
-  bypassReadOnly as h,
-  isPromise as i,
-  trackPropertyKey as j,
-  keyTrackResolve as k,
-  trackPropKey as l,
-  isController as m,
-  getControllersCount as n,
-  setAmbientChildController as o,
-  retrieveComponent as r,
-  setAmbientComponent as s,
+  createEventFactory as a,
+  trackPropertyKey as b,
+  createEvent as c,
+  trackPropKey as d,
+  propertyTrackResolve as p,
   trackKey as t
 };

package/dist/ControllerInternals-CWQrfEA8.js

@@ -0,0 +1,133 @@
+import { isEsriInternalEnv } from "@arcgis/toolkit/error";
+const controllerSymbol = 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;
+let ambientComponent;
+const setAmbientComponent = (component) => {
+  if (ambientComponent === component) {
+    return;
+  }
+  ambientComponent = component;
+  queueMicrotask(() => ambientComponent === component ? ambientComponent = void 0 : 0);
+};
+const retrieveComponent = (name) => {
+  if (process.env.NODE_ENV !== "production" && ambientComponent === void 0) {
+    throw new Error(
+      [
+        `Unable to find out which component ${name || "this"} controller `,
+        "belongs to. Possible causes:\n",
+        "- You might have multiple versions of ",
+        "@arcgis/lumina package installed\n",
+        ...isEsriInternalEnv() ? [
+          "- You tried to create controller outside the component (in ",
+          "non-component class or in global scope).",
+          "- You accidentally defined the controller using const a = ",
+          "makeController(...); rather than const a = () => ",
+          "makeController(...);",
+          "- You tried to create a controller inside an async function. ",
+          "This is not allowed without calling controller.use(). Make ",
+          "sure you use it like `await controller.use(useController())`."
+        ] : []
+      ].join("")
+    );
+  }
+  return ambientComponent;
+};
+let ambientControllers = [];
+const setParentController = (controller) => {
+  if (controller === void 0) {
+    ambientControllers = [];
+    return;
+  }
+  const index = ambientControllers.indexOf(controller);
+  ambientControllers = index === -1 ? [...ambientControllers, controller] : ambientControllers.slice(0, index + 1);
+  queueMicrotask(() => ambientControllers = []);
+};
+const retrieveParentControllers = () => ambientControllers;
+let ambientChildController;
+const setAmbientChildController = (controller) => {
+  if (ambientChildController === controller) {
+    return;
+  }
+  ambientChildController = controller;
+  queueMicrotask(() => ambientChildController === controller ? ambientChildController = void 0 : 0);
+};
+const retrieveAmbientChildController = () => {
+  const controller = ambientChildController;
+  ambientChildController = void 0;
+  return controller;
+};
+const use = async (value, watchExports) => {
+  const controller = useRefSync(value);
+  if (controller === void 0) {
+    if (process.env.NODE_ENV !== "production" && isEsriInternalEnv() && typeof watchExports === "function") {
+      throw new Error(
+        `Unable to resolve a controller from the provided value, so can't watch it's exports. The value you passed is not a controller and not a controller exports. If your controller exports a literal value, try making your controller export an object instead`
+      );
+    }
+    return value;
+  }
+  await controller.ready;
+  if (typeof watchExports === "function") {
+    if (process.env.NODE_ENV !== "production" && isEsriInternalEnv() && 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)
+    );
+  }
+  return controller.exports;
+};
+const useRef = async (value) => {
+  const controller = useRefSync(value);
+  if (process.env.NODE_ENV !== "production" && isEsriInternalEnv() && controller === void 0) {
+    throw new Error(
+      `Unable to resolve a controller from the provided value. The value you passed is not a controller and not a controller exports. If your controller exports a literal value, try making your controller export an object instead`
+    );
+  }
+  await controller.ready;
+  return controller;
+};
+const useRefSync = (value) => {
+  const component = retrieveComponent();
+  const controller = component.manager.X(value);
+  if (controller !== void 0) {
+    return controller;
+  }
+  if (isController(value)) {
+    return value;
+  }
+  const ambientChildController2 = retrieveAmbientChildController();
+  if (ambientChildController2 !== void 0) {
+    return ambientChildController2;
+  }
+  return void 0;
+};
+let shouldBypassReadOnly = false;
+const bypassReadOnly = (callback) => {
+  shouldBypassReadOnly = true;
+  try {
+    return callback();
+  } finally {
+    shouldBypassReadOnly = false;
+  }
+};
+const bypassSetter = bypassReadOnly;
+export {
+  shouldBypassReadOnly as a,
+  setParentController as b,
+  controllerSymbol as c,
+  retrieveParentControllers as d,
+  bypassSetter as e,
+  bypassReadOnly as f,
+  isController as g,
+  getControllersCount as h,
+  isPromise as i,
+  setAmbientChildController as j,
+  useRef as k,
+  useRefSync as l,
+  retrieveComponent as r,
+  setAmbientComponent as s,
+  use as u
+};

package/dist/context.js

@@ -0,0 +1,18 @@
+import { ContextProvider, ContextConsumer } from "@lit/context";
+import { r as retrieveComponent } from "./ControllerInternals-CWQrfEA8.js";
+const useContextProvider = (options) => {
+  const component = retrieveComponent();
+  const controller = new ContextProvider(component.el, options);
+  component.addController(controller);
+  return controller;
+};
+const useContextConsumer = (options) => {
+  const component = retrieveComponent();
+  const controller = new ContextConsumer(component.el, options);
+  component.addController(controller);
+  return controller;
+};
+export {
+  useContextConsumer,
+  useContextProvider
+};

package/dist/controllers/Controller.d.ts

@@ -1,4 +1,4 @@
-import { Deferred } from '@arcgis/components-utils';
+import { Deferred } from '@arcgis/toolkit/promise';
 import { BaseController, ControllerLifecycleMethods, controllerSymbol } from './types';
 import { use, useRef, useRefSync } from './ControllerInternals';
 import { PropertyValues } from 'lit';
@@ -8,8 +8,6 @@ import { LitElement } from '../LitElement';
  * Defining controller using makeController() function is more succinct for smaller
  * controllers. For controllers that need to declare several methods, or need
  * more flexibility, this class may be used
- *
- * See ./examples.tsx for many example controllers and their usages.
  */
 export declare abstract class Controller<Exports = never> implements BaseController {
     #private;

package/dist/controllers/ControllerInternals.d.ts

@@ -42,7 +42,7 @@ type InferController<ControllerOrExports> = ControllerOrExports extends BaseCont
     watchExports?: Controller["watchExports"];
 } : Controller<ControllerOrExports>;
 /**
- * If controller never sets it's exports, then it's default exports is "this".
+ * If controller never sets its exports, then its default exports is "this".
  * This allows usage of controller.use with controllers that don't have exports
  */
 type NotNever<T extends {

package/dist/controllers/accessor/index.js

@@ -1,7 +1,8 @@
-import { isEsriInternalEnv } from "@arcgis/components-utils";
-import { r as retrieveComponent, f as createEventFactory, G as GenericController, l as trackPropKey, t as trackKey } from "../../Controller-BQOv8BAL.js";
+import { isEsriInternalEnv } from "@arcgis/toolkit/error";
+import { r as retrieveComponent } from "../../ControllerInternals-CWQrfEA8.js";
 import { on, watch } from "@arcgis/core/core/reactiveUtils.js";
-import { p as proxyExports } from "../../proxyExports-Cdzj7WL_.js";
+import { a as createEventFactory, G as GenericController, d as trackPropKey, t as trackKey } from "../../Controller-ftAEcdmI.js";
+import { p as proxyExports } from "../../proxyExports-D906TEtL.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";
@@ -22,6 +23,7 @@ class AccessorController extends GenericController {
   constructor(component, createInstance) {
     super(component);
     this.Y = /* @__PURE__ */ new Map();
+    this.A = void 0;
     this.#exportsObservable = createObservable();
     const that = this;
     that.#createInstance = createInstance;
@@ -107,9 +109,12 @@ const makeBinderProxy = (component, accessorControllerRef, accessorControllerInd
     ) {
       return value;
     }
+    const accessorController = component.M[accessorControllerIndex];
+    accessorController.A = propertyName;
     return trackKey(
       component,
       (resolved) => {
+        accessorController.A = void 0;
         if (resolved !== void 0) {
           const propName = resolved.key;
           boundProperties.set(propertyName, propName);
@@ -120,15 +125,15 @@ const makeBinderProxy = (component, accessorControllerRef, accessorControllerInd
             if (!(propertyName in instance)) {
               throw new Error(`"${propertyName}" does not exist on the accessor instance`);
             }
-            const accessorController = component.M[accessorControllerIndex];
+            const accessorController2 = component.M[accessorControllerIndex];
             if (descriptor.i !== void 0 && descriptor.i !== accessorControllerIndex) {
-              console.error(component.M[descriptor.i], accessorController);
+              console.error(component.M[descriptor.i], accessorController2);
               throw Error(
                 `Expected property "${propName}" to be bound to the controller at index ${descriptor.i}, but tried to bind it to a controller at index ${accessorControllerIndex}. Double check whether you are calling useAccessor() conditionally in a way that is not supported.`
               );
             }
-            if (accessorController !== accessorControllerRef.deref()) {
-              console.error(accessorController);
+            if (accessorController2 !== accessorControllerRef.deref()) {
+              console.error(accessorController2);
               throw Error(
                 `Expected controller at index ${accessorControllerIndex} to be instance of useAccessor but it is not.`
               );
@@ -156,13 +161,6 @@ const makeBinderProxy = (component, accessorControllerRef, accessorControllerInd
       },
       value
     );
-  },
-  set(_target, propertyName, newValue) {
-    if (boundProperties.has(propertyName) || // But some properties may be never bound, yet set in the constructor - let them through
-    newValue !== (instance[propertyName] ?? void 0)) {
-      instance[propertyName] = newValue;
-    }
-    return true;
   }
 });
 const watchBoundProperty = (controllerRef, descriptor, propertyName, propName, shouldFlipBoolean, _handle) => _handle = watch(
@@ -199,7 +197,10 @@ const bindPropToProperty = (descriptor, accessorControllerIndex, propertyName, s
     return shouldFlipBoolean ? !value : value;
   };
   descriptor.d.set = function(newValue) {
-    this.M[accessorControllerIndex].exports[propertyName] = shouldFlipBoolean ? !newValue : newValue;
+    const accessorController = this.M[accessorControllerIndex];
+    if (accessorController.A !== propertyName) {
+      accessorController.exports[propertyName] = shouldFlipBoolean ? !newValue : newValue;
+    }
   };
 };
 const getAccessorControllerBoundProperties = (controller) => controller.Y;
@@ -212,10 +213,15 @@ const reCreateAccessor = (instance, component) => {
     console.error("Unable to resolve the useAccessor controller from the provided value");
   }
 };
-const createStore = (defaultValues) => {
+const createStore = (initializer) => {
   const SubClass = class extends Accessor {
   };
-  Object.entries(defaultValues).forEach(([name, value]) => property({ value })(SubClass.prototype, name));
+  const defaultValues = typeof initializer === "function" ? initializer() : initializer;
+  const descriptors = Object.getOwnPropertyDescriptors(defaultValues);
+  for (const [key, descriptor] of Object.entries(descriptors)) {
+    Object.defineProperty(SubClass.prototype, key, descriptor);
+    property()(SubClass.prototype, key);
+  }
   const State = subclass()(SubClass);
   return new State();
 };

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

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

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

@@ -1,4 +1,4 @@
-import { Controller, GenericController } from '../Controller';
+import { GenericController } from '../Controller';
 import { LitElement } from '../../LitElement';
 type Requires<Props, Accessor extends __esri.Accessor, OmitProps extends string = never> = LitElement & Omit<Pick<Accessor, keyof Accessor & keyof Props>, AlwaysOmit | OmitProps> & {
     autoDestroyDisabled: boolean;
@@ -46,6 +46,8 @@ export declare class AccessorController<Props, Accessor extends __esri.Accessor,
      * @private
      */
     _boundAccessorProperties: Map<string & keyof Accessor, string>;
+    /** @private */
+    _currentlyBindingPropertyName?: string;
     /**
      * (development only) Allow these props to mismatch the name of the Accessor's
      * property to avoid collisions
@@ -61,8 +63,11 @@ export declare class AccessorController<Props, Accessor extends __esri.Accessor,
     hostConnected(): void;
     hostDestroy(): void;
 }
-export declare const makeBinderProxy: (component: LitElement, accessorControllerRef: WeakRef<Pick<Controller<__esri.Accessor>, "component" | "exports"> & {
-    constructor: (typeof __esri.Accessor)["constructor"] & {
+type MinimalAccessorController = Pick<AccessorController<never, __esri.Accessor>, "_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;

package/dist/controllers/index.d.ts

@@ -3,7 +3,7 @@ export type { GenericControllerType } from './Controller';
 export { Controller, GenericController } from './Controller';
 export type { ControllerManager } from './ControllerManager';
 export { retrieveComponent, bypassSetter, bypassReadOnly } from './ControllerInternals';
-export { trackPropertyKey, keyTrackResolve } from './trackPropertyKey';
+export { trackPropertyKey, propertyTrackResolve } from './trackPropertyKey';
 export { trackPropKey } from './trackPropKey';
 export { trackKey } from './trackKey';
 export { makeController, makeGenericController } from './functional';
@@ -22,3 +22,7 @@ export { isController, getControllersCount } from './utils';
  * @deprecated import from "@arcgis/lumina" instead
  */
 export type EventEmitter<T = undefined> = _EventEmitter<T>;
+/**
+ * @deprecated Let us know if someone is using this
+ */
+export declare const keyTrackResolve: () => void;

package/dist/controllers/index.js

@@ -1,14 +1,18 @@
-import { C as Controller, s as setAmbientComponent, i as isPromise, d as setParentController, e as retrieveParentControllers, t as trackKey, r as retrieveComponent, f as createEventFactory } from "../Controller-BQOv8BAL.js";
-import { G, h, g, c, n, m, k, l, j } from "../Controller-BQOv8BAL.js";
-import { p as proxyExports } from "../proxyExports-Cdzj7WL_.js";
+import { C as Controller, t as trackKey, a as createEventFactory, p as propertyTrackResolve } from "../Controller-ftAEcdmI.js";
+import { G, d, b } from "../Controller-ftAEcdmI.js";
+import { s as setAmbientComponent, i as isPromise, b as setParentController, d as retrieveParentControllers, r as retrieveComponent } from "../ControllerInternals-CWQrfEA8.js";
+import { f, e, c, h, g } from "../ControllerInternals-CWQrfEA8.js";
+import { p as proxyExports } from "../proxyExports-D906TEtL.js";
 import { isServer } from "lit";
-import { observeAncestorsMutation, isEsriInternalEnv, getElementAttribute, getElementLocales, startLocaleObserver } from "@arcgis/components-utils";
+import { isEsriInternalEnv } from "@arcgis/toolkit/error";
+import { observeAncestorsMutation, getElementAttribute } from "@arcgis/toolkit/dom";
+import { getElementLocale, startLocaleObserver } from "@arcgis/toolkit/intl";
 const makeController = (constructor) => proxy(void 0, constructor);
 const makeGenericController = (constructor) => (component) => proxy(
   component,
   /**
    * GenericController is identical to Controller, in all except for typing.
-   * So dying a type-cast here so as not to needlessly add one more object
+   * So doing a type-cast here so as not to needlessly add one more object
    * to the prototype chain
    */
   constructor
@@ -127,7 +131,7 @@ const useDirection = () => makeController((component, controller) => {
       (resolved) => {
         if (resolved?.key === "dir") {
           throw new Error(
-            `Do not assign this controller to a prop called \`dir\` as that will overwrite the \`dir\` attribute on the host element - component should not be setting the \`dir\` attribute on itself. Instead, assign this controller to a property called \`direction\`.`
+            "Do not assign this controller to a prop called `dir` as that will overwrite the HTMLElement's built-in `dir` attribute - component should not be setting the `dir` attribute on itself. Instead, assign this controller to a property called `direction`."
           );
         }
       },
@@ -139,7 +143,7 @@ const useDirection = () => makeController((component, controller) => {
 const makeT9nController = (getAssetPath) => (options = {}) => (
   // eslint-disable-next-line @typescript-eslint/promise-function-async
   makeController((component, controller) => {
-    const locale = getElementLocales(component.el);
+    const locale = getElementLocale(component.el);
     const pending = { ["_lang"]: locale.lang, ["_t9nLocale"]: locale.t9nLocale, ["_loading"]: true };
     const componentWithOverrides = component;
     controller.onLifecycle(
@@ -244,25 +248,27 @@ const propertyChangeController = (...toWatch) => {
   }
   return eventEmitter;
 };
+const keyTrackResolve = propertyTrackResolve;
 export {
   Controller,
   G as GenericController,
-  h as bypassReadOnly,
-  g as bypassSetter,
+  f as bypassReadOnly,
+  e as bypassSetter,
   c as controllerSymbol,
-  n as getControllersCount,
-  m as isController,
-  k as keyTrackResolve,
+  h as getControllersCount,
+  g as isController,
+  keyTrackResolve,
   load,
   makeController,
   makeGenericController,
   makeT9nController,
+  propertyTrackResolve,
   proxyExports,
   retrieveComponent,
   toFunction,
   trackKey,
-  l as trackPropKey,
-  j as trackPropertyKey,
+  d as trackPropKey,
+  b as trackPropertyKey,
   useDirection,
   useMedia,
   usePropertyChange,

package/dist/controllers/trackPropertyKey.d.ts

@@ -26,4 +26,4 @@ export declare const trackPropertyKey: <T>(object: BaseController | LitElement,
  * property you are trying to resolve had it's default value set, thus after
  * constructor. At the start of connectedCallback is a perfect place.
  */
-export declare const keyTrackResolve: () => void;
+export declare const propertyTrackResolve: () => void;

package/dist/controllers/types.d.ts

@@ -1,4 +1,4 @@
-import { IHandle } from '@arcgis/components-utils';
+import { IHandle } from '@arcgis/toolkit/type';
 import { ReactiveControllerHost, ReactiveController, PropertyDeclaration, PropertyValues } from 'lit';
 import { LitElement } from '../LitElement';
 export type TrackKeyResolution = {

package/dist/controllers/useT9n.d.ts

@@ -1,7 +1,7 @@
-import { GenericT9nStrings, LocaleObserver } from '@arcgis/components-utils';
+import { GenericT9nStrings, LocaleObserverResult } from '@arcgis/toolkit/intl';
 export type T9nMeta<T9nStrings extends GenericT9nStrings> = {
-    _lang: LocaleObserver["lang"];
-    _t9nLocale: LocaleObserver["t9nLocale"];
+    _lang: LocaleObserverResult["lang"];
+    _t9nLocale: LocaleObserverResult["t9nLocale"];
     _loading: boolean;
     /**
      * The "_overrides" property won't actually exist at runtime and exists only

package/dist/hmrSupport.js

@@ -1,5 +1,5 @@
-import { n as noShadowRoot, P as ProxyComponent } from "./lazyLoad-DUvrNd2L.js";
-import { camelToKebab } from "@arcgis/components-utils";
+import { n as noShadowRoot, P as ProxyComponent } from "./lazyLoad-B6Te7FRR.js";
+import { camelToKebab } from "@arcgis/toolkit/string";
 function handleHmrUpdate(newModules) {
   newModules.forEach((newModule) => {
     if (newModule === void 0) {

package/dist/index.d.ts

@@ -1,4 +1,3 @@
-export { useContextProvider, useContextConsumer } from './context';
 export type { EventEmitter, EventOptions } from './createEvent';
 export { createEvent } from './createEvent';
 export { state, property, method } from './decorators';
@@ -10,7 +9,7 @@ export type { Runtime, RuntimeOptions, DevOnlyGlobalRuntime, DevOnlyGlobalCompon
 export { makeRuntime } from './makeRuntime';
 export type { EventHandler } from './jsx/baseTypes';
 export * from './jsx/types';
-export { safeClassMap, safeStyleMap, deferLoad, deferredLoaders, directive, live } from './jsx/directives';
+export { safeClassMap, safeStyleMap, deferLoad, deferredLoaders, stabilizedRef, directive, live, } from './jsx/directives';
 export { nothing, noChange, setAttribute, stringOrBoolean } from './jsx/utils';
 export { noShadowRoot, devOnly$getLitElementTagNameAndRuntime } from './utils';
 export { makeReactWrapperFactory, getReactWrapperOptions } from './wrappersUtils';

package/dist/index.js

@@ -1,30 +1,21 @@
-import { ContextProvider, ContextConsumer } from "@lit/context";
-import { r as retrieveComponent, G as GenericController, k as keyTrackResolve, s as setAmbientComponent, c as controllerSymbol, a as shouldBypassReadOnly } from "./Controller-BQOv8BAL.js";
-import { b } from "./Controller-BQOv8BAL.js";
+import { G as GenericController, p as propertyTrackResolve } from "./Controller-ftAEcdmI.js";
+import { c } from "./Controller-ftAEcdmI.js";
 import { state } from "@lit/reactive-element/decorators/state.js";
 import { property as property$1 } from "@lit/reactive-element/decorators/property.js";
-import { e as emptyFunction, n as noShadowRoot, a as attachToAncestor } from "./lazyLoad-DUvrNd2L.js";
-import { d, m } from "./lazyLoad-DUvrNd2L.js";
-import { isEsriInternalEnv, safeCall, devToolsAwareTimeout, Deferred, camelToKebab, safeAsyncCall } from "@arcgis/components-utils";
+import { e as emptyFunction, n as noShadowRoot, a as attachToAncestor } from "./lazyLoad-B6Te7FRR.js";
+import { d, m } from "./lazyLoad-B6Te7FRR.js";
+import { isEsriInternalEnv, safeCall, safeAsyncCall } from "@arcgis/toolkit/error";
+import { camelToKebab } from "@arcgis/toolkit/string";
+import { devToolsAwareTimeout, Deferred } from "@arcgis/toolkit/promise";
 import { nothing as nothing$1, LitElement as LitElement$1, isServer, notEqual, noChange as noChange$1 } from "lit";
+import { s as setAmbientComponent, c as controllerSymbol, a as shouldBypassReadOnly } from "./ControllerInternals-CWQrfEA8.js";
 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 { ref } from "lit/directives/ref.js";
 import { nothing as nothing$2, noChange as noChange$2, render } from "lit-html";
-const useContextProvider = (options) => {
-  const component = retrieveComponent();
-  const controller = new ContextProvider(component.el, options);
-  component.addController(controller);
-  return controller;
-};
-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 {
@@ -57,7 +48,7 @@ class ControllerManager extends GenericController {
         if (this.#autoDestroyTimeout !== void 0) {
           clearTimeout(this.#autoDestroyTimeout);
         }
-        keyTrackResolve();
+        propertyTrackResolve();
         for (const controller of component.M) {
           if ("triggerConnected" in controller) {
             controller.triggerConnected();
@@ -331,6 +322,7 @@ class LitElement extends LitElement$1 {
           this.#observables?.get(name)?.notify();
         }
         if (manager.T.length > 0) {
+          propertyTrackResolve();
           manager?.S(name, rawNewValue);
         }
       }
@@ -401,10 +393,10 @@ 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) {
-      if (process.env.NODE_ENV === "production") {
-        LitElement$1.prototype.createRenderRoot.call(this);
-      }
+    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) {
+      LitElement$1.prototype.createRenderRoot.call(this);
       return existingShadowRoot;
     }
     if (this.isConnected) {
@@ -593,6 +585,25 @@ class DeferLoad extends Directive {
 }
 const deferLoad = /* @__PURE__ */ directive$1(DeferLoad)();
 const deferredLoaders = /* @__PURE__ */ new Map();
+class StabilizedRef extends Directive {
+  #refValue;
+  #callback;
+  constructor(partInfo) {
+    super(partInfo);
+    const that = this;
+    this.#callback = function ref2(element) {
+      return that.#refValue.call(this, element);
+    };
+  }
+  render(refValue) {
+    if (typeof refValue === "function") {
+      this.#refValue = refValue;
+      return ref(this.#callback);
+    }
+    return ref(refValue);
+  }
+}
+const stabilizedRef = directive$1(StabilizedRef);
 const directive = directive$1;
 const live = live$1;
 const nothing = nothing$2;
@@ -662,7 +673,7 @@ export {
   bindBooleanAttribute,
   bindEvent,
   bindProperty,
-  b as createEvent,
+  c as createEvent,
   deferLoad,
   deferredLoaders,
   d as devOnly$getLitElementTagNameAndRuntime,
@@ -681,8 +692,7 @@ export {
   safeClassMap,
   safeStyleMap,
   setAttribute,
+  stabilizedRef,
   state,
-  stringOrBoolean,
-  useContextConsumer,
-  useContextProvider
+  stringOrBoolean
 };

package/dist/jsx/directives.d.ts

@@ -1,11 +1,13 @@
-import { Nil } from '@arcgis/components-utils';
+import { nil } from '@arcgis/toolkit/type';
 import { Properties as CssProperties } from 'csstype';
 import { ClassInfo } from 'lit-html/directives/class-map.js';
 import { DirectiveResult } from 'lit/directive.js';
 import { ClassMapDirective } from 'lit/directives/class-map.js';
 import { StyleMapDirective } from 'lit/directives/style-map.js';
-import { DirectiveClass, ElementPart, Directive } from 'lit-html/directive.js';
+import { DirectiveClass, ElementPart, PartInfo, Directive } from 'lit-html/directive.js';
 import { noChange } from 'lit';
+import { CustomAttributes } from './baseTypes';
+import { RefDirective } from 'lit/directives/ref.js';
 /**
  * You likely won't have to import this directly. It will be added during
  * _JSX to lit-html_ conversion.
@@ -30,7 +32,7 @@ import { noChange } from 'lit';
  *
  * @private
  */
-export declare const safeClassMap: (parameters: ClassInfo | Nil | string) => DirectiveResult<typeof ClassMapDirective> | Nil | string;
+export declare const safeClassMap: (parameters: ClassInfo | nil | string) => DirectiveResult<typeof ClassMapDirective> | nil | string;
 /**
  * You likely won't have to import this directly. It will be added during
  * _JSX to lit-html_ conversion.
@@ -55,7 +57,7 @@ export declare const safeClassMap: (parameters: ClassInfo | Nil | string) => Dir
  *
  * @private
  */
-export declare const safeStyleMap: (parameters: CssProperties | Nil | string) => DirectiveResult<typeof StyleMapDirective> | Nil | string;
+export declare const safeStyleMap: (parameters: CssProperties | nil | string) => DirectiveResult<typeof StyleMapDirective> | nil | string;
 declare class DeferLoad extends Directive {
     update(part: ElementPart): void;
     render(): typeof noChange;
@@ -72,6 +74,32 @@ export declare const deferLoad: DirectiveResult<typeof DeferLoad>;
  * [Documentation](https://qawebgis.esri.com/components/lumina/jsx#deferring-web-component-load)
  */
 export declare const deferredLoaders: Map<string, () => Promise<unknown>>;
+declare class StabilizedRef extends Directive {
+    #private;
+    constructor(partInfo: PartInfo);
+    render(refValue: CustomAttributes<Element>["ref"]): DirectiveResult<typeof RefDirective>;
+}
+/**
+ * Because of how Lit's ref() works, there are two requirements on ref
+ * function:
+ * - It must be stable between re-renders (else Lit will call it twice on each
+ *   render() - with undefined and then with element)
+ * - Each element must have a unique instance of this function - if two
+ *   elements share the same ref function, on each render Lit will call
+ *   it multiple times (undefined, element1, undefined, element2)
+ *
+ * The `stabilizedRef` directive resolves both of these requirements by creating
+ * a stable wrapper function for the ref callback.
+ *
+ * @private
+ * Lumina will insert this directive automatically when the `ref` JSX prop is
+ * authored in a way that clearly creates a new function on each render:
+ * ```tsx
+ * <my-component ref={(el) => this.myComponent = el} />
+ * <my-component ref={this.callback.bind(this, index)} />
+ * ```
+ */
+export declare const stabilizedRef: <T extends Element>(refValue: CustomAttributes<T>["ref"]) => DirectiveResult<typeof StabilizedRef>;
 /**
  * Creates a user-facing directive function from a Directive class. This
  * function has the same parameters as the directive's render() method.

package/dist/jsx/generatedTypes.d.ts

@@ -511,6 +511,7 @@ export interface AriaAttributes {
      * @see aria-controls
      */
     ["aria-owns"]?: string;
+    ariaActiveDescendantElement?: Element;
     /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/ariaAtomic) */
     ariaAtomic?: boolean | "false" | "true";
     /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/ariaAutoComplete) */
@@ -529,14 +530,19 @@ export interface AriaAttributes {
     ariaColIndex?: number | string;
     /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/ariaColSpan) */
     ariaColSpan?: number | string;
+    ariaControlsElements?: Element[];
     /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/ariaCurrent) */
     ariaCurrent?: boolean | "date" | "false" | "location" | "page" | "step" | "time" | "true";
+    ariaDescribedByElements?: Element[];
     /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/ariaDescription) */
     ariaDescription?: string;
+    ariaDetailsElements?: Element[];
     /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/ariaDisabled) */
     ariaDisabled?: boolean | "false" | "true";
+    ariaErrorMessageElement?: Element;
     /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/ariaExpanded) */
     ariaExpanded?: boolean | "false" | "true";
+    ariaFlowToElements?: Element[];
     /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/ariaHasPopup) */
     ariaHasPopup?: boolean | "dialog" | "false" | "grid" | "listbox" | "menu" | "tree" | "true";
     /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/ariaHidden) */
@@ -550,6 +556,7 @@ export interface AriaAttributes {
     ariaKeyShortcuts?: string;
     /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/ariaLabel) */
     ariaLabel?: string;
+    ariaLabelledByElements?: Element[];
     /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/ariaLevel) */
     ariaLevel?: number | string;
     /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/ariaLive) */
@@ -562,6 +569,7 @@ export interface AriaAttributes {
     ariaMultiSelectable?: boolean | "false" | "true";
     /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/ariaOrientation) */
     ariaOrientation?: "horizontal" | "vertical";
+    ariaOwnsElements?: Element[];
     /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/ariaPlaceholder) */
     ariaPlaceholder?: string;
     /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/ariaPosInSet) */

package/dist/{lazyLoad-DUvrNd2L.js → lazyLoad-B6Te7FRR.js}

@@ -1,4 +1,6 @@
-import { isEsriInternalEnv, Deferred, camelToKebab } from "@arcgis/components-utils";
+import { isEsriInternalEnv } from "@arcgis/toolkit/error";
+import { camelToKebab } from "@arcgis/toolkit/string";
+import { Deferred } from "@arcgis/toolkit/promise";
 import { lazyMetaGroupJoiner, lazyMetaItemJoiner, lazyMetaSubItemJoiner } from "./config.js";
 function devOnlyDetectIncorrectLazyUsages(LitClass) {
   const genericPrototype = LitClass.prototype;
@@ -276,7 +278,10 @@ class ProxyComponent extends HtmlElement {
       this.#pendingAttributes.push(name);
     }
     if (process.env.NODE_ENV !== "production" && isEsriInternalEnv()) {
-      this.devOnly$hmrSetAttributes.add(name);
+      const isReflecting = this.#litElement?.["__reflectingProperty"] === name;
+      if (!isReflecting) {
+        this.devOnly$hmrSetAttributes.add(name);
+      }
     }
   }
   connectedCallback() {

package/dist/lazyLoad.d.ts

@@ -1,4 +1,4 @@
-import { Deferred } from '@arcgis/components-utils';
+import { Deferred } from '@arcgis/toolkit/promise';
 import { LitElement } from './LitElement';
 import { Runtime } from './makeRuntime';
 import { ControllerManager } from './controllers/ControllerManager';

package/dist/makeRuntime.d.ts

@@ -102,7 +102,7 @@ export type RuntimeOptions = {
      */
     readonly defaultAssetPath: string;
     /**
-     * The attribute that indicates a component has rendered it's content.
+     * The attribute that indicates a component has rendered its content.
      * Usually this attribute is added after your component's `loaded()` lifecycle
      * happened. However, during SSR, "hydrated" is added right away on the
      * server.

package/dist/{proxyExports-Cdzj7WL_.js → proxyExports-D906TEtL.js}

@@ -1,4 +1,5 @@
-import { d as setParentController, e as retrieveParentControllers, o as setAmbientChildController, t as trackKey, h as bypassReadOnly } from "./Controller-BQOv8BAL.js";
+import { b as setParentController, d as retrieveParentControllers, j as setAmbientChildController, f as bypassReadOnly } from "./ControllerInternals-CWQrfEA8.js";
+import { t as trackKey } from "./Controller-ftAEcdmI.js";
 const proxyExports = (Class) => (...args) => {
   const ambientControllers = retrieveParentControllers();
   const instance = new Class(...args);

package/dist/render.d.ts

@@ -1,5 +1,11 @@
 import { JsxNode } from './jsx/types';
 /**
  * Retrieve an HTML element to be manually appended to an existing component.
+ *
+ * @example
+ * ```ts
+ * const fullScreen = renderElement(<arcgis-fullscreen />);
+ * document.body.appendChild(fullScreen);
+ * ```
  */
 export declare const renderElement: <Element extends HTMLElement = HTMLElement>(element: JsxNode) => Element;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcgis/lumina",
-  "version": "4.34.0-next.8",
+  "version": "4.34.0-next.80",
   "type": "module",
   "main": "dist/index.cjs",
   "module": "dist/index.js",
@@ -8,8 +8,8 @@
   "exports": {
     ".": "./dist/index.js",
     "./config": "./dist/config.js",
+    "./context": "./dist/context.js",
     "./hmrSupport": "./dist/hmrSupport.js",
-    "./stencilSsrCompatibility": "./dist/stencilSsrCompatibility/index.js",
     "./typings": {
       "types": "./dist/typings/index.d.ts"
     },
@@ -22,12 +22,17 @@
   ],
   "license": "SEE LICENSE IN LICENSE.md",
   "dependencies": {
-    "@arcgis/components-utils": "4.34.0-next.8",
-    "@lit-labs/ssr": "^3.2.2",
-    "@lit-labs/ssr-client": "^1.1.7",
-    "@lit/context": "^1.1.5",
+    "@arcgis/toolkit": "4.34.0-next.80",
     "csstype": "^3.1.3",
-    "lit": "^3.3.0",
     "tslib": "^2.8.1"
+  },
+  "peerDependencies": {
+    "@lit/context": "^1.1.5",
+    "lit": "^3.3.0"
+  },
+  "peerDependenciesMeta": {
+    "@lit/context": {
+      "optional": true
+    }
   }
 }

package/dist/stencilSsrCompatibility/index.d.ts

@@ -1,73 +0,0 @@
-import { RenderInfo } from '@lit-labs/ssr/lib/render.js';
-import { Readable } from 'node:stream';
-/**
- * @deprecated
- * Use `render` from `@lit-labs/ssr` instead.
- *
- * @see https://lit.dev/docs/ssr/server-usage/
- */
-export interface HydrateResults {
-    buildId: string;
-    diagnostics: any[];
-    url: string;
-    host: string;
-    hostname: string;
-    href: string;
-    port: string;
-    pathname: string;
-    search: string;
-    hash: string;
-    html: string;
-    components: HydrateComponent[];
-    anchors: any[];
-    imgs: any[];
-    scripts: any[];
-    styles: any[];
-    staticData: any[];
-    title: string;
-    hydratedCount: number;
-    httpStatus: number;
-}
-export interface HydrateComponent {
-    tag: string;
-    mode: string;
-    count: number;
-    depth: number;
-}
-/**
- * @deprecated
- * Use `getWindow` from `@lit-labs/ssr/lib/dom-shim` instead.
- *
- * @see https://lit.dev/docs/ssr/server-usage/
- */
-export declare function createWindowFromHtml(templateHtml: string, uniqueId?: string): any;
-/**
- * @deprecated
- * Use `RenderResultReadable` from `@lit-labs/ssr` instead.
- *
- * @see https://lit.dev/docs/ssr/server-usage/
- */
-export declare function streamToString(html: any, options?: Partial<RenderInfo>): Readable;
-/**
- * @deprecated
- * Use `render` from `@lit-labs/ssr` instead.
- *
- * @see https://lit.dev/docs/ssr/server-usage/
- */
-export declare function renderToString(html: any, options?: Partial<RenderInfo>): Promise<HydrateResults>;
-export declare function renderToString(html: any, options: Partial<RenderInfo> | undefined, asStream: true): Readable;
-/**
- * @deprecated
- * Use `render` from `@lit-labs/ssr` instead.
- *
- * @see https://lit.dev/docs/ssr/server-usage/
- */
-export declare function hydrateDocument(doc: any, options?: Partial<RenderInfo>): Promise<HydrateResults>;
-export declare function hydrateDocument(doc: any, options: Partial<RenderInfo> | undefined, asStream: true): Readable;
-/**
- * @deprecated
- * Use `render` from `@lit-labs/ssr` instead.
- *
- * @see https://lit.dev/docs/ssr/server-usage/
- */
-export declare function serializeDocumentToString(doc: any, _unused?: unknown): string;

package/dist/stencilSsrCompatibility/index.js

@@ -1,87 +0,0 @@
-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 { 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";
-const staticHtml = withStatic(html);
-function createWindowFromHtml(templateHtml, uniqueId = Math.random().toString()) {
-  const window = getWindow({ includeJSBuiltIns: true });
-  window.document.defaultView = window;
-  window.document.templateHtml = templateHtml;
-  window.document.buildId = uniqueId;
-  return window;
-}
-function streamToString(html2, options) {
-  const { result } = getRenderResult(html2, options);
-  return new RenderResultReadable(result);
-}
-function getRenderResult(rawSource, options) {
-  const maybeDocument = typeof rawSource === "object" && rawSource !== null ? "document" in rawSource ? rawSource.document : rawSource : void 0;
-  const source = maybeDocument && "templateHtml" in maybeDocument ? maybeDocument.templateHtml : maybeDocument && "documentElement" in maybeDocument ? maybeDocument.documentElement?.outerHTML ?? maybeDocument : rawSource;
-  const renderTemplate = typeof source === "string" ? staticHtml`${unsafeStatic(source)}` : source;
-  const tagNames = [];
-  const result = render(renderTemplate, {
-    customElementRendered(tagName) {
-      tagNames.push(tagName);
-    },
-    ...options
-  });
-  return { result, maybeDocument, tagNames };
-}
-function renderToString(html2, options, asStream = false) {
-  if (asStream) {
-    return streamToString(html2, options);
-  } else {
-    return resultsToString(html2, options);
-  }
-}
-async function resultsToString(html2, options) {
-  const { result, tagNames, maybeDocument } = getRenderResult(html2, options);
-  const collected = await collectResult(result);
-  const renderResult = {
-    buildId: maybeDocument?.buildId ?? Math.random().toString(),
-    diagnostics: [],
-    url: globalThis?.location?.href ?? "https://hydrate.stenciljs.com/",
-    host: globalThis?.location?.host ?? "hydrate.stenciljs.com",
-    hostname: globalThis?.location?.hostname ?? "hydrate.stenciljs.com",
-    href: globalThis?.location?.href ?? "https://hydrate.stenciljs.com/",
-    port: globalThis?.location?.port ?? "",
-    pathname: globalThis?.location?.pathname ?? "/",
-    search: globalThis?.location?.search ?? "",
-    hash: globalThis?.location?.hash ?? "",
-    html: collected,
-    httpStatus: 200,
-    hydratedCount: tagNames.length,
-    anchors: [],
-    components: tagNames.map((tag) => ({
-      tag,
-      mode: "$",
-      count: 1,
-      depth: 1
-    })),
-    imgs: [],
-    scripts: [],
-    staticData: [],
-    styles: [],
-    title: globalThis?.document?.title ?? "Vite + TS"
-  };
-  if (maybeDocument && "templateHtml" in maybeDocument) {
-    maybeDocument.outerHtml = collected;
-  }
-  return renderResult;
-}
-function hydrateDocument(doc, options, asStream) {
-  return renderToString(doc, options, asStream);
-}
-function serializeDocumentToString(doc, _unused) {
-  const maybeDocument = doc;
-  return maybeDocument.outerHtml ?? maybeDocument.templateHtml ?? String(maybeDocument);
-}
-export {
-  createWindowFromHtml,
-  hydrateDocument,
-  renderToString,
-  serializeDocumentToString,
-  streamToString
-};