@lwrjs/everywhere 0.13.0-alpha.0 → 0.13.0-alpha.10

package/build/__generated_site_amd_modules__/1/module/amd/1/l/en-US/mi/lwc/v/{6_3_4/s/5c26ade60a97bb24c64d3829320b13f6 → 6_6_3/s/58be00f9ece0d8c0a817bddb6ae6b439}/lwc.js

@@ -1,4 +1,4 @@
-LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
+LWR.define('lwc/v/6_6_3', ['exports'], (function (exports) { 'use strict';
 
   /**
    * Copyright (c) 2024 Salesforce, Inc.
@@ -148,6 +148,7 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
   } = String;
   // No JSDocs here - see comment for Array.prototype
   const {
+    charAt: StringCharAt,
     charCodeAt: StringCharCodeAt,
     replace: StringReplace,
     split: StringSplit,
@@ -291,7 +292,8 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
   // These must be updated when the enum is updated.
   // It's a bit annoying to do have to do this manually, but this makes the file tree-shakeable,
   // passing the `verify-treeshakeable.js` test.
-  const LOWEST_API_VERSION = 58 /* APIVersion.V58_244_SUMMER_23 */;
+  const allVersions = [58 /* APIVersion.V58_244_SUMMER_23 */, 59 /* APIVersion.V59_246_WINTER_24 */, 60 /* APIVersion.V60_248_SPRING_24 */, 61 /* APIVersion.V61_250_SUMMER_24 */, 62 /* APIVersion.V62_252_WINTER_25 */];
+  const LOWEST_API_VERSION = allVersions[0];
   /**
    *
    * @param apiVersionFeature
@@ -440,9 +442,9 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
    * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
    */
   // Increment whenever the LWC template compiler changes
-  const LWC_VERSION = "6.3.4";
+  const LWC_VERSION = "6.6.3";
   const LWC_VERSION_COMMENT_REGEX = /\/\*LWC compiler v([\d.]+)\*\/\s*}/;
-  /** version: 6.3.4 */
+  /** version: 6.6.3 */
 
   /**
    * Copyright (c) 2024 Salesforce, Inc.
@@ -528,7 +530,7 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
       setFeatureFlag(name, value);
     }
   }
-  /** version: 6.3.4 */
+  /** version: 6.6.3 */
 
   /**
    * Copyright (c) 2024 Salesforce, Inc.
@@ -783,15 +785,17 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
       if (len > 0) {
         for (let i = 0; i < len; i++) {
           const set = listeners[i];
-          if (set.length === 1) {
-            // Perf optimization for the common case - the length is usually 1, so avoid the indexOf+splice.
-            // If the length is 1, we can also be sure that `this` is the first item in the array.
-            set.length = 0;
-          } else {
-            // Slow case
-            const pos = ArrayIndexOf.call(set, this);
-            ArraySplice.call(set, pos, 1);
+          const setLength = set.length;
+          // The length is usually 1, so avoid doing an indexOf when we know for certain
+          // that `this` is the first item in the array.
+          if (setLength > 1) {
+            // Swap with the last item before removal.
+            // (Avoiding splice here is a perf optimization, and the order doesn't matter.)
+            const index = ArrayIndexOf.call(set, this);
+            set[index] = set[setLength - 1];
           }
+          // Remove the last item
+          ArrayPop.call(set);
         }
         listeners.length = 0;
       }
@@ -1718,7 +1722,7 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
       valueMutated(originalTarget, key);
       return true;
     }
-    /*LWC compiler v6.3.4*/
+    /*LWC compiler v6.6.3*/
   }
   const getterMap = new WeakMap();
   const setterMap = new WeakMap();
@@ -1811,7 +1815,7 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
       /* istanbul ignore next */
       return false;
     }
-    /*LWC compiler v6.3.4*/
+    /*LWC compiler v6.6.3*/
   }
   function extract(objectOrArray) {
     if (isArray(objectOrArray)) {
@@ -2739,7 +2743,7 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
   }
 
   /*
-   * Copyright (c) 2023, salesforce.com, inc.
+   * 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
@@ -3428,7 +3432,7 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
   }
 
   /*
-   * Copyright (c) 2018, salesforce.com, inc.
+   * 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
@@ -3518,7 +3522,7 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
   }
   function HTMLBridgeElementFactory(SuperClass, publicProperties, methods, observedFields, proto, hasCustomSuperClass) {
     const HTMLBridgeElement = class extends SuperClass {
-      /*LWC compiler v6.3.4*/
+      /*LWC compiler v6.6.3*/
     };
     // generating the hash table for attributes to avoid duplicate fields and facilitate validation
     // and false positives in case of inheritance.
