@lwc/ssr-runtime 8.6.0 → 8.8.0

package/dist/index.js

@@ -11,9 +11,6 @@
 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.');
 }
@@ -65,7 +62,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(..._) {
@@ -266,17 +263,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}. */
@@ -287,16 +284,26 @@ 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;
 // No JSDocs here - see comment for Array.prototype
 const { charAt: StringCharAt, charCodeAt: StringCharCodeAt, replace: StringReplace, split: StringSplit, slice: StringSlice, toLowerCase: StringToLowerCase, trim: StringTrim, } = String.prototype;
+/**
+ * Determines whether the argument is `undefined`.
+ * @param obj Value to test
+ * @returns `true` if the value is `undefined`.
+ */
+function isUndefined$1(obj) {
+    return obj === undefined;
+}
 /**
  * Determines whether the argument is `null`.
  * @param obj Value to test
@@ -305,19 +312,27 @@ const { charAt: StringCharAt, charCodeAt: StringCharCodeAt, replace: StringRepla
 function isNull(obj) {
     return obj === null;
 }
-const OtS = {}.toString;
+/**
+ * Determines whether the argument is a string.
+ * @param obj Value to test
+ * @returns `true` if the value is a string.
+ */
+function isString(obj) {
+    return typeof obj === 'string';
+}
+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) === ''
@@ -328,13 +343,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);
@@ -419,11 +434,114 @@ const { AriaAttrNameToPropNameMap, AriaPropNameToAttrNameMap } = /*@__PURE__*/ (
     // Synthetic creation of all AOM property descriptors for Custom Elements
     forEach.call(AriaPropertyNames, (propName) => {
         const attrName = StringToLowerCase.call(StringReplace.call(propName, /^aria/, () => 'aria-'));
+        // These type assertions are because the map types are a 1:1 mapping of ariaX to aria-x.
+        // TypeScript knows we have one of ariaX | ariaY and one of aria-x | aria-y, and tries to
+        // prevent us from doing ariaX: aria-y, but we that it's safe.
         AriaAttrNameToPropNameMap[attrName] = propName;
         AriaPropNameToAttrNameMap[propName] = attrName;
     });
     return { AriaAttrNameToPropNameMap, AriaPropNameToAttrNameMap };
 })();
+/**
+ *
+ * @param attrName
+ */
+function isAriaAttribute(attrName) {
+    return attrName in AriaAttrNameToPropNameMap;
+}
+// This list is based on https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes
+const GLOBAL_ATTRIBUTE = /*@__PURE__*/ new Set([
+    'accesskey',
+    'autocapitalize',
+    'autofocus',
+    'class',
+    'contenteditable',
+    'contextmenu',
+    'dir',
+    'draggable',
+    'enterkeyhint',
+    'exportparts',
+    'hidden',
+    'id',
+    'inputmode',
+    'is',
+    'itemid',
+    'itemprop',
+    'itemref',
+    'itemscope',
+    'itemtype',
+    'lang',
+    'nonce',
+    'part',
+    'slot',
+    'spellcheck',
+    'style',
+    'tabindex',
+    'title',
+    'translate',
+]);
+/**
+ *
+ * @param attrName
+ */
+function isGlobalHtmlAttribute(attrName) {
+    return GLOBAL_ATTRIBUTE.has(attrName);
+}
+// These are HTML standard prop/attribute IDL mappings, but are not predictable based on camel/kebab-case conversion
+const SPECIAL_PROPERTY_ATTRIBUTE_MAPPING = /*@__PURE__@*/ new Map([
+    ['accessKey', 'accesskey'],
+    ['readOnly', 'readonly'],
+    ['tabIndex', 'tabindex'],
+    ['bgColor', 'bgcolor'],
+    ['colSpan', 'colspan'],
+    ['rowSpan', 'rowspan'],
+    ['contentEditable', 'contenteditable'],
+    ['crossOrigin', 'crossorigin'],
+    ['dateTime', 'datetime'],
+    ['formAction', 'formaction'],
+    ['isMap', 'ismap'],
+    ['maxLength', 'maxlength'],
+    ['minLength', 'minlength'],
+    ['noValidate', 'novalidate'],
+    ['useMap', 'usemap'],
+    ['htmlFor', 'for'],
+]);
+/**
+ * Map associating previously transformed HTML property into HTML attribute.
+ */
+const CACHED_PROPERTY_ATTRIBUTE_MAPPING = /*@__PURE__@*/ new Map();
+/**
+ *
+ * @param propName
+ */
+function htmlPropertyToAttribute(propName) {
+    const ariaAttributeName = AriaPropNameToAttrNameMap[propName];
+    if (!isUndefined$1(ariaAttributeName)) {
+        return ariaAttributeName;
+    }
+    const specialAttributeName = SPECIAL_PROPERTY_ATTRIBUTE_MAPPING.get(propName);
+    if (!isUndefined$1(specialAttributeName)) {
+        return specialAttributeName;
+    }
+    const cachedAttributeName = CACHED_PROPERTY_ATTRIBUTE_MAPPING.get(propName);
+    if (!isUndefined$1(cachedAttributeName)) {
+        return cachedAttributeName;
+    }
+    let attributeName = '';
+    for (let i = 0, len = propName.length; i < len; i++) {
+        const code = StringCharCodeAt.call(propName, i);
+        if (code >= 65 && // "A"
+            code <= 90 // "Z"
+        ) {
+            attributeName += '-' + StringFromCharCode(code + 32);
+        }
+        else {
+            attributeName += StringFromCharCode(code);
+        }
+    }
+    CACHED_PROPERTY_ATTRIBUTE_MAPPING.set(propName, attributeName);
+    return attributeName;
+}
 
 /*
  * Copyright (c) 2020, salesforce.com, inc.
@@ -473,7 +591,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 {
@@ -482,7 +600,7 @@ function flattenStylesheets(stylesheets) {
     }
     return list;
 }
-/** version: 8.6.0 */
+/** version: 8.8.0 */
 
 /*
  * Copyright (c) 2024, Salesforce, Inc.
@@ -643,21 +761,25 @@ const mutationTracker = new MutationTracker();
  * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
  */
 /**
- * Map of global attribute or ARIA attribute to the corresponding property name.
- * Not all global attributes are included, just those from `HTMLElementTheGoodParts`.
+ * 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.
  */
