Backtestsvuerun-20261005-124535#12680

Issue #12680 Merged fix PR #15313 Run 5 Oct 2026 · run-20261005-124535 vuejs/core

$el of templateRef points to comment VNode instead of first real child of component

Better

Our patch was judged better than the merged fix.

In this judgment, Patch A = our agent, Patch B = the merged fix.

The reproduction runs in production mode (`__PROD__` playground). There, `$el` is the fragment's empty text anchor, as step 2 of the issue says. The click also fails to fall through, which shows that attrs inheritance is broken too. The root cause is that the compiler emits `DEV_ROOT_FRAGMENT` only under `__DEV__`, and the runtime honors it only under `__DEV__`. When comments are kept in production (for example via the `comments` option), the single real root is never found.

Patch A fixes this at the root. The compiler now sets the flag regardless of `__DEV__`. The runtime respects it in `renderComponentRoot`, `getChildRoot`, `filterSingleRoot`, scope-id handling, `patchFragment` and the move logic. A new `getComponentRootEl` resolves `$el` through flagged fragments and HOCs. Together these fix both symptoms in production: `$el` and the click fallthrough.

Patch A's tests cover:
- compiler output in production mode
- `$el` resolution in dev and prod
- nested fragments with updates
- HOCs
- multi-root regression
- an end-to-end test with `compilerOptions.comments = true` in production, checking class fallthrough, `$el` identity and click handling

These tests would fail before the change.

Patch B changes only the `$el` getter, and only under `__DEV__`. In production it still returns `i.vnode.el`, so the reported production scenario is not fixed. Attrs and listener fallthrough are also unaddressed, so the 'clicking does nothing' symptom remains. Its tests are reasonable for dev-mode `$el` resolution, including the Suspense and HOC cases, but they never exercise the reported production behavior.

Patch A's removal of the dev guards carries a small cost in production bundle size and forces full diffing of flagged fragments. That cost applies only when comments are preserved, and it is justified. Patch A addresses the actual issue; Patch B masks one symptom in dev only.

The judge saw only the two patches, labelled A and B in random order, with issue links and version numbers removed. The reasoning above is shown verbatim.

Solve

17m 24s

Wall-clock time in the container

Full test suite

No new failures

3,699 passed · 6 skipped · 3,705 total

Contamination audit

Clean

No sign the agent saw the real fix

Patch size

238vs 213 merged

Changed lines, ours vs merged

Vue version

3.5.15

Link to minimal reproduction

https://play.vuejs.org/#__PROD__eNp9U9uO2jAQ/ZWpVWlBAqOK9oUCUot4aNWbKI+WqigZghfHjnzJIiH+vWPnUrqs9i32nHN8Zs7kwj7VNW8CsgVbutzK2oPKdLkSzDvBwKEP9VpoWdXGetgcpSrgYE0FD3yWTpH88HFAXCA43GNVq8zjDg8TMPq7CdpjAdeO2TGEzo12HvIoQ1BYPeOOBEs1wcYEH3RGozGs1nARGiAqGIVcmbJHRyVUWKH2C8EmgzxvMhWQv0UV1Yh6d8+zotg2xPsmnUeNNkoqmZ+izM2jz5/dRAz1t0fnW68A17HQ1/i5nLVjpSHSwXfd0QlgWcgGcpU5R+OuM0svC5YqVGtHbfFAtW4KMGtpM+KtAaL2jR6bUGRk7CBL/uiMpkSTW6KbqpYK7c/aSzIu2KLvQ7BMKfP0Nd15G3DS3+dHzE8v3D+6c7wT7JdFh7ZBmk1f85ktkVqI5e3vH3im76FYmSIoQr9S3CENNUSPLexz0AXZvsElt1/Spkld7t32TDm5vqloNM0+4QWjPdu80vo/u3P+PvEoMprisNbxn/g/sDfTKeywMg2CP0pHe1DFPQNvoMpOSGHSJpAzWnp6oN0HeDL2BNPpfeRdrF3iCT3Eex/unwZtbJVczfkH/m7Orn8BgY08Yw==

Steps to reproduce

Hi, I just spent some hours debugging a very strange behavior when accessing the underlying element of a component ref by using templateRef.$el. The component I placed the template ref on had only one root level <div> inside its template, however there was a comment above it. It looks like this leads to the element being referenced by the template ref being the VNode of this comment instead of the <div> element.

