@lwc/engine-core 5.3.0 → 6.1.0

package/dist/framework/modules/attrs.d.ts

@@ -1,3 +1,4 @@
 import { RendererAPI } from '../renderer';
-import { VBaseElement } from '../vnodes';
+import { VBaseElement, VStatic } from '../vnodes';
 export declare function patchAttributes(oldVnode: VBaseElement | null, vnode: VBaseElement, renderer: RendererAPI): void;
+export declare function patchSlotAssignment(oldVnode: VBaseElement | VStatic | null, vnode: VBaseElement | VStatic, renderer: RendererAPI): void;

package/dist/framework/renderer.d.ts

@@ -42,7 +42,7 @@ export interface RendererAPI {
     isConnected: (node: N) => boolean;
     insertStylesheet: (content: string, target?: ShadowRoot) => void;
     assertInstanceOfHTMLElement: (elm: any, msg: string) => void;
-    createCustomElement: (tagName: string, upgradeCallback: LifecycleCallback) => E;
+    createCustomElement: (tagName: string, upgradeCallback: LifecycleCallback, useNativeLifecycle: boolean) => E;
     defineCustomElement: (tagName: string) => void;
     ownerDocument(elm: E): Document;
     registerContextConsumer: (element: E, adapterContextToken: string, subscriptionPayload: WireContextSubscriptionPayload) => void;

package/dist/framework/restrictions.d.ts

@@ -1,4 +1,3 @@
-import { LightningElement } from './base-lightning-element';
 export declare function unlockDomMutation(): void;
 export declare function lockDomMutation(): void;
 export declare function patchElementWithRestrictions(elm: Element, options: {
@@ -8,4 +7,3 @@ export declare function patchElementWithRestrictions(elm: Element, options: {
 }): void;
 export declare function patchShadowRootWithRestrictions(sr: ShadowRoot): void;
 export declare function patchCustomElementWithRestrictions(elm: HTMLElement): void;
-export declare function patchLightningElementPrototypeWithRestrictions(proto: typeof LightningElement.prototype): void;

package/dist/framework/utils.d.ts

@@ -1,10 +1,12 @@
 import { StylesheetFactory, TemplateStylesheetFactories } from './stylesheet';
+import { LightningElementConstructor } from './base-lightning-element';
 type Callback = () => void;
 export declare const SPACE_CHAR = 32;
 export declare const EmptyObject: any;
 export declare const EmptyArray: never[];
 export declare function addCallbackToNextTick(callback: Callback): void;
 export declare function guid(): string;
+export declare function shouldUseNativeCustomElementLifecycle(ctor: LightningElementConstructor): boolean;
 export declare function parseStyleText(cssText: string): {
     [name: string]: string;
 };

package/dist/framework/vm.d.ts

@@ -30,7 +30,6 @@ export declare const enum ShadowMode {
     Synthetic = 1
 }
 export declare const enum ShadowSupportMode {
-    Any = "any",
     Default = "reset",
     Native = "native"
 }

package/dist/framework/vnodes.d.ts

@@ -40,6 +40,7 @@ export interface VStatic extends BaseVNode {
     readonly fragment: Element;
     readonly parts: VStaticPart[] | undefined;
     elm: Element | undefined;
+    slotAssignment: string | undefined;
 }
 export interface VFragment extends BaseVNode, BaseVParent {
     sel: undefined;
@@ -65,6 +66,7 @@ export interface VBaseElement extends BaseVNode, BaseVParent {
     data: VElementData;
     elm: Element | undefined;
     key: Key;
+    slotAssignment: string | undefined;
 }
 export interface VElement extends VBaseElement {
     type: VNodeType.Element;
@@ -93,9 +95,11 @@ export interface VElementData extends VNodeData {
     readonly external?: boolean;
     readonly ref?: string;
     readonly slotData?: any;
+    readonly slotAssignment?: string;
 }
 export declare function isVBaseElement(vnode: VNode): vnode is VElement | VCustomElement;
 export declare function isSameVnode(vnode1: VNode, vnode2: VNode): boolean;
 export declare function isVCustomElement(vnode: VNode | VBaseElement): vnode is VCustomElement;
 export declare function isVFragment(vnode: VNode): vnode is VFragment;
 export declare function isVScopedSlotFragment(vnode: VNode): vnode is VScopedSlotFragment;
+export declare function isVStatic(vnode: VNode): vnode is VStatic;

package/dist/index.cjs.js

@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2023 salesforce.com, inc.
+ * Copyright (c) 2024 Salesforce, Inc.
  */
 'use strict';
 
@@ -358,6 +358,14 @@ function guid() {
     }
     return s4() + s4() + '-' + s4() + '-' + s4() + '-' + s4() + '-' + s4() + s4() + s4();
 }
+function shouldUseNativeCustomElementLifecycle(ctor) {
+    if (lwcRuntimeFlags.DISABLE_NATIVE_CUSTOM_ELEMENT_LIFECYCLE) {
+        // temporary "kill switch"
+        return false;
+    }
+    const apiVersion = getComponentAPIVersion(ctor);
+    return shared.isAPIFeatureEnabled(7 /* APIFeature.ENABLE_NATIVE_CUSTOM_ELEMENT_LIFECYCLE */, apiVersion);
+}
 // Borrowed from Vue template compiler.
 // https://github.com/vuejs/vue/blob/531371b818b0e31a989a06df43789728f23dc4e8/src/platforms/web/util/style.js#L5-L16
 const DECLARATION_DELIMITER = /;(?![^(]*\))/g;
@@ -421,8 +429,8 @@ function isCircularModuleDependency(obj) {
 }
 
 var _a, _b;
-const instrumentDef = (_a = shared.globalThis.__lwc_instrument_cmp_def) !== null && _a !== void 0 ? _a : shared.noop;
-const instrumentInstance = (_b = shared.globalThis.__lwc_instrument_cmp_instance) !== null && _b !== void 0 ? _b : shared.noop;
+const instrumentDef = (_a = globalThis.__lwc_instrument_cmp_def) !== null && _a !== void 0 ? _a : shared.noop;
+const instrumentInstance = (_b = globalThis.__lwc_instrument_cmp_instance) !== null && _b !== void 0 ? _b : shared.noop;
 
 /*
  * Copyright (c) 2018, salesforce.com, inc.
@@ -726,28 +734,6 @@ function getCustomElementRestrictionsDescriptors(elm) {
         }),
     };
 }
-function getLightningElementPrototypeRestrictionsDescriptors(proto) {
-    assertNotProd(); // this method should never leak to prod
-    const originalDispatchEvent = proto.dispatchEvent;
-    return {
-        dispatchEvent: generateDataDescriptor({
-            value(event) {
-                const vm = getAssociatedVM(this);
-                if (!shared.isNull(event) && shared.isObject(event)) {
-                    const { type } = event;
-                    if (!/^[a-z][a-z0-9_]*$/.test(type)) {
-                        logError(`Invalid event type "${type}" dispatched in element ${getComponentTag(vm)}.` +
-                            ` Event name must start with a lowercase letter and followed only lowercase` +
-                            ` letters, numbers, and underscores`, vm);
-                    }
-                }
-                // Typescript does not like it when you treat the `arguments` object as an array
-                // @ts-ignore type-mismatch
-                return originalDispatchEvent.apply(this, arguments);
-            },
-        }),
-    };
-}
 // This routine will prevent access to certain properties on a shadow root instance to guarantee
 // that all components will work fine in IE11 and other browsers without shadow dom support.
 function patchShadowRootWithRestrictions(sr) {
@@ -758,9 +744,6 @@ function patchCustomElementWithRestrictions(elm) {
     const elmProto = shared.getPrototypeOf(elm);
     shared.setPrototypeOf(elm, shared.create(elmProto, restrictionsDescriptors));
 }
-function patchLightningElementPrototypeWithRestrictions(proto) {
-    shared.defineProperties(proto, getLightningElementPrototypeRestrictionsDescriptors(proto));
-}
 
 function updateComponentValue(vm, key, newValue) {
     const { cmpFields } = vm;
@@ -1944,9 +1927,6 @@ shared.defineProperty(LightningElement, 'CustomElementConstructor', {
     },
     configurable: true,
 });
-if (process.env.NODE_ENV !== 'production') {
-    patchLightningElementPrototypeWithRestrictions(LightningElement.prototype);
-}
 
 function createObservedFieldPropertyDescriptor(key) {
     return {
@@ -3167,7 +3147,6 @@ function createComponentDef(Ctor) {
             logError(`Missing ${ctorName}.constructor, ${ctorName} should have a "constructor" property.`);
         }
         if (!shared.isUndefined(ctorShadowSupportMode) &&
-            ctorShadowSupportMode !== "any" /* ShadowSupportMode.Any */ &&
             ctorShadowSupportMode !== "reset" /* ShadowSupportMode.Default */ &&
             ctorShadowSupportMode !== "native" /* ShadowSupportMode.Native */) {
             logError(`Invalid value for static property shadowSupportMode: '${ctorShadowSupportMode}'`);
@@ -3595,6 +3574,9 @@ function isVFragment(vnode) {
 function isVScopedSlotFragment(vnode) {
     return vnode.type === 6 /* VNodeType.ScopedSlotFragment */;
 }
+function isVStatic(vnode) {
+    return vnode.type === 4 /* VNodeType.Static */;
+}
 
 /*
  * Copyright (c) 2018, salesforce.com, inc.
@@ -3643,6 +3625,20 @@ function patchAttributes(oldVnode, vnode, renderer) {
         }
     }
 }
+function patchSlotAssignment(oldVnode, vnode, renderer) {
+    const { slotAssignment } = vnode;
+    if ((oldVnode === null || oldVnode === void 0 ? void 0 : oldVnode.slotAssignment) === slotAssignment) {
+        return;
+    }
+    const { elm } = vnode;
+    const { setAttribute, removeAttribute } = renderer;
+    if (shared.isUndefined(slotAssignment) || shared.isNull(slotAssignment)) {
+        removeAttribute(elm, 'slot');
+    }
+    else {
+        setAttribute(elm, 'slot', slotAssignment);
+    }
+}
 
 /*
  * Copyright (c) 2018, salesforce.com, inc.
@@ -4092,6 +4088,8 @@ function mountElement(vnode, parent, anchor, renderer) {
 }
 function patchStatic(n1, n2, renderer) {
     const elm = (n2.elm = n1.elm);
+    // 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
     applyStaticParts(elm, n2, renderer, false);
 }
@@ -4113,11 +4111,13 @@ function mountStatic(vnode, parent, anchor, renderer) {
             elm[shared.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);
     applyStaticParts(elm, vnode, renderer, true);
 }
 function mountCustomElement(vnode, parent, anchor, renderer) {
-    const { sel, owner } = vnode;
+    const { sel, owner, ctor } = vnode;
     const { createCustomElement } = renderer;
     /**
      * Note: if the upgradable constructor does not expect, or throw when we new it
@@ -4135,7 +4135,8 @@ function mountCustomElement(vnode, parent, anchor, renderer) {
     // compiler may generate tagnames with uppercase letters so - for backwards
     // compatibility, we lower case the tagname here.
     const normalizedTagname = sel.toLowerCase();
-    const elm = createCustomElement(normalizedTagname, upgradeCallback);
+    const useNativeLifecycle = shouldUseNativeCustomElementLifecycle(ctor);
+    const elm = createCustomElement(normalizedTagname, upgradeCallback, useNativeLifecycle);
     vnode.elm = elm;
     vnode.vm = vm;
     linkNodeToShadow(elm, owner, renderer);
@@ -4147,7 +4148,7 @@ function mountCustomElement(vnode, parent, anchor, renderer) {
     insertNode(elm, parent, anchor, renderer);
     if (vm) {
         if (process.env.IS_BROWSER) {
-            if (!lwcRuntimeFlags.ENABLE_NATIVE_CUSTOM_ELEMENT_LIFECYCLE) {
+            if (!useNativeLifecycle) {
                 if (process.env.NODE_ENV !== 'production') {
                     // With synthetic lifecycle callbacks, it's possible for elements to be removed without the engine
                     // noticing it (e.g. `appendChild` the same host element twice). This test ensures we don't regress.
@@ -4338,6 +4339,7 @@ function patchElementPropsAndAttrsAndRefs$1(oldVnode, vnode, renderer) {
     patchStyleAttribute(oldVnode, vnode, renderer);
     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);
 }
@@ -4491,7 +4493,7 @@ function createViewModelHook(elm, vnode, renderer) {
     return vm;
 }
 function allocateInSlot(vm, children, owner) {
-    var _a, _b;
+    var _a;
     const { cmpSlots: { slotAssignments: oldSlotsMapping }, } = vm;
     const cmpSlotsMapping = shared.create(null);
     // Collect all slots into cmpSlotsMapping
@@ -4501,8 +4503,8 @@ function allocateInSlot(vm, children, owner) {
             continue;
         }
         let slotName = '';
-        if (isVBaseElement(vnode)) {
-            slotName = (_b = (_a = vnode.data.attrs) === null || _a === void 0 ? void 0 : _a.slot) !== null && _b !== void 0 ? _b : '';
+        if (isVBaseElement(vnode) || isVStatic(vnode)) {
+            slotName = (_a = vnode.slotAssignment) !== null && _a !== void 0 ? _a : '';
         }
         else if (isVScopedSlotFragment(vnode)) {
             slotName = vnode.slotName;
@@ -4772,6 +4774,7 @@ function st(fragment, key, parts) {
         fragment,
         owner,
         parts,
+        slotAssignment: undefined,
     };
     return vnode;
 }
@@ -4816,7 +4819,7 @@ function h(sel, data, children = EmptyArray) {
             }
         });
     }
-    const { key } = data;
+    const { key, slotAssignment } = data;
     const vnode = {
         type: 2 /* VNodeType.Element */,
         sel,
@@ -4825,6 +4828,7 @@ function h(sel, data, children = EmptyArray) {
         elm: undefined,
         key,
         owner: vmBeingRendered,
+        slotAssignment,
     };
     return vnode;
 }
@@ -4849,6 +4853,8 @@ function s(slotName, data, children, slotset) {
         shared.assert.isTrue(shared.isObject(data), `s() 2nd argument data must be an object.`);
         shared.assert.isTrue(shared.isArray(children), `h() 3rd argument children must be an array.`);
     }
+    const vmBeingRendered = getVMBeingRendered();
+    const { renderMode, apiVersion } = vmBeingRendered;
     if (!shared.isUndefined(slotset) &&
         !shared.isUndefined(slotset.slotAssignments) &&
         !shared.isUndefined(slotset.slotAssignments[slotName]) &&
@@ -4871,7 +4877,6 @@ function s(slotName, data, children, slotset) {
                 }
                 // If the passed slot content is factory, evaluate it and add the produced vnodes
                 if (assignedNodeIsScopedSlot) {
-                    const vmBeingRenderedInception = getVMBeingRendered();
                     // Evaluate in the scope of the slot content's owner
                     // if a slotset is provided, there will always be an owner. The only case where owner is
                     // undefined is for root components, but root components cannot accept slotted content
@@ -4885,20 +4890,33 @@ function s(slotName, data, children, slotset) {
                         });
                     }
                     finally {
-                        setVMBeingRendered(vmBeingRenderedInception);
+                        setVMBeingRendered(vmBeingRendered);
                     }
                 }
                 else {
+                    // This block is for standard slots (non-scoped slots)
+                    let clonedVNode;
+                    if (renderMode === 0 /* RenderMode.Light */ &&
+                        shared.isAPIFeatureEnabled(6 /* APIFeature.USE_LIGHT_DOM_SLOT_FORWARDING */, apiVersion) &&
+                        (isVBaseElement(vnode) || isVStatic(vnode)) &&
+                        // We only need to copy the vnodes when the slot assignment changes, copying every time causes issues with
+                        // disconnected/connected callback firing.
+                        vnode.slotAssignment !== data.slotAssignment) {
+                        // When the light DOM slot assignment (slot attribute) changes we can't use the same reference
+                        // to the vnode because the current way the diffing algo works, it will replace the original reference
+                        // to the host element with a new one. This means the new element will be mounted and immediately unmounted.
+                        // Creating a copy of the vnode to preserve a reference to the previous host element.
+                        clonedVNode = Object.assign(Object.assign({}, vnode), { slotAssignment: data.slotAssignment });
+                    }
                     // If the slot content is standard type, the content is static, no additional
                     // processing needed on the vnode
-                    shared.ArrayPush.call(newChildren, vnode);
+                    shared.ArrayPush.call(newChildren, clonedVNode !== null && clonedVNode !== void 0 ? clonedVNode : vnode);
                 }
             }
         }
         children = newChildren;
     }