-const attrsToProps = assign(create(null), {
-    accesskey: 'accessKey',
-    dir: 'dir',
-    draggable: 'draggable',
-    hidden: 'hidden',
-    id: 'id',
-    lang: 'lang',
-    spellcheck: 'spellcheck',
-    tabindex: 'tabIndex',
-    title: 'title',
-    ...AriaAttrNameToPropNameMap,
-});
+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 propsToAssign;
+}
 /**
  * Descriptor for IDL attribute reflections that merely reflect the string, e.g. `title`.
  */
@@ -733,21 +855,11 @@ const ariaDescriptor = (attrName) => ({
                 this.removeAttribute(attrName);
             }
             else {
-                this.setAttribute(attrName, toString(newValue));
+                this.setAttribute(attrName, toString$1(newValue));
             }
         }
     },
 });
-function reflectAttrToProp(instance, attrName, attrValue) {
-    const reflectedPropName = attrsToProps[attrName];
-    // If it is a reflected property and it was not overridden by the instance
-    if (reflectedPropName && !hasOwnProperty.call(instance, reflectedPropName)) {
-        const currentValue = instance[reflectedPropName];
-        if (currentValue !== attrValue) {
-            instance[reflectedPropName] = attrValue;
-        }
-    }
-}
 const descriptors = {
     accessKey: stringDescriptor('accesskey'),
     dir: stringDescriptor('dir'),
@@ -767,7 +879,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));
             }
         },
     },
@@ -816,27 +928,25 @@ 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;
-        reflectAttrToProp(this, 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];
-        reflectAttrToProp(this, normalizedName, null);
         // Track mutations for removal of non-existing attributes
         mutationTracker.add(this, normalizedName);
     }
@@ -922,36 +1032,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('&', '&amp;').replaceAll('"', '&quot;');
-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('&', '&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 (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)}"`;
+    }
+    // If we didn't render any `class` attribute, render one for the scope token(s)
+    if (!hasClassAttribute && combinedScopeToken) {
+        result += ` class="${combinedScopeToken}"`;
     }
-    emit(mutationTracker.renderMutatedAttrs(instance));
+    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') {
@@ -1105,6 +1221,622 @@ function* toIteratorDirective(iterable) {
     }
 }
 
-export { ClassList, LightningElement, SYMBOL__GENERATE_MARKUP, SYMBOL__SET_INTERNALS, api, createContextProvider, createElement, fallbackTmpl, fallbackTmplNoYield, freezeTemplate, getComponentDef, hasScopedStaticStylesheets, hot, htmlEscape, isComponentConstructor, mutationTracker, parseFragment, parseSVGFragment, readonly, registerComponent, registerDecorators, registerTemplate, renderAttrs, renderAttrsNoYield, serverSideRenderComponent as renderComponent, renderStylesheets, renderer, sanitizeAttribute, sanitizeHtmlContent, serverSideRenderComponent, setFeatureFlag, setFeatureFlagForTest, setHooks, swapComponent, swapStyle, swapTemplate, toIteratorDirective, track, unwrap, validateStyleTextContents, wire };
-/** version: 8.6.0 */
+/**
+ * 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
+ */
+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 [];
+    }
+    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;
+    }
+    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));
+    };
+}
+
+export { ClassList, LightningElement, SYMBOL__GENERATE_MARKUP, SYMBOL__SET_INTERNALS, api, connectContext, createContextProvider, createElement, establishContextfulRelationship, fallbackTmpl, fallbackTmplNoYield, filterProperties, freezeTemplate, getComponentDef, getReadOnlyProxy, hasScopedStaticStylesheets, hot, htmlEscape, isComponentConstructor, mutationTracker, parseFragment, parseSVGFragment, readonly, registerComponent, registerDecorators, registerTemplate, renderAttrs, renderAttrsNoYield, serverSideRenderComponent as renderComponent, renderStylesheets, renderer, sanitizeAttribute, sanitizeHtmlContent, serverSideRenderComponent, setFeatureFlag, setFeatureFlagForTest, setHooks, swapComponent, swapStyle, swapTemplate, toIteratorDirective, track, unwrap$1 as unwrap, validateStyleTextContents, wire };
+/** version: 8.8.0 */
 //# sourceMappingURL=index.js.map