@lwc/ssr-runtime 8.11.0 → 8.12.1

package/dist/index.cjs.js

@@ -316,6 +316,14 @@ function isUndefined$1(obj) {
 function isNull(obj) {
     return obj === null;
 }
+/**
+ * Determines whether the argument is an object or null.
+ * @param obj Value to test
+ * @returns `true` if the value is an object or null.
+ */
+function isObject(obj) {
+    return typeof obj === 'object';
+}
 /**
  * Determines whether the argument is a string.
  * @param obj Value to test
@@ -324,14 +332,14 @@ function isNull(obj) {
 function isString(obj) {
     return typeof obj === 'string';
 }
-const OtS$1 = {}.toString;
+const OtS = {}.toString;
 /**
  * Converts the argument to a string, safely accounting for objects with "null" prototype.
  * Note that `toString(null)` returns `"[object Null]"` rather than `"null"`.
  * @param obj Value to convert to a string.
  * @returns String representation of the value.
  */
-function toString$1(obj) {
+function toString(obj) {
     if (obj?.toString) {
         // Arrays might hold objects with "null" prototype So using
         // Array.prototype.toString directly will cause an error Iterate through
@@ -347,13 +355,13 @@ function toString$1(obj) {
             // 4. Array#toString converts recursive references to arrays to ''
             // Ex: arr = [1]; arr.push(arr, 2); arr.toString() === '1,,2'; toString(arr) throws
             // Ref: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/toString
-            return ArrayJoin.call(ArrayMap.call(obj, toString$1), ',');
+            return ArrayJoin.call(ArrayMap.call(obj, toString), ',');
         }
         return obj.toString();
     }
     else if (typeof obj === 'object') {
         // This catches null and returns "[object Null]". Weird, but kept for backwards compatibility.
-        return OtS$1.call(obj);
+        return OtS.call(obj);
     }
     else {
         return String(obj);
@@ -569,6 +577,52 @@ function htmlEscape(str, attrMode = false) {
     return str.replace(searchValue, (char) => ESCAPED_CHARS[char]);
 }
 
+/*
+ * Copyright (c) 2020, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+/**
+ * [ncls] - Normalize class name attribute.
+ *
+ * Transforms the provided class property value from an object/string into a string the diffing algo
+ * can operate on.
+ *
+ * This implementation is borrowed from Vue:
+ * https://github.com/vuejs/core/blob/e790e1bdd7df7be39e14780529db86e4da47a3db/packages/shared/src/normalizeProp.ts#L63-L82
+ */
+function normalizeClass(value) {
+    if (isUndefined$1(value) || isNull(value)) {
+        // Returning undefined here improves initial render cost, because the old vnode's class will be considered
+        // undefined in the `patchClassAttribute` routine, so `oldClass === newClass` will be true so we return early
+        return undefined;
+    }
+    let res = '';
+    if (isString(value)) {
+        res = value;
+    }
+    else if (isArray$1(value)) {
+        for (let i = 0; i < value.length; i++) {
+            const normalized = normalizeClass(value[i]);
+            if (normalized) {
+                res += normalized + ' ';
+            }
+        }
+    }
+    else if (isObject(value) && !isNull(value)) {
+        // Iterate own enumerable keys of the object
+        const _keys = keys(value);
+        for (let i = 0; i < _keys.length; i += 1) {
+            const key = _keys[i];
+            if (value[key]) {
+                res += key + ' ';
+            }
+        }
+    }
+    return StringTrim.call(res);
+}
+
 /*
  * Copyright (c) 2024, Salesforce, Inc.
  * All rights reserved.
@@ -599,7 +653,7 @@ function setHooks(hooks) {
  * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
  */
 const DEFAULT_SSR_MODE = 'sync';
-/** version: 8.11.0 */
+/** version: 8.12.1 */
 
 /*
  * Copyright (c) 2024, Salesforce, Inc.
@@ -677,444 +731,418 @@ class ClassList {
     }
 }
 
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
-
-
-function __classPrivateFieldGet(receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-}
-
-function __classPrivateFieldSet(receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
-
-/*
- * Copyright (c) 2024, Salesforce, Inc.
- * All rights reserved.
- * SPDX-License-Identifier: MIT
- * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+/**
+ * Copyright (C) 2017 salesforce.com, inc.
  */
-var _MutationTracker_enabledSet, _MutationTracker_mutationMap;
-class MutationTracker {
-    constructor() {
-        _MutationTracker_enabledSet.set(this, new WeakSet());
-        _MutationTracker_mutationMap.set(this, new WeakMap());
+const { isArray } = Array;
+const { prototype: ObjectDotPrototype, getPrototypeOf, create: ObjectCreate, defineProperty: ObjectDefineProperty, isExtensible, getOwnPropertyDescriptor, getOwnPropertyNames, getOwnPropertySymbols, preventExtensions, hasOwnProperty, } = Object;
+const { push: ArrayPush, concat: ArrayConcat } = Array.prototype;
+function isUndefined(obj) {
+    return obj === undefined;
+}
+function isFunction(obj) {
+    return typeof obj === 'function';
+}
+const proxyToValueMap = new WeakMap();
+function registerProxy(proxy, value) {
+    proxyToValueMap.set(proxy, value);
+}
+const unwrap = (replicaOrAny) => proxyToValueMap.get(replicaOrAny) || replicaOrAny;
+
+class BaseProxyHandler {
+    constructor(membrane, value) {
+        this.originalTarget = value;
+        this.membrane = membrane;
     }
-    add(instance, attrName) {
-        if (__classPrivateFieldGet(this, _MutationTracker_enabledSet, "f").has(instance)) {
-            let mutatedAttrs = __classPrivateFieldGet(this, _MutationTracker_mutationMap, "f").get(instance);
-            if (!mutatedAttrs) {
-                mutatedAttrs = new Set();
-                __classPrivateFieldGet(this, _MutationTracker_mutationMap, "f").set(instance, mutatedAttrs);
+    // Shared utility methods
+    wrapDescriptor(descriptor) {
+        if (hasOwnProperty.call(descriptor, 'value')) {
+            descriptor.value = this.wrapValue(descriptor.value);
+        }
+        else {
+            const { set: originalSet, get: originalGet } = descriptor;
+            if (!isUndefined(originalGet)) {
+                descriptor.get = this.wrapGetter(originalGet);
+            }
+            if (!isUndefined(originalSet)) {
+                descriptor.set = this.wrapSetter(originalSet);
             }
-            mutatedAttrs.add(attrName.toLowerCase());
         }
+        return descriptor;
     }
-    enable(instance) {
-        __classPrivateFieldGet(this, _MutationTracker_enabledSet, "f").add(instance);
+    copyDescriptorIntoShadowTarget(shadowTarget, key) {
+        const { originalTarget } = this;
+        // Note: a property might get defined multiple times in the shadowTarget
+        //       but it will always be compatible with the previous descriptor
+        //       to preserve the object invariants, which makes these lines safe.
+        const originalDescriptor = getOwnPropertyDescriptor(originalTarget, key);
+        // TODO: it should be impossible for the originalDescriptor to ever be undefined, this `if` can be removed
+        /* istanbul ignore else */
+        if (!isUndefined(originalDescriptor)) {
+            const wrappedDesc = this.wrapDescriptor(originalDescriptor);
+            ObjectDefineProperty(shadowTarget, key, wrappedDesc);
+        }
     }
-    disable(instance) {
-        __classPrivateFieldGet(this, _MutationTracker_enabledSet, "f").delete(instance);
+    lockShadowTarget(shadowTarget) {
+        const { originalTarget } = this;
+        const targetKeys = ArrayConcat.call(getOwnPropertyNames(originalTarget), getOwnPropertySymbols(originalTarget));
+        targetKeys.forEach((key) => {
+            this.copyDescriptorIntoShadowTarget(shadowTarget, key);
+        });
+        const { membrane: { tagPropertyKey }, } = this;
+        if (!isUndefined(tagPropertyKey) && !hasOwnProperty.call(shadowTarget, tagPropertyKey)) {
+            ObjectDefineProperty(shadowTarget, tagPropertyKey, ObjectCreate(null));
+        }
+        preventExtensions(shadowTarget);
     }
-    renderMutatedAttrs(instance) {
-        const mutatedAttrs = __classPrivateFieldGet(this, _MutationTracker_mutationMap, "f").get(instance);
-        if (mutatedAttrs) {
-            return ` data-lwc-host-mutated="${[...mutatedAttrs].sort().join(' ')}"`;
+    // Shared Traps
+    // TODO: apply() is never called
+    /* istanbul ignore next */
+    apply(shadowTarget, thisArg, argArray) {
+        /* No op */
+    }
+    // TODO: construct() is never called
+    /* istanbul ignore next */
+    construct(shadowTarget, argArray, newTarget) {
+        /* No op */
+    }
+    get(shadowTarget, key) {
+        const { originalTarget, membrane: { valueObserved }, } = this;
+        const value = originalTarget[key];
+        valueObserved(originalTarget, key);
+        return this.wrapValue(value);
+    }
+    has(shadowTarget, key) {
+        const { originalTarget, membrane: { tagPropertyKey, valueObserved }, } = this;
+        valueObserved(originalTarget, key);
+        // since key is never going to be undefined, and tagPropertyKey might be undefined
+        // we can simply compare them as the second part of the condition.
+        return key in originalTarget || key === tagPropertyKey;
+    }
+    ownKeys(shadowTarget) {
+        const { originalTarget, membrane: { tagPropertyKey }, } = this;
+        // if the membrane tag key exists and it is not in the original target, we add it to the keys.
+        const keys = isUndefined(tagPropertyKey) || hasOwnProperty.call(originalTarget, tagPropertyKey)
+            ? []
+            : [tagPropertyKey];
+        // small perf optimization using push instead of concat to avoid creating an extra array
+        ArrayPush.apply(keys, getOwnPropertyNames(originalTarget));
+        ArrayPush.apply(keys, getOwnPropertySymbols(originalTarget));
+        return keys;
+    }
+    isExtensible(shadowTarget) {
+        const { originalTarget } = this;
+        // optimization to avoid attempting to lock down the shadowTarget multiple times
+        if (!isExtensible(shadowTarget)) {
+            return false; // was already locked down
         }
-        else {
-            return '';
+        if (!isExtensible(originalTarget)) {
+            this.lockShadowTarget(shadowTarget);
+            return false;
+        }
+        return true;
+    }
+    getPrototypeOf(shadowTarget) {
+        const { originalTarget } = this;
+        return getPrototypeOf(originalTarget);
+    }
+    getOwnPropertyDescriptor(shadowTarget, key) {
+        const { originalTarget, membrane: { valueObserved, tagPropertyKey }, } = this;
+        // keys looked up via getOwnPropertyDescriptor need to be reactive
+        valueObserved(originalTarget, key);
+        let desc = getOwnPropertyDescriptor(originalTarget, key);
+        if (isUndefined(desc)) {
+            if (key !== tagPropertyKey) {
+                return undefined;
+            }
+            // if the key is the membrane tag key, and is not in the original target,
+            // we produce a synthetic descriptor and install it on the shadow target
+            desc = { value: undefined, writable: false, configurable: false, enumerable: false };
+            ObjectDefineProperty(shadowTarget, tagPropertyKey, desc);
+            return desc;
         }
+        if (desc.configurable === false) {
+            // updating the descriptor to non-configurable on the shadow
+            this.copyDescriptorIntoShadowTarget(shadowTarget, key);
+        }
+        // Note: by accessing the descriptor, the key is marked as observed
+        // but access to the value, setter or getter (if available) cannot observe
+        // mutations, just like regular methods, in which case we just do nothing.
+        return this.wrapDescriptor(desc);
     }
 }
-_MutationTracker_enabledSet = new WeakMap(), _MutationTracker_mutationMap = new WeakMap();
-const mutationTracker = new MutationTracker();
 
-/*
- * Copyright (c) 2024, Salesforce, Inc.
- * All rights reserved.
- * SPDX-License-Identifier: MIT
- * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
- */
-/**
- * Filters out the following types of properties that should not be set.
- * - Properties that are not public.
- * - Properties that are not global.
- * - Properties that are global but are internally overridden.
- */
-function filterProperties(props, publicFields, privateFields) {
-    const propsToAssign = create(null);
-    const publicFieldSet = new Set(publicFields);
-    const privateFieldSet = new Set(privateFields);
-    keys(props).forEach((propName) => {
-        const attrName = htmlPropertyToAttribute(propName);
-        if (publicFieldSet.has(propName) ||
-            ((isGlobalHtmlAttribute(attrName) || isAriaAttribute(attrName)) &&
-                !privateFieldSet.has(propName))) {
-            propsToAssign[propName] = props[propName];
+const getterMap$1 = new WeakMap();
+const setterMap$1 = new WeakMap();
+const reverseGetterMap = new WeakMap();
+const reverseSetterMap = new WeakMap();
+class ReactiveProxyHandler extends BaseProxyHandler {
+    wrapValue(value) {
+        return this.membrane.getProxy(value);
+    }
+    wrapGetter(originalGet) {
+        const wrappedGetter = getterMap$1.get(originalGet);
+        if (!isUndefined(wrappedGetter)) {
+            return wrappedGetter;
         }
-    });
-    return propsToAssign;
-}
-/**
- * Descriptor for IDL attribute reflections that merely reflect the string, e.g. `title`.
- */
-const stringDescriptor = (attrName) => ({
-    configurable: true,
-    enumerable: true,
-    get() {
-        return this.getAttribute(attrName);
-    },
-    set(newValue) {
-        const currentValue = this.getAttribute(attrName);
-        const normalizedValue = String(newValue);
-        if (normalizedValue !== currentValue) {
-            this.setAttribute(attrName, normalizedValue);
-        }
-    },
-});
-/** Descriptor for a boolean that checks for `attr="true"` or `attr="false"`, e.g. `spellcheck` and `draggable`. */
-const explicitBooleanDescriptor = (attrName, defaultValue) => ({
-    configurable: true,
-    enumerable: true,
-    get() {
-        const value = this.getAttribute(attrName);
-        if (value === null)
-            return defaultValue;
-        // spellcheck=false => false, everything else => true
-        // draggable=true => true, everything else => false
-        return value.toLowerCase() === String(defaultValue) ? defaultValue : !defaultValue;
-    },
-    set(newValue) {
-        const currentValue = this.getAttribute(attrName);
-        const normalizedValue = String(Boolean(newValue));
-        if (normalizedValue !== currentValue) {
-            this.setAttribute(attrName, normalizedValue);
+        const handler = this;
+        const get = function () {
+            // invoking the original getter with the original target
+            return handler.wrapValue(originalGet.call(unwrap(this)));
+        };
+        getterMap$1.set(originalGet, get);
+        reverseGetterMap.set(get, originalGet);
+        return get;
+    }
+    wrapSetter(originalSet) {
+        const wrappedSetter = setterMap$1.get(originalSet);
+        if (!isUndefined(wrappedSetter)) {
+            return wrappedSetter;
         }
-    },
-});
-/**
- * Descriptor for a "true" boolean attribute that checks solely for presence, e.g. `hidden`.
- */
-const booleanAttributeDescriptor = (attrName) => ({
-    configurable: true,
-    enumerable: true,
-    get() {
-        return this.hasAttribute(attrName);
-    },
-    set(newValue) {
-        const hasAttribute = this.hasAttribute(attrName);
-        if (newValue) {
-            if (!hasAttribute) {
-                this.setAttribute(attrName, '');
-            }
+        const set = function (v) {
+            // invoking the original setter with the original target
+            originalSet.call(unwrap(this), unwrap(v));
+        };
+        setterMap$1.set(originalSet, set);
+        reverseSetterMap.set(set, originalSet);
+        return set;
+    }
+    unwrapDescriptor(descriptor) {
+        if (hasOwnProperty.call(descriptor, 'value')) {
+            // dealing with a data descriptor
+            descriptor.value = unwrap(descriptor.value);
         }
         else {
-            if (hasAttribute) {
-                this.removeAttribute(attrName);
-            }
-        }
-    },
-});
-/**
- * Descriptor for ARIA reflections, e.g. `ariaLabel` and `role`.
- */
-const ariaDescriptor = (attrName) => ({
-    configurable: true,
-    enumerable: true,
-    get() {
-        return this.getAttribute(attrName);
-    },
-    set(newValue) {
-        const currentValue = this.getAttribute(attrName);
-        if (newValue !== currentValue) {
-            // TODO [#3284]: According to the spec, IDL nullable type values
-            // (null and undefined) should remove the attribute; however, we
-            // only do so in the case of null for historical reasons.
-            if (isNull(newValue)) {
-                this.removeAttribute(attrName);
+            const { set, get } = descriptor;
+            if (!isUndefined(get)) {
+                descriptor.get = this.unwrapGetter(get);
             }
-            else {
-                this.setAttribute(attrName, toString$1(newValue));
+            if (!isUndefined(set)) {
+                descriptor.set = this.unwrapSetter(set);
             }
         }
-    },
-});
-const tabIndexDescriptor = () => ({
-    configurable: true,
-    enumerable: true,
-    get() {
-        const str = this.getAttribute('tabindex');
-        const num = Number(str);
-        return isFinite(num) ? Math.trunc(num) : -1;
-    },
-    set(newValue) {
-        const currentValue = this.getAttribute('tabindex');
-        const num = Number(newValue);
-        const normalizedValue = isFinite(num) ? String(Math.trunc(num)) : '0';
-        if (normalizedValue !== currentValue) {
-            this.setAttribute('tabindex', toString$1(newValue));
-        }
-    },
-});
-const descriptors = {
-    accessKey: stringDescriptor('accesskey'),
-    dir: stringDescriptor('dir'),
-    draggable: explicitBooleanDescriptor('draggable', true),
-    hidden: booleanAttributeDescriptor('hidden'),
-    id: stringDescriptor('id'),
-    lang: stringDescriptor('lang'),
-    spellcheck: explicitBooleanDescriptor('spellcheck', false),
-    tabIndex: tabIndexDescriptor(),
-    title: stringDescriptor('title'),
-};
-// Add descriptors for ARIA attributes
-for (const [attrName, propName] of entries(AriaAttrNameToPropNameMap)) {
-    descriptors[propName] = ariaDescriptor(attrName);
-}
-
-/*
- * Copyright (c) 2024, salesforce.com, inc.
- * All rights reserved.
- * SPDX-License-Identifier: MIT
- * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
- */
-var _LightningElement_attrs, _LightningElement_classList;
-const SYMBOL__SET_INTERNALS = Symbol('set-internals');
-const SYMBOL__GENERATE_MARKUP = Symbol('generate-markup');
-const SYMBOL__DEFAULT_TEMPLATE = Symbol('default-template');
-class LightningElement {
-    constructor(propsAvailableAtConstruction) {
-        this.isConnected = false;
-        this.className = '';
-        _LightningElement_attrs.set(this, void 0);
-        _LightningElement_classList.set(this, null);
-        assign(this, propsAvailableAtConstruction);
-    }
-    [(_LightningElement_attrs = new WeakMap(), _LightningElement_classList = new WeakMap(), SYMBOL__SET_INTERNALS)](props, attrs) {
-        __classPrivateFieldSet(this, _LightningElement_attrs, attrs, "f");
-        assign(this, props);
-        defineProperty(this, 'className', {
-            get() {
-                return props.class ?? '';
-            },
-            set(newVal) {
-                props.class = newVal;
-                attrs.class = newVal;
-                mutationTracker.add(this, 'class');
-            },
-        });
+        return descriptor;
     }
-    get classList() {
-        if (__classPrivateFieldGet(this, _LightningElement_classList, "f")) {
-            return __classPrivateFieldGet(this, _LightningElement_classList, "f");
+    unwrapGetter(redGet) {
+        const reverseGetter = reverseGetterMap.get(redGet);
+        if (!isUndefined(reverseGetter)) {
+            return reverseGetter;
         }
-        return (__classPrivateFieldSet(this, _LightningElement_classList, new ClassList(this), "f"));
-    }
-    setAttribute(attrName, attrValue) {
-        const normalizedName = StringToLowerCase.call(toString$1(attrName));
-        const normalizedValue = String(attrValue);
-        __classPrivateFieldGet(this, _LightningElement_attrs, "f")[normalizedName] = normalizedValue;
-        mutationTracker.add(this, normalizedName);
+        const handler = this;
+        const get = function () {
+            // invoking the red getter with the proxy of this
+            return unwrap(redGet.call(handler.wrapValue(this)));
+        };
+        getterMap$1.set(get, redGet);
+        reverseGetterMap.set(redGet, get);
+        return get;
     }
-    getAttribute(attrName) {
-        const normalizedName = StringToLowerCase.call(toString$1(attrName));
-        if (hasOwnProperty$1.call(__classPrivateFieldGet(this, _LightningElement_attrs, "f"), normalizedName)) {
-            return __classPrivateFieldGet(this, _LightningElement_attrs, "f")[normalizedName];
+    unwrapSetter(redSet) {
+        const reverseSetter = reverseSetterMap.get(redSet);
+        if (!isUndefined(reverseSetter)) {
+            return reverseSetter;
         }
-        return null;
-    }
-    hasAttribute(attrName) {
-        const normalizedName = StringToLowerCase.call(toString$1(attrName));
-        return hasOwnProperty$1.call(__classPrivateFieldGet(this, _LightningElement_attrs, "f"), normalizedName);
-    }
-    removeAttribute(attrName) {
-        const normalizedName = StringToLowerCase.call(toString$1(attrName));
-        delete __classPrivateFieldGet(this, _LightningElement_attrs, "f")[normalizedName];
-        // Track mutations for removal of non-existing attributes
-        mutationTracker.add(this, normalizedName);
-    }
-    addEventListener(_type, _listener, _options) {
-        // noop
-    }
-    removeEventListener(_type, _listener, _options) {
-        // noop
-    }
-    // ----------------------------------------------------------- //
-    // Props/methods explicitly not available in this environment  //
-    // Getters are named "get*" for parity with @lwc/engine-server //
-    // ----------------------------------------------------------- //
-    get children() {
-        throw new TypeError('"getChildren" is not supported in this environment');
-    }
-    get childNodes() {
-        throw new TypeError('"getChildNodes" is not supported in this environment');
-    }
-    get firstChild() {
-        throw new TypeError('"getFirstChild" is not supported in this environment');
-    }
-    get firstElementChild() {
-        throw new TypeError('"getFirstElementChild" is not supported in this environment');
-    }
-    get hostElement() {
-        // Intentionally different to match @lwc/engine-*core*
-        throw new TypeError('this.hostElement is not supported in this environment');
-    }
-    get lastChild() {
-        throw new TypeError('"getLastChild" is not supported in this environment');
-    }
-    get lastElementChild() {
-        throw new TypeError('"getLastElementChild" is not supported in this environment');
+        const handler = this;
+        const set = function (v) {
+            // invoking the red setter with the proxy of this
+            redSet.call(handler.wrapValue(this), handler.wrapValue(v));
+        };
+        setterMap$1.set(set, redSet);
+        reverseSetterMap.set(redSet, set);
+        return set;
     }
-    get ownerDocument() {
-        // Intentionally not "get*" to match @lwc/engine-server
-        throw new TypeError('"ownerDocument" is not supported in this environment');
+    set(shadowTarget, key, value) {
+        const { originalTarget, membrane: { valueMutated }, } = this;
+        const oldValue = originalTarget[key];
+        if (oldValue !== value) {
+            originalTarget[key] = value;
+            valueMutated(originalTarget, key);
+        }
+        else if (key === 'length' && isArray(originalTarget)) {
+            // fix for issue #236: push will add the new index, and by the time length
+            // is updated, the internal length is already equal to the new length value
+            // therefore, the oldValue is equal to the value. This is the forking logic
+            // to support this use case.
+            valueMutated(originalTarget, key);
+        }
+        return true;
     }
-    get style() {
-        // Intentionally not "get*" to match @lwc/engine-server
-        throw new TypeError('"style" is not supported in this environment');
+    deleteProperty(shadowTarget, key) {
+        const { originalTarget, membrane: { valueMutated }, } = this;
+        delete originalTarget[key];
+        valueMutated(originalTarget, key);
+        return true;
     }
-    attachInternals() {
-        throw new TypeError('"attachInternals" is not supported in this environment');
+    setPrototypeOf(shadowTarget, prototype) {
     }
-    dispatchEvent(_event) {
-        throw new TypeError('"dispatchEvent" is not supported in this environment');
+    preventExtensions(shadowTarget) {
+        if (isExtensible(shadowTarget)) {
+            const { originalTarget } = this;
+            preventExtensions(originalTarget);
+            // if the originalTarget is a proxy itself, it might reject
+            // the preventExtension call, in which case we should not attempt to lock down
+            // the shadow target.
+            // TODO: It should not actually be possible to reach this `if` statement.
+            // If a proxy rejects extensions, then calling preventExtensions will throw an error:
+            // https://codepen.io/nolanlawson-the-selector/pen/QWMOjbY
+            /* istanbul ignore if */
+            if (isExtensible(originalTarget)) {
+                return false;
+            }
+            this.lockShadowTarget(shadowTarget);
+        }
+        return true;
     }
-    getBoundingClientRect() {
-        throw new TypeError('"getBoundingClientRect" is not supported in this environment');
+    defineProperty(shadowTarget, key, descriptor) {
+        const { originalTarget, membrane: { valueMutated, tagPropertyKey }, } = this;
+        if (key === tagPropertyKey && !hasOwnProperty.call(originalTarget, key)) {
+            // To avoid leaking the membrane tag property into the original target, we must
+            // be sure that the original target doesn't have yet.
+            // NOTE: we do not return false here because Object.freeze and equivalent operations
+            // will attempt to set the descriptor to the same value, and expect no to throw. This
+            // is an small compromise for the sake of not having to diff the descriptors.
+            return true;
+        }
+        ObjectDefineProperty(originalTarget, key, this.unwrapDescriptor(descriptor));
+        // intentionally testing if false since it could be undefined as well
+        if (descriptor.configurable === false) {
+            this.copyDescriptorIntoShadowTarget(shadowTarget, key);
+        }
+        valueMutated(originalTarget, key);
+        return true;
     }
-    getElementsByClassName(_classNames) {
-        throw new TypeError('"getElementsByClassName" is not supported in this environment');
+}
+
+const getterMap = new WeakMap();
+const setterMap = new WeakMap();
+class ReadOnlyHandler extends BaseProxyHandler {
+    wrapValue(value) {
+        return this.membrane.getReadOnlyProxy(value);
     }
-    getElementsByTagName(_qualifiedName) {
-        throw new TypeError('"getElementsByTagName" is not supported in this environment');
+    wrapGetter(originalGet) {
+        const wrappedGetter = getterMap.get(originalGet);
+        if (!isUndefined(wrappedGetter)) {
+            return wrappedGetter;
+        }
+        const handler = this;
+        const get = function () {
+            // invoking the original getter with the original target
+            return handler.wrapValue(originalGet.call(unwrap(this)));
+        };
+        getterMap.set(originalGet, get);
+        return get;
     }
-    querySelector(_selectors) {
-        throw new TypeError('"querySelector" is not supported in this environment');
+    wrapSetter(originalSet) {
+        const wrappedSetter = setterMap.get(originalSet);
+        if (!isUndefined(wrappedSetter)) {
+            return wrappedSetter;
+        }
+        const set = function (v) {
+        };
+        setterMap.set(originalSet, set);
+        return set;
     }
-    querySelectorAll(_selectors) {
-        throw new TypeError('"querySelectorAll" is not supported in this environment');
+    set(shadowTarget, key, value) {
+        /* istanbul ignore next */
+        return false;
     }
-    getAttributeNS(_namespace, _localName) {
-        throw new Error('Method "getAttributeNS" not implemented.');
+    deleteProperty(shadowTarget, key) {
+        /* istanbul ignore next */
+        return false;
     }
-    hasAttributeNS(_namespace, _localName) {
-        throw new Error('Method "hasAttributeNS" not implemented.');
+    setPrototypeOf(shadowTarget, prototype) {
     }
-    removeAttributeNS(_namespace, _localName) {
-        throw new Error('Method "removeAttributeNS" not implemented.');
+    preventExtensions(shadowTarget) {
+        /* istanbul ignore next */
+        return false;
     }
-    setAttributeNS(_namespace, _qualifiedName, _value) {
-        throw new Error('Method "setAttributeNS" not implemented.');
+    defineProperty(shadowTarget, key, descriptor) {
+        /* istanbul ignore next */
+        return false;
     }
 }
-defineProperties(LightningElement.prototype, descriptors);
 
-/*
- * Copyright (c) 2024, salesforce.com, inc.
- * All rights reserved.
- * SPDX-License-Identifier: MIT
- * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
- */
-const escapeAttrVal = (attrValue) => attrValue.replaceAll('&', '&amp;').replaceAll('"', '&quot;');
-function renderAttrsPrivate(instance, attrs, hostScopeToken, scopeToken) {
-    // The scopeToken is e.g. `lwc-xyz123` which is the token our parent gives us.
-    // The hostScopeToken is e.g. `lwc-abc456-host` which is the token for our own component.
-    // It's possible to have both, one, the other, or neither.
-    const combinedScopeToken = scopeToken && hostScopeToken
-        ? `${scopeToken} ${hostScopeToken}`
-        : scopeToken || hostScopeToken || '';
-    let result = '';
-    let hasClassAttribute = false;
-    for (const attrName of getOwnPropertyNames$1(attrs)) {
-        let attrValue = attrs[attrName];
-        if (isNull(attrValue) || isUndefined$1(attrValue)) {
-            attrValue = '';
-        }
-        else if (!isString(attrValue)) {
-            attrValue = String(attrValue);
-        }
-        if (combinedScopeToken && attrName === 'class') {
-            attrValue += ' ' + combinedScopeToken;
-            hasClassAttribute = true;
-        }
-        result += attrValue === '' ? ` ${attrName}` : ` ${attrName}="${escapeAttrVal(attrValue)}"`;
+function defaultValueIsObservable(value) {
+    // intentionally checking for null
+    if (value === null) {
+        return false;
     }
-    // If we didn't render any `class` attribute, render one for the scope token(s)
-    if (!hasClassAttribute && combinedScopeToken) {
-        result += ` class="${combinedScopeToken}"`;
+    // treat all non-object types, including undefined, as non-observable values
+    if (typeof value !== 'object') {
+        return false;
     }
-    // For the host scope token only, we encode a special attribute for hydration
-    if (hostScopeToken) {
-        result += ` data-lwc-host-scope-token="${hostScopeToken}"`;
+    if (isArray(value)) {
+        return true;
     }
-    result += mutationTracker.renderMutatedAttrs(instance);
-    return result;
-}
-function* renderAttrs(instance, attrs, hostScopeToken, scopeToken) {
-    yield renderAttrsPrivate(instance, attrs, hostScopeToken, scopeToken);
-}
-function renderAttrsNoYield(emit, instance, attrs, hostScopeToken, scopeToken) {
-    emit(renderAttrsPrivate(instance, attrs, hostScopeToken, scopeToken));
+    const proto = getPrototypeOf(value);
+    return proto === ObjectDotPrototype || proto === null || getPrototypeOf(proto) === null;
 }
-function* fallbackTmpl(_props, _attrs, _shadowSlottedContent, _lightSlottedContent, Cmp, _instance) {
-    if (Cmp.renderMode !== 'light') {
-        yield '<template shadowrootmode="open"></template>';
-    }
+const defaultValueObserved = (obj, key) => {
+    /* do nothing */
+};
+const defaultValueMutated = (obj, key) => {
+    /* do nothing */
+};
+function createShadowTarget(value) {
+    return isArray(value) ? [] : {};
 }
-function fallbackTmplNoYield(emit, _props, _attrs, _shadowSlottedContent, _lightSlottedContent, Cmp, _instance) {
-    if (Cmp.renderMode !== 'light') {
-        emit('<template shadowrootmode="open"></template>');
+class ObservableMembrane {
+    constructor(options = {}) {
+        this.readOnlyObjectGraph = new WeakMap();
+        this.reactiveObjectGraph = new WeakMap();
+        const { valueMutated, valueObserved, valueIsObservable, tagPropertyKey } = options;
+        this.valueMutated = isFunction(valueMutated) ? valueMutated : defaultValueMutated;
+        this.valueObserved = isFunction(valueObserved) ? valueObserved : defaultValueObserved;
+        this.valueIsObservable = isFunction(valueIsObservable)
+            ? valueIsObservable
+            : defaultValueIsObservable;
+        this.tagPropertyKey = tagPropertyKey;
     }
-}
-async function serverSideRenderComponent(tagName, Component, props = {}, mode = DEFAULT_SSR_MODE) {
-    if (typeof tagName !== 'string') {
-        throw new Error(`tagName must be a string, found: ${tagName}`);
+    getProxy(value) {
+        const unwrappedValue = unwrap(value);
+        if (this.valueIsObservable(unwrappedValue)) {
+            // When trying to extract the writable version of a readonly we return the readonly.
+            if (this.readOnlyObjectGraph.get(unwrappedValue) === value) {
+                return value;
+            }
+            return this.getReactiveHandler(unwrappedValue);
+        }
+        return unwrappedValue;
     }
-    const generateMarkup = Component[SYMBOL__GENERATE_MARKUP];
-    let markup = '';
-    const emit = (segment) => {
-        markup += segment;
-    };
-    if (mode === 'asyncYield') {
-        for await (const segment of generateMarkup(tagName, props, null, null, null)) {
-            markup += segment;
+    getReadOnlyProxy(value) {
+        value = unwrap(value);
+        if (this.valueIsObservable(value)) {
+            return this.getReadOnlyHandler(value);
         }
+        return value;
     }
-    else if (mode === 'async') {
-        await generateMarkup(emit, tagName, props, null, null, null);
+    unwrapProxy(p) {
+        return unwrap(p);
     }
-    else if (mode === 'sync') {
-        generateMarkup(emit, tagName, props, null, null, null);
+    getReactiveHandler(value) {
+        let proxy = this.reactiveObjectGraph.get(value);
+        if (isUndefined(proxy)) {
+            // caching the proxy after the first time it is accessed
+            const handler = new ReactiveProxyHandler(this, value);
+            proxy = new Proxy(createShadowTarget(value), handler);
+            registerProxy(proxy, value);
+            this.reactiveObjectGraph.set(value, proxy);
+        }
+        return proxy;
     }
-    else {
-        throw new Error(`Invalid mode: ${mode}`);
+    getReadOnlyHandler(value) {
+        let proxy = this.readOnlyObjectGraph.get(value);
+        if (isUndefined(proxy)) {
+            // caching the proxy after the first time it is accessed
+            const handler = new ReadOnlyHandler(this, value);
+            proxy = new Proxy(createShadowTarget(value), handler);
+            registerProxy(proxy, value);
+            this.readOnlyObjectGraph.set(value, proxy);
+        }
+        return proxy;
     }
-    return markup;
 }
+/** version: 2.0.0 */
 
 /*
  * Copyright (c) 2024, Salesforce, Inc.
@@ -1122,90 +1150,231 @@ async function serverSideRenderComponent(tagName, Component, props = {}, mode =
  * SPDX-License-Identifier: MIT
  * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
  */
-/**
- * Per the HTML spec on restrictions for "raw text elements" like `<style>`:
- *
- * > The text in raw text and escapable raw text elements must not contain any occurrences of the string
- * > "</" (U+003C LESS-THAN SIGN, U+002F SOLIDUS) followed by characters that case-insensitively match the tag name of
- * > the element followed by one of:
- * > - U+0009 CHARACTER TABULATION (tab)
- * > - U+000A LINE FEED (LF)
- * > - U+000C FORM FEED (FF)
- * > - U+000D CARRIAGE RETURN (CR)
- * > - U+0020 SPACE
- * > - U+003E GREATER-THAN SIGN (>), or
- * > - U+002F SOLIDUS (/)
- * @see https://html.spec.whatwg.org/multipage/syntax.html#cdata-rcdata-restrictions
- */
-const INVALID_STYLE_CONTENT = /<\/style[\t\n\f\r >/]/i;
-/**
- * The text content inside `<style>` is a special case. It is _only_ rendered by the LWC engine itself; `<style>` tags
- * are disallowed inside of HTML templates.
- *
- * The `<style>` tag is unusual in how it's defined in HTML. Like `<script>`, it is considered a "raw text element,"
- * which means that it is parsed as raw text, but certain character sequences are disallowed, namely to avoid XSS
- * attacks like `</style><script>alert("pwned")</script>`.
- *
- * This also means that we cannot use "normal" HTML escaping inside `<style>` tags, e.g. we cannot use `&lt;`,
- * `&gt;`, etc., because these are treated as-is by the HTML parser.
- *
- *
- * @param contents CSS source to validate
- * @throws Throws if the contents provided are not valid.
- * @see https://html.spec.whatwg.org/multipage/syntax.html#raw-text-elements
- * @see https://github.com/salesforce/lwc/issues/3439
- * @example
- * validateStyleTextContents('div { color: red }') // Ok
- * validateStyleTextContents('</style><script>alert("pwned")</script>') // Throws
- */
-function validateStyleTextContents(contents) {
-    if (INVALID_STYLE_CONTENT.test(contents)) {
-        throw new Error('CSS contains unsafe characters and cannot be serialized inside a style element');
-    }
+const reactiveMembrane = new ObservableMembrane();
+// Modeled after `getReadOnlyProxy` in `membrane.ts` in `engine-core`
+// Return a proxy over the given object so that access is immutable
+// https://github.com/salesforce/lwc/blob/e9db491/packages/%40lwc/engine-core/src/framework/membrane.ts#L29-L33
+function getReadOnlyProxy(value) {
+    return reactiveMembrane.getReadOnlyProxy(value);
 }
 
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __classPrivateFieldGet(receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+}
+
+function __classPrivateFieldSet(receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
 /*
  * Copyright (c) 2024, Salesforce, Inc.
  * All rights reserved.
  * SPDX-License-Identifier: MIT
  * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
  */
-// Traverse in the same order as `flattenStylesheets` but without creating unnecessary additional arrays
-function traverseStylesheets(stylesheets, callback) {
-    if (isArray$1(stylesheets)) {
-        for (let i = 0; i < stylesheets.length; i++) {
-            traverseStylesheets(stylesheets[i], callback);
+var _MutationTracker_enabledSet, _MutationTracker_mutationMap;
+class MutationTracker {
+    constructor() {
+        _MutationTracker_enabledSet.set(this, new WeakSet());
+        _MutationTracker_mutationMap.set(this, new WeakMap());
+    }
+    add(instance, attrName) {
+        if (__classPrivateFieldGet(this, _MutationTracker_enabledSet, "f").has(instance)) {
+            let mutatedAttrs = __classPrivateFieldGet(this, _MutationTracker_mutationMap, "f").get(instance);
+            if (!mutatedAttrs) {
+                mutatedAttrs = new Set();
+                __classPrivateFieldGet(this, _MutationTracker_mutationMap, "f").set(instance, mutatedAttrs);
+            }
+            mutatedAttrs.add(attrName.toLowerCase());
         }
     }
-    else if (stylesheets) {
-        callback(stylesheets);
+    enable(instance) {
+        __classPrivateFieldGet(this, _MutationTracker_enabledSet, "f").add(instance);
+    }
+    disable(instance) {
+        __classPrivateFieldGet(this, _MutationTracker_enabledSet, "f").delete(instance);
+    }
+    renderMutatedAttrs(instance) {
+        const mutatedAttrs = __classPrivateFieldGet(this, _MutationTracker_mutationMap, "f").get(instance);
+        if (mutatedAttrs) {
+            return ` data-lwc-host-mutated="${[...mutatedAttrs].sort().join(' ')}"`;
+        }
+        else {
+            return '';
+        }
     }
 }
-function hasScopedStaticStylesheets(Component) {
-    let scoped = false;
-    traverseStylesheets(Component.stylesheets, (stylesheet) => {
-        scoped ||= !!stylesheet.$scoped$;
+_MutationTracker_enabledSet = new WeakMap(), _MutationTracker_mutationMap = new WeakMap();
+const mutationTracker = new MutationTracker();
+
+/*
+ * Copyright (c) 2024, Salesforce, Inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+/**
+ * Filters out the following types of properties that should not be set.
+ * - Properties that are not public.
+ * - Properties that are not global.
+ * - Properties that are global but are internally overridden.
+ */
+function filterProperties(props, publicFields, privateFields) {
+    const propsToAssign = create(null);
+    const publicFieldSet = new Set(publicFields);
+    const privateFieldSet = new Set(privateFields);
+    keys(props).forEach((propName) => {
+        const attrName = htmlPropertyToAttribute(propName);
+        if (publicFieldSet.has(propName) ||
+            ((isGlobalHtmlAttribute(attrName) || isAriaAttribute(attrName)) &&
+                !privateFieldSet.has(propName))) {
+            propsToAssign[propName] = props[propName];
+        }
     });
-    return scoped;
+    return propsToAssign;
 }
-function renderStylesheets(defaultStylesheets, defaultScopedStylesheets, staticStylesheets, scopeToken, Component, hasScopedTemplateStyles) {
-    const hasAnyScopedStyles = hasScopedTemplateStyles || hasScopedStaticStylesheets(Component);
-    const { renderMode } = Component;
-    let result = '';
-    const renderStylesheet = (stylesheet) => {
-        const { $scoped$: scoped } = stylesheet;
-        const token = scoped ? scopeToken : undefined;
-        const useActualHostSelector = !scoped || renderMode !== 'light';
-        const useNativeDirPseudoclass = true;
-        const styleContents = stylesheet(token, useActualHostSelector, useNativeDirPseudoclass);
-        validateStyleTextContents(styleContents);
-        // TODO [#2869]: `<style>`s should not have scope token classes
-        result += `<style${hasAnyScopedStyles ? ` class="${scopeToken}"` : ''} type="text/css">${styleContents}</style>`;
-    };
-    traverseStylesheets(defaultStylesheets, renderStylesheet);
-    traverseStylesheets(defaultScopedStylesheets, renderStylesheet);
-    traverseStylesheets(staticStylesheets, renderStylesheet);
-    return result;
+/**
+ * Descriptor for IDL attribute reflections that merely reflect the string, e.g. `title`.
+ */
+const stringDescriptor = (attrName) => ({
+    configurable: true,
+    enumerable: true,
+    get() {
+        return this.getAttribute(attrName);
+    },
+    set(newValue) {
+        const currentValue = this.getAttribute(attrName);
+        const normalizedValue = String(newValue);
+        if (normalizedValue !== currentValue) {
+            this.setAttribute(attrName, normalizedValue);
+        }
+    },
+});
+/** Descriptor for a boolean that checks for `attr="true"` or `attr="false"`, e.g. `spellcheck` and `draggable`. */
+const explicitBooleanDescriptor = (attrName, defaultValue) => ({
+    configurable: true,
+    enumerable: true,
+    get() {
+        const value = this.getAttribute(attrName);
+        if (value === null)
+            return defaultValue;
+        // spellcheck=false => false, everything else => true
+        // draggable=true => true, everything else => false
+        return value.toLowerCase() === String(defaultValue) ? defaultValue : !defaultValue;
+    },
+    set(newValue) {
+        const currentValue = this.getAttribute(attrName);
+        const normalizedValue = String(Boolean(newValue));
+        if (normalizedValue !== currentValue) {
+            this.setAttribute(attrName, normalizedValue);
+        }
+    },
+});
+/**
+ * Descriptor for a "true" boolean attribute that checks solely for presence, e.g. `hidden`.
+ */
+const booleanAttributeDescriptor = (attrName) => ({
+    configurable: true,
+    enumerable: true,
+    get() {
+        return this.hasAttribute(attrName);
+    },
+    set(newValue) {
+        const hasAttribute = this.hasAttribute(attrName);
+        if (newValue) {
+            if (!hasAttribute) {
+                this.setAttribute(attrName, '');
+            }
+        }
+        else {
+            if (hasAttribute) {
+                this.removeAttribute(attrName);
+            }
+        }
+    },
+});
+/**
+ * Descriptor for ARIA reflections, e.g. `ariaLabel` and `role`.
+ */
+const ariaDescriptor = (attrName) => ({
+    configurable: true,
+    enumerable: true,
+    get() {
+        return this.getAttribute(attrName);
+    },
+    set(newValue) {
+        const currentValue = this.getAttribute(attrName);
+        if (newValue !== currentValue) {
+            // TODO [#3284]: According to the spec, IDL nullable type values
+            // (null and undefined) should remove the attribute; however, we
+            // only do so in the case of null for historical reasons.
+            if (isNull(newValue)) {
+                this.removeAttribute(attrName);
+            }
+            else {
+                this.setAttribute(attrName, toString(newValue));
+            }
+        }
+    },
+});
+const tabIndexDescriptor = () => ({
+    configurable: true,
+    enumerable: true,
+    get() {
+        const str = this.getAttribute('tabindex');
+        const num = Number(str);
+        return isFinite(num) ? Math.trunc(num) : -1;
+    },
+    set(newValue) {
+        const currentValue = this.getAttribute('tabindex');
+        const num = Number(newValue);
+        const normalizedValue = isFinite(num) ? String(Math.trunc(num)) : '0';
+        if (normalizedValue !== currentValue) {
+            this.setAttribute('tabindex', toString(newValue));
+        }
+    },
+});
+const descriptors = {
+    accessKey: stringDescriptor('accesskey'),
+    dir: stringDescriptor('dir'),
+    draggable: explicitBooleanDescriptor('draggable', true),
+    hidden: booleanAttributeDescriptor('hidden'),
+    id: stringDescriptor('id'),
+    lang: stringDescriptor('lang'),
+    spellcheck: explicitBooleanDescriptor('spellcheck', false),
+    tabIndex: tabIndexDescriptor(),
+    title: stringDescriptor('title'),
+};
+// Add descriptors for ARIA attributes
+for (const [attrName, propName] of entries(AriaAttrNameToPropNameMap)) {
+    descriptors[propName] = ariaDescriptor(attrName);
 }
 
 /*
@@ -1214,581 +1383,225 @@ function renderStylesheets(defaultStylesheets, defaultScopedStylesheets, staticS
  * SPDX-License-Identifier: MIT
  * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
  */
-/**
- * Converts an iterable into one that emits the object used by the [`iterator` directive](
- * https://lwc.dev/guide/html_templates#iterator).
- */
-function* toIteratorDirective(iterable) {
-    if (iterable === undefined || iterable === null)
-        return;
-    if (!iterable[Symbol.iterator]) {
-        throw new Error(
-        // Mimic error message from "[i]terable node" in engine-core's api.ts
-        `Invalid template iteration for value \`${iterable}\`. It must be an array-like object.`);
-    }
-    const iterator = iterable[Symbol.iterator]();
-    let next = iterator.next();
-    let index = 0;
-    let { value, done: last = false } = next;
-    while (last === false) {
-        // using a look-back approach because we need to know if the element is the last
-        next = iterator.next();
-        last = next.done ?? false;
-        yield {
-            value,
-            index,
-            first: index === 0,
-            last,
-        };
-        index += 1;
-        value = next.value;
-    }
-}
-
-/**
- * Copyright (C) 2017 salesforce.com, inc.
- */
-const { isArray } = Array;
-const { prototype: ObjectDotPrototype, getPrototypeOf, create: ObjectCreate, defineProperty: ObjectDefineProperty, isExtensible, getOwnPropertyDescriptor, getOwnPropertyNames, getOwnPropertySymbols, preventExtensions, hasOwnProperty, } = Object;
-const { push: ArrayPush, concat: ArrayConcat } = Array.prototype;
-const OtS = {}.toString;
-function toString(obj) {
-    if (obj && obj.toString) {
-        return obj.toString();
-    }
-    else if (typeof obj === 'object') {
-        return OtS.call(obj);
-    }
-    else {
-        return obj + '';
+var _LightningElement_attrs, _LightningElement_classList;
+const SYMBOL__SET_INTERNALS = Symbol('set-internals');
+const SYMBOL__GENERATE_MARKUP = Symbol('generate-markup');
+const SYMBOL__DEFAULT_TEMPLATE = Symbol('default-template');
+class LightningElement {
+    constructor(propsAvailableAtConstruction) {
+        this.isConnected = false;
+        this.className = '';
+        _LightningElement_attrs.set(this, void 0);
+        _LightningElement_classList.set(this, null);
+        assign(this, propsAvailableAtConstruction);
     }
-}
-function isUndefined(obj) {
-    return obj === undefined;
-}
-function isFunction(obj) {
-    return typeof obj === 'function';
-}
-const proxyToValueMap = new WeakMap();
-function registerProxy(proxy, value) {
-    proxyToValueMap.set(proxy, value);
-}
-const unwrap = (replicaOrAny) => proxyToValueMap.get(replicaOrAny) || replicaOrAny;
-
-class BaseProxyHandler {
-    constructor(membrane, value) {
-        this.originalTarget = value;
-        this.membrane = membrane;
+    [(_LightningElement_attrs = new WeakMap(), _LightningElement_classList = new WeakMap(), SYMBOL__SET_INTERNALS)](props, attrs) {
+        __classPrivateFieldSet(this, _LightningElement_attrs, attrs, "f");
+        assign(this, props);
+        defineProperty(this, 'className', {
+            get() {
+                return props.class ?? '';
+            },
+            set(newVal) {
+                props.class = newVal;
+                attrs.class = newVal;
+                mutationTracker.add(this, 'class');
+            },
+        });
     }
-    // Shared utility methods
-    wrapDescriptor(descriptor) {
-        if (hasOwnProperty.call(descriptor, 'value')) {
-            descriptor.value = this.wrapValue(descriptor.value);
-        }
-        else {
-            const { set: originalSet, get: originalGet } = descriptor;
-            if (!isUndefined(originalGet)) {
-                descriptor.get = this.wrapGetter(originalGet);
-            }
-            if (!isUndefined(originalSet)) {
-                descriptor.set = this.wrapSetter(originalSet);
-            }
+    get classList() {
+        if (__classPrivateFieldGet(this, _LightningElement_classList, "f")) {
+            return __classPrivateFieldGet(this, _LightningElement_classList, "f");
         }
-        return descriptor;
+        return (__classPrivateFieldSet(this, _LightningElement_classList, new ClassList(this), "f"));
     }
-    copyDescriptorIntoShadowTarget(shadowTarget, key) {
-        const { originalTarget } = this;
-        // Note: a property might get defined multiple times in the shadowTarget
-        //       but it will always be compatible with the previous descriptor
-        //       to preserve the object invariants, which makes these lines safe.
-        const originalDescriptor = getOwnPropertyDescriptor(originalTarget, key);
-        // TODO: it should be impossible for the originalDescriptor to ever be undefined, this `if` can be removed
-        /* istanbul ignore else */
-        if (!isUndefined(originalDescriptor)) {
-            const wrappedDesc = this.wrapDescriptor(originalDescriptor);
-            ObjectDefineProperty(shadowTarget, key, wrappedDesc);
-        }
+    setAttribute(attrName, attrValue) {
+        const normalizedName = StringToLowerCase.call(toString(attrName));
+        const normalizedValue = String(attrValue);
+        __classPrivateFieldGet(this, _LightningElement_attrs, "f")[normalizedName] = normalizedValue;
+        mutationTracker.add(this, normalizedName);
     }
-    lockShadowTarget(shadowTarget) {
-        const { originalTarget } = this;
-        const targetKeys = ArrayConcat.call(getOwnPropertyNames(originalTarget), getOwnPropertySymbols(originalTarget));
-        targetKeys.forEach((key) => {
-            this.copyDescriptorIntoShadowTarget(shadowTarget, key);
-        });
-        const { membrane: { tagPropertyKey }, } = this;
-        if (!isUndefined(tagPropertyKey) && !hasOwnProperty.call(shadowTarget, tagPropertyKey)) {
-            ObjectDefineProperty(shadowTarget, tagPropertyKey, ObjectCreate(null));
+    getAttribute(attrName) {
+        const normalizedName = StringToLowerCase.call(toString(attrName));
+        if (hasOwnProperty$1.call(__classPrivateFieldGet(this, _LightningElement_attrs, "f"), normalizedName)) {
+            return __classPrivateFieldGet(this, _LightningElement_attrs, "f")[normalizedName];
         }
-        preventExtensions(shadowTarget);
-    }
-    // Shared Traps
-    // TODO: apply() is never called
-    /* istanbul ignore next */
-    apply(shadowTarget, thisArg, argArray) {
-        /* No op */
-    }
-    // TODO: construct() is never called
-    /* istanbul ignore next */
-    construct(shadowTarget, argArray, newTarget) {
-        /* No op */
-    }
-    get(shadowTarget, key) {
-        const { originalTarget, membrane: { valueObserved }, } = this;
-        const value = originalTarget[key];
-        valueObserved(originalTarget, key);
-        return this.wrapValue(value);
-    }
-    has(shadowTarget, key) {
-        const { originalTarget, membrane: { tagPropertyKey, valueObserved }, } = this;
-        valueObserved(originalTarget, key);
-        // since key is never going to be undefined, and tagPropertyKey might be undefined
-        // we can simply compare them as the second part of the condition.
-        return key in originalTarget || key === tagPropertyKey;
-    }
-    ownKeys(shadowTarget) {
-        const { originalTarget, membrane: { tagPropertyKey }, } = this;
-        // if the membrane tag key exists and it is not in the original target, we add it to the keys.
-        const keys = isUndefined(tagPropertyKey) || hasOwnProperty.call(originalTarget, tagPropertyKey)
-            ? []
-            : [tagPropertyKey];
-        // small perf optimization using push instead of concat to avoid creating an extra array
-        ArrayPush.apply(keys, getOwnPropertyNames(originalTarget));
-        ArrayPush.apply(keys, getOwnPropertySymbols(originalTarget));
-        return keys;
+        return null;
     }
-    isExtensible(shadowTarget) {
-        const { originalTarget } = this;
-        // optimization to avoid attempting to lock down the shadowTarget multiple times
-        if (!isExtensible(shadowTarget)) {
-            return false; // was already locked down
-        }
-        if (!isExtensible(originalTarget)) {
-            this.lockShadowTarget(shadowTarget);
-            return false;
-        }
-        return true;
+    hasAttribute(attrName) {
+        const normalizedName = StringToLowerCase.call(toString(attrName));
+        return hasOwnProperty$1.call(__classPrivateFieldGet(this, _LightningElement_attrs, "f"), normalizedName);
     }
-    getPrototypeOf(shadowTarget) {
-        const { originalTarget } = this;
-        return getPrototypeOf(originalTarget);
+    removeAttribute(attrName) {
+        const normalizedName = StringToLowerCase.call(toString(attrName));
+        delete __classPrivateFieldGet(this, _LightningElement_attrs, "f")[normalizedName];
+        // Track mutations for removal of non-existing attributes
+        mutationTracker.add(this, normalizedName);
     }
-    getOwnPropertyDescriptor(shadowTarget, key) {
-        const { originalTarget, membrane: { valueObserved, tagPropertyKey }, } = this;
-        // keys looked up via getOwnPropertyDescriptor need to be reactive
-        valueObserved(originalTarget, key);
-        let desc = getOwnPropertyDescriptor(originalTarget, key);
-        if (isUndefined(desc)) {
-            if (key !== tagPropertyKey) {
-                return undefined;
-            }
-            // if the key is the membrane tag key, and is not in the original target,
-            // we produce a synthetic descriptor and install it on the shadow target
-            desc = { value: undefined, writable: false, configurable: false, enumerable: false };
-            ObjectDefineProperty(shadowTarget, tagPropertyKey, desc);
-            return desc;
-        }
-        if (desc.configurable === false) {
-            // updating the descriptor to non-configurable on the shadow
-            this.copyDescriptorIntoShadowTarget(shadowTarget, key);
-        }
-        // Note: by accessing the descriptor, the key is marked as observed
-        // but access to the value, setter or getter (if available) cannot observe
-        // mutations, just like regular methods, in which case we just do nothing.
-        return this.wrapDescriptor(desc);
+    addEventListener(_type, _listener, _options) {
+        // noop
     }
-}
-
-const getterMap$1 = new WeakMap();
-const setterMap$1 = new WeakMap();
-const reverseGetterMap = new WeakMap();
-const reverseSetterMap = new WeakMap();
-class ReactiveProxyHandler extends BaseProxyHandler {
-    wrapValue(value) {
-        return this.membrane.getProxy(value);
+    removeEventListener(_type, _listener, _options) {
+        // noop
     }
-    wrapGetter(originalGet) {
-        const wrappedGetter = getterMap$1.get(originalGet);
-        if (!isUndefined(wrappedGetter)) {
-            return wrappedGetter;
-        }
-        const handler = this;
-        const get = function () {
-            // invoking the original getter with the original target
-            return handler.wrapValue(originalGet.call(unwrap(this)));
-        };
-        getterMap$1.set(originalGet, get);
-        reverseGetterMap.set(get, originalGet);
-        return get;
+    // ----------------------------------------------------------- //
+    // Props/methods explicitly not available in this environment  //
+    // Getters are named "get*" for parity with @lwc/engine-server //
+    // ----------------------------------------------------------- //
+    get children() {
+        throw new TypeError('"getChildren" is not supported in this environment');
     }
-    wrapSetter(originalSet) {
-        const wrappedSetter = setterMap$1.get(originalSet);
-        if (!isUndefined(wrappedSetter)) {
-            return wrappedSetter;
-        }
-        const set = function (v) {
-            // invoking the original setter with the original target
-            originalSet.call(unwrap(this), unwrap(v));
-        };
-        setterMap$1.set(originalSet, set);
-        reverseSetterMap.set(set, originalSet);
-        return set;
+    get childNodes() {
+        throw new TypeError('"getChildNodes" is not supported in this environment');
     }
-    unwrapDescriptor(descriptor) {
-        if (hasOwnProperty.call(descriptor, 'value')) {
-            // dealing with a data descriptor
-            descriptor.value = unwrap(descriptor.value);
-        }
-        else {
-            const { set, get } = descriptor;
-            if (!isUndefined(get)) {
-                descriptor.get = this.unwrapGetter(get);
-            }
-            if (!isUndefined(set)) {
-                descriptor.set = this.unwrapSetter(set);
-            }
-        }
-        return descriptor;
+    get firstChild() {
+        throw new TypeError('"getFirstChild" is not supported in this environment');
     }
-    unwrapGetter(redGet) {
-        const reverseGetter = reverseGetterMap.get(redGet);
-        if (!isUndefined(reverseGetter)) {
-            return reverseGetter;
-        }
-        const handler = this;
-        const get = function () {
-            // invoking the red getter with the proxy of this
-            return unwrap(redGet.call(handler.wrapValue(this)));
-        };
-        getterMap$1.set(get, redGet);
-        reverseGetterMap.set(redGet, get);
-        return get;
+    get firstElementChild() {
+        throw new TypeError('"getFirstElementChild" is not supported in this environment');
     }
-    unwrapSetter(redSet) {
-        const reverseSetter = reverseSetterMap.get(redSet);
-        if (!isUndefined(reverseSetter)) {
-            return reverseSetter;
-        }
-        const handler = this;
-        const set = function (v) {
-            // invoking the red setter with the proxy of this
-            redSet.call(handler.wrapValue(this), handler.wrapValue(v));
-        };
-        setterMap$1.set(set, redSet);
-        reverseSetterMap.set(redSet, set);
-        return set;
+    get hostElement() {
+        // Intentionally different to match @lwc/engine-*core*
+        throw new TypeError('this.hostElement is not supported in this environment');
     }
-    set(shadowTarget, key, value) {
-        const { originalTarget, membrane: { valueMutated }, } = this;
-        const oldValue = originalTarget[key];
-        if (oldValue !== value) {
-            originalTarget[key] = value;
-            valueMutated(originalTarget, key);
-        }
-        else if (key === 'length' && isArray(originalTarget)) {
-            // fix for issue #236: push will add the new index, and by the time length
-            // is updated, the internal length is already equal to the new length value
-            // therefore, the oldValue is equal to the value. This is the forking logic
-            // to support this use case.
-            valueMutated(originalTarget, key);
-        }
-        return true;
+    get lastChild() {
+        throw new TypeError('"getLastChild" is not supported in this environment');
     }
-    deleteProperty(shadowTarget, key) {
-        const { originalTarget, membrane: { valueMutated }, } = this;
-        delete originalTarget[key];
-        valueMutated(originalTarget, key);
-        return true;
+    get lastElementChild() {
+        throw new TypeError('"getLastElementChild" is not supported in this environment');
     }
-    setPrototypeOf(shadowTarget, prototype) {
-        /* istanbul ignore else */
-        if (process.env.NODE_ENV !== 'production') {
-            throw new Error(`Invalid setPrototypeOf invocation for reactive proxy ${toString(this.originalTarget)}. Prototype of reactive objects cannot be changed.`);
-        }
+    get ownerDocument() {
+        // Intentionally not "get*" to match @lwc/engine-server
+        throw new TypeError('"ownerDocument" is not supported in this environment');
     }
-    preventExtensions(shadowTarget) {
-        if (isExtensible(shadowTarget)) {
-            const { originalTarget } = this;
-            preventExtensions(originalTarget);
-            // if the originalTarget is a proxy itself, it might reject
-            // the preventExtension call, in which case we should not attempt to lock down
-            // the shadow target.
-            // TODO: It should not actually be possible to reach this `if` statement.
-            // If a proxy rejects extensions, then calling preventExtensions will throw an error:
-            // https://codepen.io/nolanlawson-the-selector/pen/QWMOjbY
-            /* istanbul ignore if */
-            if (isExtensible(originalTarget)) {
-                return false;
-            }
-            this.lockShadowTarget(shadowTarget);
-        }
-        return true;
+    get style() {
+        // Intentionally not "get*" to match @lwc/engine-server
+        throw new TypeError('"style" is not supported in this environment');
     }
-    defineProperty(shadowTarget, key, descriptor) {
-        const { originalTarget, membrane: { valueMutated, tagPropertyKey }, } = this;
-        if (key === tagPropertyKey && !hasOwnProperty.call(originalTarget, key)) {
-            // To avoid leaking the membrane tag property into the original target, we must
-            // be sure that the original target doesn't have yet.
-            // NOTE: we do not return false here because Object.freeze and equivalent operations
-            // will attempt to set the descriptor to the same value, and expect no to throw. This
-            // is an small compromise for the sake of not having to diff the descriptors.
-            return true;
-        }
-        ObjectDefineProperty(originalTarget, key, this.unwrapDescriptor(descriptor));
-        // intentionally testing if false since it could be undefined as well
-        if (descriptor.configurable === false) {
-            this.copyDescriptorIntoShadowTarget(shadowTarget, key);
-        }
-        valueMutated(originalTarget, key);
-        return true;
+    attachInternals() {
+        throw new TypeError('"attachInternals" is not supported in this environment');
     }
-}
-
-const getterMap = new WeakMap();
-const setterMap = new WeakMap();
-class ReadOnlyHandler extends BaseProxyHandler {
-    wrapValue(value) {
-        return this.membrane.getReadOnlyProxy(value);
+    dispatchEvent(_event) {
+        throw new TypeError('"dispatchEvent" is not supported in this environment');
     }
-    wrapGetter(originalGet) {
-        const wrappedGetter = getterMap.get(originalGet);
-        if (!isUndefined(wrappedGetter)) {
-            return wrappedGetter;
-        }
-        const handler = this;
-        const get = function () {
-            // invoking the original getter with the original target
-            return handler.wrapValue(originalGet.call(unwrap(this)));
-        };
-        getterMap.set(originalGet, get);
-        return get;
+    getBoundingClientRect() {
+        throw new TypeError('"getBoundingClientRect" is not supported in this environment');
     }
-    wrapSetter(originalSet) {
-        const wrappedSetter = setterMap.get(originalSet);
-        if (!isUndefined(wrappedSetter)) {
-            return wrappedSetter;
-        }
-        const handler = this;
-        const set = function (v) {
-            /* istanbul ignore else */
-            if (process.env.NODE_ENV !== 'production') {
-                const { originalTarget } = handler;
-                throw new Error(`Invalid mutation: Cannot invoke a setter on "${originalTarget}". "${originalTarget}" is read-only.`);
-            }
-        };
-        setterMap.set(originalSet, set);
-        return set;
+    getElementsByClassName(_classNames) {
+        throw new TypeError('"getElementsByClassName" is not supported in this environment');
     }
-    set(shadowTarget, key, value) {
-        /* istanbul ignore else */
-        if (process.env.NODE_ENV !== 'production') {
-            const { originalTarget } = this;
-            const msg = isArray(originalTarget)
-                ? `Invalid mutation: Cannot mutate array at index ${key.toString()}. Array is read-only.`
-                : `Invalid mutation: Cannot set "${key.toString()}" on "${originalTarget}". "${originalTarget}" is read-only.`;
-            throw new Error(msg);
-        }
-        /* istanbul ignore next */
-        return false;
+    getElementsByTagName(_qualifiedName) {
+        throw new TypeError('"getElementsByTagName" is not supported in this environment');
     }
-    deleteProperty(shadowTarget, key) {
-        /* istanbul ignore else */
-        if (process.env.NODE_ENV !== 'production') {
-            const { originalTarget } = this;
-            throw new Error(`Invalid mutation: Cannot delete "${key.toString()}" on "${originalTarget}". "${originalTarget}" is read-only.`);
-        }
-        /* istanbul ignore next */
-        return false;
+    querySelector(_selectors) {
+        throw new TypeError('"querySelector" is not supported in this environment');
     }
-    setPrototypeOf(shadowTarget, prototype) {
-        /* istanbul ignore else */
-        if (process.env.NODE_ENV !== 'production') {
-            const { originalTarget } = this;
-            throw new Error(`Invalid prototype mutation: Cannot set prototype on "${originalTarget}". "${originalTarget}" prototype is read-only.`);
-        }
+    querySelectorAll(_selectors) {
+        throw new TypeError('"querySelectorAll" is not supported in this environment');
     }
-    preventExtensions(shadowTarget) {
-        /* istanbul ignore else */
-        if (process.env.NODE_ENV !== 'production') {
-            const { originalTarget } = this;
-            throw new Error(`Invalid mutation: Cannot preventExtensions on ${originalTarget}". "${originalTarget} is read-only.`);
-        }
-        /* istanbul ignore next */
-        return false;
+    getAttributeNS(_namespace, _localName) {
+        throw new Error('Method "getAttributeNS" not implemented.');
     }
-    defineProperty(shadowTarget, key, descriptor) {
-        /* istanbul ignore else */
-        if (process.env.NODE_ENV !== 'production') {
-            const { originalTarget } = this;
-            throw new Error(`Invalid mutation: Cannot defineProperty "${key.toString()}" on "${originalTarget}". "${originalTarget}" is read-only.`);
-        }
-        /* istanbul ignore next */
-        return false;
+    hasAttributeNS(_namespace, _localName) {
+        throw new Error('Method "hasAttributeNS" not implemented.');
+    }
+    removeAttributeNS(_namespace, _localName) {
+        throw new Error('Method "removeAttributeNS" not implemented.');
+    }
+    setAttributeNS(_namespace, _qualifiedName, _value) {
+        throw new Error('Method "setAttributeNS" not implemented.');
     }
 }
+defineProperties(LightningElement.prototype, descriptors);
 
-function extract(objectOrArray) {
-    if (isArray(objectOrArray)) {
-        return objectOrArray.map((item) => {
-            const original = unwrap(item);
-            if (original !== item) {
-                return extract(original);
-            }
-            return item;
-        });
-    }
-    const obj = ObjectCreate(getPrototypeOf(objectOrArray));
-    const names = getOwnPropertyNames(objectOrArray);
-    return ArrayConcat.call(names, getOwnPropertySymbols(objectOrArray)).reduce((seed, key) => {
-        const item = objectOrArray[key];
-        const original = unwrap(item);
-        if (original !== item) {
-            seed[key] = extract(original);
+/*
+ * Copyright (c) 2024, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+const escapeAttrVal = (attrValue) => attrValue.replaceAll('&', '&amp;').replaceAll('"', '&quot;');
+function renderAttrsPrivate(instance, attrs, hostScopeToken, scopeToken) {
+    // The scopeToken is e.g. `lwc-xyz123` which is the token our parent gives us.
+    // The hostScopeToken is e.g. `lwc-abc456-host` which is the token for our own component.
+    // It's possible to have both, one, the other, or neither.
+    const combinedScopeToken = scopeToken && hostScopeToken
+        ? `${scopeToken} ${hostScopeToken}`
+        : scopeToken || hostScopeToken || '';
+    let result = '';
+    let hasClassAttribute = false;
+    for (const attrName of getOwnPropertyNames$1(attrs)) {
+        let attrValue = attrs[attrName];
+        if (isNull(attrValue) || isUndefined$1(attrValue)) {
+            attrValue = '';
         }
-        else {
-            seed[key] = item;
+        else if (!isString(attrValue)) {
+            attrValue = String(attrValue);
         }
-        return seed;
-    }, obj);
-}
-const formatter = {
-    header: (plainOrProxy) => {
-        const originalTarget = unwrap(plainOrProxy);
-        // if originalTarget is falsy or not unwrappable, exit
-        if (!originalTarget || originalTarget === plainOrProxy) {
-            return null;
+        if (attrName === 'class') {
+            if (attrValue === '') {
+                // If the class attribute is empty, we don't render it.
+                continue;
+            }
+            if (combinedScopeToken) {
+                attrValue += ' ' + combinedScopeToken;
+                hasClassAttribute = true;
+            }
         }
-        const obj = extract(plainOrProxy);
-        return ['object', { object: obj }];
-    },
-    hasBody: () => {
-        return false;
-    },
-    body: () => {
-        return null;
-    },
-};
-// Inspired from paulmillr/es6-shim
-// https://github.com/paulmillr/es6-shim/blob/master/es6-shim.js#L176-L185
-/* istanbul ignore next */
-function getGlobal() {
-    // the only reliable means to get the global object is `Function('return this')()`
-    // However, this causes CSP violations in Chrome apps.
-    if (typeof globalThis !== 'undefined') {
-        return globalThis;
-    }
-    if (typeof self !== 'undefined') {
-        return self;
-    }
-    if (typeof window !== 'undefined') {
-        return window;
-    }
-    if (typeof global !== 'undefined') {
-        return global;
-    }
-    // Gracefully degrade if not able to locate the global object
-    return {};
-}
-function init() {
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV === 'production') {
-        // this method should never leak to prod
-        throw new ReferenceError();
-    }
-    const global = getGlobal();
-    // Custom Formatter for Dev Tools. To enable this, open Chrome Dev Tools
-    //  - Go to Settings,
-    //  - Under console, select "Enable custom formatters"
-    // For more information, https://docs.google.com/document/d/1FTascZXT9cxfetuPRT2eXPQKXui4nWFivUnS_335T3U/preview
-    const devtoolsFormatters = global.devtoolsFormatters || [];
-    ArrayPush.call(devtoolsFormatters, formatter);
-    global.devtoolsFormatters = devtoolsFormatters;
-}
-
-/* istanbul ignore else */
-if (process.env.NODE_ENV !== 'production') {
-    init();
-}
-function defaultValueIsObservable(value) {
-    // intentionally checking for null
-    if (value === null) {
-        return false;
+        result += attrValue === '' ? ` ${attrName}` : ` ${attrName}="${escapeAttrVal(attrValue)}"`;
     }
-    // treat all non-object types, including undefined, as non-observable values
-    if (typeof value !== 'object') {
-        return false;
+    // If we didn't render any `class` attribute, render one for the scope token(s)
+    if (!hasClassAttribute && combinedScopeToken) {
+        result += ` class="${combinedScopeToken}"`;
     }
-    if (isArray(value)) {
-        return true;
+    // For the host scope token only, we encode a special attribute for hydration
+    if (hostScopeToken) {
+        result += ` data-lwc-host-scope-token="${hostScopeToken}"`;
     }
-    const proto = getPrototypeOf(value);
-    return proto === ObjectDotPrototype || proto === null || getPrototypeOf(proto) === null;
+    result += mutationTracker.renderMutatedAttrs(instance);
+    return result;
 }
-const defaultValueObserved = (obj, key) => {
-    /* do nothing */
-};
-const defaultValueMutated = (obj, key) => {
-    /* do nothing */
-};
-function createShadowTarget(value) {
-    return isArray(value) ? [] : {};
+function* renderAttrs(instance, attrs, hostScopeToken, scopeToken) {
+    yield renderAttrsPrivate(instance, attrs, hostScopeToken, scopeToken);
 }
-class ObservableMembrane {
-    constructor(options = {}) {
-        this.readOnlyObjectGraph = new WeakMap();
-        this.reactiveObjectGraph = new WeakMap();
-        const { valueMutated, valueObserved, valueIsObservable, tagPropertyKey } = options;
-        this.valueMutated = isFunction(valueMutated) ? valueMutated : defaultValueMutated;
-        this.valueObserved = isFunction(valueObserved) ? valueObserved : defaultValueObserved;
-        this.valueIsObservable = isFunction(valueIsObservable)
-            ? valueIsObservable
-            : defaultValueIsObservable;
-        this.tagPropertyKey = tagPropertyKey;
+function renderAttrsNoYield(emit, instance, attrs, hostScopeToken, scopeToken) {
+    emit(renderAttrsPrivate(instance, attrs, hostScopeToken, scopeToken));
+}
+function* fallbackTmpl(_props, _attrs, _shadowSlottedContent, _lightSlottedContent, Cmp, _instance) {
+    if (Cmp.renderMode !== 'light') {
+        yield '<template shadowrootmode="open"></template>';
     }
-    getProxy(value) {
-        const unwrappedValue = unwrap(value);
-        if (this.valueIsObservable(unwrappedValue)) {
-            // When trying to extract the writable version of a readonly we return the readonly.
-            if (this.readOnlyObjectGraph.get(unwrappedValue) === value) {
-                return value;
-            }
-            return this.getReactiveHandler(unwrappedValue);
-        }
-        return unwrappedValue;
+}
+function fallbackTmplNoYield(emit, _props, _attrs, _shadowSlottedContent, _lightSlottedContent, Cmp, _instance) {
+    if (Cmp.renderMode !== 'light') {
+        emit('<template shadowrootmode="open"></template>');
     }
-    getReadOnlyProxy(value) {
-        value = unwrap(value);
-        if (this.valueIsObservable(value)) {
-            return this.getReadOnlyHandler(value);
+}
+async function serverSideRenderComponent(tagName, Component, props = {}, mode = DEFAULT_SSR_MODE) {
+    if (typeof tagName !== 'string') {
+        throw new Error(`tagName must be a string, found: ${tagName}`);
+    }
+    const generateMarkup = Component[SYMBOL__GENERATE_MARKUP];
+    let markup = '';
+    const emit = (segment) => {
+        markup += segment;
+    };
+    if (mode === 'asyncYield') {
+        for await (const segment of generateMarkup(tagName, props, null, null, null, null, null, null)) {
+            markup += segment;
         }
-        return value;
     }
-    unwrapProxy(p) {
-        return unwrap(p);
+    else if (mode === 'async') {
+        await generateMarkup(emit, tagName, props, null, null, null, null, null, null);
     }
-    getReactiveHandler(value) {
-        let proxy = this.reactiveObjectGraph.get(value);
-        if (isUndefined(proxy)) {
-            // caching the proxy after the first time it is accessed
-            const handler = new ReactiveProxyHandler(this, value);
-            proxy = new Proxy(createShadowTarget(value), handler);
-            registerProxy(proxy, value);
-            this.reactiveObjectGraph.set(value, proxy);
-        }
-        return proxy;
+    else if (mode === 'sync') {
+        generateMarkup(emit, tagName, props, null, null, null, null, null, null);
     }
-    getReadOnlyHandler(value) {
-        let proxy = this.readOnlyObjectGraph.get(value);
-        if (isUndefined(proxy)) {
-            // caching the proxy after the first time it is accessed
-            const handler = new ReadOnlyHandler(this, value);
-            proxy = new Proxy(createShadowTarget(value), handler);
-            registerProxy(proxy, value);
-            this.readOnlyObjectGraph.set(value, proxy);
-        }
-        return proxy;
+    else {
+        throw new Error(`Invalid mode: ${mode}`);
     }
+    return markup;
 }
-/** version: 2.0.0 */
 
 /*
  * Copyright (c) 2024, Salesforce, Inc.
@@ -1796,12 +1609,143 @@ class ObservableMembrane {
  * SPDX-License-Identifier: MIT
  * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
  */
-const reactiveMembrane = new ObservableMembrane();
-// Modeled after `getReadOnlyProxy` in `membrane.ts` in `engine-core`
-// Return a proxy over the given object so that access is immutable
-// https://github.com/salesforce/lwc/blob/e9db491/packages/%40lwc/engine-core/src/framework/membrane.ts#L29-L33
-function getReadOnlyProxy(value) {
-    return reactiveMembrane.getReadOnlyProxy(value);
+/**
+ * Given an object, render it for use as a text content node.
+ * @param value
+ */
+function massageTextContent(value) {
+    // Using non strict equality to align with original implementation (ex. undefined == null)
+    // See: https://github.com/salesforce/lwc/blob/348130f/packages/%40lwc/engine-core/src/framework/api.ts#L548
+    return value == null ? '' : String(value);
+}
+
+/*
+ * Copyright (c) 2024, Salesforce, Inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+/**
+ * Per the HTML spec on restrictions for "raw text elements" like `<style>`:
+ *
+ * > The text in raw text and escapable raw text elements must not contain any occurrences of the string
+ * > "</" (U+003C LESS-THAN SIGN, U+002F SOLIDUS) followed by characters that case-insensitively match the tag name of
+ * > the element followed by one of:
+ * > - U+0009 CHARACTER TABULATION (tab)
+ * > - U+000A LINE FEED (LF)
+ * > - U+000C FORM FEED (FF)
+ * > - U+000D CARRIAGE RETURN (CR)
+ * > - U+0020 SPACE
+ * > - U+003E GREATER-THAN SIGN (>), or
+ * > - U+002F SOLIDUS (/)
+ * @see https://html.spec.whatwg.org/multipage/syntax.html#cdata-rcdata-restrictions
+ */
+const INVALID_STYLE_CONTENT = /<\/style[\t\n\f\r >/]/i;
+/**
+ * The text content inside `<style>` is a special case. It is _only_ rendered by the LWC engine itself; `<style>` tags
+ * are disallowed inside of HTML templates.
+ *
+ * The `<style>` tag is unusual in how it's defined in HTML. Like `<script>`, it is considered a "raw text element,"
+ * which means that it is parsed as raw text, but certain character sequences are disallowed, namely to avoid XSS
+ * attacks like `</style><script>alert("pwned")</script>`.
+ *
+ * This also means that we cannot use "normal" HTML escaping inside `<style>` tags, e.g. we cannot use `&lt;`,
+ * `&gt;`, etc., because these are treated as-is by the HTML parser.
+ *
+ *
+ * @param contents CSS source to validate
+ * @throws Throws if the contents provided are not valid.
+ * @see https://html.spec.whatwg.org/multipage/syntax.html#raw-text-elements
+ * @see https://github.com/salesforce/lwc/issues/3439
+ * @example
+ * validateStyleTextContents('div { color: red }') // Ok
+ * validateStyleTextContents('</style><script>alert("pwned")</script>') // Throws
+ */
+function validateStyleTextContents(contents) {
+    if (INVALID_STYLE_CONTENT.test(contents)) {
+        throw new Error('CSS contains unsafe characters and cannot be serialized inside a style element');
+    }
+}
+
+/*
+ * Copyright (c) 2024, Salesforce, Inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+// Traverse in the same order as `flattenStylesheets` but without creating unnecessary additional arrays
+function traverseStylesheets(stylesheets, callback) {
+    if (isArray$1(stylesheets)) {
+        for (let i = 0; i < stylesheets.length; i++) {
+            traverseStylesheets(stylesheets[i], callback);
+        }
+    }
+    else if (stylesheets) {
+        callback(stylesheets);
+    }
+}
+function hasScopedStaticStylesheets(Component) {
+    let scoped = false;
+    traverseStylesheets(Component.stylesheets, (stylesheet) => {
+        scoped ||= !!stylesheet.$scoped$;
+    });
+    return scoped;
+}
+function renderStylesheets(defaultStylesheets, defaultScopedStylesheets, staticStylesheets, scopeToken, Component, hasScopedTemplateStyles) {
+    const hasAnyScopedStyles = hasScopedTemplateStyles || hasScopedStaticStylesheets(Component);
+    const { renderMode } = Component;
+    let result = '';
+    const renderStylesheet = (stylesheet) => {
+        const { $scoped$: scoped } = stylesheet;
+        const token = scoped ? scopeToken : undefined;
+        const useActualHostSelector = !scoped || renderMode !== 'light';
+        const useNativeDirPseudoclass = true;
+        const styleContents = stylesheet(token, useActualHostSelector, useNativeDirPseudoclass);
+        validateStyleTextContents(styleContents);
+        // TODO [#2869]: `<style>`s should not have scope token classes
+        result += `<style${hasAnyScopedStyles ? ` class="${scopeToken}"` : ''} type="text/css">${styleContents}</style>`;
+    };
+    traverseStylesheets(defaultStylesheets, renderStylesheet);
+    traverseStylesheets(defaultScopedStylesheets, renderStylesheet);
+    traverseStylesheets(staticStylesheets, renderStylesheet);
+    return result;
+}
+
+/*
+ * Copyright (c) 2024, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+/**
+ * Converts an iterable into one that emits the object used by the [`iterator` directive](
+ * https://lwc.dev/guide/html_templates#iterator).
+ */
+function* toIteratorDirective(iterable) {
+    if (iterable === undefined || iterable === null)
+        return;
+    if (!iterable[Symbol.iterator]) {
+        throw new Error(
+        // Mimic error message from "[i]terable node" in engine-core's api.ts
+        `Invalid template iteration for value \`${iterable}\`. It must be an array-like object.`);
+    }
+    const iterator = iterable[Symbol.iterator]();
+    let next = iterator.next();
+    let index = 0;
+    let { value, done: last = false } = next;
+    while (last === false) {
+        // using a look-back approach because we need to know if the element is the last
+        next = iterator.next();
+        last = next.done ?? false;
+        yield {
+            value,
+            index,
+            first: index === 0,
+            last,
+        };
+        index += 1;
+        value = next.value;
+    }
 }
 
 /*
@@ -1881,7 +1825,9 @@ exports.hasScopedStaticStylesheets = hasScopedStaticStylesheets;
 exports.hot = hot;
 exports.htmlEscape = htmlEscape;
 exports.isComponentConstructor = isComponentConstructor;
+exports.massageTextContent = massageTextContent;
 exports.mutationTracker = mutationTracker;
+exports.normalizeClass = normalizeClass;
 exports.parseFragment = parseFragment;
 exports.parseSVGFragment = parseSVGFragment;
 exports.readonly = readonly;
@@ -1906,5 +1852,5 @@ exports.track = track;
 exports.unwrap = unwrap$1;
 exports.validateStyleTextContents = validateStyleTextContents;
 exports.wire = wire;
-/** version: 8.11.0 */
+/** version: 8.12.1 */
 //# sourceMappingURL=index.cjs.js.map