@@ -3630,125 +3634,448 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
   seal(BaseBridgeElement.prototype);
 
   /*
-   * Copyright (c) 2023, salesforce.com, inc.
+   * Copyright (c) 2018, 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 supportsWeakRefs = typeof WeakRef === 'function' && typeof FinalizationRegistry === 'function';
-  // In browsers that doesn't support WeakRefs, the values will still leak, but at least the keys won't
-  class LegacyWeakMultiMap {
-    constructor() {
-      this._map = new WeakMap();
+  // These are only used for HMR in dev mode
+  // The "pure" annotations are so that Rollup knows for sure it can remove these from prod mode
+  let stylesheetsToCssContent = /*@__PURE__@*/new WeakMap();
+  let cssContentToAbortControllers = /*@__PURE__@*/new Map();
+  // Only used in LWC's Karma tests
+  if (process.env.NODE_ENV === 'test-karma-lwc') {
+    // Used to reset the global state between test runs
+    window.__lwcResetStylesheetCache = () => {
+      stylesheetsToCssContent = new WeakMap();
+      cssContentToAbortControllers = new Map();
+    };
+  }
+  function linkStylesheetToCssContentInDevMode(stylesheet, cssContent) {
+    // Should never leak to prod; only used for HMR
+    assertNotProd();
+    let cssContents = stylesheetsToCssContent.get(stylesheet);
+    if (isUndefined$1(cssContents)) {
+      cssContents = new Set();
+      stylesheetsToCssContent.set(stylesheet, cssContents);
     }
-    _getValues(key) {
-      let values = this._map.get(key);
-      if (isUndefined$1(values)) {
-        values = new Set();
-        this._map.set(key, values);
+    cssContents.add(cssContent);
+  }
+  function getOrCreateAbortControllerInDevMode(cssContent) {
+    // Should never leak to prod; only used for HMR
+    assertNotProd();
+    let abortController = cssContentToAbortControllers.get(cssContent);
+    if (isUndefined$1(abortController)) {
+      abortController = new AbortController();
+      cssContentToAbortControllers.set(cssContent, abortController);
+    }
+    return abortController;
+  }
+  function getOrCreateAbortSignal(cssContent) {
+    // abort controller/signal is only used for HMR in development
+    if (process.env.NODE_ENV !== 'production') {
+      return getOrCreateAbortControllerInDevMode(cssContent).signal;
+    }
+    return undefined;
+  }
+  function makeHostToken(token) {
+    // Note: if this ever changes, update the `cssScopeTokens` returned by `@lwc/compiler`
+    return `${token}-host`;
+  }
+  function createInlineStyleVNode(content) {
+    return api.h('style', {
+      key: 'style',
+      // special key
+      attrs: {
+        type: 'text/css'
       }
-      return values;
+    }, [api.t(content)]);
+  }
+  // TODO [#3733]: remove support for legacy scope tokens
+  function updateStylesheetToken(vm, template, legacy) {
+    const {
+      elm,
+      context,
+      renderMode,
+      shadowMode,
+      renderer: {
+        getClassList,
+        removeAttribute,
+        setAttribute
+      }
+    } = vm;
+    const {
+      stylesheets: newStylesheets
+    } = template;
+    const newStylesheetToken = legacy ? template.legacyStylesheetToken : template.stylesheetToken;
+    const {
+      stylesheets: newVmStylesheets
+    } = vm;
+    const isSyntheticShadow = renderMode === 1 /* RenderMode.Shadow */ && shadowMode === 1 /* ShadowMode.Synthetic */;
+    const {
+      hasScopedStyles
+    } = context;
+    let newToken;
+    let newHasTokenInClass;
+    let newHasTokenInAttribute;
+    // Reset the styling token applied to the host element.
+    let oldToken;
+    let oldHasTokenInClass;
+    let oldHasTokenInAttribute;
+    if (legacy) {
+      oldToken = context.legacyStylesheetToken;
+      oldHasTokenInClass = context.hasLegacyTokenInClass;
+      oldHasTokenInAttribute = context.hasLegacyTokenInAttribute;
+    } else {
+      oldToken = context.stylesheetToken;
+      oldHasTokenInClass = context.hasTokenInClass;
+      oldHasTokenInAttribute = context.hasTokenInAttribute;
     }
-    get(key) {
-      return this._getValues(key);
+    if (!isUndefined$1(oldToken)) {
+      if (oldHasTokenInClass) {
+        getClassList(elm).remove(makeHostToken(oldToken));
+      }
+      if (oldHasTokenInAttribute) {
+        removeAttribute(elm, makeHostToken(oldToken));
+      }
     }
-    add(key, vm) {
-      const set = this._getValues(key);
-      set.add(vm);
+    // Apply the new template styling token to the host element, if the new template has any
+    // associated stylesheets. In the case of light DOM, also ensure there is at least one scoped stylesheet.
+    const hasNewStylesheets = hasStyles(newStylesheets);
+    const hasNewVmStylesheets = hasStyles(newVmStylesheets);
+    if (hasNewStylesheets || hasNewVmStylesheets) {
+      newToken = newStylesheetToken;
     }
-    delete(key) {
-      this._map.delete(key);
+    // Set the new styling token on the host element
+    if (!isUndefined$1(newToken)) {
+      if (hasScopedStyles) {
+        getClassList(elm).add(makeHostToken(newToken));
+        newHasTokenInClass = true;
+      }
+      if (isSyntheticShadow) {
+        setAttribute(elm, makeHostToken(newToken), '');
+        newHasTokenInAttribute = true;
+      }
+    }
+    // Update the styling tokens present on the context object.
+    if (legacy) {
+      context.legacyStylesheetToken = newToken;
+      context.hasLegacyTokenInClass = newHasTokenInClass;
+      context.hasLegacyTokenInAttribute = newHasTokenInAttribute;
+    } else {
+      context.stylesheetToken = newToken;
+      context.hasTokenInClass = newHasTokenInClass;
+      context.hasTokenInAttribute = newHasTokenInAttribute;
     }
   }
-  // This implementation relies on the WeakRef/FinalizationRegistry proposal.
-  // For some background, see: https://github.com/tc39/proposal-weakrefs
-  class ModernWeakMultiMap {
-    constructor() {
-      this._map = new WeakMap();
-      this._registry = new FinalizationRegistry(weakRefs => {
-        // This should be considered an optional cleanup method to remove GC'ed values from their respective arrays.
-        // JS VMs are not obligated to call FinalizationRegistry callbacks.
-        // Work backwards, removing stale VMs
-        for (let i = weakRefs.length - 1; i >= 0; i--) {
-          const vm = weakRefs[i].deref();
-          if (isUndefined$1(vm)) {
-            ArraySplice.call(weakRefs, i, 1); // remove
+  function evaluateStylesheetsContent(stylesheets, stylesheetToken, vm) {
+    const content = [];
+    let root;
+    for (let i = 0; i < stylesheets.length; i++) {
+      let stylesheet = stylesheets[i];
+      if (isArray$1(stylesheet)) {
+        ArrayPush$1.apply(content, evaluateStylesheetsContent(stylesheet, stylesheetToken, vm));
+      } else {
+        if (process.env.NODE_ENV !== 'production') {
+          // Check for compiler version mismatch in dev mode only
+          checkVersionMismatch(stylesheet, 'stylesheet');
+          // in dev-mode, we support hot swapping of stylesheet, which means that
+          // the component instance might be attempting to use an old version of
+          // the stylesheet, while internally, we have a replacement for it.
+          stylesheet = getStyleOrSwappedStyle(stylesheet);
+        }
+        const isScopedCss = stylesheet[KEY__SCOPED_CSS];
+        if (lwcRuntimeFlags.DISABLE_LIGHT_DOM_UNSCOPED_CSS && !isScopedCss && vm.renderMode === 0 /* RenderMode.Light */) {
+          logError('Unscoped CSS is not supported in Light DOM in this environment. Please use scoped CSS ' + '(*.scoped.css) instead of unscoped CSS (*.css). See also: https://sfdc.co/scoped-styles-light-dom');
+          continue;
+        }
+        // Apply the scope token only if the stylesheet itself is scoped, or if we're rendering synthetic shadow.
+        const scopeToken = isScopedCss || vm.shadowMode === 1 /* ShadowMode.Synthetic */ && vm.renderMode === 1 /* RenderMode.Shadow */ ? stylesheetToken : undefined;
+        // Use the actual `:host` selector if we're rendering global CSS for light DOM, or if we're rendering
+        // native shadow DOM. Synthetic shadow DOM never uses `:host`.
+        const useActualHostSelector = vm.renderMode === 0 /* RenderMode.Light */ ? !isScopedCss : vm.shadowMode === 0 /* ShadowMode.Native */;
+        // Use the native :dir() pseudoclass only in native shadow DOM. Otherwise, in synthetic shadow,
+        // we use an attribute selector on the host to simulate :dir().
+        let useNativeDirPseudoclass;
+        if (vm.renderMode === 1 /* RenderMode.Shadow */) {
+          useNativeDirPseudoclass = vm.shadowMode === 0 /* ShadowMode.Native */;
+        } else {
+          // Light DOM components should only render `[dir]` if they're inside of a synthetic shadow root.
+          // At the top level (root is null) or inside of a native shadow root, they should use `:dir()`.
+          if (isUndefined$1(root)) {
+            // Only calculate the root once as necessary
+            root = getNearestShadowComponent(vm);
           }
+          useNativeDirPseudoclass = isNull(root) || root.shadowMode === 0 /* ShadowMode.Native */;
         }
-      });
-    }
-    _getWeakRefs(key) {
-      let weakRefs = this._map.get(key);
-      if (isUndefined$1(weakRefs)) {
-        weakRefs = [];
-        this._map.set(key, weakRefs);
-      }
-      return weakRefs;
-    }
-    get(key) {
-      const weakRefs = this._getWeakRefs(key);
-      const result = new Set();
-      for (const weakRef of weakRefs) {
-        const vm = weakRef.deref();
-        if (!isUndefined$1(vm)) {
-          result.add(vm);
+        const cssContent = stylesheet(scopeToken, useActualHostSelector, useNativeDirPseudoclass);
+        if (process.env.NODE_ENV !== 'production') {
+          linkStylesheetToCssContentInDevMode(stylesheet, cssContent);
         }
+        ArrayPush$1.call(content, cssContent);
       }
-      return result;
     }
-    add(key, value) {
-      const weakRefs = this._getWeakRefs(key);
-      // We could check for duplicate values here, but it doesn't seem worth it.
-      // We transform the output into a Set anyway
-      ArrayPush$1.call(weakRefs, new WeakRef(value));
-      // It's important here not to leak the second argument, which is the "held value." The FinalizationRegistry
-      // effectively creates a strong reference between the first argument (the "target") and the held value. When
-      // the target is GC'ed, the callback is called, and then the held value is GC'ed.
-      // Putting the key here would mean the key is not GC'ed until the value is GC'ed, which defeats the purpose
-      // of the WeakMap. Whereas putting the weakRefs array here is fine, because it doesn't have a strong reference
-      // to anything. See also this example:
-      // https://gist.github.com/nolanlawson/79a3d36e8e6cc25c5048bb17c1795aea
-      this._registry.register(value, weakRefs);
+    return content;
+  }
+  function getStylesheetsContent(vm, template) {
+    const {
+      stylesheets,
+      stylesheetToken
+    } = template;
+    const {
+      stylesheets: vmStylesheets
+    } = vm;
+    let content = [];
+    if (hasStyles(stylesheets)) {
+      content = evaluateStylesheetsContent(stylesheets, stylesheetToken, vm);
     }
-    delete(key) {
-      this._map.delete(key);
+    // VM (component) stylesheets apply after template stylesheets
+    if (hasStyles(vmStylesheets)) {
+      ArrayPush$1.apply(content, evaluateStylesheetsContent(vmStylesheets, stylesheetToken, vm));
     }
+    return content;
   }
-  const WeakMultiMap = supportsWeakRefs ? ModernWeakMultiMap : LegacyWeakMultiMap;
-
-  /*
-   * 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
-   */
-  const swappedTemplateMap = new WeakMap();
-  const swappedComponentMap = new WeakMap();
-  const swappedStyleMap = new WeakMap();
-  // The important thing here is the weak values – VMs are transient (one per component instance) and should be GC'ed,
-  // so we don't want to create strong references to them.
-  // The weak keys are kind of useless, because Templates, LightningElementConstructors, and StylesheetFactories are
-  // never GC'ed. But maybe they will be someday, so we may as well use weak keys too.
-  const activeTemplates = new WeakMultiMap();
-  const activeComponents = new WeakMultiMap();
-  const activeStyles = new WeakMultiMap();
-  function rehydrateHotTemplate(tpl) {
-    const list = activeTemplates.get(tpl);
-    for (const vm of list) {
-      if (isFalse(vm.isDirty)) {
-        // forcing the vm to rehydrate in the micro-task:
-        markComponentAsDirty(vm);
-        scheduleRehydration(vm);
+  // It might be worth caching this to avoid doing the lookup repeatedly, but
+  // perf testing has not shown it to be a huge improvement yet:
+  // https://github.com/salesforce/lwc/pull/2460#discussion_r691208892
+  function getNearestShadowComponent(vm) {
+    let owner = vm;
+    while (!isNull(owner)) {
+      if (owner.renderMode === 1 /* RenderMode.Shadow */) {
+        return owner;
       }
+      owner = owner.owner;
     }
-    // Resetting the Set since these VMs are no longer related to this template, instead
-    // they will get re-associated once these instances are rehydrated.
-    activeTemplates.delete(tpl);
-    return true;
+    return owner;
   }
-  function rehydrateHotStyle(style) {
-    const list = activeStyles.get(style);
-    for (const vm of list) {
+  /**
+   * If the component that is currently being rendered uses scoped styles,
+   * this returns the unique token for that scoped stylesheet. Otherwise
+   * it returns null.
+   * @param owner
+   * @param legacy
+   */
+  // TODO [#3733]: remove support for legacy scope tokens
+  function getScopeTokenClass(owner, legacy) {
+    const {
+      cmpTemplate,
+      context
+    } = owner;
+    return context.hasScopedStyles && (legacy ? cmpTemplate?.legacyStylesheetToken : cmpTemplate?.stylesheetToken) || null;
+  }
+  /**
+   * This function returns the host style token for a custom element if it
+   * exists. Otherwise it returns null.
+   *
+   * A host style token is applied to the component if scoped styles are used.
+   * @param vnode
+   */
+  function getStylesheetTokenHost(vnode) {
+    const {
+      template
+    } = getComponentInternalDef(vnode.ctor);
+    const {
+      vm
+    } = vnode;
+    const {
+      stylesheetToken
+    } = template;
+    return !isUndefined$1(stylesheetToken) && computeHasScopedStyles(template, vm) ? makeHostToken(stylesheetToken) : null;
+  }
+  function getNearestNativeShadowComponent(vm) {
+    const owner = getNearestShadowComponent(vm);
+    if (!isNull(owner) && owner.shadowMode === 1 /* ShadowMode.Synthetic */) {
+      // Synthetic-within-native is impossible. So if the nearest shadow component is
+      // synthetic, we know we won't find a native component if we go any further.
+      return null;
+    }
+    return owner;
+  }
+  function createStylesheet(vm, stylesheets) {
+    const {
+      renderMode,
+      shadowMode,
+      renderer: {
+        insertStylesheet
+      }
+    } = vm;
+    if (renderMode === 1 /* RenderMode.Shadow */ && shadowMode === 1 /* ShadowMode.Synthetic */) {
+      for (let i = 0; i < stylesheets.length; i++) {
+        const stylesheet = stylesheets[i];
+        insertStylesheet(stylesheet, undefined, getOrCreateAbortSignal(stylesheet));
+      }
+    } else if (vm.hydrated) {
+      // Note: We need to ensure that during hydration, the stylesheets method is the same as those in ssr.
+      //       This works in the client, because the stylesheets are created, and cached in the VM
+      //       the first time the VM renders.
+      // native shadow or light DOM, SSR
+      return ArrayMap.call(stylesheets, createInlineStyleVNode);
+    } else {
+      // native shadow or light DOM, DOM renderer
+      const root = getNearestNativeShadowComponent(vm);
+      // null root means a global style
+      const target = isNull(root) ? undefined : root.shadowRoot;
+      for (let i = 0; i < stylesheets.length; i++) {
+        const stylesheet = stylesheets[i];
+        insertStylesheet(stylesheet, target, getOrCreateAbortSignal(stylesheet));
+      }
+    }
+    return null;
+  }
+  function unrenderStylesheet(stylesheet) {
+    // should never leak to prod; only used for HMR
+    assertNotProd();
+    const cssContents = stylesheetsToCssContent.get(stylesheet);
+    /* istanbul ignore if */
+    if (isUndefined$1(cssContents)) {
+      throw new Error('Cannot unrender stylesheet which was never rendered');
+    }
+    for (const cssContent of cssContents) {
+      const abortController = cssContentToAbortControllers.get(cssContent);
+      /* istanbul ignore if */
+      if (isUndefined$1(abortController)) {
+        throw new Error('Cannot find AbortController for CSS content');
+      }
+      abortController.abort();
+      // remove association with AbortController in case stylesheet is rendered again
+      cssContentToAbortControllers.delete(cssContent);
+    }
+  }
+
+  /*
+   * Copyright (c) 2023, 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 supportsWeakRefs = typeof WeakRef === 'function' && typeof FinalizationRegistry === 'function';
+  // In browsers that doesn't support WeakRefs, the values will still leak, but at least the keys won't
+  class LegacyWeakMultiMap {
+    constructor() {
+      this._map = new WeakMap();
+    }
+    _getValues(key) {
+      let values = this._map.get(key);
+      if (isUndefined$1(values)) {
+        values = new Set();
+        this._map.set(key, values);
+      }
+      return values;
+    }
+    get(key) {
+      return this._getValues(key);
+    }
+    add(key, vm) {
+      const set = this._getValues(key);
+      set.add(vm);
+    }
+    delete(key) {
+      this._map.delete(key);
+    }
+  }
+  // This implementation relies on the WeakRef/FinalizationRegistry proposal.
+  // For some background, see: https://github.com/tc39/proposal-weakrefs
+  class ModernWeakMultiMap {
+    constructor() {
+      this._map = new WeakMap();
+      this._registry = new FinalizationRegistry(weakRefs => {
+        // This should be considered an optional cleanup method to remove GC'ed values from their respective arrays.
+        // JS VMs are not obligated to call FinalizationRegistry callbacks.
+        // Work backwards, removing stale VMs
+        for (let i = weakRefs.length - 1; i >= 0; i--) {
+          const vm = weakRefs[i].deref();
+          if (isUndefined$1(vm)) {
+            ArraySplice.call(weakRefs, i, 1); // remove
+          }
+        }
+      });
+    }
+    _getWeakRefs(key) {
+      let weakRefs = this._map.get(key);
+      if (isUndefined$1(weakRefs)) {
+        weakRefs = [];
+        this._map.set(key, weakRefs);
+      }
+      return weakRefs;
+    }
+    get(key) {
+      const weakRefs = this._getWeakRefs(key);
+      const result = new Set();
+      for (const weakRef of weakRefs) {
+        const vm = weakRef.deref();
+        if (!isUndefined$1(vm)) {
+          result.add(vm);
+        }
+      }
+      return result;
+    }
+    add(key, value) {
+      const weakRefs = this._getWeakRefs(key);
+      // We could check for duplicate values here, but it doesn't seem worth it.
+      // We transform the output into a Set anyway
+      ArrayPush$1.call(weakRefs, new WeakRef(value));
+      // It's important here not to leak the second argument, which is the "held value." The FinalizationRegistry
+      // effectively creates a strong reference between the first argument (the "target") and the held value. When
+      // the target is GC'ed, the callback is called, and then the held value is GC'ed.
+      // Putting the key here would mean the key is not GC'ed until the value is GC'ed, which defeats the purpose
+      // of the WeakMap. Whereas putting the weakRefs array here is fine, because it doesn't have a strong reference
+      // to anything. See also this example:
+      // https://gist.github.com/nolanlawson/79a3d36e8e6cc25c5048bb17c1795aea
+      this._registry.register(value, weakRefs);
+    }
+    delete(key) {
+      this._map.delete(key);
+    }
+  }
+  const WeakMultiMap = supportsWeakRefs ? ModernWeakMultiMap : LegacyWeakMultiMap;
+
+  /*
+   * 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
+   */
+  let swappedTemplateMap = /*@__PURE__@*/new WeakMap();
+  let swappedComponentMap = /*@__PURE__@*/new WeakMap();
+  let swappedStyleMap = /*@__PURE__@*/new WeakMap();
+  // The important thing here is the weak values – VMs are transient (one per component instance) and should be GC'ed,
+  // so we don't want to create strong references to them.
+  // The weak keys are kind of useless, because Templates, LightningElementConstructors, and StylesheetFactories are
+  // never GC'ed. But maybe they will be someday, so we may as well use weak keys too.
+  // The "pure" annotations are so that Rollup knows for sure it can remove these from prod mode
+  let activeTemplates = /*@__PURE__@*/new WeakMultiMap();
+  let activeComponents = /*@__PURE__@*/new WeakMultiMap();
+  let activeStyles = /*@__PURE__@*/new WeakMultiMap();
+  // Only used in LWC's Karma tests
+  if (process.env.NODE_ENV === 'test-karma-lwc') {
+    // Used to reset the global state between test runs
+    window.__lwcResetHotSwaps = () => {
+      swappedTemplateMap = new WeakMap();
+      swappedComponentMap = new WeakMap();
+      swappedStyleMap = new WeakMap();
+      activeTemplates = new WeakMultiMap();
+      activeComponents = new WeakMultiMap();
+      activeStyles = new WeakMultiMap();
+    };
+  }
+  function rehydrateHotTemplate(tpl) {
+    const list = activeTemplates.get(tpl);
+    for (const vm of list) {
+      if (isFalse(vm.isDirty)) {
+        // forcing the vm to rehydrate in the micro-task:
+        markComponentAsDirty(vm);
+        scheduleRehydration(vm);
+      }
+    }
+    // Resetting the Set since these VMs are no longer related to this template, instead
+    // they will get re-associated once these instances are rehydrated.
+    activeTemplates.delete(tpl);
+    return true;
+  }
+  function rehydrateHotStyle(style) {
+    const activeVMs = activeStyles.get(style);
+    unrenderStylesheet(style);
+    for (const vm of activeVMs) {
       // if a style definition is swapped, we must reset
       // vm's template content in the next micro-task:
       forceRehydration(vm);
@@ -3786,6 +4113,7 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
   }
   function getTemplateOrSwappedTemplate(tpl) {
     assertNotProd(); // this method should never leak to prod
+    // TODO [#4154]: shows stale content when swapping content back and forth multiple times
     const visited = new Set();
     while (swappedTemplateMap.has(tpl) && !visited.has(tpl)) {
       visited.add(tpl);
@@ -3795,6 +4123,7 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
   }
   function getComponentOrSwappedComponent(Ctor) {
     assertNotProd(); // this method should never leak to prod
+    // TODO [#4154]: shows stale content when swapping content back and forth multiple times
     const visited = new Set();
     while (swappedComponentMap.has(Ctor) && !visited.has(Ctor)) {
       visited.add(Ctor);
@@ -3804,6 +4133,7 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
   }
   function getStyleOrSwappedStyle(style) {
     assertNotProd(); // this method should never leak to prod
+    // TODO [#4154]: shows stale content when swapping content back and forth multiple times
     const visited = new Set();
     while (swappedStyleMap.has(style) && !visited.has(style)) {
       visited.add(style);
@@ -3811,6 +4141,22 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
     }
     return style;
   }
+  function addActiveStylesheets(stylesheets, vm) {
+    if (isUndefined$1(stylesheets) || isNull(stylesheets)) {
+      // Ignore non-existent stylesheets
+      return;
+    }
+    for (const stylesheet of flattenStylesheets(stylesheets)) {
+      // this is necessary because we don't hold the list of styles
+      // in the vm, we only hold the selected (already swapped template)
+      // but the styles attached to the template might not be the actual
+      // active ones, but the swapped versions of those.
+      const swappedStylesheet = getStyleOrSwappedStyle(stylesheet);
+      // this will allow us to keep track of the stylesheet that are
+      // being used by a hot component
+      activeStyles.add(swappedStylesheet, vm);
+    }
+  }
   function setActiveVM(vm) {
     assertNotProd(); // this method should never leak to prod
     // tracking active component
@@ -3818,25 +4164,15 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
     // this will allow us to keep track of the hot components
     activeComponents.add(Ctor, vm);
     // tracking active template
-    const tpl = vm.cmpTemplate;
-    if (tpl) {
+    const template = vm.cmpTemplate;
+    if (!isNull(template)) {
       // this will allow us to keep track of the templates that are
       // being used by a hot component
-      activeTemplates.add(tpl, vm);
-      // tracking active styles associated to template
-      const stylesheets = tpl.stylesheets;
-      if (!isUndefined$1(stylesheets)) {
-        for (const stylesheet of flattenStylesheets(stylesheets)) {
-          // this is necessary because we don't hold the list of styles
-          // in the vm, we only hold the selected (already swapped template)
-          // but the styles attached to the template might not be the actual
-          // active ones, but the swapped versions of those.
-          const swappedStylesheet = getStyleOrSwappedStyle(stylesheet);
-          // this will allow us to keep track of the stylesheet that are
-          // being used by a hot component
-          activeStyles.add(swappedStylesheet, vm);
-        }
-      }
+      activeTemplates.add(template, vm);
+      // Tracking active styles from the template or the VM. `template.stylesheets` are implicitly associated
+      // (e.g. `foo.css` associated with `foo.html`), whereas `vm.stylesheets` are from `static stylesheets`.
+      addActiveStylesheets(template.stylesheets, vm);
+      addActiveStylesheets(vm.stylesheets, vm);
     }
   }
   function swapTemplate(oldTpl, newTpl) {
@@ -4107,284 +4443,39 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
     // for some external services, e.g.: Locker Service, usually, all they care
     // is about the shape of the constructor, the internals of it are not relevant
     // because they don't have a way to mess with that.
-    const {
-      ctor,
-      name,
-      props,
-      propsConfig,
-      methods
-    } = def;
-    const publicProps = {};
-    for (const key in props) {
-      // avoid leaking the reference to the public props descriptors
-      publicProps[key] = {
-        config: propsConfig[key] || 0,
-        // a property by default
-        type: "any" /* PropDefType.any */,
-        // no type inference for public services
-        attr: htmlPropertyToAttribute(key)
-      };
-    }
-    const publicMethods = {};
-    for (const key in methods) {
-      // avoid leaking the reference to the public method descriptors
-      publicMethods[key] = methods[key].value;
-    }
-    return {
-      ctor,
-      name,
-      props: publicProps,
-      methods: publicMethods
-    };
-  }
-
-  /*
-   * Copyright (c) 2018, 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
-   */
-  function makeHostToken(token) {
-    // Note: if this ever changes, update the `cssScopeTokens` returned by `@lwc/compiler`
-    return `${token}-host`;
-  }
-  function createInlineStyleVNode(content) {
-    return api.h('style', {
-      key: 'style',
-      // special key
-      attrs: {
-        type: 'text/css'
-      }
-    }, [api.t(content)]);
-  }
-  // TODO [#3733]: remove support for legacy scope tokens
-  function updateStylesheetToken(vm, template, legacy) {
-    const {
-      elm,
-      context,
-      renderMode,
-      shadowMode,
-      renderer: {
-        getClassList,
-        removeAttribute,
-        setAttribute
-      }
-    } = vm;
-    const {
-      stylesheets: newStylesheets
-    } = template;
-    const newStylesheetToken = legacy ? template.legacyStylesheetToken : template.stylesheetToken;
-    const {
-      stylesheets: newVmStylesheets
-    } = vm;
-    const isSyntheticShadow = renderMode === 1 /* RenderMode.Shadow */ && shadowMode === 1 /* ShadowMode.Synthetic */;
-    const {
-      hasScopedStyles
-    } = context;
-    let newToken;
-    let newHasTokenInClass;
-    let newHasTokenInAttribute;
-    // Reset the styling token applied to the host element.
-    let oldToken;
-    let oldHasTokenInClass;
-    let oldHasTokenInAttribute;
-    if (legacy) {
-      oldToken = context.legacyStylesheetToken;
-      oldHasTokenInClass = context.hasLegacyTokenInClass;
-      oldHasTokenInAttribute = context.hasLegacyTokenInAttribute;
-    } else {
-      oldToken = context.stylesheetToken;
-      oldHasTokenInClass = context.hasTokenInClass;
-      oldHasTokenInAttribute = context.hasTokenInAttribute;
-    }
-    if (!isUndefined$1(oldToken)) {
-      if (oldHasTokenInClass) {
-        getClassList(elm).remove(makeHostToken(oldToken));
-      }
-      if (oldHasTokenInAttribute) {
-        removeAttribute(elm, makeHostToken(oldToken));
-      }
-    }
-    // Apply the new template styling token to the host element, if the new template has any
-    // associated stylesheets. In the case of light DOM, also ensure there is at least one scoped stylesheet.
-    const hasNewStylesheets = hasStyles(newStylesheets);
-    const hasNewVmStylesheets = hasStyles(newVmStylesheets);
-    if (hasNewStylesheets || hasNewVmStylesheets) {
-      newToken = newStylesheetToken;
-    }
-    // Set the new styling token on the host element
-    if (!isUndefined$1(newToken)) {
-      if (hasScopedStyles) {
-        getClassList(elm).add(makeHostToken(newToken));
-        newHasTokenInClass = true;
-      }
-      if (isSyntheticShadow) {
-        setAttribute(elm, makeHostToken(newToken), '');
-        newHasTokenInAttribute = true;
-      }
-    }
-    // Update the styling tokens present on the context object.
-    if (legacy) {
-      context.legacyStylesheetToken = newToken;
-      context.hasLegacyTokenInClass = newHasTokenInClass;
-      context.hasLegacyTokenInAttribute = newHasTokenInAttribute;
-    } else {
-      context.stylesheetToken = newToken;
-      context.hasTokenInClass = newHasTokenInClass;
-      context.hasTokenInAttribute = newHasTokenInAttribute;
-    }
-  }
-  function evaluateStylesheetsContent(stylesheets, stylesheetToken, vm) {
-    const content = [];
-    let root;
-    for (let i = 0; i < stylesheets.length; i++) {
-      let stylesheet = stylesheets[i];
-      if (isArray$1(stylesheet)) {
-        ArrayPush$1.apply(content, evaluateStylesheetsContent(stylesheet, stylesheetToken, vm));
-      } else {
-        if (process.env.NODE_ENV !== 'production') {
-          // Check for compiler version mismatch in dev mode only
-          checkVersionMismatch(stylesheet, 'stylesheet');
-          // in dev-mode, we support hot swapping of stylesheet, which means that
-          // the component instance might be attempting to use an old version of
-          // the stylesheet, while internally, we have a replacement for it.
-          stylesheet = getStyleOrSwappedStyle(stylesheet);
-        }
-        const isScopedCss = stylesheet[KEY__SCOPED_CSS];
-        if (lwcRuntimeFlags.DISABLE_LIGHT_DOM_UNSCOPED_CSS && !isScopedCss && vm.renderMode === 0 /* RenderMode.Light */) {
-          logError('Unscoped CSS is not supported in Light DOM in this environment. Please use scoped CSS ' + '(*.scoped.css) instead of unscoped CSS (*.css). See also: https://sfdc.co/scoped-styles-light-dom');
-          continue;
-        }
-        // Apply the scope token only if the stylesheet itself is scoped, or if we're rendering synthetic shadow.
-        const scopeToken = isScopedCss || vm.shadowMode === 1 /* ShadowMode.Synthetic */ && vm.renderMode === 1 /* RenderMode.Shadow */ ? stylesheetToken : undefined;
-        // Use the actual `:host` selector if we're rendering global CSS for light DOM, or if we're rendering
-        // native shadow DOM. Synthetic shadow DOM never uses `:host`.
-        const useActualHostSelector = vm.renderMode === 0 /* RenderMode.Light */ ? !isScopedCss : vm.shadowMode === 0 /* ShadowMode.Native */;
-        // Use the native :dir() pseudoclass only in native shadow DOM. Otherwise, in synthetic shadow,
-        // we use an attribute selector on the host to simulate :dir().
-        let useNativeDirPseudoclass;
-        if (vm.renderMode === 1 /* RenderMode.Shadow */) {
-          useNativeDirPseudoclass = vm.shadowMode === 0 /* ShadowMode.Native */;
-        } else {
-          // Light DOM components should only render `[dir]` if they're inside of a synthetic shadow root.
-          // At the top level (root is null) or inside of a native shadow root, they should use `:dir()`.
-          if (isUndefined$1(root)) {
-            // Only calculate the root once as necessary
-            root = getNearestShadowComponent(vm);
-          }
-          useNativeDirPseudoclass = isNull(root) || root.shadowMode === 0 /* ShadowMode.Native */;
-        }
-        ArrayPush$1.call(content, stylesheet(scopeToken, useActualHostSelector, useNativeDirPseudoclass));
-      }
-    }
-    return content;
-  }
-  function getStylesheetsContent(vm, template) {
-    const {
-      stylesheets,
-      stylesheetToken
-    } = template;
-    const {
-      stylesheets: vmStylesheets
-    } = vm;
-    let content = [];
-    if (hasStyles(stylesheets)) {
-      content = evaluateStylesheetsContent(stylesheets, stylesheetToken, vm);
-    }
-    // VM (component) stylesheets apply after template stylesheets
-    if (hasStyles(vmStylesheets)) {
-      ArrayPush$1.apply(content, evaluateStylesheetsContent(vmStylesheets, stylesheetToken, vm));
-    }
-    return content;
-  }
-  // It might be worth caching this to avoid doing the lookup repeatedly, but
-  // perf testing has not shown it to be a huge improvement yet:
-  // https://github.com/salesforce/lwc/pull/2460#discussion_r691208892
-  function getNearestShadowComponent(vm) {
-    let owner = vm;
-    while (!isNull(owner)) {
-      if (owner.renderMode === 1 /* RenderMode.Shadow */) {
-        return owner;
-      }
-      owner = owner.owner;
-    }
-    return owner;
-  }
-  /**
-   * If the component that is currently being rendered uses scoped styles,
-   * this returns the unique token for that scoped stylesheet. Otherwise
-   * it returns null.
-   * @param owner
-   * @param legacy
-   */
-  // TODO [#3733]: remove support for legacy scope tokens
-  function getScopeTokenClass(owner, legacy) {
-    const {
-      cmpTemplate,
-      context
-    } = owner;
-    return context.hasScopedStyles && (legacy ? cmpTemplate?.legacyStylesheetToken : cmpTemplate?.stylesheetToken) || null;
-  }
-  /**
-   * This function returns the host style token for a custom element if it
-   * exists. Otherwise it returns null.
-   *
-   * A host style token is applied to the component if scoped styles are used.
-   * @param vnode
-   */
-  function getStylesheetTokenHost(vnode) {
-    const {
-      template
-    } = getComponentInternalDef(vnode.ctor);
-    const {
-      vm
-    } = vnode;
-    const {
-      stylesheetToken
-    } = template;
-    return !isUndefined$1(stylesheetToken) && computeHasScopedStyles(template, vm) ? makeHostToken(stylesheetToken) : null;
-  }
-  function getNearestNativeShadowComponent(vm) {
-    const owner = getNearestShadowComponent(vm);
-    if (!isNull(owner) && owner.shadowMode === 1 /* ShadowMode.Synthetic */) {
-      // Synthetic-within-native is impossible. So if the nearest shadow component is
-      // synthetic, we know we won't find a native component if we go any further.
-      return null;
-    }
-    return owner;
-  }
-  function createStylesheet(vm, stylesheets) {
-    const {
-      renderMode,
-      shadowMode,
-      renderer: {
-        insertStylesheet
-      }
-    } = vm;
-    if (renderMode === 1 /* RenderMode.Shadow */ && shadowMode === 1 /* ShadowMode.Synthetic */) {
-      for (let i = 0; i < stylesheets.length; i++) {
-        insertStylesheet(stylesheets[i]);
-      }
-    } else if (vm.hydrated) {
-      // Note: We need to ensure that during hydration, the stylesheets method is the same as those in ssr.
-      //       This works in the client, because the stylesheets are created, and cached in the VM
-      //       the first time the VM renders.
-      // native shadow or light DOM, SSR
-      return ArrayMap.call(stylesheets, createInlineStyleVNode);
-    } else {
-      // native shadow or light DOM, DOM renderer
-      const root = getNearestNativeShadowComponent(vm);
-      // null root means a global style
-      const target = isNull(root) ? undefined : root.shadowRoot;
-      for (let i = 0; i < stylesheets.length; i++) {
-        insertStylesheet(stylesheets[i], target);
-      }
+    const {
+      ctor,
+      name,
+      props,
+      propsConfig,
+      methods
+    } = def;
+    const publicProps = {};
+    for (const key in props) {
+      // avoid leaking the reference to the public props descriptors
+      publicProps[key] = {
+        config: propsConfig[key] || 0,
+        // a property by default
+        type: "any" /* PropDefType.any */,
+        // no type inference for public services
+        attr: htmlPropertyToAttribute(key)
+      };
     }
-    return null;
+    const publicMethods = {};
+    for (const key in methods) {
+      // avoid leaking the reference to the public method descriptors
+      publicMethods[key] = methods[key].value;
+    }
+    return {
+      ctor,
+      name,
+      props: publicProps,
+      methods: publicMethods
+    };
   }
 
   /*
-   * Copyright (c) 2018, salesforce.com, inc.
+   * 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
@@ -4410,6 +4501,12 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
   function isVStatic(vnode) {
     return vnode.type === 4 /* VNodeType.Static */;
   }
+  function isVStaticPartElement(vnode) {
+    return vnode.type === 1 /* VStaticPartType.Element */;
+  }
+  function isVStaticPartText(vnode) {
+    return vnode.type === 0 /* VStaticPartType.Text */;
+  }
 
   /*
    * Copyright (c) 2018, salesforce.com, inc.
@@ -4420,9 +4517,12 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
   const ColonCharCode = 58;
   function patchAttributes(oldVnode, vnode, renderer) {
     const {
-      attrs,
-      external
-    } = vnode.data;
+      data,
+      elm
+    } = vnode;
+    const {
+      attrs
+    } = data;
     if (isUndefined$1(attrs)) {
       return;
     }
@@ -4431,9 +4531,8 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
     if (oldAttrs === attrs) {
       return;
     }
-    const {
-      elm
-    } = vnode;
+    // Note VStaticPartData does not contain the external property so it will always default to false.
+    const external = 'external' in data ? data.external : false;
     const {
       setAttribute,
       removeAttribute,
@@ -4549,8 +4648,7 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
    */
   const classNameToClassMap = create(null);
   function getMapFromClassName(className) {
-    // Intentionally using == to match undefined and null values from computed style attribute
-    if (className == null) {
+    if (isUndefined$1(className) || isNull(className) || className === '') {
       return EmptyObject;
     }
     // computed class names must be string
@@ -4594,12 +4692,18 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
     if (oldClass === newClass) {
       return;
     }
+    const newClassMap = getMapFromClassName(newClass);
+    const oldClassMap = getMapFromClassName(oldClass);
+    if (oldClassMap === newClassMap) {
+      // These objects are cached by className string (`classNameToClassMap`), so we can only get here if there is
+      // a key collision due to types, e.g. oldClass is `undefined` and newClass is `""` (empty string), or oldClass
+      // is `1` (number) and newClass is `"1"` (string).
+      return;
+    }
     const {
       getClassList
     } = renderer;
     const classList = getClassList(elm);
-    const newClassMap = getMapFromClassName(newClass);
-    const oldClassMap = getMapFromClassName(oldClass);
     let name;
     for (name in oldClassMap) {
       // remove only if it is not in the new class collection and it is not set from within the instance
@@ -4621,13 +4725,18 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
    * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
    */
   // The style property is a string when defined via an expression in the template.
-  function patchStyleAttribute(oldVnode, vnode, renderer) {
+  function patchStyleAttribute(oldVnode, vnode, renderer, owner) {
     const {
       elm,
       data: {
         style: newStyle
       }
     } = vnode;
+    if (process.env.NODE_ENV !== 'production') {
+      if (!isNull(newStyle) && !isUndefined$1(newStyle) && !isString(newStyle)) {
+        logError(`Invalid 'style' attribute passed to <${elm.tagName.toLowerCase()}> is ignored. This attribute must be a string value.`, owner);
+      }
+    }
     const oldStyle = isNull(oldVnode) ? undefined : oldVnode.data.style;
     if (oldStyle === newStyle) {
       return;
@@ -4651,9 +4760,12 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
    */
   function applyEventListeners(vnode, renderer) {
     const {
-      elm
+      elm,
+      data
     } = vnode;
-    const on = vnode.data?.on;
+    const {
+      on
+    } = data;
     if (isUndefined$1(on)) {
       return;
     }
@@ -4751,11 +4863,51 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
   }
 
   /*
-   * Copyright (c) 2023, salesforce.com, inc.
+   * 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
+   */
+  function patchTextVNode(n1, n2, renderer) {
+    n2.elm = n1.elm;
+    if (n2.text !== n1.text) {
+      updateTextContent$1(n2, renderer);
+    }
+  }
+  function patchTextVStaticPart(n1, n2, renderer) {
+    if (isNull(n1) || n2.text !== n1.text) {
+      updateTextContent$1(n2, renderer);
+    }
+  }
+  function updateTextContent$1(vnode, renderer) {
+    const {
+      elm,
+      text
+    } = vnode;
+    const {
+      setText
+    } = renderer;
+    if (process.env.NODE_ENV !== 'production') {
+      unlockDomMutation();
+    }
+    setText(elm, text);
+    if (process.env.NODE_ENV !== 'production') {
+      lockDomMutation();
+    }
+  }
+
+  /*
+   * 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
    */
+  /**
+   * Given an array of static parts, mounts the DOM element to the part based on the staticPartId
+   * @param root the root element
+   * @param parts an array of VStaticParts
+   * @param renderer the renderer to use
+   */
   function traverseAndSetElements(root, parts, renderer) {
     const numParts = parts.length;
     // Optimization given that, in most cases, there will be one part, and it's just the root
@@ -4771,34 +4923,59 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
     for (const staticPart of parts) {
       partIdsToParts.set(staticPart.partId, staticPart);
     }
-    let numFoundParts = 0;
+    // Note that we traverse using `*Child`/`*Sibling` rather than `children` because the browser uses a linked
+    // list under the hood to represent the DOM tree, so it's faster to do this than to create an underlying array
+    // by calling `children`.
     const {
-      previousSibling,
-      getLastChild
+      nextSibling,
+      getFirstChild,
+      getParentNode
     } = renderer;
-    const stack = [root];
+    let numFoundParts = 0;
     let partId = -1;
+    // We should never traverse up to the root. We should exit early due to numFoundParts === numParts.
+    // This is just a sanity check, in case the static parts generated by @lwc/template-compiler are wrong.
+    function assertNotRoot(node) {
+      if (process.env.NODE_ENV !== 'production') {
+        assert.isFalse(node === root, `Reached the root without finding all parts. Found ${numFoundParts}, needed ${numParts}.`);
+      }
+    }
     // Depth-first traversal. We assign a partId to each element, which is an integer based on traversal order.
-    while (stack.length > 0) {
-      const elm = ArrayShift.call(stack);
+    // This function is very hot, which is why it's micro-optimized. Note we don't use a stack at all; we traverse
+    // using an algorithm that relies on the parentNode getter: https://stackoverflow.com/a/5285417
+    // This is very slightly faster than a TreeWalker (~0.5% on js-framework-benchmark create-10k), but basically
+    // the same idea.
+    let node = root;
+    while (!isNull(node)) {
+      // visit node
       partId++;
       const part = partIdsToParts.get(partId);
       if (!isUndefined$1(part)) {
-        part.elm = elm;
-        if (++numFoundParts === numParts) {
+        part.elm = node;
+        numFoundParts++;
+        if (numFoundParts === numParts) {
           return; // perf optimization - stop traversing once we've found everything we need
         }
       }
-      // For depth-first traversal, prepend to the stack in reverse order
-      // Note that we traverse using `*Child`/`*Sibling` rather than `children` because the browser uses a linked
-      // list under the hood to represent the DOM tree, so it's faster to do this than to create an underlying array
-      // by calling `children`.
-      let child = getLastChild(elm);
-      while (!isNull(child)) {
-        ArrayUnshift.call(stack, child);
-        child = previousSibling(child);
+      const child = getFirstChild(node);
+      if (!isNull(child)) {
+        // walk down
+        node = child;
+      } else {
+        let sibling;
+        while (isNull(sibling = nextSibling(node))) {
+          // we never want to walk up from the root
+          assertNotRoot(node);
+          // walk up
+          node = getParentNode(node);
+        }
+        // we never want to walk right from the root
+        assertNotRoot(node);
+        // walk right
+        node = sibling;
       }
     }
+    /* istanbul ignore next */
     if (process.env.NODE_ENV !== 'production') {
       assert.isTrue(numFoundParts === numParts, `Should have found all parts by now. Found ${numFoundParts}, needed ${numParts}.`);
     }
@@ -4822,18 +4999,29 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
     traverseAndSetElements(root, parts, renderer);
     // Currently only event listeners and refs are supported for static vnodes
     for (const part of parts) {
-      // Event listeners only need to be applied once when mounting
-      applyEventListeners(part, renderer);
-      // Refs must be updated after every render due to refVNodes getting reset before every render
-      applyRefs(part, owner);
+      if (isVStaticPartElement(part)) {
+        // Event listeners only need to be applied once when mounting
+        applyEventListeners(part, renderer);
+        // Refs must be updated after every render due to refVNodes getting reset before every render
+        applyRefs(part, owner);
+        patchAttributes(null, part, renderer);
+        patchClassAttribute(null, part, renderer);
+        patchStyleAttribute(null, part, renderer, owner);
+      } else {
+        if (process.env.NODE_ENV !== 'production' && !isVStaticPartText(part)) {
+          throw new Error(`LWC internal error, encountered unknown static part type: ${part.type}`);
+        }
+        patchTextVStaticPart(null, part, renderer);
+      }
     }
   }
   /**
-   * Mounts elements to the newly generated VStatic node
+   * Updates the static elements based on the content of the VStaticParts
    * @param n1 the previous VStatic vnode
    * @param n2 the current VStatic vnode
+   * @param renderer the renderer to use
    */
-  function patchStaticParts(n1, n2) {
+  function patchStaticParts(n1, n2, renderer) {
     const {
       parts: currParts,
       owner: currPartsOwner
@@ -4848,17 +5036,53 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
       assert.isTrue(currParts.length === prevParts?.length, 'Expected static parts to be the same for the same element. This is an error with the LWC framework itself.');
     }
     for (let i = 0; i < currParts.length; i++) {
+      const prevPart = prevParts[i];
       const part = currParts[i];
       // Patch only occurs if the vnode is newly generated, which means the part.elm is always undefined
       // Since the vnode and elements are the same we can safely assume that prevParts[i].elm is defined.
-      part.elm = prevParts[i].elm;
-      // Refs must be updated after every render due to refVNodes getting reset before every render
-      applyRefs(part, currPartsOwner);
+      part.elm = prevPart.elm;
+      if (process.env.NODE_ENV !== 'production' && prevPart.type !== part.type) {
+        throw new Error(`LWC internal error, static part types do not match. Previous type was ${prevPart.type} and current type is ${part.type}`);
+      }
+      if (isVStaticPartElement(part)) {
+        // Refs must be updated after every render due to refVNodes getting reset before every render
+        applyRefs(part, currPartsOwner);
+        patchAttributes(prevPart, part, renderer);
+        patchClassAttribute(prevPart, part, renderer);
+        patchStyleAttribute(prevPart, part, renderer, currPartsOwner);
+      } else {
+        patchTextVStaticPart(null, part, renderer);
+      }
+    }
+  }
+  /**
+   * Mounts the hydration specific attributes
+   * @param vnode the parent VStatic node
+   * @param renderer the renderer to use
+   */
+  function hydrateStaticParts(vnode, renderer) {
+    const {
+      parts,
+      owner
+    } = vnode;
+    if (isUndefined$1(parts)) {
+      return;
+    }
+    // Note, hydration doesn't patch attributes because hydration validation occurs before this routine
+    // which guarantees that the elements are the same.
+    // We only need to apply the parts for things that cannot be done on the server.
+    for (const part of parts) {
+      if (isVStaticPartElement(part)) {
+        // Event listeners only need to be applied once when mounting
+        applyEventListeners(part, renderer);
+        // Refs must be updated after every render due to refVNodes getting reset before every render
+        applyRefs(part, owner);
+      }
     }
   }
 
   /*
-   * Copyright (c) 2018, salesforce.com, inc.
+   * 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
@@ -4893,7 +5117,7 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
     switch (n2.type) {
       case 0 /* VNodeType.Text */:
         // VText has no special capability, fallback to the owner's renderer
-        patchText(n1, n2, renderer);
+        patchTextVNode(n1, n2, renderer);
         break;
       case 1 /* VNodeType.Comment */:
         // VComment has no special capability, fallback to the owner's renderer
@@ -4940,12 +5164,6 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
         break;
     }
   }
-  function patchText(n1, n2, renderer) {
-    n2.elm = n1.elm;
-    if (n2.text !== n1.text) {
-      updateTextContent(n2, renderer);
-    }
-  }
   function mountText(vnode, parent, anchor, renderer) {
     const {
       owner
@@ -4962,7 +5180,7 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
     // FIXME: Comment nodes should be static, we shouldn't need to diff them together. However
     // it is the case today.
     if (n2.text !== n1.text) {
-      updateTextContent(n2, renderer);
+      updateTextContent$1(n2, renderer);
     }
   }
   function mountComment(vnode, parent, anchor, renderer) {
@@ -5022,7 +5240,7 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
     // slotAssignments can only apply to the top level element, never to a static part.
     patchSlotAssignment(n1, n2, renderer);
     // The `refs` object is blown away in every re-render, so we always need to re-apply them
-    patchStaticParts(n1, n2);
+    patchStaticParts(n1, n2, renderer);
   }
   function patchElement(n1, n2, renderer) {
     const elm = n2.elm = n1.elm;
@@ -5038,22 +5256,23 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
       isSyntheticShadowDefined
     } = renderer;
     const elm = vnode.elm = cloneNode(vnode.fragment, true);
+    // Define the root node shadow resolver
     linkNodeToShadow(elm, owner, renderer);
     applyElementRestrictions(elm, vnode);
-    // Marks this node as Static to propagate the shadow resolver. must happen after elm is assigned to the proper shadow
     const {
       renderMode,
       shadowMode
     } = owner;
     if (isSyntheticShadowDefined) {
+      // Marks this node as Static to propagate the shadow resolver. must happen after elm is assigned to the proper shadow
       if (shadowMode === 1 /* ShadowMode.Synthetic */ || renderMode === 0 /* RenderMode.Light */) {
         elm[KEY__SHADOW_STATIC] = true;
       }
     }
     // slotAssignments can only apply to the top level element, never to a static part.
     patchSlotAssignment(null, vnode, renderer);
-    insertNode(elm, parent, anchor, renderer);
     mountStaticParts(elm, vnode, renderer);
+    insertNode(elm, parent, anchor, renderer);
   }
   function mountCustomElement(vnode, parent, anchor, renderer) {
     const {
@@ -5234,22 +5453,6 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
       }
     }
   }
-  function updateTextContent(vnode, renderer) {
-    const {
-      elm,
-      text
-    } = vnode;
-    const {
-      setText
-    } = renderer;
-    if (process.env.NODE_ENV !== 'production') {
-      unlockDomMutation();
-    }
-    setText(elm, text);
-    if (process.env.NODE_ENV !== 'production') {
-      lockDomMutation();
-    }
-  }
   function insertFragmentOrNode(vnode, parent, anchor, renderer) {
     if (process.env.NODE_ENV !== 'production') {
       unlockDomMutation();
@@ -5293,15 +5496,18 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
       applyStaticClassAttribute(vnode, renderer);
       applyStaticStyleAttribute(vnode, renderer);
     }
+    const {
+      owner
+    } = vnode;
     // Attrs need to be applied to element before props IE11 will wipe out value on radio inputs if
     // value is set before type=radio.
     patchClassAttribute(oldVnode, vnode, renderer);
-    patchStyleAttribute(oldVnode, vnode, renderer);
+    patchStyleAttribute(oldVnode, vnode, renderer, owner);
     patchAttributes(oldVnode, vnode, renderer);
     patchProps(oldVnode, vnode, renderer);
     patchSlotAssignment(oldVnode, vnode, renderer);
     // The `refs` object is blown away in every re-render, so we always need to re-apply them
-    applyRefs(vnode, vnode.owner);
+    applyRefs(vnode, owner);
   }
   function applyStyleScoping(elm, owner, renderer) {
     const {
@@ -5699,7 +5905,7 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
   }
 
   /*
-   * Copyright (c) 2018, salesforce.com, inc.
+   * 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
@@ -5709,10 +5915,14 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
     ArrayPush$1.call(getVMBeingRendered().velements, vnode);
   }
   // [s]tatic [p]art
-  function sp(partId, data) {
+  function sp(partId, data, text) {
+    // Static part will always have either text or data, it's guaranteed by the compiler.
+    const type = isNull(text) ? 1 /* VStaticPartType.Element */ : 0 /* VStaticPartType.Text */;
     return {
+      type,
       partId,
       data,
+      text,
       elm: undefined // elm is defined later
     };
   }
@@ -5729,8 +5939,9 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
     };
   }
   // [st]atic node
-  function st(fragment, key, parts) {
+  function st(fragmentFactory, key, parts) {
     const owner = getVMBeingRendered();
+    const fragment = fragmentFactory(parts);
     const vnode = {
       type: 4 /* VNodeType.Static */,
       sel: undefined,
@@ -5772,9 +5983,6 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
       // checking reserved internal data properties
       assert.isFalse(data.className && data.classMap, `vnode.data.className and vnode.data.classMap ambiguous declaration.`);
       assert.isFalse(data.styleDecls && data.style, `vnode.data.styleDecls and vnode.data.style ambiguous declaration.`);
-      if (data.style && !isString(data.style)) {
-        logError(`Invalid 'style' attribute passed to <${sel}> is ignored. This attribute must be a string value.`, vmBeingRendered);
-      }
       forEach.call(children, childVnode => {
         if (childVnode != null) {
           assert.isTrue('type' in childVnode && 'sel' in childVnode && 'elm' in childVnode && 'key' in childVnode, `${childVnode} is not a vnode.`);
@@ -5984,22 +6192,28 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
       if (isArray$1(vnode)) {
         ArrayPush$1.apply(list, vnode);
       } else {
+        // `isArray` doesn't narrow this block properly...
         ArrayPush$1.call(list, vnode);
       }
       if (process.env.NODE_ENV !== 'production') {
         const vnodes = isArray$1(vnode) ? vnode : [vnode];
         forEach.call(vnodes, childVnode => {
-          if (!isNull(childVnode) && isObject(childVnode) && !isUndefined$1(childVnode.sel)) {
+          // Check that the child vnode is either an element or VStatic
+          if (!isNull(childVnode) && (isVBaseElement(childVnode) || isVStatic(childVnode))) {
             const {
               key
             } = childVnode;
+            // In @lwc/engine-server the fragment doesn't have a tagName, default to the VM's tagName.
+            const {
+              tagName
+            } = vmBeingRendered;
             if (isString(key) || isNumber(key)) {
               if (keyMap[key] === 1 && isUndefined$1(iterationError)) {
-                iterationError = `Duplicated "key" attribute value for "<${childVnode.sel}>" in ${vmBeingRendered} for item number ${j}. A key with value "${childVnode.key}" appears more than once in the iteration. Key values must be unique numbers or strings.`;
+                iterationError = `Duplicated "key" attribute value in "<${tagName}>" for item number ${j}. A key with value "${key}" appears more than once in the iteration. Key values must be unique numbers or strings.`;
               }
               keyMap[key] = 1;
             } else if (isUndefined$1(iterationError)) {
-              iterationError = `Invalid "key" attribute value in "<${childVnode.sel}>" in ${vmBeingRendered} for item number ${j}. Set a unique "key" value on all iterated child elements.`;
+              iterationError = `Invalid "key" attribute value in "<${tagName}>" for item number ${j}. Set a unique "key" value on all iterated child elements.`;
             }
           }
         });
@@ -6032,6 +6246,7 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
       if (isArray$1(item)) {
         ArrayPush$1.apply(flattened, item);
       } else {
+        // `isArray` doesn't narrow this block properly...
         ArrayPush$1.call(flattened, item);
       }
     }
@@ -6349,7 +6564,7 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
   }
 
   /*
-   * Copyright (c) 2018, salesforce.com, inc.
+   * 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
@@ -6386,6 +6601,28 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
       }
     }
   }
+  const browserExpressionSerializer = (partToken, classAttrToken) => {
+    // This will insert the scoped style token as a static class attribute in the fragment
+    // bypassing the need to call applyStyleScoping when mounting static parts.
+    const type = StringCharAt.call(partToken, 0);
+    switch (type) {
+      case "c" /* STATIC_PART_TOKEN_ID.CLASS */:
+        return classAttrToken;
+      case "t" /* STATIC_PART_TOKEN_ID.TEXT */:
+        // Using a single space here gives us a single empty text node
+        return ' ';
+      default:
+        return '';
+    }
+  };
+  // This function serializes the expressions generated by static content optimization.
+  // Currently this is only needed for SSR.
+  // TODO [#4078]: Split the implementation between @lwc/engine-dom and @lwc/engine-server
+  function buildSerializeExpressionFn(parts) {
+    {
+      return browserExpressionSerializer;
+    }
+  }
   // This should be a no-op outside of LWC's Karma tests, where it's not needed
   let registerFragmentCache = noop;
   // Only used in LWC's Karma tests
@@ -6407,7 +6644,7 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
     return (strings, ...keys) => {
       const cache = create(null);
       registerFragmentCache(cache);
-      return function () {
+      return function (parts) {
         const {
           context: {
             hasScopedStyles,
@@ -6427,14 +6664,27 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
         if (hasStyleToken && isSyntheticShadow) {
           cacheKey |= 2 /* FragmentCache.SHADOW_MODE_SYNTHETIC */;
         }
-        if (!isUndefined$1(cache[cacheKey])) {
-          return cache[cacheKey];
+        // Cache is only here to prevent calling innerHTML multiple times which doesn't happen on the server.
+        {
+          // Disable this on the server to prevent cache poisoning when expressions are used.
+          const cached = cache[cacheKey];
+          if (!isUndefined$1(cached)) {
+            return cached;
+          }
         }
         // If legacy stylesheet tokens are required, then add them to the rendered string
         const stylesheetTokenToRender = stylesheetToken + (hasLegacyToken ? ` ${legacyStylesheetToken}` : '');
         const classToken = hasScopedStyles && hasStyleToken ? ' ' + stylesheetTokenToRender : '';
         const classAttrToken = hasScopedStyles && hasStyleToken ? ` class="${stylesheetTokenToRender}"` : '';
         const attrToken = hasStyleToken && isSyntheticShadow ? ' ' + stylesheetTokenToRender : '';
+        // In the browser, we provide the entire class attribute as a perf optimization to avoid applying it on mount.
+        // The remaining class expression will be applied when the static parts are mounted.
+        // In SSR, the entire class attribute (expression included) is assembled along with the fragment.
+        // This is why in the browser we provide the entire class attribute and in SSR we only provide the class token.
+        const exprClassToken = classAttrToken;
+        // TODO [#3624]: The implementation of this function should be specific to @lwc/engine-dom and @lwc/engine-server.
+        // Find a way to split this in a future refactor.
+        const serializeExpression = buildSerializeExpressionFn();
         let htmlFragment = '';
         for (let i = 0, n = keys.length; i < n; i++) {
           switch (keys[i]) {
@@ -6454,6 +6704,10 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
               // ${1}${2}
               htmlFragment += strings[i] + classAttrToken + attrToken;
               break;
+            default:
+              // expressions ${partId:attributeName/textId}
+              htmlFragment += strings[i] + serializeExpression(keys[i], exprClassToken);
+              break;
           }
         }
         htmlFragment += strings[strings.length - 1];
@@ -7387,7 +7641,7 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
       scheduleRehydration(vm);
     }
   }
-  function runFormAssociatedCustomElementCallback(vm, faceCb) {
+  function runFormAssociatedCustomElementCallback(vm, faceCb, args) {
     const {
       renderMode,
       shadowMode
@@ -7395,24 +7649,24 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
     if (shadowMode === 1 /* ShadowMode.Synthetic */ && renderMode !== 0 /* RenderMode.Light */) {
       throw new Error('Form associated lifecycle methods are not available in synthetic shadow. Please use native shadow or light DOM.');
     }
-    invokeComponentCallback(vm, faceCb);
+    invokeComponentCallback(vm, faceCb, args);
   }
-  function runFormAssociatedCallback(elm) {
+  function runFormAssociatedCallback(elm, form) {
     const vm = getAssociatedVM(elm);
     const {
       formAssociatedCallback
     } = vm.def;
     if (!isUndefined$1(formAssociatedCallback)) {
-      runFormAssociatedCustomElementCallback(vm, formAssociatedCallback);
+      runFormAssociatedCustomElementCallback(vm, formAssociatedCallback, [form]);
     }
   }
-  function runFormDisabledCallback(elm) {
+  function runFormDisabledCallback(elm, disabled) {
     const vm = getAssociatedVM(elm);
     const {
       formDisabledCallback
     } = vm.def;
     if (!isUndefined$1(formDisabledCallback)) {
-      runFormAssociatedCustomElementCallback(vm, formDisabledCallback);
+      runFormAssociatedCustomElementCallback(vm, formDisabledCallback, [disabled]);
     }
   }
   function runFormResetCallback(elm) {
@@ -7424,13 +7678,13 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
       runFormAssociatedCustomElementCallback(vm, formResetCallback);
     }
   }
-  function runFormStateRestoreCallback(elm) {
+  function runFormStateRestoreCallback(elm, state, reason) {
     const vm = getAssociatedVM(elm);
     const {
       formStateRestoreCallback
     } = vm.def;
     if (!isUndefined$1(formStateRestoreCallback)) {
-      runFormAssociatedCustomElementCallback(vm, formStateRestoreCallback);
+      runFormAssociatedCustomElementCallback(vm, formStateRestoreCallback, [state, reason]);
     }
   }
   function resetRefVNodes(vm) {
@@ -7800,9 +8054,12 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
     if (!hasCorrectNodeType(vnode, node, 3 /* EnvNodeTypes.TEXT */, renderer)) {
       return handleMismatch(node, vnode, renderer);
     }
+    return updateTextContent(node, vnode, vnode.owner, renderer);
+  }
+  function updateTextContent(node, vnode, owner, renderer) {
     if (process.env.NODE_ENV !== 'production') {
       if (!textNodeContentsAreEqual(node, vnode, renderer)) {
-        logWarn('Hydration mismatch: text values do not match, will recover from the difference', vnode.owner);
+        logWarn('Hydration mismatch: text values do not match, will recover from the difference', owner);
       }
     }
     const {
@@ -7833,11 +8090,26 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
     return node;
   }
   function hydrateStaticElement(elm, vnode, renderer) {
-    if (!hasCorrectNodeType(vnode, elm, 1 /* EnvNodeTypes.ELEMENT */, renderer) || !areCompatibleNodes(vnode.fragment, elm, vnode, renderer)) {
+    if (!hasCorrectNodeType(vnode, elm, 1 /* EnvNodeTypes.ELEMENT */, renderer) || !areCompatibleStaticNodes(vnode.fragment, elm, vnode, renderer)) {
+      return handleMismatch(elm, vnode, renderer);
+    }
+    return hydrateStaticElementParts(elm, vnode, renderer);
+  }
+  function hydrateStaticElementParts(elm, vnode, renderer) {
+    const {
+      parts
+    } = vnode;
+    if (!isUndefined$1(parts)) {
+      // Elements must first be set on the static part to validate against.
+      traverseAndSetElements(elm, parts, renderer);
+    }
+    if (!haveCompatibleStaticParts(vnode, renderer)) {
       return handleMismatch(elm, vnode, renderer);
     }
     vnode.elm = elm;
-    mountStaticParts(elm, vnode, renderer);
+    // Hydration only requires applying event listeners and refs.
+    // All other expressions should be applied during SSR or through the handleMismatch routine.
+    hydrateStaticParts(vnode, renderer);
     return elm;
   }
   function hydrateFragment(elm, vnode, renderer) {
@@ -8045,9 +8317,12 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
       }
       return false;
     }
-    const hasCompatibleAttrs = validateAttrs(vnode, elm, renderer, shouldValidateAttr);
-    const hasCompatibleClass = shouldValidateAttr('class') ? validateClassAttr(vnode, elm, renderer) : true;
-    const hasCompatibleStyle = shouldValidateAttr('style') ? validateStyleAttr(vnode, elm, renderer) : true;
+    const {
+      data
+    } = vnode;
+    const hasCompatibleAttrs = validateAttrs(vnode, elm, data, renderer, shouldValidateAttr);
+    const hasCompatibleClass = shouldValidateAttr('class') ? validateClassAttr(vnode, elm, data, renderer) : true;
+    const hasCompatibleStyle = shouldValidateAttr('style') ? validateStyleAttr(vnode, elm, data, renderer) : true;
     return hasCompatibleAttrs && hasCompatibleClass && hasCompatibleStyle;
   }
   function attributeValuesAreEqual(vnodeValue, value) {
@@ -8063,12 +8338,10 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
     // In all other cases, the two values are not considered equal
     return false;
   }
-  function validateAttrs(vnode, elm, renderer, shouldValidateAttr) {
+  function validateAttrs(vnode, elm, data, renderer, shouldValidateAttr) {
     const {
-      data: {
-        attrs = {}
-      }
-    } = vnode;
+      attrs = {}
+    } = data;
     let nodesAreCompatible = true;
     // Validate attributes, though we could always recovery from those by running the update mods.
     // Note: intentionally ONLY matching vnodes.attrs to elm.attrs, in case SSR is adding extra attributes.
@@ -8076,9 +8349,6 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
       if (!shouldValidateAttr(attrName)) {
         continue;
       }
-      const {
-        owner
-      } = vnode;
       const {
         getAttribute
       } = renderer;
@@ -8088,18 +8358,19 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
           const {
             getProperty
           } = renderer;
-          logError(`Mismatch hydrating element <${getProperty(elm, 'tagName').toLowerCase()}>: attribute "${attrName}" has different values, expected "${attrValue}" but found ${isNull(elmAttrValue) ? 'null' : `"${elmAttrValue}"`}`, owner);
+          logError(`Mismatch hydrating element <${getProperty(elm, 'tagName').toLowerCase()}>: attribute "${attrName}" has different values, expected "${attrValue}" but found ${isNull(elmAttrValue) ? 'null' : `"${elmAttrValue}"`}`, vnode.owner);
         }
         nodesAreCompatible = false;
       }
     }
     return nodesAreCompatible;
   }
-  function validateClassAttr(vnode, elm, renderer) {
+  function validateClassAttr(vnode, elm, data, renderer) {
     const {
-      data,
       owner
     } = vnode;
+    // classMap is never available on VStaticPartData so it can default to undefined
+    // casting to prevent TS error.
     let {
       className,
       classMap
@@ -8179,13 +8450,12 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
     }
     return nodesAreCompatible;
   }
-  function validateStyleAttr(vnode, elm, renderer) {
+  function validateStyleAttr(vnode, elm, data, renderer) {
+    // Note styleDecls is always undefined for VStaticPartData, casting here to default it to undefined
     const {
-      data: {
-        style,
-        styleDecls
-      }
-    } = vnode;
+      style,
+      styleDecls
+    } = data;
     const {
       getAttribute
     } = renderer;
@@ -8226,7 +8496,7 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
     }
     return nodesAreCompatible;
   }
-  function areCompatibleNodes(client, ssr, vnode, renderer) {
+  function areCompatibleStaticNodes(client, ssr, vnode, renderer) {
     const {
       getProperty,
       getAttribute
@@ -8246,24 +8516,72 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
     if (!hasCorrectNodeType(vnode, ssr, 1 /* EnvNodeTypes.ELEMENT */, renderer)) {
       return false;
     }
+    const {
+      owner,
+      parts
+    } = vnode;
     let isCompatibleElements = true;
     if (getProperty(client, 'tagName') !== getProperty(ssr, 'tagName')) {
       if (process.env.NODE_ENV !== 'production') {
-        logError(`Hydration mismatch: expecting element with tag "${getProperty(client, 'tagName').toLowerCase()}" but found "${getProperty(ssr, 'tagName').toLowerCase()}".`, vnode.owner);
+        logError(`Hydration mismatch: expecting element with tag "${getProperty(client, 'tagName').toLowerCase()}" but found "${getProperty(ssr, 'tagName').toLowerCase()}".`, owner);
       }
       return false;
     }
     const clientAttrsNames = getProperty(client, 'getAttributeNames').call(client);
     clientAttrsNames.forEach(attrName => {
       if (getAttribute(client, attrName) !== getAttribute(ssr, attrName)) {
-        if (process.env.NODE_ENV !== 'production') {
-          logError(`Mismatch hydrating element <${getProperty(client, 'tagName').toLowerCase()}>: attribute "${attrName}" has different values, expected "${getAttribute(client, attrName)}" but found "${getAttribute(ssr, attrName)}"`, vnode.owner);
+        // Check if the root element attributes have expressions, if it does then we need to delegate hydration
+        // validation to haveCompatibleStaticParts.
+        // Note if there are no parts then it is a fully static fragment.
+        // partId === 0 will always refer to the root element, this is guaranteed by the compiler.
+        if (parts?.[0].partId !== 0) {
+          if (process.env.NODE_ENV !== 'production') {
+            logError(`Mismatch hydrating element <${getProperty(client, 'tagName').toLowerCase()}>: attribute "${attrName}" has different values, expected "${getAttribute(client, attrName)}" but found "${getAttribute(ssr, attrName)}"`, owner);
+          }
+          isCompatibleElements = false;
         }
-        isCompatibleElements = false;
       }
     });
     return isCompatibleElements;
   }
+  function haveCompatibleStaticParts(vnode, renderer) {
+    const {
+      parts,
+      owner
+    } = vnode;
+    if (isUndefined$1(parts)) {
+      return true;
+    }
+    // The validation here relies on 2 key invariants:
+    // 1. It's never the case that `parts` is undefined on the server but defined on the client (or vice-versa)
+    // 2. It's never the case that `parts` has one length on the server but another on the client
+    for (const part of parts) {
+      const {
+        elm
+      } = part;
+      if (isVStaticPartElement(part)) {
+        if (!hasCorrectNodeType(vnode, elm, 1 /* EnvNodeTypes.ELEMENT */, renderer)) {
+          return false;
+        }
+        const {
+          data
+        } = part;
+        const hasMatchingAttrs = validateAttrs(vnode, elm, data, renderer, () => true);
+        const hasMatchingStyleAttr = validateStyleAttr(vnode, elm, data, renderer);
+        const hasMatchingClass = validateClassAttr(vnode, elm, data, renderer);
+        if (isFalse(hasMatchingAttrs && hasMatchingStyleAttr && hasMatchingClass)) {
+          return false;
+        }
+      } else {
+        // VStaticPartText
+        if (!hasCorrectNodeType(vnode, elm, 3 /* EnvNodeTypes.TEXT */, renderer)) {
+          return false;
+        }
+        updateTextContent(elm, part, owner, renderer);
+      }
+    }
+    return true;
+  }
 
   /*
    * Copyright (c) 2018, salesforce.com, inc.
@@ -8279,7 +8597,7 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
   }
 
   /*
-   * Copyright (c) 2018, salesforce.com, inc.
+   * 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
@@ -8336,9 +8654,9 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
     // we can at least warn when they use the most common mutation methods.
     for (const prop of ARRAY_MUTATION_METHODS) {
       const originalArrayMethod = getOriginalArrayMethod(prop);
+      // Assertions used here because TypeScript can't handle mapping over our types
       stylesheets[prop] = function arrayMutationWarningWrapper() {
         reportTemplateViolation('stylesheets');
-        // @ts-expect-error can't properly determine the right `this`
         return originalArrayMethod.apply(this, arguments);
       };
     }
@@ -8520,7 +8838,7 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
     }
     return getReadOnlyProxy(obj);
   }
-  /** version: 6.3.4 */
+  /** version: 6.6.3 */
 
   /*
    * Copyright (c) 2018, salesforce.com, inc.
@@ -8650,7 +8968,7 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
     stylesheet.replaceSync(content);
     return stylesheet;
   }
-  function insertConstructableStylesheet(content, target, cacheData) {
+  function insertConstructableStylesheet(content, target, cacheData, signal) {
     const {
       adoptedStyleSheets
     } = target;
@@ -8659,10 +8977,32 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
     } = cacheData;
     // The reason we prefer .push() rather than reassignment is for perf: https://github.com/salesforce/lwc/pull/2683
     adoptedStyleSheets.push(stylesheet);
+    if (process.env.NODE_ENV !== 'production') {
+      /* istanbul ignore if */
+      if (isUndefined$1(signal)) {
+        throw new Error('Expected AbortSignal to be defined in dev mode');
+      }
+      // TODO [#4155]: unrendering should account for stylesheet content collisions
+      signal.addEventListener('abort', () => {
+        adoptedStyleSheets.splice(adoptedStyleSheets.indexOf(stylesheet), 1);
+        stylesheetCache.delete(content);
+      });
+    }
   }
-  function insertStyleElement(content, target, cacheData) {
+  function insertStyleElement(content, target, cacheData, signal) {
     const elm = createStyleElement(content, cacheData);
     target.appendChild(elm);
+    if (process.env.NODE_ENV !== 'production') {
+      /* istanbul ignore if */
+      if (isUndefined$1(signal)) {
+        throw new Error('Expected AbortSignal to be defined in dev mode');
+      }
+      // TODO [#4155]: unrendering should account for stylesheet content collisions
+      signal.addEventListener('abort', () => {
+        target.removeChild(elm);
+        stylesheetCache.delete(content);
+      });
+    }
   }
   function getCacheData(content, useConstructableStylesheet) {
     let cacheData = stylesheetCache.get(content);
@@ -8684,7 +9024,7 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
     }
     return cacheData;
   }
-  function insertGlobalStylesheet(content) {
+  function insertGlobalStylesheet(content, signal) {
     // Force a <style> element for global stylesheets. See comment below.
     const cacheData = getCacheData(content, false);
     if (cacheData.global) {
@@ -8693,9 +9033,9 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
     }
     cacheData.global = true; // mark inserted
     // TODO [#2922]: use document.adoptedStyleSheets in supported browsers. Currently we can't, due to backwards compat.
-    insertStyleElement(content, document.head, cacheData);
+    insertStyleElement(content, document.head, cacheData, signal);
   }
-  function insertLocalStylesheet(content, target) {
+  function insertLocalStylesheet(content, target, signal) {
     const cacheData = getCacheData(content, supportsConstructableStylesheets);
     let {
       roots
@@ -8711,19 +9051,25 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
     // https://caniuse.com/mdn-api_document_adoptedstylesheets
     // The reason we use it is for perf: https://github.com/salesforce/lwc/pull/2460
     if (supportsConstructableStylesheets) {
-      insertConstructableStylesheet(content, target, cacheData);
+      insertConstructableStylesheet(content, target, cacheData, signal);
     } else {
       // Fall back to <style> element
-      insertStyleElement(content, target, cacheData);
+      insertStyleElement(content, target, cacheData, signal);
     }
   }
-  function insertStylesheet(content, target) {
+  /**
+   * Injects a stylesheet into the global (document) level or inside a shadow root.
+   * @param content CSS content to insert
+   * @param target ShadowRoot to insert into, or undefined if global (document) level
+   * @param signal AbortSignal for aborting the stylesheet render. Used in dev mode for HMR to unrender stylesheets.
+   */
+  function insertStylesheet(content, target, signal) {
     if (isUndefined$1(target)) {
       // global
-      insertGlobalStylesheet(content);
+      insertGlobalStylesheet(content, signal);
     } else {
       // local
-      insertLocalStylesheet(content, target);
+      insertLocalStylesheet(content, target, signal);
     }
   }
 
@@ -8733,25 +9079,19 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
    * SPDX-License-Identifier: MIT
    * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
    */
-  const LIFECYCLE_CALLBACKS = {
-    connectedCallback: connectRootElement,
-    disconnectedCallback: disconnectRootElement,
-    formAssociatedCallback: runFormAssociatedCallback,
-    formDisabledCallback: runFormDisabledCallback,
-    formResetCallback: runFormResetCallback,
-    formStateRestoreCallback: runFormStateRestoreCallback
-  };
   const cachedConstructors = new Map();
   const nativeLifecycleElementsToUpgradedByLWC = new WeakMap();
   let elementBeingUpgradedByLWC = false;
-  // Creates a constructor that is intended to be used directly as a custom element, except that the upgradeCallback is
-  // passed in to the constructor so LWC can reuse the same custom element constructor for multiple components.
-  // Another benefit is that only LWC can create components that actually do anything – if you do
-  // `customElements.define('x-foo')`, then you don't have access to the upgradeCallback, so it's a dummy custom element.
-  // This class should be created once per tag name.
-  const createUpgradableConstructor = isFormAssociated => {
+  let BaseUpgradableConstructor;
+  let BaseHTMLElement;
+  function createBaseUpgradableConstructor() {
+    // Creates a constructor that is intended to be used directly as a custom element, except that the upgradeCallback is
+    // passed in to the constructor so LWC can reuse the same custom element constructor for multiple components.
+    // Another benefit is that only LWC can create components that actually do anything – if you do
+    // `customElements.define('x-foo')`, then you don't have access to the upgradeCallback, so it's a dummy custom element.
+    // This class should be created once per tag name.
     // TODO [#2972]: this class should expose observedAttributes as necessary
-    class UpgradableConstructor extends HTMLElement {
+    BaseUpgradableConstructor = class TheBaseUpgradableConstructor extends HTMLElement {
       constructor(upgradeCallback, useNativeLifecycle) {
         super();
         if (useNativeLifecycle) {
@@ -8768,17 +9108,57 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
         // TODO [#2970]: LWC elements cannot be upgraded via new Ctor()
         // Do we want to support this? Throw an error? Currently for backwards compat it's a no-op.
       }
-      /*LWC compiler v6.3.4*/
-    }
-    UpgradableConstructor.formAssociated = isFormAssociated;
-    for (const [propName, callback] of entries(LIFECYCLE_CALLBACKS)) {
-      UpgradableConstructor.prototype[propName] = function () {
-        // If the element is in the WeakMap (i.e. it's marked as native lifecycle), and if it was upgraded by LWC,
-        // then it can use native lifecycle
+      connectedCallback() {
         if (isTrue(nativeLifecycleElementsToUpgradedByLWC.get(this))) {
-          callback(this);
+          connectRootElement(this);
         }
-      };
+      }
+      disconnectedCallback() {
+        if (isTrue(nativeLifecycleElementsToUpgradedByLWC.get(this))) {
+          disconnectRootElement(this);
+        }
+      }
+      formAssociatedCallback(form) {
+        if (isTrue(nativeLifecycleElementsToUpgradedByLWC.get(this))) {
+          runFormAssociatedCallback(this, form);
+        }
+      }
+      formDisabledCallback(disabled) {
+        if (isTrue(nativeLifecycleElementsToUpgradedByLWC.get(this))) {
+          runFormDisabledCallback(this, disabled);
+        }
+      }
+      formResetCallback() {
+        if (isTrue(nativeLifecycleElementsToUpgradedByLWC.get(this))) {
+          runFormResetCallback(this);
+        }
+      }
+      formStateRestoreCallback(state, reason) {
+        if (isTrue(nativeLifecycleElementsToUpgradedByLWC.get(this))) {
+          runFormStateRestoreCallback(this, state, reason);
+        }
+      }
+      /*LWC compiler v6.6.3*/
+    };
+    BaseHTMLElement = HTMLElement; // cache to track if it changes
+  }
+  const createUpgradableConstructor = isFormAssociated => {
+    if (HTMLElement !== BaseHTMLElement) {
+      // If the global HTMLElement changes out from under our feet, then we need to create a new
+      // BaseUpgradableConstructor from scratch (since it extends from HTMLElement). This can occur if
+      // polyfills are in play, e.g. a polyfill for scoped custom element registries.
+      // This workaround can potentially be removed when W-15361244 is resolved.
+      createBaseUpgradableConstructor();
+    }
+    // Using a BaseUpgradableConstructor superclass here is a perf optimization to avoid
+    // re-defining the same logic (connectedCallback, disconnectedCallback, etc.) over and over.
+    class UpgradableConstructor extends BaseUpgradableConstructor {
+      /*LWC compiler v6.6.3*/
+    }
+    if (isFormAssociated) {
+      // Perf optimization - the vast majority of components have formAssociated=false,
+      // so we can skip the setter in those cases, since undefined works the same as false.
+      UpgradableConstructor.formAssociated = isFormAssociated;
     }
     return UpgradableConstructor;
   };
@@ -8796,11 +9176,11 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
   }
   const createCustomElement = (tagName, upgradeCallback, useNativeLifecycle, isFormAssociated) => {
     const UpgradableConstructor = getUpgradableConstructor(tagName, isFormAssociated);
+    if (Boolean(UpgradableConstructor.formAssociated) !== isFormAssociated) {
+      throw new Error(`<${tagName}> was already registered with formAssociated=${UpgradableConstructor.formAssociated}. It cannot be re-registered with formAssociated=${isFormAssociated}. Please rename your component to have a different name than <${tagName}>`);
+    }
     elementBeingUpgradedByLWC = true;
     try {
-      if (UpgradableConstructor.formAssociated !== isFormAssociated) {
-        throw new Error(`<${tagName}> was already registered with formAssociated=${UpgradableConstructor.formAssociated}. It cannot be re-registered with formAssociated=${isFormAssociated}. Please rename your component to have a different name than <${tagName}>`);
-      }
       return new UpgradableConstructor(upgradeCallback, useNativeLifecycle);
     } finally {
       elementBeingUpgradedByLWC = false;
@@ -8896,7 +9276,7 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
       function isNull(obj) {
         return obj === null;
       }
-      /** version: 6.3.4 */
+      /** version: 6.6.3 */
 
       /*
        * Copyright (c) 2023, salesforce.com, inc.
@@ -8916,7 +9296,7 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
           this.setNewContext = setNewContext;
           this.setDisconnectedCallback = setDisconnectedCallback;
         }
-        /*LWC compiler v6.3.4*/
+        /*LWC compiler v6.6.3*/
       }
       function registerContextConsumer(elm, adapterContextToken, subscriptionPayload) {
         dispatchEvent(elm, new WireContextSubscriptionEvent(adapterContextToken, subscriptionPayload));
@@ -8971,6 +9351,9 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
       function previousSibling(node) {
         return node.previousSibling;
       }
+      function getParentNode(node) {
+        return node.parentNode;
+      }
       function attachShadow(element, options) {
         // `shadowRoot` will be non-null in two cases:
         //   1. upon initial load with an SSR-generated DOM, while in Shadow render mode
@@ -9095,6 +9478,7 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
       exports.getFirstElementChild = getFirstElementChild;
       exports.getLastChild = getLastChild;
       exports.getLastElementChild = getLastElementChild;
+      exports.getParentNode = getParentNode;
       exports.getProperty = getProperty;
       exports.getTagName = getTagName;
       exports.insert = insert;
@@ -9314,19 +9698,19 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
       attributeChangedCallback(name, oldValue, newValue) {
         attributeChangedCallback.call(this, name, oldValue, newValue);
       }
-      formAssociatedCallback() {
-        runFormAssociatedCallback(this);
+      formAssociatedCallback(form) {
+        runFormAssociatedCallback(this, form);
       }
-      formDisabledCallback() {
-        runFormDisabledCallback(this);
+      formDisabledCallback(disabled) {
+        runFormDisabledCallback(this, disabled);
       }
       formResetCallback() {
         runFormResetCallback(this);
       }
-      formStateRestoreCallback() {
-        runFormStateRestoreCallback(this);
+      formStateRestoreCallback(state, reason) {
+        runFormStateRestoreCallback(this, state, reason);
       }
-      /*LWC compiler v6.3.4*/
+      /*LWC compiler v6.6.3*/
     }, _a.observedAttributes = observedAttributes,
     // Note CustomElementConstructor is not upgraded by LWC and inherits directly from HTMLElement which means it calls the native
     // attachInternals API.
@@ -9390,9 +9774,6 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
       }
     });
   }
-  // For some reason, JSDOC says "options.is" is a syntax error. And we can't disable the rule using
-  // `eslint-disable-next-line` because that gets included in the JSDOC, so we need this workaround.
-  /* eslint-disable jsdoc/valid-types */
   /**
    * EXPERIMENTAL: This function is almost identical to document.createElement with the slightly
    * difference that in the options, you can pass the `is` property set to a Constructor instead of
@@ -9407,8 +9788,7 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
    * @example
    * const el = createElement('x-foo', { is: FooCtor });
    */
-  function createElement( /* eslint-enable jsdoc/valid-types */
-  sel, options) {
+  function createElement(sel, options) {
     if (!isObject(options) || isNull(options)) {
       throw new TypeError(`"createElement" function expects an object as second parameter but received "${toString$1(options)}".`);
     }
@@ -9559,7 +9939,7 @@ LWR.define('lwc/v/6_3_4', ['exports'], (function (exports) { 'use strict';
       });
     });
   }
-  /** version: 6.3.4 */
+  /** version: 6.6.3 */
 
   exports.LightningElement = LightningElement;
   exports.__unstable__ProfilerControl = profilerControl;