-    const vmBeingRendered = getVMBeingRendered();
-    const { renderMode, shadowMode, apiVersion } = vmBeingRendered;
+    const { shadowMode } = vmBeingRendered;
     if (renderMode === 0 /* RenderMode.Light */) {
         // light DOM slots - backwards-compatible behavior uses flattening, new behavior uses fragments
         if (shared.isAPIFeatureEnabled(2 /* APIFeature.USE_FRAGMENTS_FOR_LIGHT_DOM_SLOTS */, apiVersion)) {
@@ -4940,7 +4958,7 @@ function c(sel, Ctor, data, children = EmptyArray) {
             });
         }
     }
-    const { key } = data;
+    const { key, slotAssignment } = data;
     let elm, aChildren, vm;
     const vnode = {
         type: 3 /* VNodeType.CustomElement */,
@@ -4949,6 +4967,7 @@ function c(sel, Ctor, data, children = EmptyArray) {
         children,
         elm,
         key,
+        slotAssignment,
         ctor: Ctor,
         owner: vmBeingRendered,
         mode: 'open', // TODO [#1294]: this should be defined in Ctor
@@ -5463,7 +5482,6 @@ const parseSVGFragment = buildParseFragmentFn((html, renderer) => {
 });
 function evaluateTemplate(vm, html) {
     if (process.env.NODE_ENV !== 'production') {
-        shared.assert.isTrue(shared.isFunction(html), `evaluateTemplate() second argument must be an imported template instead of ${shared.toString(html)}`);
         // in dev-mode, we support hot swapping of templates, which means that
         // the component instance might be attempting to use an old version of
         // the template, while internally, we have a replacement for it.
@@ -5482,6 +5500,10 @@ function evaluateTemplate(vm, html) {
         tro.observe(() => {
             // Reset the cache memoizer for template when needed.
             if (html !== cmpTemplate) {
+                // Check that the template was built by the compiler.
+                if (!isTemplateRegistered(html)) {
+                    throw new TypeError(`Invalid template returned by the render() method on ${vm.tagName}. It must return an imported template (e.g.: \`import html from "./${vm.def.name}.html"\`), instead, it has returned: ${shared.toString(html)}.`);
+                }
                 if (process.env.NODE_ENV !== 'production') {
                     validateLightDomTemplate(html, vm);
                 }
@@ -5493,10 +5515,6 @@ function evaluateTemplate(vm, html) {
                     // and snabbdom just rely on the IDs.
                     resetComponentRoot(vm);
                 }
-                // Check that the template was built by the compiler.
-                if (!isTemplateRegistered(html)) {
-                    throw new TypeError(`Invalid template returned by the render() method on ${vm}. It must return an imported template (e.g.: \`import html from "./${vm.def.name}.html"\`), instead, it has returned: ${shared.toString(html)}.`);
-                }
                 vm.cmpTemplate = html;
                 // Create a brand new template cache for the swapped templated.
                 context.tplCache = shared.create(null);
@@ -5798,7 +5816,7 @@ function resetComponentStateWhenRemoved(vm) {
 // old vnode.children is removed from the DOM.
 function removeVM(vm) {
     if (process.env.NODE_ENV !== 'production') {
-        if (!lwcRuntimeFlags.ENABLE_NATIVE_CUSTOM_ELEMENT_LIFECYCLE) {
+        if (!shouldUseNativeCustomElementLifecycle(vm.component.constructor)) {
             // With native lifecycle, we cannot be certain that connectedCallback was called before a component
             // was removed from the VDOM. If the component is disconnected, then connectedCallback will not fire
             // in native mode, although it will fire in synthetic mode due to appendChild triggering it.
@@ -5970,36 +5988,28 @@ function computeShadowMode(def, owner, renderer) {
     }
     const { isSyntheticShadowDefined } = renderer;
     let shadowMode;
-    // If ENABLE_FORCE_SHADOW_MIGRATE_MODE is true, then ShadowMode.Synthetic here will mean "force-migrate" mode.
     if (isSyntheticShadowDefined || lwcRuntimeFlags.ENABLE_FORCE_SHADOW_MIGRATE_MODE) {
         if (def.renderMode === 0 /* RenderMode.Light */) {
             // ShadowMode.Native implies "not synthetic shadow" which is consistent with how
             // everything defaults to native when the synthetic shadow polyfill is unavailable.
             shadowMode = 0 /* ShadowMode.Native */;
         }
-        else if (lwcRuntimeFlags.ENABLE_MIXED_SHADOW_MODE ||
-            def.shadowSupportMode === "native" /* ShadowSupportMode.Native */) {
-            if (def.shadowSupportMode === "any" /* ShadowSupportMode.Any */ ||
-                def.shadowSupportMode === "native" /* ShadowSupportMode.Native */) {
+        else if (def.shadowSupportMode === "native" /* ShadowSupportMode.Native */) {
+            shadowMode = 0 /* ShadowMode.Native */;
+        }
+        else {
+            const shadowAncestor = getNearestShadowAncestor(owner);
+            if (!shared.isNull(shadowAncestor) && shadowAncestor.shadowMode === 0 /* ShadowMode.Native */) {
+                // Transitive support for native Shadow DOM. A component in native mode
+                // transitively opts all of its descendants into native.
                 shadowMode = 0 /* ShadowMode.Native */;
             }
             else {
-                const shadowAncestor = getNearestShadowAncestor(owner);
-                if (!shared.isNull(shadowAncestor) && shadowAncestor.shadowMode === 0 /* ShadowMode.Native */) {
-                    // Transitive support for native Shadow DOM. A component in native mode
-                    // transitively opts all of its descendants into native.
-                    shadowMode = 0 /* ShadowMode.Native */;
-                }
-                else {
-                    // Synthetic if neither this component nor any of its ancestors are configured
-                    // to be native.
-                    shadowMode = 1 /* ShadowMode.Synthetic */;
-                }
+                // Synthetic if neither this component nor any of its ancestors are configured
+                // to be native.
+                shadowMode = 1 /* ShadowMode.Synthetic */;
             }
         }
-        else {
-            shadowMode = 1 /* ShadowMode.Synthetic */;
-        }
     }
     else {
         // Native if the synthetic shadow polyfill is unavailable.
@@ -6126,7 +6136,7 @@ function runConnectedCallback(vm) {
     // This test only makes sense in the browser, with synthetic lifecycle, and when reporting is enabled or
     // we're in dev mode. This is to detect a particular issue with synthetic lifecycle.
     if (process.env.IS_BROWSER &&
-        !lwcRuntimeFlags.ENABLE_NATIVE_CUSTOM_ELEMENT_LIFECYCLE &&
+        !shouldUseNativeCustomElementLifecycle(vm.component.constructor) &&
         (process.env.NODE_ENV !== 'production' || isReportingEnabled())) {
         if (!vm.renderer.isConnected(vm.elm)) {
             if (process.env.NODE_ENV !== 'production') {
@@ -6374,12 +6384,12 @@ function resetRefVNodes(vm) {
 // See: https://sfdc.co/synthetic-aria
 //
 // Use the unpatched native getElementById/querySelectorAll rather than the synthetic one
-const getElementById = shared.globalThis[shared.KEY__NATIVE_GET_ELEMENT_BY_ID];
-const querySelectorAll = shared.globalThis[shared.KEY__NATIVE_QUERY_SELECTOR_ALL];
+const getElementById = globalThis[shared.KEY__NATIVE_GET_ELEMENT_BY_ID];
+const querySelectorAll = globalThis[shared.KEY__NATIVE_QUERY_SELECTOR_ALL];
 // This is a "handoff" from synthetic-shadow to engine-core – we want to clean up after ourselves
 // so nobody else can misuse these global APIs.
-delete shared.globalThis[shared.KEY__NATIVE_GET_ELEMENT_BY_ID];
-delete shared.globalThis[shared.KEY__NATIVE_QUERY_SELECTOR_ALL];
+delete globalThis[shared.KEY__NATIVE_GET_ELEMENT_BY_ID];
+delete globalThis[shared.KEY__NATIVE_QUERY_SELECTOR_ALL];
 function isSyntheticShadowRootInstance(rootNode) {
     return rootNode !== document && shared.isTrue(rootNode.synthetic);
 }
@@ -7430,5 +7440,5 @@ exports.swapTemplate = swapTemplate;
 exports.track = track;
 exports.unwrap = unwrap;
 exports.wire = wire;
-/** version: 5.3.0 */
+/** version: 6.1.0 */
 //# sourceMappingURL=index.cjs.js.map