@lwc/ssr-runtime 8.7.0 → 8.8.0

package/dist/index.cjs.js

@@ -15,9 +15,6 @@ Object.defineProperty(exports, '__esModule', { value: true });
 function api(..._) {
     throw new Error('@api cannot be used in SSR context.');
 }
-function createContextProvider(..._) {
-    throw new Error('createContextProvider cannot be used in SSR context.');
-}
 function createElement(..._) {
     throw new Error('createElement cannot be used in SSR context.');
 }
@@ -69,7 +66,7 @@ function swapTemplate(..._) {
 function track(..._) {
     throw new Error('@track cannot be used in SSR context.');
 }
-function unwrap(..._) {
+function unwrap$1(..._) {
     throw new Error('unwrap cannot be used in SSR context.');
 }
 function wire(..._) {
@@ -270,17 +267,17 @@ freeze,
 /** Detached {@linkcode Object.fromEntries}; see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/fromEntries MDN Reference}. */
 fromEntries, 
 /** Detached {@linkcode Object.getOwnPropertyDescriptor}; see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyDescriptor MDN Reference}. */
-getOwnPropertyDescriptor, 
+getOwnPropertyDescriptor: getOwnPropertyDescriptor$1, 
 /** Detached {@linkcode Object.getOwnPropertyDescriptors}; see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyDescriptors MDN Reference}. */
 getOwnPropertyDescriptors, 
 /** Detached {@linkcode Object.getOwnPropertyNames}; see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyNames MDN Reference}. */
-getOwnPropertyNames, 
+getOwnPropertyNames: getOwnPropertyNames$1, 
 /** Detached {@linkcode Object.getOwnPropertySymbols}; see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertySymbols MDN Reference}. */
-getOwnPropertySymbols, 
+getOwnPropertySymbols: getOwnPropertySymbols$1, 
 /** Detached {@linkcode Object.getPrototypeOf}; see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getPrototypeOf MDN Reference}. */
-getPrototypeOf, 
+getPrototypeOf: getPrototypeOf$1, 
 /** Detached {@linkcode Object.hasOwnProperty}; see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwnProperty MDN Reference}. */
-hasOwnProperty, 
+hasOwnProperty: hasOwnProperty$1, 
 /** Detached {@linkcode Object.isFrozen}; see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/isFrozen MDN Reference}. */
 isFrozen, 
 /** Detached {@linkcode Object.keys}; see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys MDN Reference}. */
@@ -291,13 +288,13 @@ seal,
 setPrototypeOf, } = Object;
 const { 
 /** Detached {@linkcode Array.isArray}; see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray MDN Reference}. */
-isArray, 
+isArray: isArray$1, 
 /** Detached {@linkcode Array.from}; see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from MDN Reference}. */
 from: ArrayFrom, } = Array;
 // For some reason, JSDoc don't get picked up for multiple renamed destructured constants (even
 // though it works fine for one, e.g. isArray), so comments for these are added to the export
 // statement, rather than this declaration.
-const { concat: ArrayConcat, copyWithin: ArrayCopyWithin, every: ArrayEvery, fill: ArrayFill, filter: ArrayFilter, find: ArrayFind, findIndex: ArrayFindIndex, includes: ArrayIncludes, indexOf: ArrayIndexOf, join: ArrayJoin, map: ArrayMap, pop: ArrayPop, push: ArrayPush, reduce: ArrayReduce, reverse: ArrayReverse, shift: ArrayShift, slice: ArraySlice, some: ArraySome, sort: ArraySort, splice: ArraySplice, unshift: ArrayUnshift, forEach, // Weird anomaly!
+const { concat: ArrayConcat$1, copyWithin: ArrayCopyWithin, every: ArrayEvery, fill: ArrayFill, filter: ArrayFilter, find: ArrayFind, findIndex: ArrayFindIndex, includes: ArrayIncludes, indexOf: ArrayIndexOf, join: ArrayJoin, map: ArrayMap, pop: ArrayPop, push: ArrayPush$1, reduce: ArrayReduce, reverse: ArrayReverse, shift: ArrayShift, slice: ArraySlice, some: ArraySome, sort: ArraySort, splice: ArraySplice, unshift: ArrayUnshift, forEach, // Weird anomaly!
  } = Array.prototype;
 /** Detached {@linkcode String.fromCharCode}; see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fromCharCode MDN Reference}. */
 const { fromCharCode: StringFromCharCode } = String;
@@ -308,7 +305,7 @@ const { charAt: StringCharAt, charCodeAt: StringCharCodeAt, replace: StringRepla
  * @param obj Value to test
  * @returns `true` if the value is `undefined`.
  */
-function isUndefined(obj) {
+function isUndefined$1(obj) {
     return obj === undefined;
 }
 /**
@@ -320,26 +317,26 @@ function isNull(obj) {
     return obj === null;
 }
 /**
- * Determines whether the argument is an object or null.
+ * Determines whether the argument is a string.
  * @param obj Value to test
- * @returns `true` if the value is an object or null.
+ * @returns `true` if the value is a string.
  */
-function isObject(obj) {
-    return typeof obj === 'object';
+function isString(obj) {
+    return typeof obj === 'string';
 }
-const OtS = {}.toString;
+const OtS$1 = {}.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(obj) {
+function toString$1(obj) {
     if (obj?.toString) {
         // Arrays might hold objects with "null" prototype So using
         // Array.prototype.toString directly will cause an error Iterate through
         // all the items and handle individually.
-        if (isArray(obj)) {
+        if (isArray$1(obj)) {
             // This behavior is slightly different from Array#toString:
             // 1. Array#toString calls `this.join`, rather than Array#join
             // Ex: arr = []; arr.join = () => 1; arr.toString() === 1; toString(arr) === ''
@@ -350,13 +347,13 @@ function toString(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), ',');
+            return ArrayJoin.call(ArrayMap.call(obj, toString$1), ',');
         }
         return obj.toString();
     }
     else if (typeof obj === 'object') {
         // This catches null and returns "[object Null]". Weird, but kept for backwards compatibility.
-        return OtS.call(obj);
+        return OtS$1.call(obj);
     }
     else {
         return String(obj);
@@ -523,15 +520,15 @@ const CACHED_PROPERTY_ATTRIBUTE_MAPPING = /*@__PURE__@*/ new Map();
  */
 function htmlPropertyToAttribute(propName) {
     const ariaAttributeName = AriaPropNameToAttrNameMap[propName];
-    if (!isUndefined(ariaAttributeName)) {
+    if (!isUndefined$1(ariaAttributeName)) {
         return ariaAttributeName;
     }
     const specialAttributeName = SPECIAL_PROPERTY_ATTRIBUTE_MAPPING.get(propName);
-    if (!isUndefined(specialAttributeName)) {
+    if (!isUndefined$1(specialAttributeName)) {
         return specialAttributeName;
     }
     const cachedAttributeName = CACHED_PROPERTY_ATTRIBUTE_MAPPING.get(propName);
-    if (!isUndefined(cachedAttributeName)) {
+    if (!isUndefined$1(cachedAttributeName)) {
         return cachedAttributeName;
     }
     let attributeName = '';
@@ -598,7 +595,7 @@ function setHooks(hooks) {
 function flattenStylesheets(stylesheets) {
     const list = [];
     for (const stylesheet of stylesheets) {
-        if (!isArray(stylesheet)) {
+        if (!isArray$1(stylesheet)) {
             list.push(stylesheet);
         }
         else {
@@ -607,7 +604,7 @@ function flattenStylesheets(stylesheets) {
     }
     return list;
 }
-/** version: 8.7.0 */
+/** version: 8.8.0 */
 
 /*
  * Copyright (c) 2024, Salesforce, Inc.
@@ -862,7 +859,7 @@ const ariaDescriptor = (attrName) => ({
                 this.removeAttribute(attrName);
             }
             else {
-                this.setAttribute(attrName, toString(newValue));
+                this.setAttribute(attrName, toString$1(newValue));
             }
         }
     },
@@ -886,7 +883,7 @@ const descriptors = {
             const num = Number(newValue);
             const normalizedValue = isFinite(num) ? String(Math.trunc(num)) : '0';
             if (normalizedValue !== currentValue) {
-                this.setAttribute('tabindex', toString(newValue));
+                this.setAttribute('tabindex', toString$1(newValue));
             }
         },
     },
@@ -935,24 +932,24 @@ class LightningElement {
         return (__classPrivateFieldSet(this, _LightningElement_classList, new ClassList(this), "f"));
     }
     setAttribute(attrName, attrValue) {
-        const normalizedName = StringToLowerCase.call(toString(attrName));
+        const normalizedName = StringToLowerCase.call(toString$1(attrName));
         const normalizedValue = String(attrValue);
         __classPrivateFieldGet(this, _LightningElement_attrs, "f")[normalizedName] = normalizedValue;
         mutationTracker.add(this, normalizedName);
     }
     getAttribute(attrName) {
-        const normalizedName = StringToLowerCase.call(toString(attrName));
-        if (hasOwnProperty.call(__classPrivateFieldGet(this, _LightningElement_attrs, "f"), normalizedName)) {
+        const normalizedName = StringToLowerCase.call(toString$1(attrName));
+        if (hasOwnProperty$1.call(__classPrivateFieldGet(this, _LightningElement_attrs, "f"), normalizedName)) {
             return __classPrivateFieldGet(this, _LightningElement_attrs, "f")[normalizedName];
         }
         return null;
     }
     hasAttribute(attrName) {
-        const normalizedName = StringToLowerCase.call(toString(attrName));
-        return hasOwnProperty.call(__classPrivateFieldGet(this, _LightningElement_attrs, "f"), normalizedName);
+        const normalizedName = StringToLowerCase.call(toString$1(attrName));
+        return hasOwnProperty$1.call(__classPrivateFieldGet(this, _LightningElement_attrs, "f"), normalizedName);
     }
     removeAttribute(attrName) {
-        const normalizedName = StringToLowerCase.call(toString(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);
@@ -1039,36 +1036,42 @@ defineProperties(LightningElement.prototype, descriptors);
  * SPDX-License-Identifier: MIT
  * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
  */
-const escapeAttrVal = (attrVal) => attrVal.replaceAll('&', '&').replaceAll('"', '"');
-function* renderAttrs(instance, attrs) {
-    if (!attrs) {
-        return;
-    }
-    for (const attrName of Object.getOwnPropertyNames(attrs)) {
-        const attrVal = attrs[attrName];
-        if (typeof attrVal === 'string') {
-            yield attrVal === '' ? ` ${attrName}` : ` ${attrName}="${escapeAttrVal(attrVal)}"`;
+const escapeAttrVal = (attrValue) => attrValue.replaceAll('&', '&').replaceAll('"', '"');
+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 (attrVal === null) {
-            yield '';
+        else if (!isString(attrValue)) {
+            attrValue = String(attrValue);
         }
-    }
-    yield mutationTracker.renderMutatedAttrs(instance);
-}
-function renderAttrsNoYield(emit, instance, attrs) {
-    if (!attrs) {
-        return;
-    }
-    for (const attrName of Object.getOwnPropertyNames(attrs)) {
-        const attrVal = attrs[attrName];
-        if (typeof attrVal === 'string') {
-            emit(attrVal === '' ? ` ${attrName}` : ` ${attrName}="${escapeAttrVal(attrVal)}"`);
-        }
-        else if (attrVal === null) {
-            emit('');
+        if (combinedScopeToken && attrName === 'class') {
+            attrValue += ' ' + combinedScopeToken;
+            hasClassAttribute = true;
         }
+        result += attrValue === '' ? ` ${attrName}` : ` ${attrName}="${escapeAttrVal(attrValue)}"`;
     }
-    emit(mutationTracker.renderMutatedAttrs(instance));
+    // If we didn't render any `class` attribute, render one for the scope token(s)
+    if (!hasClassAttribute && combinedScopeToken) {
+        result += ` class="${combinedScopeToken}"`;
+    }
+    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));
 }
 function* fallbackTmpl(_props, _attrs, _slotted, Cmp, _instance) {
     if (Cmp.renderMode !== 'light') {
@@ -1222,52 +1225,637 @@ function* toIteratorDirective(iterable) {
     }
 }
 
+/**
+ * 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 + '';
+    }
+}
+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;
+    }
+    // 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);
+            }
+        }
+        return descriptor;
+    }
+    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);
+        }
+    }
+    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);
+    }
+    // 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
+        }
+        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);
+    }
+}
+
+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;
+        }
+        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;
+        }
+        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 {
+            const { set, get } = descriptor;
+            if (!isUndefined(get)) {
+                descriptor.get = this.unwrapGetter(get);
+            }
+            if (!isUndefined(set)) {
+                descriptor.set = this.unwrapSetter(set);
+            }
+        }
+        return descriptor;
+    }
+    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;
+    }
+    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;
+    }
+    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;
+    }
+    deleteProperty(shadowTarget, key) {
+        const { originalTarget, membrane: { valueMutated }, } = this;
+        delete originalTarget[key];
+        valueMutated(originalTarget, key);
+        return true;
+    }
+    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.`);
+        }
+    }
+    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;
+    }
+    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;
+    }
+}
+
+const getterMap = new WeakMap();
+const setterMap = new WeakMap();
+class ReadOnlyHandler extends BaseProxyHandler {
+    wrapValue(value) {
+        return this.membrane.getReadOnlyProxy(value);
+    }
+    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;
+    }
+    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;
+    }
+    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;
+    }
+    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;
+    }
+    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.`);
+        }
+    }
+    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;
+    }
+    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;
+    }
+}
+
+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);
+        }
+        else {
+            seed[key] = item;
+        }
+        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;
+        }
+        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;
+    }
+    // treat all non-object types, including undefined, as non-observable values
+    if (typeof value !== 'object') {
+        return false;
+    }
+    if (isArray(value)) {
+        return true;
+    }
+    const proto = getPrototypeOf(value);
+    return proto === ObjectDotPrototype || proto === null || getPrototypeOf(proto) === null;
+}
+const defaultValueObserved = (obj, key) => {
+    /* do nothing */
+};
+const defaultValueMutated = (obj, key) => {
+    /* do nothing */
+};
+function createShadowTarget(value) {
+    return isArray(value) ? [] : {};
+}
+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;
+    }
+    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;
+    }
+    getReadOnlyProxy(value) {
+        value = unwrap(value);
+        if (this.valueIsObservable(value)) {
+            return this.getReadOnlyHandler(value);
+        }
+        return value;
+    }
+    unwrapProxy(p) {
+        return unwrap(p);
+    }
+    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;
+    }
+    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;
+    }
+}
+/** version: 2.0.0 */
+
 /*
  * 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
  */
-// Deep freeze and clone an object. Designed for cloning/freezing child props when passed from a parent to a child so
-// that they are immutable. This is one of the normal guarantees of both engine-dom and engine-server that we want to
-// emulate in ssr-runtime. The goal here is that a child cannot mutate the props of its parent and thus affect
-// the parent's rendering, which would lead to bidirectional reactivity and mischief.
-function cloneAndDeepFreeze(obj) {
-    if (isArray(obj)) {
-        const res = [];
-        for (const item of obj) {
-            ArrayPush.call(res, cloneAndDeepFreeze(item));
-        }
-        freeze(res);
-        return res;
+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) 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 contextfulRelationships = new WeakMap();
+function establishContextfulRelationship(parentLe, childLe) {
+    contextfulRelationships.set(childLe, parentLe);
+}
+function getContextfulStack(le) {
+    const contextfulParent = contextfulRelationships.get(le);
+    if (!contextfulParent) {
+        return [];
     }
-    else if (isObject(obj) && !isNull(obj)) {
-        const res = create(null);
-        for (const [key, value] of entries(obj)) {
-            res[key] = cloneAndDeepFreeze(value);
-        }
-        freeze(res);
-        return res;
+    return [contextfulParent, ...getContextfulStack(contextfulParent)];
+}
+const contextProviders = new WeakMap();
+function registerContextProvider(adapter, attachedLe, consumerCallback) {
+    let elementMap = contextProviders.get(adapter);
+    if (!elementMap) {
+        elementMap = new WeakMap();
+        contextProviders.set(adapter, elementMap);
+    }
+    elementMap.set(attachedLe, consumerCallback);
+}
+function connectContext(adapter, contextConsumer, onNewValue) {
+    const elementMap = contextProviders.get(adapter);
+    if (!elementMap) {
+        return;
     }
-    else {
-        // primitive
-        return obj;
+    const contextfulStack = getContextfulStack(contextConsumer);
+    for (const ancestor of contextfulStack) {
+        const onConsumerConnected = elementMap.get(ancestor);
+        if (onConsumerConnected) {
+            onConsumerConnected({
+                provide(newContextValue) {
+                    onNewValue(newContextValue);
+                },
+            });
+            return;
+        }
     }
 }
+function createContextProvider(adapter) {
+    return (le, options) => {
+        if (!(le instanceof LightningElement)) {
+            throw new Error('Unable to register context provider on provided `elm`.');
+        }
+        if (!le.isConnected || !options?.consumerConnectedCallback) {
+            return;
+        }
+        const { consumerConnectedCallback } = options;
+        registerContextProvider(adapter, le, (consumer) => consumerConnectedCallback(consumer));
+    };
+}
 
 exports.ClassList = ClassList;
 exports.LightningElement = LightningElement;
 exports.SYMBOL__GENERATE_MARKUP = SYMBOL__GENERATE_MARKUP;
 exports.SYMBOL__SET_INTERNALS = SYMBOL__SET_INTERNALS;
 exports.api = api;
-exports.cloneAndDeepFreeze = cloneAndDeepFreeze;
+exports.connectContext = connectContext;
 exports.createContextProvider = createContextProvider;
 exports.createElement = createElement;
+exports.establishContextfulRelationship = establishContextfulRelationship;
 exports.fallbackTmpl = fallbackTmpl;
 exports.fallbackTmplNoYield = fallbackTmplNoYield;
 exports.filterProperties = filterProperties;
 exports.freezeTemplate = freezeTemplate;
 exports.getComponentDef = getComponentDef;
+exports.getReadOnlyProxy = getReadOnlyProxy;
 exports.hasScopedStaticStylesheets = hasScopedStaticStylesheets;
 exports.hot = hot;
 exports.htmlEscape = htmlEscape;
@@ -1294,8 +1882,8 @@ exports.swapStyle = swapStyle;
 exports.swapTemplate = swapTemplate;
 exports.toIteratorDirective = toIteratorDirective;
 exports.track = track;
-exports.unwrap = unwrap;
+exports.unwrap = unwrap$1;
 exports.validateStyleTextContents = validateStyleTextContents;
 exports.wire = wire;
-/** version: 8.7.0 */
+/** version: 8.8.0 */
 //# sourceMappingURL=index.cjs.js.map