@namiml/web-sdk 3.4.0-dev.202605201800 → 3.4.0-dev.202605261547

package/dist/legacy-support.mjs

@@ -2164,217 +2164,14 @@ var __classPrivateFieldGet = (undefined && undefined.__classPrivateFieldGet) ||
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
 var _Event_cancelable, _Event_bubbles, _Event_composed, _Event_defaultPrevented, _Event_timestamp, _Event_propagationStopped, _Event_type, _Event_target, _Event_isBeingDispatched, _a$1, _CustomEvent_detail, _b;
-const isCaptureEventListener = (options) => (typeof options === 'boolean' ? options : (options?.capture ?? false));
 // Event phases
 const NONE = 0;
 const CAPTURING_PHASE = 1;
 const AT_TARGET = 2;
 const BUBBLING_PHASE = 3;
-// Shim the global EventTarget object
-class EventTarget {
-    constructor() {
-        this.__eventListeners = new Map();
-        this.__captureEventListeners = new Map();
-    }
-    addEventListener(type, callback, options) {
-        if (callback === undefined || callback === null) {
-            return;
-        }
-        const eventListenersMap = isCaptureEventListener(options)
-            ? this.__captureEventListeners
-            : this.__eventListeners;
-        let eventListeners = eventListenersMap.get(type);
-        if (eventListeners === undefined) {
-            eventListeners = new Map();
-            eventListenersMap.set(type, eventListeners);
-        }
-        else if (eventListeners.has(callback)) {
-            return;
-        }
-        const normalizedOptions = typeof options === 'object' && options ? options : {};
-        normalizedOptions.signal?.addEventListener('abort', () => this.removeEventListener(type, callback, options));
-        eventListeners.set(callback, normalizedOptions ?? {});
-    }
-    removeEventListener(type, callback, options) {
-        if (callback === undefined || callback === null) {
-            return;
-        }
-        const eventListenersMap = isCaptureEventListener(options)
-            ? this.__captureEventListeners
-            : this.__eventListeners;
-        const eventListeners = eventListenersMap.get(type);
-        if (eventListeners !== undefined) {
-            eventListeners.delete(callback);
-            if (!eventListeners.size) {
-                eventListenersMap.delete(type);
-            }
-        }
-    }
-    dispatchEvent(event) {
-        const composedPath = [this];
-        let parent = this.__eventTargetParent;
-        if (event.composed) {
-            while (parent) {
-                composedPath.push(parent);
-                parent = parent.__eventTargetParent;
-            }
-        }
-        else {
-            // If the event is not composed and the event was dispatched inside
-            // shadow DOM, we need to stop before the host of the shadow DOM.
-            while (parent && parent !== this.__host) {
-                composedPath.push(parent);
-                parent = parent.__eventTargetParent;
-            }
-        }
-        // We need to patch various properties that would either be empty or wrong
-        // in this scenario.
-        let stopPropagation = false;
-        let stopImmediatePropagation = false;
-        let eventPhase = NONE;
-        let target = null;
-        let tmpTarget = null;
-        let currentTarget = null;
-        const originalStopPropagation = event.stopPropagation;
-        const originalStopImmediatePropagation = event.stopImmediatePropagation;
-        Object.defineProperties(event, {
-            target: {
-                get() {
-                    return target ?? tmpTarget;
-                },
-                ...enumerableProperty,
-            },
-            srcElement: {
-                get() {
-                    return event.target;
-                },
-                ...enumerableProperty,
-            },
-            currentTarget: {
-                get() {
-                    return currentTarget;
-                },
-                ...enumerableProperty,
-            },
-            eventPhase: {
-                get() {
-                    return eventPhase;
-                },
-                ...enumerableProperty,
-            },
-            composedPath: {
-                value: () => composedPath,
-                ...enumerableProperty,
-            },
-            stopPropagation: {
-                value: () => {
-                    stopPropagation = true;
-                    originalStopPropagation.call(event);
-                },
-                ...enumerableProperty,
-            },
-            stopImmediatePropagation: {
-                value: () => {
-                    stopImmediatePropagation = true;
-                    originalStopImmediatePropagation.call(event);
-                },
-                ...enumerableProperty,
-            },
-        });
-        // An event handler can either be a function, an object with a handleEvent
-        // method or null. This function takes care to call the event handler
-        // correctly.
-        const invokeEventListener = (listener, options, eventListenerMap) => {
-            if (typeof listener === 'function') {
-                listener(event);
-            }
-            else if (typeof listener?.handleEvent === 'function') {
-                listener.handleEvent(event);
-            }
-            if (options.once) {
-                eventListenerMap.delete(listener);
-            }
-        };
-        // When an event is finished being dispatched, which can be after the event
-        // tree has been traversed or stopPropagation/stopImmediatePropagation has
-        // been called. Once that is the case, the currentTarget and eventPhase
-        // need to be reset and a value, representing whether the event has not
-        // been prevented, needs to be returned.
-        const finishDispatch = () => {
-            currentTarget = null;
-            eventPhase = NONE;
-            return !event.defaultPrevented;
-        };
-        // An event starts with the capture order, where it starts from the top.
-        // This is done even if bubbles is set to false, which is the default.
-        const captureEventPath = composedPath.slice().reverse();
-        // If the event target, which dispatches the event, is either in the light DOM
-        // or the event is not composed, the target is always itself. If that is not
-        // the case, the target needs to be retargeted: https://dom.spec.whatwg.org/#retarget
-        target = !this.__host || !event.composed ? this : null;
-        const retarget = (eventTargets) => {
-            // eslint-disable-next-line @typescript-eslint/no-this-alias
-            tmpTarget = this;
-            while (tmpTarget.__host && eventTargets.includes(tmpTarget.__host)) {
-                tmpTarget = tmpTarget.__host;
-            }
-        };
-        for (const eventTarget of captureEventPath) {
-            if (!target && (!tmpTarget || tmpTarget === eventTarget.__host)) {
-                retarget(captureEventPath.slice(captureEventPath.indexOf(eventTarget)));
-            }
-            currentTarget = eventTarget;
-            eventPhase = eventTarget === event.target ? AT_TARGET : CAPTURING_PHASE;
-            const captureEventListeners = eventTarget.__captureEventListeners.get(event.type);
-            if (captureEventListeners) {
-                for (const [listener, options] of captureEventListeners) {
-                    invokeEventListener(listener, options, captureEventListeners);
-                    if (stopImmediatePropagation) {
-                        // Event.stopImmediatePropagation() stops any following invocation
-                        // of an event handler even on the same event target.
-                        return finishDispatch();
-                    }
-                }
-            }
-            if (stopPropagation) {
-                // Event.stopPropagation() stops any following invocation
-                // of an event handler for any following event targets.
-                return finishDispatch();
-            }
-        }
-        const bubbleEventPath = event.bubbles ? composedPath : [this];
-        tmpTarget = null;
-        for (const eventTarget of bubbleEventPath) {
-            if (!target &&
-                (!tmpTarget || eventTarget === tmpTarget.__host)) {
-                retarget(bubbleEventPath.slice(0, bubbleEventPath.indexOf(eventTarget) + 1));
-            }
-            currentTarget = eventTarget;
-            eventPhase = eventTarget === event.target ? AT_TARGET : BUBBLING_PHASE;
-            const captureEventListeners = eventTarget.__eventListeners.get(event.type);
-            if (captureEventListeners) {
-                for (const [listener, options] of captureEventListeners) {
-                    invokeEventListener(listener, options, captureEventListeners);
-                    if (stopImmediatePropagation) {
-                        // Event.stopImmediatePropagation() stops any following invocation
-                        // of an event handler even on the same event target.
-                        return finishDispatch();
-                    }
-                }
-            }
-            if (stopPropagation) {
-                // Event.stopPropagation() stops any following invocation
-                // of an event handler for any following event targets.
-                return finishDispatch();
-            }
-        }
-        return finishDispatch();
-    }
-}
-const EventTargetShimWithRealType = EventTarget;
-const enumerableProperty = { __proto__: null };
-enumerableProperty.enumerable = true;
-Object.freeze(enumerableProperty);
+const enumerableProperty$1 = { __proto__: null };
+enumerableProperty$1.enumerable = true;
+Object.freeze(enumerableProperty$1);
 // TODO: Remove this when we remove support for vm modules (--experimental-vm-modules).
 const EventShim = (_a$1 = class Event {
         constructor(type, options = {}) {
@@ -2479,24 +2276,24 @@ const EventShim = (_a$1 = class Event {
     _a$1.BUBBLING_PHASE = BUBBLING_PHASE,
     _a$1);
 Object.defineProperties(EventShim.prototype, {
-    initEvent: enumerableProperty,
-    stopImmediatePropagation: enumerableProperty,
-    preventDefault: enumerableProperty,
-    target: enumerableProperty,
-    currentTarget: enumerableProperty,
-    srcElement: enumerableProperty,
-    type: enumerableProperty,
-    cancelable: enumerableProperty,
-    defaultPrevented: enumerableProperty,
-    timeStamp: enumerableProperty,
-    composedPath: enumerableProperty,
-    returnValue: enumerableProperty,
-    bubbles: enumerableProperty,
-    composed: enumerableProperty,
-    eventPhase: enumerableProperty,
-    cancelBubble: enumerableProperty,
-    stopPropagation: enumerableProperty,
-    isTrusted: enumerableProperty,
+    initEvent: enumerableProperty$1,
+    stopImmediatePropagation: enumerableProperty$1,
+    preventDefault: enumerableProperty$1,
+    target: enumerableProperty$1,
+    currentTarget: enumerableProperty$1,
+    srcElement: enumerableProperty$1,
+    type: enumerableProperty$1,
+    cancelable: enumerableProperty$1,
+    defaultPrevented: enumerableProperty$1,
+    timeStamp: enumerableProperty$1,
+    composedPath: enumerableProperty$1,
+    returnValue: enumerableProperty$1,
+    bubbles: enumerableProperty$1,
+    composed: enumerableProperty$1,
+    eventPhase: enumerableProperty$1,
+    cancelBubble: enumerableProperty$1,
+    stopPropagation: enumerableProperty$1,
+    isTrusted: enumerableProperty$1,
 });
 // TODO: Remove this when we remove support for vm modules (--experimental-vm-modules).
 const CustomEventShim = (_b = class CustomEvent extends EventShim {
@@ -2515,7 +2312,7 @@ const CustomEventShim = (_b = class CustomEvent extends EventShim {
     _CustomEvent_detail = new WeakMap(),
     _b);
 Object.defineProperties(CustomEventShim.prototype, {
-    detail: enumerableProperty,
+    detail: enumerableProperty$1,
 });
 const EventShimWithRealType = EventShim;
 const CustomEventShimWithRealType = CustomEventShim;
@@ -2588,6 +2385,7 @@ const CSSRuleShim = (_a = class CSSRule {
             this.SUPPORTS_RULE = 12;
             this.COUNTER_STYLE_RULE = 11;
             this.FONT_FEATURE_VALUES_RULE = 14;
+            this.MARGIN_RULE = 9;
             this.__parentStyleSheet = null;
             this.cssText = '';
         }
@@ -2613,6 +2411,7 @@ const CSSRuleShim = (_a = class CSSRule {
     _a.SUPPORTS_RULE = 12,
     _a.COUNTER_STYLE_RULE = 11,
     _a.FONT_FEATURE_VALUES_RULE = 14,
+    _a.MARGIN_RULE = 9,
     _a);
 const CSSRuleShimWithRealType = CSSRuleShim;
 const CSSRuleListShim = class CSSRuleList extends Array {
@@ -2660,6 +2459,60 @@ const CSSStyleSheetShim = class CSSStyleSheet extends StyleSheetShim {
 };
 const CSSStyleSheetShimWithRealType = CSSStyleSheetShim;
 
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+/**
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver
+ */
+const MutationObserverShim = class MutationObserver {
+    constructor(_callback) { }
+    disconnect() { }
+    observe(_target, _options) { }
+    takeRecords() {
+        return [];
+    }
+};
+const MutationObserverShimWithRealType = MutationObserverShim;
+/**
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/ResizeObserver
+ */
+const ResizeObserverShim = class ResizeObserver {
+    constructor(_callback) { }
+    disconnect() { }
+    observe(_target, _options) { }
+    unobserve(_target) { }
+};
+const ResizeObserverShimWithRealType = ResizeObserverShim;
+/**
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/IntersectionObserver
+ */
+const IntersectionObserverShim = class IntersectionObserver {
+    constructor(_callback, __options) {
+        this.__options = __options;
+    }
+    get root() {
+        return this.__options?.root ?? null;
+    }
+    get rootMargin() {
+        return this.__options?.rootMargin ?? '0px 0px 0px 0px';
+    }
+    get thresholds() {
+        return Array.isArray(this.__options?.threshold)
+            ? this.__options.threshold
+            : [this.__options?.threshold ?? 0];
+    }
+    disconnect() { }
+    observe(_target) { }
+    takeRecords() {
+        return [];
+    }
+    unobserve(_target) { }
+};
+const IntersectionObserverShimWithRealType = IntersectionObserverShim;
+
 /**
  * @license
  * Copyright 2019 Google LLC
@@ -2670,6 +2523,286 @@ const CSSStyleSheetShimWithRealType = CSSStyleSheetShim;
 // for vm modules (--experimental-vm-modules).
 globalThis.Event ??= EventShimWithRealType;
 globalThis.CustomEvent ??= CustomEventShimWithRealType;
+const constructionToken = Symbol();
+const isCaptureEventListener = (options) => (typeof options === 'boolean' ? options : (options?.capture ?? false));
+const enumerableProperty = { __proto__: null };
+enumerableProperty.enumerable = true;
+Object.freeze(enumerableProperty);
+/**
+ * This is a basic implementation of an EventTarget.
+ *
+ * This is not fully spec compliant (e.g. validation),
+ * but should work well enough for our use cases.
+ *
+ * @see https://dom.spec.whatwg.org/#eventtarget
+ *
+ * Example Event Path
+ * ------------------
+ *
+ * Note that this depends on the logic in `packages/labs/ssr/src/lib/render-value.ts`.
+ * Any element that is not a custom element or a slot element is skipped in the chain.
+ *
+ * <main>
+ *   <my-el1>
+ *     #shadow-dom (open)
+ *       <div>
+ *         <slot></slot>
+ *         <my-el2>
+ *           #shadow-dom (closed)
+ *             <slot></slot>
+ *             <event-dispatcher3></event-dispatcher3>
+ *           <slot name="nested"></slot>
+ *         </my-el2>
+ *       </div>
+ *     <event-dispatcher1></event-dispatcher1>
+ *     <event-dispatcher2 slot="nested"></event-dispatcher2>
+ *   </my-el1>
+ * </main>
+ *
+ * Given the previous structure, the event path of this shim would be as follows,
+ * for the given dispatcher with an event that bubbles (document-fragment
+ * represents a ShadowRoot/#shadow-dom instance):
+ *
+ * <event-dispatcher1>:
+ * [event-dispatcher1, slot{my-el1}, document-fragment{my-el1}, my-el1, document]
+ *
+ * <event-dispatcher2>:
+ * [
+ *   event-dispatcher2,
+ *   slot[name="nested"]{my-el1},
+ *   slot{my-el2},
+ *   document-fragment{my-el2},
+ *   my-el2,
+ *   document-fragment{my-el1},
+ *   my-el1,
+ *   document
+ * ]
+ *
+ * <event-dispatcher3> (without composed):
+ * [event-dispatcher3, document-fragment{my-el2}]
+ *
+ * <event-dispatcher3> (composed):
+ * [
+ *   event-dispatcher3,
+ *   document-fragment{my-el2},
+ *   my-el2,
+ *   document-fragment{my-el1},
+ *   my-el1,
+ *   document
+ * ]
+ */
+class EventTarget {
+    constructor() {
+        this.__eventListeners = new Map();
+        this.__captureEventListeners = new Map();
+    }
+    addEventListener(type, callback, options) {
+        if (callback === undefined || callback === null) {
+            return;
+        }
+        const eventListenersMap = isCaptureEventListener(options)
+            ? this.__captureEventListeners
+            : this.__eventListeners;
+        let eventListeners = eventListenersMap.get(type);
+        if (eventListeners === undefined) {
+            eventListeners = new Map();
+            eventListenersMap.set(type, eventListeners);
+        }
+        else if (eventListeners.has(callback)) {
+            return;
+        }
+        const normalizedOptions = typeof options === 'object' && options ? options : {};
+        normalizedOptions.signal?.addEventListener('abort', () => this.removeEventListener(type, callback, options));
+        eventListeners.set(callback, normalizedOptions ?? {});
+    }
+    removeEventListener(type, callback, options) {
+        if (callback === undefined || callback === null) {
+            return;
+        }
+        const eventListenersMap = isCaptureEventListener(options)
+            ? this.__captureEventListeners
+            : this.__eventListeners;
+        const eventListeners = eventListenersMap.get(type);
+        if (eventListeners !== undefined) {
+            eventListeners.delete(callback);
+            if (!eventListeners.size) {
+                eventListenersMap.delete(type);
+            }
+        }
+    }
+    dispatchEvent(event) {
+        let composedPath = this.__resolveFullEventPath();
+        if (!event.composed && this.__host) {
+            // If the event is not composed and the event was dispatched inside
+            // shadow DOM, we need to stop the event chain before the host of the
+            // shadow DOM.
+            composedPath = composedPath.slice(0, composedPath.indexOf(this.__host));
+        }
+        // We need to patch various properties that would either be empty or wrong
+        // in this scenario.
+        let stopPropagation = false;
+        let stopImmediatePropagation = false;
+        let eventPhase = EventShimWithRealType.NONE;
+        let target = null;
+        let tmpTarget = null;
+        let currentTarget = null;
+        const originalStopPropagation = event.stopPropagation;
+        const originalStopImmediatePropagation = event.stopImmediatePropagation;
+        Object.defineProperties(event, {
+            target: {
+                get() {
+                    return target ?? tmpTarget;
+                },
+                ...enumerableProperty,
+            },
+            srcElement: {
+                get() {
+                    return event.target;
+                },
+                ...enumerableProperty,
+            },
+            currentTarget: {
+                get() {
+                    return currentTarget;
+                },
+                ...enumerableProperty,
+            },
+            eventPhase: {
+                get() {
+                    return eventPhase;
+                },
+                ...enumerableProperty,
+            },
+            composedPath: {
+                value: () => composedPath,
+                ...enumerableProperty,
+            },
+            stopPropagation: {
+                value: () => {
+                    stopPropagation = true;
+                    originalStopPropagation.call(event);
+                },
+                ...enumerableProperty,
+            },
+            stopImmediatePropagation: {
+                value: () => {
+                    stopImmediatePropagation = true;
+                    originalStopImmediatePropagation.call(event);
+                },
+                ...enumerableProperty,
+            },
+        });
+        // An event handler can either be a function, an object with a handleEvent
+        // method or null. This function takes care to call the event handler
+        // correctly.
+        const invokeEventListener = (listener, options, eventListenerMap) => {
+            if (typeof listener === 'function') {
+                listener(event);
+            }
+            else if (typeof listener?.handleEvent === 'function') {
+                listener.handleEvent(event);
+            }
+            if (options.once) {
+                eventListenerMap.delete(listener);
+            }
+        };
+        // When an event is finished being dispatched, which can be after the event
+        // tree has been traversed or stopPropagation/stopImmediatePropagation has
+        // been called. Once that is the case, the currentTarget and eventPhase
+        // need to be reset and a value, representing whether the event has not
+        // been prevented, needs to be returned.
+        const finishDispatch = () => {
+            currentTarget = null;
+            eventPhase = EventShimWithRealType.NONE;
+            return !event.defaultPrevented;
+        };
+        // An event starts with the capture order, where it starts from the top.
+        // This is done even if bubbles is set to false, which is the default.
+        const captureEventPath = composedPath.slice().reverse();
+        // If the event target, which dispatches the event, is either in the light DOM
+        // or the event is not composed, the target is always itself. If that is not
+        // the case, the target needs to be retargeted: https://dom.spec.whatwg.org/#retarget
+        target = !this.__host || !event.composed ? this : null;
+        const retarget = (eventTargets) => {
+            // eslint-disable-next-line @typescript-eslint/no-this-alias
+            tmpTarget = this;
+            while (tmpTarget.__host && eventTargets.includes(tmpTarget.__host)) {
+                tmpTarget = tmpTarget.__host;
+            }
+        };
+        for (const eventTarget of captureEventPath) {
+            if (!target && (!tmpTarget || tmpTarget === eventTarget.__host)) {
+                retarget(captureEventPath.slice(captureEventPath.indexOf(eventTarget)));
+            }
+            currentTarget = eventTarget;
+            eventPhase =
+                eventTarget === event.target
+                    ? EventShimWithRealType.AT_TARGET
+                    : EventShimWithRealType.CAPTURING_PHASE;
+            const captureEventListeners = eventTarget.__captureEventListeners.get(event.type);
+            if (captureEventListeners) {
+                for (const [listener, options] of captureEventListeners) {
+                    invokeEventListener(listener, options, captureEventListeners);
+                    if (stopImmediatePropagation) {
+                        // Event.stopImmediatePropagation() stops any following invocation
+                        // of an event handler even on the same event target.
+                        return finishDispatch();
+                    }
+                }
+            }
+            if (stopPropagation) {
+                // Event.stopPropagation() stops any following invocation
+                // of an event handler for any following event targets.
+                return finishDispatch();
+            }
+        }
+        const bubbleEventPath = event.bubbles ? composedPath : [this];
+        tmpTarget = null;
+        for (const eventTarget of bubbleEventPath) {
+            if (!target &&
+                (!tmpTarget || eventTarget === tmpTarget.__host)) {
+                retarget(bubbleEventPath.slice(0, bubbleEventPath.indexOf(eventTarget) + 1));
+            }
+            currentTarget = eventTarget;
+            eventPhase =
+                eventTarget === event.target
+                    ? EventShimWithRealType.AT_TARGET
+                    : EventShimWithRealType.BUBBLING_PHASE;
+            const eventListeners = eventTarget.__eventListeners.get(event.type);
+            if (eventListeners) {
+                for (const [listener, options] of eventListeners) {
+                    invokeEventListener(listener, options, eventListeners);
+                    if (stopImmediatePropagation) {
+                        // Event.stopImmediatePropagation() stops any following invocation
+                        // of an event handler even on the same event target.
+                        return finishDispatch();
+                    }
+                }
+            }
+            if (stopPropagation) {
+                // Event.stopPropagation() stops any following invocation
+                // of an event handler for any following event targets.
+                return finishDispatch();
+            }
+        }
+        return finishDispatch();
+    }
+    __resolveFullEventPath() {
+        if (this.__eventPathCache) {
+            return this.__eventPathCache;
+        }
+        else if (!this.__eventTargetParent) {
+            return (this.__eventPathCache = [this, documentShim, windowShim]);
+        }
+        else {
+            return (this.__eventPathCache = [
+                this,
+                ...this.__eventTargetParent.__resolveFullEventPath(),
+            ]);
+        }
+    }
+}
+const EventTargetShimWithRealType = EventTarget;
 const attributes = new WeakMap();
 const attributesForElement = (element) => {
     let attrs = attributes.get(element);
@@ -2689,7 +2822,58 @@ const attributesForElement = (element) => {
 //    `const ElementShimWithRealType = ElementShim as object as typeof Element;`.
 // 4. We want the exported names to match the real ones, hence e.g.
 //    `export {ElementShimWithRealType as Element}`.
-const ElementShim = class Element extends EventTargetShimWithRealType {
+const NodeShim = class Node extends EventTarget {
+    getRootNode(options) {
+        if (options?.composed) {
+            return document$1;
+        }
+        // getRootNode returns the containing ShadowRoot instance, even if that was
+        // created in closed mode.
+        const host = this.__host;
+        return (host?.__shadowRoot ?? document$1);
+    }
+};
+const NodeShimWithRealType = NodeShim;
+const DocumentShim = class Document extends NodeShim {
+    get adoptedStyleSheets() {
+        return [];
+    }
+    createTreeWalker() {
+        return {};
+    }
+    createTextNode() {
+        return {};
+    }
+    createElement() {
+        return {};
+    }
+};
+const DocumentShimWithRealType = DocumentShim;
+const documentShim = new DocumentShim();
+const document$1 = documentShim;
+const WindowShim = class Window extends NodeShim {
+    constructor(token) {
+        super();
+        if (token !== constructionToken) {
+            throw new TypeError('Illegal constructor');
+        }
+        Object.assign(this, globalThis, {
+            CustomElementRegistry,
+            customElements,
+            document: document$1,
+            Document: DocumentShim,
+            Element: ElementShim,
+            EventTarget,
+            HTMLElement: HTMLElementShim,
+            Node: NodeShim,
+            ShadowRoot: ShadowRootShim,
+            window: this,
+            Window: WindowShim,
+        });
+    }
+};
+const WindowShimWithRealType = WindowShim;
+const ElementShim = class Element extends NodeShim {
     constructor() {
         super(...arguments);
         this.__shadowRootMode = null;
@@ -2750,12 +2934,11 @@ const ElementShim = class Element extends EventTargetShimWithRealType {
         return attributesForElement(this).has(name);
     }
     attachShadow(init) {
-        const shadowRoot = { host: this };
         this.__shadowRootMode = init.mode;
-        if (init && init.mode === 'open') {
-            this.__shadowRoot = shadowRoot;
-        }
-        return shadowRoot;
+        const shadowRoot = new ShadowRootShim(constructionToken, init);
+        shadowRoot.__eventTargetParent = this;
+        shadowRoot.__host = this;
+        return (this.__shadowRoot = shadowRoot);
     }
     attachInternals() {
         if (this.__internals !== null) {
@@ -2775,6 +2958,25 @@ const ElementShimWithRealType = ElementShim;
 const HTMLElementShim = class HTMLElement extends ElementShim {
 };
 const HTMLElementShimWithRealType = HTMLElementShim;
+const HTMLSlotElementShim = class HTMLSlotElement extends HTMLElementShim {
+    get localName() {
+        return 'slot';
+    }
+};
+const HTMLSlotElementShimWithRealType = HTMLSlotElementShim;
+const ShadowRootShim = class ShadowRoot extends NodeShim {
+    get host() {
+        return this.__host;
+    }
+    constructor(constructionToken, init) {
+        super();
+        if (constructionToken !== constructionToken) {
+            throw new TypeError('Illegal constructor');
+        }
+        this.mode = init.mode;
+    }
+};
+const ShadowRootShimWithRealType = ShadowRootShim;
 // For convenience, we provide a global instance of a HTMLElement as an event
 // target. This facilitates registering global event handlers
 // (e.g. for @lit/context ContextProvider).
@@ -2847,6 +3049,10 @@ class CustomElementRegistry {
     getName(ctor) {
         return this.__reverseDefinitions.get(ctor) ?? null;
     }
+    initialize(_root) {
+        throw new Error(`customElements.initialize is not currently supported in SSR. ` +
+            `Please file a bug if you need it.`);
+    }
     upgrade(_element) {
         // In SSR this doesn't make a lot of sense, so we do nothing.
         throw new Error(`customElements.upgrade is not currently supported in SSR. ` +
@@ -2867,6 +3073,10 @@ class CustomElementRegistry {
 }
 const CustomElementRegistryShimWithRealType = CustomElementRegistry;
 const customElements = new CustomElementRegistryShimWithRealType();
+// The window variable instantiation must happen after all shims
+// have been declared, as they will be included in the window instance.
+const windowShim = new WindowShim(constructionToken);
+const window$1 = windowShim;
 
 if (typeof HTMLElement === 'undefined') {
     globalThis.HTMLElement = HTMLElementShimWithRealType;