Steps to reproduce:

  1. Open the Playground
  2. Open the console and see that the element referenced by childRef.value.$el is a text VNode
  3. Click on the text "Test" in the preview (Nothing should be logged to the console)
  4. Go into the component "Child.vue" and remove the comment in line 2
  5. After a hot reload (or manual one) childRef.value.$el should point to the div element as logged to the console. Clicking on the text "Test" in the preview should now also log "Clicked Test" to the console

What is expected?

I would expect templateRef.$el to point to the first real element inside the component excluding comments.

What is actually happening?

templateRef.$el points to a VNode for the comment inside the components template.

System Info

_No response_

Any additional comments?

_No response_

The two patches

Our patch+212 −26
packages/compiler-core/__tests__/transform.spec.tsindex 0946d3648..8db28fe50 100644@@ -377,5 +377,23 @@ describe('compiler: transform', () => {         ),       )     })++    test('multiple children w/ single root + comments (prod, comments: true)', () => {+      __DEV__ = false+      const ast = baseParse(`<!--foo--><div/>`, { comments: true })+      transform(ast, { nodeTransforms: [transformElement] })+      __DEV__ = true+      expect(ast.codegenNode).toMatchObject(+        createBlockMatcher(+          FRAGMENT,+          undefined,+          [+            { type: NodeTypes.COMMENT },+            { type: NodeTypes.ELEMENT, tag: `div` },+          ] as any,+          PatchFlags.STABLE_FRAGMENT | PatchFlags.DEV_ROOT_FRAGMENT,+        ),+      )+    })   }) })packages/compiler-core/src/transform.tsindex 42de65def..531bff7e4 100644@@ -380,10 +380,7 @@ function createRootCodegen(root: RootNode, context: TransformContext) {     let patchFlag = PatchFlags.STABLE_FRAGMENT     // check if the fragment actually contains a single valid child with     // the rest being comments-    if (-      __DEV__ &&-      children.filter(c => c.type !== NodeTypes.COMMENT).length === 1-    ) {+    if (children.filter(c => c.type !== NodeTypes.COMMENT).length === 1) {       patchFlag |= PatchFlags.DEV_ROOT_FRAGMENT     }     root.codegenNode = createVNodeCall(packages/runtime-core/__tests__/componentPublicInstance.spec.tsindex c9958efc7..495171940 100644@@ -1,12 +1,22 @@ import {+  Fragment,   createApp,+  createBlock,+  createCommentVNode,+  createElementBlock,+  createElementVNode,   defineComponent,   getCurrentInstance,   h,+  nextTick,   nodeOps,+  openBlock,+  ref,   render,+  serializeInner,   shallowReadonly, } from '@vue/runtime-test'+import { PatchFlags } from '@vue/shared' import type {   ComponentInternalInstance,   ComponentOptions,@@ -510,4 +520,117 @@ describe('component: proxy', () => {     render(h(Comp), nodeOps.createElement('div'))     expect(`Cannot mutate <script setup> binding "foo"`).toHaveBeenWarned()   })++  describe('$el w/ single element root + comments', () => {+    const CommentRootChild = {+      setup() {+        return () => (+          openBlock(),+          createElementBlock(+            Fragment,+            null,+            [+              createCommentVNode('comment'),+              createElementVNode('div', null, 'Test'),+            ],+            PatchFlags.STABLE_FRAGMENT | PatchFlags.DEV_ROOT_FRAGMENT,+          )+        )+      },+    }++    const mountWithRef = (Child: any) => {+      const childRef = ref<any>(null)+      const Parent = {+        setup() {+          return () => h(Child, { ref: childRef })+        },+      }+      const root = nodeOps.createElement('div')+      render(h(Parent), root)+      return { root, childRef }+    }++    test('should point to the real root element', () => {+      const { root, childRef } = mountWithRef(CommentRootChild)+      expect(serializeInner(root)).toBe(`<!--comment--><div>Test</div>`)+      expect(childRef.value.$el).toBe(root.children[2])+      expect((childRef.value.$el as any).tag).toBe('div')+    })++    test('should point to the real root element in prod', () => {+      __DEV__ = false+      try {+        const { root, childRef } = mountWithRef(CommentRootChild)+        expect(serializeInner(root)).toBe(`<!--comment--><div>Test</div>`)+        expect(childRef.value.$el).toBe(root.children[2])+      } finally {+        __DEV__ = true+      }+    })++    test('should resolve nested root fragments and update', async () => {+      const toggle = ref(false)+      const Child = {+        setup() {+          return () => (+            openBlock(),+            createElementBlock(+              Fragment,+              null,+              [+                createCommentVNode(' comment A '),+                toggle.value+                  ? (openBlock(),+                    createElementBlock('span', { key: 0 }, 'Foo'))+                  : (openBlock(),+                    createElementBlock(+                      Fragment,+                      { key: 1 },+                      [+                        createCommentVNode(' comment B '),+                        createElementVNode('div', null, 'Bar'),+                      ],+                      PatchFlags.STABLE_FRAGMENT | PatchFlags.DEV_ROOT_FRAGMENT,+                    )),+              ],+              PatchFlags.STABLE_FRAGMENT | PatchFlags.DEV_ROOT_FRAGMENT,+            )+          )+        },+      }+      const { root, childRef } = mountWithRef(Child)+      expect(serializeInner(root)).toBe(+        `<!-- comment A --><!-- comment B --><div>Bar</div>`,+      )+      expect((childRef.value.$el as any).tag).toBe('div')++      toggle.value = true+      await nextTick()+      expect(serializeInner(root)).toBe(`<!-- comment A --><span>Foo</span>`)+      expect((childRef.value.$el as any).tag).toBe('span')+    })++    test('should resolve through HOC', () => {+      const Wrapper = {+        setup() {+          return () => (openBlock(), createBlock(CommentRootChild))+        },+      }+      const { root, childRef } = mountWithRef(Wrapper)+      expect(serializeInner(root)).toBe(`<!--comment--><div>Test</div>`)+      expect(childRef.value.$el).toBe(root.children[2])+    })++    test('should still point to the fragment anchor for multi-root', () => {+      const Child = {+        setup() {+          return () => [h('div'), h('span')]+        },+      }+      const { root, childRef } = mountWithRef(Child)+      expect(childRef.value.$el).toBe(root.children[0])+      expect((childRef.value.$el as any).type).toBe('text')+    })+  }) })packages/runtime-core/src/componentPublicInstance.tsindex 7a8af5871..dfb2ecf4a 100644@@ -51,7 +51,10 @@ import { } from './componentOptions' import type { EmitFn, EmitsOptions } from './componentEmits' import type { SlotsType, UnwrapSlotsType } from './componentSlots'-import { markAttrsAccessed } from './componentRenderUtils'+import {+  getComponentRootEl,+  markAttrsAccessed,+} from './componentRenderUtils' import { currentRenderingInstance } from './componentRenderContext' import { warn } from './warning' import { installCompatInstanceProperties } from './compat/instance'@@ -363,7 +366,7 @@ export const publicPropertiesMap: PublicPropertiesMap =   // due to type annotation   /*@__PURE__*/ extend(Object.create(null), {     $: i => i,-    $el: i => i.vnode.el,+    $el: i => getComponentRootEl(i),     $data: i => i.data,     $props: i => (__DEV__ ? shallowReadonly(i.props) : i.props),     $attrs: i => (__DEV__ ? shallowReadonly(i.attrs) : i.attrs),packages/runtime-core/src/componentRenderUtils.tsindex be58e5b0a..a6a3dfb49 100644@@ -148,15 +148,12 @@ export function renderComponentRoot(   }    // attr merging-  // in dev mode, comments are preserved, and it's possible for a template-  // to have comments along side the root element which makes it a fragment+  // in dev mode (or in prod with the `comments` compiler option), comments are+  // preserved, and it's possible for a template to have comments along side+  // the root element which makes it a fragment   let root = result   let setRoot: SetRootFn = undefined-  if (-    __DEV__ &&-    result.patchFlag > 0 &&-    result.patchFlag & PatchFlags.DEV_ROOT_FRAGMENT-  ) {+  if (result.patchFlag > 0 && result.patchFlag & PatchFlags.DEV_ROOT_FRAGMENT) {     ;[root, setRoot] = getChildRoot(result)   } @@ -266,7 +263,7 @@ export function renderComponentRoot(     setTransitionHooks(child, vnode.transition)   } -  if (__DEV__ && setRoot) {+  if (setRoot) {     setRoot(root)   } else {     result = root@@ -277,10 +274,10 @@ export function renderComponentRoot( }  /**- * dev only- * In dev mode, template root level comments are rendered, which turns the- * template into a fragment root, but we need to locate the single element- * root for attrs and scope id processing.+ * In dev mode (or in prod with the `comments` compiler option), template root+ * level comments are rendered, which turns the template into a fragment root,+ * but we need to locate the single element root for attrs and scope id+ * processing.  */ const getChildRoot = (vnode: VNode): [VNode, SetRootFn] => {   const rawChildren = vnode.children as VNodeArrayChildren@@ -289,7 +286,6 @@ const getChildRoot = (vnode: VNode): [VNode, SetRootFn] => {   if (!childRoot) {     return [vnode, undefined]   } else if (-    __DEV__ &&     childRoot.patchFlag > 0 &&     childRoot.patchFlag & PatchFlags.DEV_ROOT_FRAGMENT   ) {@@ -327,7 +323,6 @@ export function filterSingleRoot(         } else {           singleRoot = child           if (-            __DEV__ &&             recurse &&             singleRoot.patchFlag > 0 &&             singleRoot.patchFlag & PatchFlags.DEV_ROOT_FRAGMENT@@ -343,6 +338,34 @@ export function filterSingleRoot(   return singleRoot } +/**+ * Resolve the element exposed as `$el`. When a template root contains a single+ * real node alongside comments, the subTree is a fragment flagged with+ * DEV_ROOT_FRAGMENT; in that case `$el` should be the single real root rather+ * than the fragment's placeholder anchor.+ */+export function getComponentRootEl(+  instance: ComponentInternalInstance,+): VNode['el'] {+  const { vnode, subTree } = instance+  if (subTree && subTree.el) {+    if (+      subTree.patchFlag > 0 &&+      subTree.patchFlag & PatchFlags.DEV_ROOT_FRAGMENT+    ) {+      const root = filterSingleRoot(subTree.children as VNodeArrayChildren)+      if (root && root.el) {+        return root.component ? getComponentRootEl(root.component) : root.el+      }+    } else if (subTree.component) {+      // HOC: the root is a child component which may itself have a+      // comment-wrapped root+      return getComponentRootEl(subTree.component)+    }+  }+  return vnode.el+}+ const getFunctionalFallthrough = (attrs: Data): Data | undefined => {   let res: Data | undefined   for (const key in attrs) {packages/runtime-core/src/renderer.tsindex c0fab7373..95903c4db 100644@@ -771,7 +771,6 @@ function baseCreateRenderer(     if (parentComponent) {       let subTree = parentComponent.subTree       if (-        __DEV__ &&         subTree.patchFlag > 0 &&         subTree.patchFlag & PatchFlags.DEV_ROOT_FRAGMENT       ) {@@ -1071,9 +1070,9 @@ function baseCreateRenderer(     let { patchFlag, dynamicChildren, slotScopeIds: fragmentSlotScopeIds } = n2      if (-      __DEV__ &&+      (__DEV__ && isHmrUpdating) ||       // #5523 dev root fragment may inherit directives-      (isHmrUpdating || patchFlag & PatchFlags.DEV_ROOT_FRAGMENT)+      (patchFlag > 0 && patchFlag & PatchFlags.DEV_ROOT_FRAGMENT)     ) {       // HMR updated / Dev root fragment (w/ comments), force full diff       patchFlag = 0@@ -2270,7 +2269,6 @@ function baseCreateRenderer(     const { type, el, anchor, transition } = vnode     if (type === Fragment) {       if (-        __DEV__ &&         vnode.patchFlag > 0 &&         vnode.patchFlag & PatchFlags.DEV_ROOT_FRAGMENT &&         transition &&packages/shared/src/patchFlags.tsindex 289da1902..6d44482e1 100644@@ -95,8 +95,9 @@ export enum PatchFlags {    /**    * Indicates a fragment that was created only because the user has placed-   * comments at the root level of a template. This is a dev-only flag since-   * comments are stripped in production.+   * comments at the root level of a template. Comments are stripped in+   * production by default, but they can be preserved via the `comments`+   * compiler option, so this flag must be respected in production as well.    */   DEV_ROOT_FRAGMENT = 1 << 11, packages/vue/__tests__/runtimeCompilerOptions.spec.tsindex b144be448..b0bdfc40a 100644@@ -24,6 +24,29 @@ describe('config.compilerOptions', () => {     __DEV__ = true   }) +  test('comments: single element root + comments in prod', () => {+    const onClick = vi.fn()+    const Child = {+      template: `<!--comment--><div>Test</div>`,+    }+    const app = createApp({+      components: { Child },+      template: `<Child ref="child" class="foo" @click="onClick" />`,+      methods: { onClick },+    })+    app.config.compilerOptions.comments = true+    __DEV__ = false+    const root = document.createElement('div')+    const vm = app.mount(root) as any+    __DEV__ = true++    expect(root.innerHTML).toBe('<!--comment--><div class="foo">Test</div>')+    const div = root.querySelector('div')!+    expect(vm.$refs.child.$el).toBe(div)+    div.dispatchEvent(new Event('click'))+    expect(onClick).toHaveBeenCalledTimes(1)+  })+   test('whitespace', () => {     const app = createApp({       template: `<div><span/>\n  <span/></div>`, 
Merged fix · PR #15313+211 −2
packages/runtime-core/__tests__/componentPublicInstance.spec.tsindex c9958efc7..47a9b2996 100644@@ -1,9 +1,15 @@ import {+  Fragment,+  Suspense,+  TestNodeTypes,   createApp,+  createCommentVNode,+  createElementBlock,   defineComponent,   getCurrentInstance,   h,   nodeOps,+  openBlock,   render,   shallowReadonly, } from '@vue/runtime-test'@@ -11,6 +17,7 @@ import type {   ComponentInternalInstance,   ComponentOptions, } from '../src/component'+import { PatchFlags } from '@vue/shared'  describe('component: proxy', () => {   test('data', () => {@@ -107,6 +114,168 @@ describe('component: proxy', () => {     expect(nextTickThis).toBe(instanceProxy)   }) +  // #12680+  test('$el should resolve to the real root element when root is a dev comment + single element fragment', () => {+    let instanceProxy: any+    const Comp = {+      setup() {+        return () => (+          openBlock(),+          createElementBlock(+            Fragment,+            null,+            [createCommentVNode(' comment '), h('div', 'real root')],+            PatchFlags.STABLE_FRAGMENT | PatchFlags.DEV_ROOT_FRAGMENT,+          )+        )+      },+      mounted() {+        instanceProxy = this+      },+    }+    render(h(Comp), nodeOps.createElement('div'))+    expect(instanceProxy.$el.type).toBe(TestNodeTypes.ELEMENT)+    expect(instanceProxy.$el.tag).toBe('div')+  })++  // #12680+  test('$el should resolve through a single-root child component to its real root element', () => {+    let instanceProxy: any+    const Inner = {+      setup() {+        return () => (+          openBlock(),+          createElementBlock(+            Fragment,+            null,+            [createCommentVNode(' comment '), h('div', 'inner root')],+            PatchFlags.STABLE_FRAGMENT | PatchFlags.DEV_ROOT_FRAGMENT,+          )+        )+      },+    }+    const Outer = {+      setup() {+        return () => h(Inner)+      },+      mounted() {+        instanceProxy = this+      },+    }+    render(h(Outer), nodeOps.createElement('div'))+    expect(instanceProxy.$el.type).toBe(TestNodeTypes.ELEMENT)+    expect(instanceProxy.$el.tag).toBe('div')+  })++  // #12680+  test('$el should resolve through nested dev comment fragments across component boundaries', () => {+    let instanceProxy: any+    const Inner = {+      setup() {+        return () => (+          openBlock(),+          createElementBlock(+            Fragment,+            null,+            [createCommentVNode(' comment '), h('div', 'inner root')],+            PatchFlags.STABLE_FRAGMENT | PatchFlags.DEV_ROOT_FRAGMENT,+          )+        )+      },+    }+    const Outer = {+      setup() {+        return () => (+          openBlock(),+          createElementBlock(+            Fragment,+            null,+            [createCommentVNode(' comment '), h(Inner)],+            PatchFlags.STABLE_FRAGMENT | PatchFlags.DEV_ROOT_FRAGMENT,+          )+        )+      },+      mounted() {+        instanceProxy = this+      },+    }+    render(h(Outer), nodeOps.createElement('div'))+    expect(instanceProxy.$el.type).toBe(TestNodeTypes.ELEMENT)+    expect(instanceProxy.$el.tag).toBe('div')+  })++  test('$el access should be safe while a root child component is mounting', () => {+    const Child = {+      setup() {+        getCurrentInstance()!.parent!.proxy!.$el+        return () => h('div')+      },+    }+    const Parent = {+      setup: () => () => h(Child),+    }++    expect(() => render(h(Parent), nodeOps.createElement('div'))).not.toThrow()+  })++  test('$el should resolve through a Suspense root', () => {+    let instanceProxy: any+    const Inner = {+      setup() {+        return () => (+          openBlock(),+          createElementBlock(+            Fragment,+            null,+            [createCommentVNode(' comment '), h('div', 'inner root')],+            PatchFlags.STABLE_FRAGMENT | PatchFlags.DEV_ROOT_FRAGMENT,+          )+        )+      },+    }+    const Outer = {+      setup() {+        return () =>+          h(Suspense, null, {+            default: () => h(Inner),+          })+      },+      mounted() {+        instanceProxy = this+      },+    }++    render(h(Outer), nodeOps.createElement('div'))+    expect(instanceProxy.$el.type).toBe(TestNodeTypes.ELEMENT)+    expect(instanceProxy.$el.tag).toBe('div')+  })++  test('$el should preserve the unresolved async root value without a dev root fragment', () => {+    let instance: ComponentInternalInstance+    let instanceProxy: any+    const Child = {+      name: 'Child',+      async setup() {+        await new Promise(() => {})+      },+    }+    const Parent = {+      setup: () => () => h(Child),+      mounted() {+        instance = getCurrentInstance()!+        instanceProxy = this+      },+    }++    render(h(Parent), nodeOps.createElement('div'))++    expect(+      `A component with async setup() must be nested in a <Suspense>`,+    ).toHaveBeenWarned()+    expect(instance!.vnode.el).toBeNull()+    expect(instanceProxy.$el === instance!.vnode.el).toBe(true)+  })+   test('user attached properties', async () => {     let instance: ComponentInternalInstance     let instanceProxy: anypackages/runtime-core/src/componentPublicInstance.tsindex 7a8af5871..8a8a5d93b 100644@@ -17,6 +17,7 @@ import {   EMPTY_OBJ,   type IfAny,   NOOP,+  PatchFlags,   type Prettify,   type UnionToIntersection,   extend,@@ -51,11 +52,12 @@ import { } from './componentOptions' import type { EmitFn, EmitsOptions } from './componentEmits' import type { SlotsType, UnwrapSlotsType } from './componentSlots'-import { markAttrsAccessed } from './componentRenderUtils'+import { filterSingleRoot, markAttrsAccessed } from './componentRenderUtils' import { currentRenderingInstance } from './componentRenderContext' import { warn } from './warning' import { installCompatInstanceProperties } from './compat/instance' import type { Directive } from './directives'+import type { VNode, VNodeArrayChildren } from './vnode'  /**  * Custom properties added to component instances in any way and can be accessed through `this`@@ -358,12 +360,50 @@ const getPublicInstance = (   return getPublicInstance(i.parent) } +// Component and Suspense roots can hide a dev root fragment. Only return a+// resolved element after finding one so other root chains keep their existing+// `$el` semantics.+const resolveDevRootEl = (vnode: VNode): VNode['el'] | undefined => {+  let found = false++  while (true) {+    if (vnode.patchFlag > 0 && vnode.patchFlag & PatchFlags.DEV_ROOT_FRAGMENT) {+      const root = filterSingleRoot(vnode.children as VNodeArrayChildren)+      if (!root) {+        return+      }+      vnode = root+      found = true+      continue+    }++    const component = vnode.component+    if (component && component.subTree) {+      vnode = component.subTree+      continue+    }++    const suspense = vnode.suspense+    if (suspense && suspense.activeBranch) {+      vnode = suspense.activeBranch+      continue+    }++    return found ? vnode.el : undefined+  }+}++const getDevRootFragmentEl = (i: ComponentInternalInstance) => {+  const el = i.subTree && resolveDevRootEl(i.subTree)+  return el === undefined ? i.vnode.el : el+}+ export const publicPropertiesMap: PublicPropertiesMap =   // Move PURE marker to new line to workaround compiler discarding it   // due to type annotation   /*@__PURE__*/ extend(Object.create(null), {     $: i => i,-    $el: i => i.vnode.el,+    $el: i => (__DEV__ ? getDevRootFragmentEl(i) : i.vnode.el),     $data: i => i.data,     $props: i => (__DEV__ ? shallowReadonly(i.props) : i.props),     $attrs: i => (__DEV__ ? shallowReadonly(i.attrs) : i.attrs),