@lwc/engine-core 2.18.0 → 2.20.0

package/dist/engine-core.js

@@ -1434,7 +1434,7 @@ const LightningElement = function () {
     // 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 {
@@ -1450,7 +1450,7 @@ const LightningElement = function () {
 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,
     });
@@ -1573,7 +1573,7 @@ LightningElement.prototype = {
     get template() {
         const vm = getAssociatedVM(this);
         if (process.env.NODE_ENV !== 'production') {
-            if (vm.renderMode === 0 /* Light */) {
+            if (vm.renderMode === 0 /* RenderMode.Light */) {
                 logError('`this.template` returns null for light DOM components. Since there is no shadow, the rendered content can be accessed via `this` itself. e.g. instead of `this.template.querySelector`, use `this.querySelector`.');
             }
         }
@@ -1945,13 +1945,13 @@ function internalWireFieldDecorator(key) {
  */
 function getClassDescriptorType(descriptor) {
     if (isFunction$1(descriptor.value)) {
-        return "method" /* Method */;
+        return "method" /* DescriptorType.Method */;
     }
     else if (isFunction$1(descriptor.set) || isFunction$1(descriptor.get)) {
-        return "accessor" /* Accessor */;
+        return "accessor" /* DescriptorType.Accessor */;
     }
     else {
-        return "field" /* Field */;
+        return "field" /* DescriptorType.Field */;
     }
 }
 function validateObservedField(Ctor, fieldName, descriptor) {
@@ -1960,7 +1960,7 @@ function validateObservedField(Ctor, fieldName, descriptor) {
         const message = `Invalid observed ${fieldName} field. Found a duplicate ${type} with the same name.`;
         // [W-9927596] Ideally we always throw an error when detecting duplicate observed field.
         // This branch is only here for backward compatibility reasons.
-        if (type === "accessor" /* Accessor */) {
+        if (type === "accessor" /* DescriptorType.Accessor */) {
             logError(message);
         }
         else {
@@ -1991,7 +1991,7 @@ function validateFieldDecoratedWithApi(Ctor, fieldName, descriptor) {
         const message = `Invalid @api ${fieldName} field. Found a duplicate ${type} with the same name.`;
         // [W-9927596] Ideally we always throw an error when detecting duplicate public properties.
         // This branch is only here for backward compatibility reasons.
-        if (type === "accessor" /* Accessor */) {
+        if (type === "accessor" /* DescriptorType.Accessor */) {
             logError(message);
         }
         else {
@@ -2713,8 +2713,8 @@ function createComponentDef(Ctor) {
         // assert.isTrue(ctorName && isString(ctorName), `${toString(Ctor)} should have a "name" property with string value, but found ${ctorName}.`);
         assert.isTrue(Ctor.constructor, `Missing ${ctorName}.constructor, ${ctorName} should have a "constructor" property.`);
         if (!isUndefined$1(ctorShadowSupportMode)) {
-            assert.invariant(ctorShadowSupportMode === "any" /* Any */ ||
-                ctorShadowSupportMode === "reset" /* Default */, `Invalid value for static property shadowSupportMode: '${ctorShadowSupportMode}'`);
+            assert.invariant(ctorShadowSupportMode === "any" /* ShadowSupportMode.Any */ ||
+                ctorShadowSupportMode === "reset" /* ShadowSupportMode.Default */, `Invalid value for static property shadowSupportMode: '${ctorShadowSupportMode}'`);
         }
         if (!isUndefined$1(ctorRenderMode)) {
             assert.invariant(ctorRenderMode === 'light' || ctorRenderMode === 'shadow', `Invalid value for static property renderMode: '${ctorRenderMode}'. renderMode must be either 'light' or 'shadow'.`);
@@ -2742,7 +2742,7 @@ function createComponentDef(Ctor) {
     }
     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;
@@ -2835,8 +2835,8 @@ const lightingElementDef = {
     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,
@@ -2858,7 +2858,7 @@ function getComponentDef(Ctor) {
         // 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),
         };
     }
@@ -2915,7 +2915,7 @@ function getUpgradableConstructor(tagName, renderer) {
  */
 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;
@@ -3171,21 +3171,21 @@ function patch(n1, n2, renderer) {
         }
     }
     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;
     }
@@ -3193,23 +3193,23 @@ function patch(n1, n2, renderer) {
 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;
@@ -3268,12 +3268,12 @@ function mountStatic(vnode, parent, anchor, renderer) {
     // 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;
         }
     }
     if (process.env.NODE_ENV !== 'production') {
-        const isLight = renderMode === 0 /* Light */;
+        const isLight = renderMode === 0 /* RenderMode.Light */;
         patchElementWithRestrictions(elm, { isPortal: false, isLight });
     }
     insertNode(elm, parent, anchor, renderer);
@@ -3305,7 +3305,7 @@ function mountCustomElement(vnode, parent, anchor, renderer) {
     insertNode(elm, parent, anchor, renderer);
     if (vm) {
         if (process.env.NODE_ENV !== 'production') {
-            assert.isTrue(vm.state === 0 /* created */, `${vm} cannot be recycled.`);
+            assert.isTrue(vm.state === 0 /* VMState.created */, `${vm} cannot be recycled.`);
         }
         runConnectedCallback(vm);
     }
@@ -3350,14 +3350,14 @@ function unmount(vnode, parent, renderer, doRemove = false) {
         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.
@@ -3400,7 +3400,7 @@ function linkNodeToShadow(elm, owner, renderer) {
     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];
         }
     }
@@ -3450,12 +3450,12 @@ function patchElementPropsAndAttrs$1(oldVnode, vnode, renderer) {
 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);
         }
@@ -3469,8 +3469,8 @@ function fallbackElmHook(elm, vnode, renderer) {
         const { data: { context }, } = vnode;
         const isPortal = !isUndefined$1(context) &&
             !isUndefined$1(context.lwc) &&
-            context.lwc.dom === "manual" /* Manual */;
-        const isLight = owner.renderMode === 0 /* Light */;
+            context.lwc.dom === "manual" /* LwcDomMode.Manual */;
+        const isLight = owner.renderMode === 0 /* RenderMode.Light */;
         patchElementWithRestrictions(elm, { isPortal, isLight });
     }
 }
@@ -3488,7 +3488,7 @@ function allocateChildren(vnode, vm) {
     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.
@@ -3507,7 +3507,7 @@ function createViewModelHook(elm, vnode, renderer) {
     }
     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.
@@ -3749,7 +3749,7 @@ function addVNodeToChildLWC(vnode) {
 // [st]atic node
 function st(fragment, key) {
     return {
-        type: 4 /* Static */,
+        type: 4 /* VNodeType.Static */,
         sel: undefined,
         key,
         elm: undefined,
@@ -3783,7 +3783,7 @@ function h(sel, data, children = EmptyArray) {
     let elm;
     const { key } = data;
     return {
-        type: 2 /* Element */,
+        type: 2 /* VNodeType.Element */,
         sel,
         data,
         children,
@@ -3820,11 +3820,11 @@ function s(slotName, data, children, slotset) {
     }
     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);
     }
@@ -3858,7 +3858,7 @@ function c(sel, Ctor, data, children = EmptyArray) {
     const { key } = data;
     let elm, aChildren, vm;
     const vnode = {
-        type: 3 /* CustomElement */,
+        type: 3 /* VNodeType.CustomElement */,
         sel,
         data,
         children,
@@ -3966,7 +3966,7 @@ function f(items) {
 function t(text) {
     let sel, key, elm;
     return {
-        type: 0 /* Text */,
+        type: 0 /* VNodeType.Text */,
         sel,
         text,
         elm,
@@ -3978,7 +3978,7 @@ function t(text) {
 function co(text) {
     let sel, key, elm;
     return {
-        type: 1 /* Comment */,
+        type: 1 /* VNodeType.Comment */,
         sel,
         text,
         elm,
@@ -4027,7 +4027,7 @@ function gid(id) {
         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;
@@ -4049,7 +4049,7 @@ function fid(url) {
     }
     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;
@@ -4172,7 +4172,7 @@ function createInlineStyleVNode(content) {
 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;
@@ -4228,19 +4228,19 @@ function evaluateStylesheetsContent(stylesheets, stylesheetToken, vm) {
             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.
@@ -4249,7 +4249,7 @@ function evaluateStylesheetsContent(stylesheets, stylesheetToken, vm) {
                     // 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));
         }
@@ -4270,7 +4270,7 @@ function getStylesheetsContent(vm, template) {
 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;
@@ -4279,7 +4279,7 @@ function getNearestShadowComponent(vm) {
 }
 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;
@@ -4288,7 +4288,7 @@ function getNearestNativeShadowComponent(vm) {
 }
 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]);
         }
@@ -4391,7 +4391,7 @@ function logOperationStart(opId, vm) {
         start(markName);
     }
     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) {
@@ -4401,7 +4401,7 @@ function logOperationEnd(opId, vm) {
         end(measureName, markName);
     }
     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) {
@@ -4411,7 +4411,7 @@ function logGlobalOperationStart(opId, vm) {
         start(markName);
     }
     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) {
@@ -4421,7 +4421,7 @@ function logGlobalOperationEnd(opId, vm) {
         end(opName, markName);
     }
     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);
     }
 }
 
@@ -4447,11 +4447,11 @@ function validateSlots(vm, html) {
     const { cmpSlots } = vm;
     const { slots = EmptyArray } = html;
     for (const slotName in cmpSlots) {
-        // eslint-disable-next-line lwc-internal/no-production-assert
+        // eslint-disable-next-line @lwc/lwc-internal/no-production-assert
         assert.isTrue(isArray$1(cmpSlots[slotName]), `Slots can only be set to an array, instead received ${toString$1(cmpSlots[slotName])} for slot "${slotName}" in ${vm}.`);
         if (slotName !== '' && ArrayIndexOf.call(slots, slotName) === -1) {
             // TODO [#1297]: this should never really happen because the compiler should always validate
-            // eslint-disable-next-line lwc-internal/no-production-assert
+            // eslint-disable-next-line @lwc/lwc-internal/no-production-assert
             logError(`Ignoring unknown provided slot name "${slotName}" in ${vm}. Check for a typo on the slot attribute.`, vm);
         }
     }
@@ -4459,7 +4459,7 @@ function validateSlots(vm, html) {
 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 {
@@ -4472,13 +4472,13 @@ function buildParseFragmentFn(createFragmentFn) {
         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];
@@ -4533,7 +4533,7 @@ function evaluateTemplate(vm, html) {
     runWithBoundaryProtection(vm, vm.owner, () => {
         // pre
         vmBeingRendered = vm;
-        logOperationStart(1 /* Render */, vm);
+        logOperationStart(1 /* OperationId.Render */, vm);
     }, () => {
         // job
         const { component, context, cmpSlots, cmpTemplate, tro } = vm;
@@ -4591,7 +4591,7 @@ function evaluateTemplate(vm, html) {
         // post
         isUpdatingTemplate = isUpdatingTemplateInception;
         vmBeingRendered = vmOfTemplateBeingUpdatedInception;
-        logOperationEnd(1 /* Render */, vm);
+        logOperationEnd(1 /* OperationId.Render */, vm);
     });
     if (process.env.NODE_ENV !== 'production') {
         assert.invariant(isArray$1(vnodes), `Compiler should produce html functions that always return an array.`);
@@ -4630,7 +4630,7 @@ function invokeComponentCallback(vm, fn, args) {
 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
@@ -4652,7 +4652,7 @@ function invokeComponentConstructor(vm, Ctor) {
         error = Object(e);
     }
     finally {
-        logOperationEnd(0 /* Constructor */, vm);
+        logOperationEnd(0 /* OperationId.Constructor */, vm);
         vmBeingConstructed = vmBeingConstructedInception;
         if (!isUndefined$1(error)) {
             addErrorComponentStack(vm, error);
@@ -4833,12 +4833,12 @@ function rerenderVM(vm) {
 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);
   }
@@ -4846,7 +4846,7 @@ function connectRootElement(elm) {
   runConnectedCallback(vm);
   rehydrate(vm);
   logGlobalOperationEnd(7
-  /* GlobalHydrate */
+  /* OperationId.GlobalHydrate */
   , vm);
 }
 function disconnectRootElement(elm) {
@@ -4864,7 +4864,7 @@ function resetComponentStateWhenRemoved(vm) {
   } = vm;
 
   if (state !== 2
-  /* disconnected */
+  /* VMState.disconnected */
   ) {
     const {
       oar,
@@ -4893,9 +4893,9 @@ function resetComponentStateWhenRemoved(vm) {
 function removeVM(vm) {
   if (process.env.NODE_ENV !== 'production') {
     assert.isTrue(vm.state === 1
-    /* connected */
+    /* VMState.connected */
     || vm.state === 2
-    /* disconnected */
+    /* VMState.disconnected */
     , `${vm} must have been connected.`);
   }
 
@@ -4906,7 +4906,7 @@ function getNearestShadowAncestor(vm) {
   let ancestor = vm.owner;
 
   while (!isNull(ancestor) && ancestor.renderMode === 0
-  /* Light */
+  /* RenderMode.Light */
   ) {
     ancestor = ancestor.owner;
   }
@@ -4927,7 +4927,7 @@ function createVM(elm, ctor, renderer, options) {
     def,
     idx: idx++,
     state: 0
-    /* created */
+    /* VMState.created */
     ,
     isScheduled: false,
     isDirty: true,
@@ -4976,7 +4976,7 @@ function createVM(elm, ctor, renderer, options) {
 
     if (runtimeFlags.ENABLE_FORCE_NATIVE_SHADOW_MODE_FOR_TEST) {
       vm.shadowMode = 0
-      /* Native */
+      /* ShadowMode.Native */
       ;
     }
   } // Create component instance associated to the vm and the element.
@@ -5003,57 +5003,57 @@ function computeShadowMode(vm, renderer) {
 
   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 */
     ;
   }
 
@@ -5113,7 +5113,7 @@ function patchShadowRoot(vm, newCh) {
       runWithBoundaryProtection(vm, vm, () => {
         // pre
         logOperationStart(2
-        /* Patch */
+        /* OperationId.Patch */
         , vm);
       }, () => {
         // job
@@ -5121,14 +5121,14 @@ function patchShadowRoot(vm, newCh) {
       }, () => {
         // 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
@@ -5162,11 +5162,11 @@ function runRenderedCallback(vm) {
 
   if (!isUndefined$1(renderedCallback)) {
     logOperationStart(4
-    /* RenderedCallback */
+    /* OperationId.RenderedCallback */
     , vm);
     invokeComponentCallback(vm, renderedCallback);
     logOperationEnd(4
-    /* RenderedCallback */
+    /* OperationId.RenderedCallback */
     , vm);
   }
 }
@@ -5174,7 +5174,7 @@ let rehydrateQueue = [];
 
 function flushRehydrationQueue() {
   logGlobalOperationStart(8
-  /* GlobalRehydrate */
+  /* OperationId.GlobalRehydrate */
   );
 
   if (process.env.NODE_ENV !== 'production') {
@@ -5201,7 +5201,7 @@ function flushRehydrationQueue() {
 
 
       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.
 
@@ -5210,7 +5210,7 @@ function flushRehydrationQueue() {
   }
 
   logGlobalOperationEnd(8
-  /* GlobalRehydrate */
+  /* OperationId.GlobalRehydrate */
   );
 }
 
@@ -5220,13 +5220,13 @@ function runConnectedCallback(vm) {
   } = 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 {
@@ -5247,11 +5247,11 @@ function runConnectedCallback(vm) {
 
   if (!isUndefined$1(connectedCallback)) {
     logOperationStart(3
-    /* ConnectedCallback */
+    /* OperationId.ConnectedCallback */
     , vm);
     invokeComponentCallback(vm, connectedCallback);
     logOperationEnd(3
-    /* ConnectedCallback */
+    /* OperationId.ConnectedCallback */
     , vm);
   }
 }
@@ -5263,7 +5263,7 @@ function hasWireAdapters(vm) {
 function runDisconnectedCallback(vm) {
   if (process.env.NODE_ENV !== 'production') {
     assert.isTrue(vm.state !== 2
-    /* disconnected */
+    /* VMState.disconnected */
     , `${vm} must be inserted.`);
   }
 
@@ -5276,7 +5276,7 @@ function runDisconnectedCallback(vm) {
   }
 
   vm.state = 2
-  /* disconnected */
+  /* VMState.disconnected */
   ; // reporting disconnection
 
   const {
@@ -5297,11 +5297,11 @@ function runDisconnectedCallback(vm) {
 
   if (!isUndefined$1(disconnectedCallback)) {
     logOperationStart(5
-    /* DisconnectedCallback */
+    /* OperationId.DisconnectedCallback */
     , vm);
     invokeComponentCallback(vm, disconnectedCallback);
     logOperationEnd(5
-    /* DisconnectedCallback */
+    /* OperationId.DisconnectedCallback */
     , vm);
   }
 }
@@ -5357,13 +5357,13 @@ function recursivelyDisconnectChildren(vnodes) {
     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);
@@ -5454,13 +5454,13 @@ function runWithBoundaryProtection(vm, owner, pre, job, post) {
       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);
     }
   }
@@ -5555,7 +5555,7 @@ function createConfigWatcher(component, configCallback, callbackWhenConfigIsRead
 
   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
 
@@ -5597,7 +5597,7 @@ function createContextWatcher(vm, wireDef, callbackWhenContextIsReady) {
     // 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);
       },
@@ -5661,7 +5661,7 @@ function createConnector(vm, name, wireDef) {
         // (ever), while context can have identity
 
         if (vm.state === 1
-        /* connected */
+        /* VMState.connected */
         ) {
           computeConfigAndUpdate();
         }
@@ -5865,22 +5865,22 @@ function hydrateNode(node, vnode, renderer) {
     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;
     }
@@ -5888,7 +5888,7 @@ function hydrateNode(node, vnode, renderer) {
 }
 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);
     }
     if (process.env.NODE_ENV !== 'production') {
@@ -5905,7 +5905,7 @@ function hydrateText(node, vnode, renderer) {
 }
 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);
     }
     if (process.env.NODE_ENV !== 'production') {
@@ -5928,14 +5928,14 @@ function hydrateStaticElement(elm, vnode, renderer) {
     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.
@@ -5961,7 +5961,7 @@ function hydrateElement(elm, vnode, renderer) {
     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);
     }
@@ -5978,10 +5978,10 @@ function hydrateCustomElement(elm, vnode, renderer) {
     patchElementPropsAndAttrs(vnode, renderer);
     // Insert hook section:
     if (process.env.NODE_ENV !== 'production') {
-        assert.isTrue(vm.state === 0 /* created */, `${vm} cannot be recycled.`);
+        assert.isTrue(vm.state === 0 /* VMState.created */, `${vm} cannot be recycled.`);
     }
     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
@@ -6164,19 +6164,19 @@ function validateStyleAttr(vnode, elm, renderer) {
 }
 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;
@@ -6332,4 +6332,4 @@ function getComponentConstructor(elm) {
 }
 
 export { LightningElement, profilerControl as __unstable__ProfilerControl, api$1 as api, connectRootElement, createContextProvider, createVM, disconnectRootElement, freezeTemplate, getAssociatedVMIfPresent, getComponentConstructor, getComponentDef, getComponentHtmlPrototype, getUpgradableConstructor, hydrateRoot, isComponentConstructor, parseFragment, parseSVGFragment, readonly, register, registerComponent, registerDecorators, registerTemplate, sanitizeAttribute, setHooks, swapComponent, swapStyle, swapTemplate, track, unwrap, wire };
-/* version: 2.18.0 */
+/* version: 2.20.0 */