lwc 2.16.0 → 2.19.0

package/dist/engine-dom/umd/es2017/engine-dom_debug.js

@@ -294,7 +294,7 @@
   const XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
   const SVG_NAMESPACE = 'http://www.w3.org/2000/svg';
   const XLINK_NAMESPACE = 'http://www.w3.org/1999/xlink';
-  /** version: 2.16.0 */
+  /** version: 2.19.0 */
 
   /*
    * Copyright (c) 2018, salesforce.com, inc.
@@ -1364,7 +1364,7 @@
       // Linking elm, shadow root and component with the VM.
       associateVM(component, vm);
       associateVM(elm, vm);
-      if (vm.renderMode === 1 /* Shadow */) {
+      if (vm.renderMode === 1 /* RenderMode.Shadow */) {
           vm.renderRoot = doAttachShadow(vm);
       }
       else {
@@ -1375,7 +1375,7 @@
   function doAttachShadow(vm) {
       const { elm, mode, shadowMode, def: { ctor }, renderer: { attachShadow }, } = vm;
       const shadowRoot = attachShadow(elm, {
-          [KEY__SYNTHETIC_MODE]: shadowMode === 1 /* Synthetic */,
+          [KEY__SYNTHETIC_MODE]: shadowMode === 1 /* ShadowMode.Synthetic */,
           delegatesFocus: Boolean(ctor.delegatesFocus),
           mode,
       });
@@ -2166,7 +2166,7 @@
       }
       let renderMode = superDef.renderMode;
       if (!isUndefined$1(ctorRenderMode)) {
-          renderMode = ctorRenderMode === 'light' ? 0 /* Light */ : 1 /* Shadow */;
+          renderMode = ctorRenderMode === 'light' ? 0 /* RenderMode.Light */ : 1 /* RenderMode.Shadow */;
       }
       const template = getComponentRegisteredTemplate(Ctor) || superDef.template;
       const name = Ctor.name || superDef.name;
@@ -2253,8 +2253,8 @@
       props: lightningBasedDescriptors,
       propsConfig: EmptyObject,
       methods: EmptyObject,
-      renderMode: 1 /* Shadow */,
-      shadowSupportMode: "reset" /* Default */,
+      renderMode: 1 /* RenderMode.Shadow */,
+      shadowSupportMode: "reset" /* ShadowSupportMode.Default */,
       wire: EmptyObject,
       bridge: BaseBridgeElement,
       template: defaultEmptyTemplate,
@@ -2276,7 +2276,7 @@
           // avoid leaking the reference to the public props descriptors
           publicProps[key] = {
               config: propsConfig[key] || 0,
-              type: "any" /* any */,
+              type: "any" /* PropDefType.any */,
               attr: htmlPropertyToAttribute(key),
           };
       }
@@ -2333,7 +2333,7 @@
    */
   function isVBaseElement(vnode) {
       const { type } = vnode;
-      return type === 2 /* Element */ || type === 3 /* CustomElement */;
+      return type === 2 /* VNodeType.Element */ || type === 3 /* VNodeType.CustomElement */;
   }
   function isSameVnode(vnode1, vnode2) {
       return vnode1.key === vnode2.key && vnode1.sel === vnode2.sel;
@@ -2577,21 +2577,21 @@
           return;
       }
       switch (n2.type) {
-          case 0 /* Text */:
+          case 0 /* VNodeType.Text */:
               // VText has no special capability, fallback to the owner's renderer
               patchText(n1, n2, renderer);
               break;
-          case 1 /* Comment */:
+          case 1 /* VNodeType.Comment */:
               // VComment has no special capability, fallback to the owner's renderer
               patchComment(n1, n2, renderer);
               break;
-          case 4 /* Static */:
+          case 4 /* VNodeType.Static */:
               n2.elm = n1.elm;
               break;
-          case 2 /* Element */:
+          case 2 /* VNodeType.Element */:
               patchElement(n1, n2, (_a = n2.data.renderer) !== null && _a !== void 0 ? _a : renderer);
               break;
-          case 3 /* CustomElement */:
+          case 3 /* VNodeType.CustomElement */:
               patchCustomElement(n1, n2, (_b = n2.data.renderer) !== null && _b !== void 0 ? _b : renderer);
               break;
       }
@@ -2599,23 +2599,23 @@
   function mount(node, parent, renderer, anchor) {
       var _a, _b;
       switch (node.type) {
-          case 0 /* Text */:
+          case 0 /* VNodeType.Text */:
               // VText has no special capability, fallback to the owner's renderer
               mountText(node, parent, anchor, renderer);
               break;
-          case 1 /* Comment */:
+          case 1 /* VNodeType.Comment */:
               // VComment has no special capability, fallback to the owner's renderer
               mountComment(node, parent, anchor, renderer);
               break;
-          case 4 /* Static */:
+          case 4 /* VNodeType.Static */:
               // VStatic cannot have a custom renderer associated to them, using owner's renderer
               mountStatic(node, parent, anchor, renderer);
               break;
-          case 2 /* Element */:
+          case 2 /* VNodeType.Element */:
               // If the vnode data has a renderer override use it, else fallback to owner's renderer
               mountElement(node, parent, anchor, (_a = node.data.renderer) !== null && _a !== void 0 ? _a : renderer);
               break;
-          case 3 /* CustomElement */:
+          case 3 /* VNodeType.CustomElement */:
               // If the vnode data has a renderer override use it, else fallback to owner's renderer
               mountCustomElement(node, parent, anchor, (_b = node.data.renderer) !== null && _b !== void 0 ? _b : renderer);
               break;
@@ -2674,7 +2674,7 @@
       // 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) {
-          if (shadowMode === 1 /* Synthetic */ || renderMode === 0 /* Light */) {
+          if (shadowMode === 1 /* ShadowMode.Synthetic */ || renderMode === 0 /* RenderMode.Light */) {
               elm[KEY__SHADOW_STATIC] = true;
           }
       }
@@ -2749,14 +2749,14 @@
           removeNode(elm, parent, renderer);
       }
       switch (type) {
-          case 2 /* Element */: {
+          case 2 /* VNodeType.Element */: {
               // Slot content is removed to trigger slotchange event when removing slot.
               // Only required for synthetic shadow.
-              const shouldRemoveChildren = sel === 'slot' && vnode.owner.shadowMode === 1 /* Synthetic */;
+              const shouldRemoveChildren = sel === 'slot' && vnode.owner.shadowMode === 1 /* ShadowMode.Synthetic */;
               unmountVNodes(vnode.children, elm, renderer, shouldRemoveChildren);
               break;
           }
-          case 3 /* CustomElement */: {
+          case 3 /* VNodeType.CustomElement */: {
               const { vm } = vnode;
               // No need to unmount the children here, `removeVM` will take care of removing the
               // children.
@@ -2799,7 +2799,7 @@
       const { isSyntheticShadowDefined } = renderer;
       // TODO [#1164]: this should eventually be done by the polyfill directly
       if (isSyntheticShadowDefined) {
-          if (shadowMode === 1 /* Synthetic */ || renderMode === 0 /* Light */) {
+          if (shadowMode === 1 /* ShadowMode.Synthetic */ || renderMode === 0 /* RenderMode.Light */) {
               elm[KEY__SHADOW_RESOLVER] = renderRoot[KEY__SHADOW_RESOLVER];
           }
       }
@@ -2831,12 +2831,12 @@
   function fallbackElmHook(elm, vnode, renderer) {
       const { owner } = vnode;
       setScopeTokenClassIfNecessary(elm, owner, renderer);
-      if (owner.shadowMode === 1 /* Synthetic */) {
+      if (owner.shadowMode === 1 /* ShadowMode.Synthetic */) {
           const { data: { context }, } = vnode;
           const { stylesheetToken } = owner.context;
           if (!isUndefined$1(context) &&
               !isUndefined$1(context.lwc) &&
-              context.lwc.dom === "manual" /* Manual */) {
+              context.lwc.dom === "manual" /* LwcDomMode.Manual */) {
               // this element will now accept any manual content inserted into it
               observeElementChildNodes(elm);
           }
@@ -2861,7 +2861,7 @@
       const children = vnode.aChildren || vnode.children;
       vm.aChildren = children;
       const { renderMode, shadowMode } = vm;
-      if (shadowMode === 1 /* Synthetic */ || renderMode === 0 /* Light */) {
+      if (shadowMode === 1 /* ShadowMode.Synthetic */ || renderMode === 0 /* RenderMode.Light */) {
           // slow path
           allocateInSlot(vm, children);
           // save the allocated children in case this vnode is reused.
@@ -2880,7 +2880,7 @@
       }
       const { sel, mode, ctor, owner } = vnode;
       setScopeTokenClassIfNecessary(elm, owner, renderer);
-      if (owner.shadowMode === 1 /* Synthetic */) {
+      if (owner.shadowMode === 1 /* ShadowMode.Synthetic */) {
           const { stylesheetToken } = owner.context;
           // when running in synthetic shadow mode, we need to set the shadowToken value
           // into each element from the template, so they can be styled accordingly.
@@ -3119,7 +3119,7 @@
   // [st]atic node
   function st(fragment, key) {
       return {
-          type: 4 /* Static */,
+          type: 4 /* VNodeType.Static */,
           sel: undefined,
           key,
           elm: undefined,
@@ -3133,7 +3133,7 @@
       let elm;
       const { key } = data;
       return {
-          type: 2 /* Element */,
+          type: 2 /* VNodeType.Element */,
           sel,
           data,
           children,
@@ -3159,11 +3159,11 @@
       }
       const vmBeingRendered = getVMBeingRendered();
       const { renderMode, shadowMode } = vmBeingRendered;
-      if (renderMode === 0 /* Light */) {
+      if (renderMode === 0 /* RenderMode.Light */) {
           sc(children);
           return children;
       }
-      if (shadowMode === 1 /* Synthetic */) {
+      if (shadowMode === 1 /* ShadowMode.Synthetic */) {
           // TODO [#1276]: compiler should give us some sort of indicator when a vnodes collection is dynamic
           sc(children);
       }
@@ -3175,7 +3175,7 @@
       const { key } = data;
       let elm, aChildren, vm;
       const vnode = {
-          type: 3 /* CustomElement */,
+          type: 3 /* VNodeType.CustomElement */,
           sel,
           data,
           children,
@@ -3243,7 +3243,7 @@
   function t(text) {
       let sel, key, elm;
       return {
-          type: 0 /* Text */,
+          type: 0 /* VNodeType.Text */,
           sel,
           text,
           elm,
@@ -3255,7 +3255,7 @@
   function co(text) {
       let sel, key, elm;
       return {
-          type: 1 /* Comment */,
+          type: 1 /* VNodeType.Comment */,
           sel,
           text,
           elm,
@@ -3297,7 +3297,7 @@
           return null;
       }
       const { idx, shadowMode } = vmBeingRendered;
-      if (shadowMode === 1 /* Synthetic */) {
+      if (shadowMode === 1 /* ShadowMode.Synthetic */) {
           return StringReplace.call(id, /\S+/g, (id) => `${id}-${idx}`);
       }
       return id;
@@ -3314,7 +3314,7 @@
       }
       const { idx, shadowMode } = vmBeingRendered;
       // Apply transformation only for fragment-only-urls, and only in shadow DOM
-      if (shadowMode === 1 /* Synthetic */ && /^#/.test(url)) {
+      if (shadowMode === 1 /* ShadowMode.Synthetic */ && /^#/.test(url)) {
           return `${url}-${idx}`;
       }
       return url;
@@ -3429,7 +3429,7 @@
   function updateStylesheetToken(vm, template) {
       const { elm, context, renderMode, shadowMode, renderer: { getClassList, removeAttribute, setAttribute }, } = vm;
       const { stylesheets: newStylesheets, stylesheetToken: newStylesheetToken } = template;
-      const isSyntheticShadow = renderMode === 1 /* Shadow */ && shadowMode === 1 /* Synthetic */;
+      const isSyntheticShadow = renderMode === 1 /* RenderMode.Shadow */ && shadowMode === 1 /* ShadowMode.Synthetic */;
       const { hasScopedStyles } = context;
       let newToken;
       let newHasTokenInClass;
@@ -3477,19 +3477,19 @@
               const isScopedCss = stylesheet[KEY__SCOPED_CSS];
               // Apply the scope token only if the stylesheet itself is scoped, or if we're rendering synthetic shadow.
               const scopeToken = isScopedCss ||
-                  (vm.shadowMode === 1 /* Synthetic */ && vm.renderMode === 1 /* Shadow */)
+                  (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 /* Light */
+              const useActualHostSelector = vm.renderMode === 0 /* RenderMode.Light */
                   ? !isScopedCss
-                  : vm.shadowMode === 0 /* Native */;
+                  : 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 /* Shadow */) {
-                  useNativeDirPseudoclass = vm.shadowMode === 0 /* Native */;
+              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.
@@ -3498,7 +3498,7 @@
                       // Only calculate the root once as necessary
                       root = getNearestShadowComponent(vm);
                   }
-                  useNativeDirPseudoclass = isNull(root) || root.shadowMode === 0 /* Native */;
+                  useNativeDirPseudoclass = isNull(root) || root.shadowMode === 0 /* ShadowMode.Native */;
               }
               ArrayPush$1.call(content, stylesheet(scopeToken, useActualHostSelector, useNativeDirPseudoclass));
           }
@@ -3519,7 +3519,7 @@
   function getNearestShadowComponent(vm) {
       let owner = vm;
       while (!isNull(owner)) {
-          if (owner.renderMode === 1 /* Shadow */) {
+          if (owner.renderMode === 1 /* RenderMode.Shadow */) {
               return owner;
           }
           owner = owner.owner;
@@ -3528,7 +3528,7 @@
   }
   function getNearestNativeShadowComponent(vm) {
       const owner = getNearestShadowComponent(vm);
-      if (!isNull(owner) && owner.shadowMode === 1 /* Synthetic */) {
+      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;
@@ -3537,7 +3537,7 @@
   }
   function createStylesheet(vm, stylesheets) {
       const { renderMode, shadowMode, renderer: { ssr, insertStylesheet }, } = vm;
-      if (renderMode === 1 /* Shadow */ && shadowMode === 1 /* Synthetic */) {
+      if (renderMode === 1 /* RenderMode.Shadow */ && shadowMode === 1 /* ShadowMode.Synthetic */) {
           for (let i = 0; i < stylesheets.length; i++) {
               insertStylesheet(stylesheets[i]);
           }
@@ -3584,22 +3584,22 @@
   };
   function logOperationStart(opId, vm) {
       if (isProfilerEnabled) {
-          currentDispatcher(opId, 0 /* Start */, vm.tagName, vm.idx, vm.renderMode, vm.shadowMode);
+          currentDispatcher(opId, 0 /* Phase.Start */, vm.tagName, vm.idx, vm.renderMode, vm.shadowMode);
       }
   }
   function logOperationEnd(opId, vm) {
       if (isProfilerEnabled) {
-          currentDispatcher(opId, 1 /* Stop */, vm.tagName, vm.idx, vm.renderMode, vm.shadowMode);
+          currentDispatcher(opId, 1 /* Phase.Stop */, vm.tagName, vm.idx, vm.renderMode, vm.shadowMode);
       }
   }
   function logGlobalOperationStart(opId, vm) {
       if (isProfilerEnabled) {
-          currentDispatcher(opId, 0 /* Start */, vm === null || vm === void 0 ? void 0 : vm.tagName, vm === null || vm === void 0 ? void 0 : vm.idx, vm === null || vm === void 0 ? void 0 : vm.renderMode, vm === null || vm === void 0 ? void 0 : vm.shadowMode);
+          currentDispatcher(opId, 0 /* Phase.Start */, vm === null || vm === void 0 ? void 0 : vm.tagName, vm === null || vm === void 0 ? void 0 : vm.idx, vm === null || vm === void 0 ? void 0 : vm.renderMode, vm === null || vm === void 0 ? void 0 : vm.shadowMode);
       }
   }
   function logGlobalOperationEnd(opId, vm) {
       if (isProfilerEnabled) {
-          currentDispatcher(opId, 1 /* Stop */, vm === null || vm === void 0 ? void 0 : vm.tagName, vm === null || vm === void 0 ? void 0 : vm.idx, vm === null || vm === void 0 ? void 0 : vm.renderMode, vm === null || vm === void 0 ? void 0 : vm.shadowMode);
+          currentDispatcher(opId, 1 /* Phase.Stop */, vm === null || vm === void 0 ? void 0 : vm.tagName, vm === null || vm === void 0 ? void 0 : vm.idx, vm === null || vm === void 0 ? void 0 : vm.renderMode, vm === null || vm === void 0 ? void 0 : vm.shadowMode);
       }
   }
 
@@ -3626,7 +3626,7 @@
   function validateLightDomTemplate(template, vm) {
       if (template === defaultEmptyTemplate)
           return;
-      if (vm.renderMode === 0 /* Light */) {
+      if (vm.renderMode === 0 /* RenderMode.Light */) {
           assert.isTrue(template.renderMode === 'light', `Light DOM components can't render shadow DOM templates. Add an 'lwc:render-mode="light"' directive to the root template tag of ${getComponentTag(vm)}.`);
       }
       else {
@@ -3639,13 +3639,13 @@
           return function () {
               const { context: { hasScopedStyles, stylesheetToken }, shadowMode, renderer, } = getVMBeingRendered();
               const hasStyleToken = !isUndefined$1(stylesheetToken);
-              const isSyntheticShadow = shadowMode === 1 /* Synthetic */;
+              const isSyntheticShadow = shadowMode === 1 /* ShadowMode.Synthetic */;
               let cacheKey = 0;
               if (hasStyleToken && hasScopedStyles) {
-                  cacheKey |= 1 /* HAS_SCOPED_STYLE */;
+                  cacheKey |= 1 /* FragmentCache.HAS_SCOPED_STYLE */;
               }
               if (hasStyleToken && isSyntheticShadow) {
-                  cacheKey |= 2 /* SHADOW_MODE_SYNTHETIC */;
+                  cacheKey |= 2 /* FragmentCache.SHADOW_MODE_SYNTHETIC */;
               }
               if (!isUndefined$1(cache[cacheKey])) {
                   return cache[cacheKey];
@@ -3693,7 +3693,7 @@
       runWithBoundaryProtection(vm, vm.owner, () => {
           // pre
           vmBeingRendered = vm;
-          logOperationStart(1 /* Render */, vm);
+          logOperationStart(1 /* OperationId.Render */, vm);
       }, () => {
           // job
           const { component, context, cmpSlots, cmpTemplate, tro } = vm;
@@ -3744,7 +3744,7 @@
           // post
           isUpdatingTemplate = isUpdatingTemplateInception;
           vmBeingRendered = vmOfTemplateBeingUpdatedInception;
-          logOperationEnd(1 /* Render */, vm);
+          logOperationEnd(1 /* OperationId.Render */, vm);
       });
       return vnodes;
   }
@@ -3772,7 +3772,7 @@
   function invokeComponentConstructor(vm, Ctor) {
       const vmBeingConstructedInception = vmBeingConstructed;
       let error;
-      logOperationStart(0 /* Constructor */, vm);
+      logOperationStart(0 /* OperationId.Constructor */, vm);
       vmBeingConstructed = vm;
       /**
        * Constructors don't need to be wrapped with a boundary because for root elements
@@ -3794,7 +3794,7 @@
           error = Object(e);
       }
       finally {
-          logOperationEnd(0 /* Constructor */, vm);
+          logOperationEnd(0 /* OperationId.Constructor */, vm);
           vmBeingConstructed = vmBeingConstructedInception;
           if (!isUndefined$1(error)) {
               addErrorComponentStack(vm, error);
@@ -3950,12 +3950,12 @@
   function connectRootElement(elm) {
     const vm = getAssociatedVM(elm);
     logGlobalOperationStart(7
-    /* GlobalHydrate */
+    /* OperationId.GlobalHydrate */
     , vm); // Usually means moving the element from one place to another, which is observable via
     // life-cycle hooks.
 
     if (vm.state === 1
-    /* connected */
+    /* VMState.connected */
     ) {
       disconnectRootElement(elm);
     }
@@ -3963,7 +3963,7 @@
     runConnectedCallback(vm);
     rehydrate(vm);
     logGlobalOperationEnd(7
-    /* GlobalHydrate */
+    /* OperationId.GlobalHydrate */
     , vm);
   }
   function disconnectRootElement(elm) {
@@ -3981,7 +3981,7 @@
     } = vm;
 
     if (state !== 2
-    /* disconnected */
+    /* VMState.disconnected */
     ) {
       const {
         oar,
@@ -4012,7 +4012,7 @@
     let ancestor = vm.owner;
 
     while (!isNull(ancestor) && ancestor.renderMode === 0
-    /* Light */
+    /* RenderMode.Light */
     ) {
       ancestor = ancestor.owner;
     }
@@ -4033,7 +4033,7 @@
       def,
       idx: idx++,
       state: 0
-      /* created */
+      /* VMState.created */
       ,
       isScheduled: false,
       isDirty: true,
@@ -4097,57 +4097,57 @@
 
     if (isSyntheticShadowDefined) {
       if (def.renderMode === 0
-      /* Light */
+      /* 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
-        /* Native */
+        /* ShadowMode.Native */
         ;
       } else if (isNativeShadowDefined) {
         // Not combined with above condition because @lwc/features only supports identifiers in
         // the if-condition.
         if (runtimeFlags.ENABLE_MIXED_SHADOW_MODE) {
           if (def.shadowSupportMode === "any"
-          /* Any */
+          /* ShadowSupportMode.Any */
           ) {
             shadowMode = 0
-            /* Native */
+            /* ShadowMode.Native */
             ;
           } else {
             const shadowAncestor = getNearestShadowAncestor(vm);
 
             if (!isNull(shadowAncestor) && shadowAncestor.shadowMode === 0
-            /* Native */
+            /* ShadowMode.Native */
             ) {
               // Transitive support for native Shadow DOM. A component in native mode
               // transitively opts all of its descendants into native.
               shadowMode = 0
-              /* Native */
+              /* ShadowMode.Native */
               ;
             } else {
               // Synthetic if neither this component nor any of its ancestors are configured
               // to be native.
               shadowMode = 1
-              /* Synthetic */
+              /* ShadowMode.Synthetic */
               ;
             }
           }
         } else {
           shadowMode = 1
-          /* Synthetic */
+          /* ShadowMode.Synthetic */
           ;
         }
       } else {
         // Synthetic if there is no native Shadow DOM support.
         shadowMode = 1
-        /* Synthetic */
+        /* ShadowMode.Synthetic */
         ;
       }
     } else {
       // Native if the synthetic shadow polyfill is unavailable.
       shadowMode = 0
-      /* Native */
+      /* ShadowMode.Native */
       ;
     }
 
@@ -4191,7 +4191,7 @@
         runWithBoundaryProtection(vm, vm, () => {
           // pre
           logOperationStart(2
-          /* Patch */
+          /* OperationId.Patch */
           , vm);
         }, () => {
           // job
@@ -4199,14 +4199,14 @@
         }, () => {
           // post
           logOperationEnd(2
-          /* Patch */
+          /* OperationId.Patch */
           , vm);
         });
       }
     }
 
     if (vm.state === 1
-    /* connected */
+    /* VMState.connected */
     ) {
       // If the element is connected, that means connectedCallback was already issued, and
       // any successive rendering should finish with the call to renderedCallback, otherwise
@@ -4240,11 +4240,11 @@
 
     if (!isUndefined$1(renderedCallback)) {
       logOperationStart(4
-      /* RenderedCallback */
+      /* OperationId.RenderedCallback */
       , vm);
       invokeComponentCallback(vm, renderedCallback);
       logOperationEnd(4
-      /* RenderedCallback */
+      /* OperationId.RenderedCallback */
       , vm);
     }
   }
@@ -4252,7 +4252,7 @@
 
   function flushRehydrationQueue() {
     logGlobalOperationStart(8
-    /* GlobalRehydrate */
+    /* OperationId.GlobalRehydrate */
     );
 
     const vms = rehydrateQueue.sort((a, b) => a.idx - b.idx);
@@ -4275,7 +4275,7 @@
 
 
         logGlobalOperationEnd(8
-        /* GlobalRehydrate */
+        /* OperationId.GlobalRehydrate */
         ); // re-throwing the original error will break the current tick, but since the next tick is
         // already scheduled, it should continue patching the rest.
 
@@ -4284,7 +4284,7 @@
     }
 
     logGlobalOperationEnd(8
-    /* GlobalRehydrate */
+    /* OperationId.GlobalRehydrate */
     );
   }
 
@@ -4294,13 +4294,13 @@
     } = vm;
 
     if (state === 1
-    /* connected */
+    /* VMState.connected */
     ) {
       return; // nothing to do since it was already connected
     }
 
     vm.state = 1
-    /* connected */
+    /* VMState.connected */
     ; // reporting connection
 
     const {
@@ -4321,11 +4321,11 @@
 
     if (!isUndefined$1(connectedCallback)) {
       logOperationStart(3
-      /* ConnectedCallback */
+      /* OperationId.ConnectedCallback */
       , vm);
       invokeComponentCallback(vm, connectedCallback);
       logOperationEnd(3
-      /* ConnectedCallback */
+      /* OperationId.ConnectedCallback */
       , vm);
     }
   }
@@ -4345,7 +4345,7 @@
     }
 
     vm.state = 2
-    /* disconnected */
+    /* VMState.disconnected */
     ; // reporting disconnection
 
     const {
@@ -4366,11 +4366,11 @@
 
     if (!isUndefined$1(disconnectedCallback)) {
       logOperationStart(5
-      /* DisconnectedCallback */
+      /* OperationId.DisconnectedCallback */
       , vm);
       invokeComponentCallback(vm, disconnectedCallback);
       logOperationEnd(5
-      /* DisconnectedCallback */
+      /* OperationId.DisconnectedCallback */
       , vm);
     }
   }
@@ -4426,13 +4426,13 @@
       if (!isNull(vnode) && !isUndefined$1(vnode.elm)) {
         switch (vnode.type) {
           case 2
-          /* Element */
+          /* VNodeType.Element */
           :
             recursivelyDisconnectChildren(vnode.children);
             break;
 
           case 3
-          /* CustomElement */
+          /* VNodeType.CustomElement */
           :
             {
               const vm = getAssociatedVM(vnode.elm);
@@ -4523,13 +4523,13 @@
         resetComponentRoot(vm); // remove offenders
 
         logOperationStart(6
-        /* ErrorCallback */
+        /* OperationId.ErrorCallback */
         , vm); // error boundaries must have an ErrorCallback
 
         const errorCallback = errorBoundaryVm.def.errorCallback;
         invokeComponentCallback(errorBoundaryVm, errorCallback, [error, error.wcStack]);
         logOperationEnd(6
-        /* ErrorCallback */
+        /* OperationId.ErrorCallback */
         , vm);
       }
     }
@@ -4607,7 +4607,7 @@
 
     const computeConfigAndUpdate = () => {
       let config;
-      ro.observe(() => config = configCallback(component)); // eslint-disable-next-line lwc-internal/no-invalid-todo
+      ro.observe(() => config = configCallback(component)); // eslint-disable-next-line @lwc/lwc-internal/no-invalid-todo
       // TODO: dev-mode validation of config based on the adapter.configSchema
       // @ts-ignore it is assigned in the observe() callback
 
@@ -4649,7 +4649,7 @@
       // guarantee that the linkage can be forged.
       const contextRegistrationEvent = new WireContextRegistrationEvent(adapterContextToken, {
         setNewContext(newContext) {
-          // eslint-disable-next-line lwc-internal/no-invalid-todo
+          // eslint-disable-next-line @lwc/lwc-internal/no-invalid-todo
           // TODO: dev-mode validation of config based on the adapter.contextSchema
           callbackWhenContextIsReady(newContext);
         },
@@ -4713,7 +4713,7 @@
           // (ever), while context can have identity
 
           if (vm.state === 1
-          /* connected */
+          /* VMState.connected */
           ) {
             computeConfigAndUpdate();
           }
@@ -4907,22 +4907,22 @@
       var _a, _b;
       let hydratedNode;
       switch (vnode.type) {
-          case 0 /* Text */:
+          case 0 /* VNodeType.Text */:
               // VText has no special capability, fallback to the owner's renderer
               hydratedNode = hydrateText(node, vnode, renderer);
               break;
-          case 1 /* Comment */:
+          case 1 /* VNodeType.Comment */:
               // VComment has no special capability, fallback to the owner's renderer
               hydratedNode = hydrateComment(node, vnode, renderer);
               break;
-          case 4 /* Static */:
+          case 4 /* VNodeType.Static */:
               // VStatic are cacheable and cannot have custom renderer associated to them
               hydratedNode = hydrateStaticElement(node, vnode, renderer);
               break;
-          case 2 /* Element */:
+          case 2 /* VNodeType.Element */:
               hydratedNode = hydrateElement(node, vnode, (_a = vnode.data.renderer) !== null && _a !== void 0 ? _a : renderer);
               break;
-          case 3 /* CustomElement */:
+          case 3 /* VNodeType.CustomElement */:
               hydratedNode = hydrateCustomElement(node, vnode, (_b = vnode.data.renderer) !== null && _b !== void 0 ? _b : renderer);
               break;
       }
@@ -4930,7 +4930,7 @@
   }
   function hydrateText(node, vnode, renderer) {
       var _a;
-      if (!hasCorrectNodeType(vnode, node, 3 /* TEXT */, renderer)) {
+      if (!hasCorrectNodeType(vnode, node, 3 /* EnvNodeTypes.TEXT */, renderer)) {
           return handleMismatch(node, vnode, renderer);
       }
       const { setText } = renderer;
@@ -4940,7 +4940,7 @@
   }
   function hydrateComment(node, vnode, renderer) {
       var _a;
-      if (!hasCorrectNodeType(vnode, node, 8 /* COMMENT */, renderer)) {
+      if (!hasCorrectNodeType(vnode, node, 8 /* EnvNodeTypes.COMMENT */, renderer)) {
           return handleMismatch(node, vnode, renderer);
       }
       const { setProperty } = renderer;
@@ -4956,14 +4956,14 @@
       return elm;
   }
   function hydrateElement(elm, vnode, renderer) {
-      if (!hasCorrectNodeType(vnode, elm, 1 /* ELEMENT */, renderer) ||
+      if (!hasCorrectNodeType(vnode, elm, 1 /* EnvNodeTypes.ELEMENT */, renderer) ||
           !isMatchingElement(vnode, elm, renderer)) {
           return handleMismatch(elm, vnode, renderer);
       }
       vnode.elm = elm;
       const { owner } = vnode;
       const { context } = vnode.data;
-      const isDomManual = Boolean(!isUndefined$1(context) && !isUndefined$1(context.lwc) && context.lwc.dom === "manual" /* Manual */);
+      const isDomManual = Boolean(!isUndefined$1(context) && !isUndefined$1(context.lwc) && context.lwc.dom === "manual" /* LwcDomMode.Manual */);
       if (isDomManual) {
           // it may be that this element has lwc:inner-html, we need to diff and in case are the same,
           // remove the innerHTML from props so it reuses the existing dom elements.
@@ -4984,7 +4984,7 @@
       return elm;
   }
   function hydrateCustomElement(elm, vnode, renderer) {
-      if (!hasCorrectNodeType(vnode, elm, 1 /* ELEMENT */, renderer) ||
+      if (!hasCorrectNodeType(vnode, elm, 1 /* EnvNodeTypes.ELEMENT */, renderer) ||
           !isMatchingElement(vnode, elm, renderer)) {
           return handleMismatch(elm, vnode, renderer);
       }
@@ -5000,7 +5000,7 @@
       allocateChildren(vnode, vm);
       patchElementPropsAndAttrs(vnode, renderer);
       runConnectedCallback(vm);
-      if (vm.renderMode !== 0 /* Light */) {
+      if (vm.renderMode !== 0 /* RenderMode.Light */) {
           const { getFirstChild } = renderer;
           // VM is not rendering in Light DOM, we can proceed and hydrate the slotted content.
           // Note: for Light DOM, this is handled while hydrating the VM
@@ -5145,19 +5145,19 @@
   }
   function areCompatibleNodes(client, ssr, vnode, renderer) {
       const { getProperty, getAttribute } = renderer;
-      if (getProperty(client, 'nodeType') === 3 /* TEXT */) {
-          if (!hasCorrectNodeType(vnode, ssr, 3 /* TEXT */, renderer)) {
+      if (getProperty(client, 'nodeType') === 3 /* EnvNodeTypes.TEXT */) {
+          if (!hasCorrectNodeType(vnode, ssr, 3 /* EnvNodeTypes.TEXT */, renderer)) {
               return false;
           }
           return getProperty(client, 'nodeValue') === getProperty(ssr, 'nodeValue');
       }
-      if (getProperty(client, 'nodeType') === 8 /* COMMENT */) {
-          if (!hasCorrectNodeType(vnode, ssr, 8 /* COMMENT */, renderer)) {
+      if (getProperty(client, 'nodeType') === 8 /* EnvNodeTypes.COMMENT */) {
+          if (!hasCorrectNodeType(vnode, ssr, 8 /* EnvNodeTypes.COMMENT */, renderer)) {
               return false;
           }
           return getProperty(client, 'nodeValue') === getProperty(ssr, 'nodeValue');
       }
-      if (!hasCorrectNodeType(vnode, ssr, 1 /* ELEMENT */, renderer)) {
+      if (!hasCorrectNodeType(vnode, ssr, 1 /* EnvNodeTypes.ELEMENT */, renderer)) {
           return false;
       }
       let isCompatibleElements = true;
@@ -5213,7 +5213,7 @@
       }
       return ctor;
   }
-  /* version: 2.16.0 */
+  /* version: 2.19.0 */
 
   /*
    * Copyright (c) 2018, salesforce.com, inc.
@@ -5722,7 +5722,7 @@
    * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
    */
   // TODO [#2472]: Remove this workaround when appropriate.
-  // eslint-disable-next-line lwc-internal/no-global-node
+  // eslint-disable-next-line @lwc/lwc-internal/no-global-node
   const _Node$1 = Node;
   const ConnectingSlot = new WeakMap();
   const DisconnectingSlot = new WeakMap();
@@ -5808,7 +5808,7 @@
    * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
    */
   // TODO [#2472]: Remove this workaround when appropriate.
-  // eslint-disable-next-line lwc-internal/no-global-node
+  // eslint-disable-next-line @lwc/lwc-internal/no-global-node
   const _Node = Node;
   /**
    * EXPERIMENTAL: The purpose of this function is to detect shadowed nodes. THIS API WILL BE REMOVED
@@ -5869,7 +5869,7 @@
   });
   freeze(LightningElement);
   seal(LightningElement.prototype);
-  /* version: 2.16.0 */
+  /* version: 2.19.0 */
 
   exports.LightningElement = LightningElement;
   exports.__unstable__ProfilerControl = profilerControl;