lwc 2.17.0 → 2.19.1

package/dist/engine-dom/esm/es2017/engine-dom.js

@@ -299,9 +299,9 @@ const XLINK_NAMESPACE = 'http://www.w3.org/1999/xlink';
  * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
  */
 // Increment whenever the LWC template compiler changes
-const LWC_VERSION = "2.17.0";
+const LWC_VERSION = "2.19.1";
 const LWC_VERSION_COMMENT_REGEX = /\/\*LWC compiler v([\d.]+)\*\/\s*}/;
-/** version: 2.17.0 */
+/** version: 2.19.1 */
 
 /*
  * Copyright (c) 2018, salesforce.com, inc.
@@ -455,7 +455,7 @@ function setFeatureFlagForTest(name, value) {
         setFeatureFlag(name, value);
     }
 }
-/** version: 2.17.0 */
+/** version: 2.19.1 */
 
 /*
  * Copyright (c) 2018, salesforce.com, inc.
@@ -1915,7 +1915,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 {
@@ -1931,7 +1931,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,
     });
@@ -2054,7 +2054,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`.');
             }
         }
@@ -2426,13 +2426,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) {
@@ -2441,7 +2441,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 {
@@ -2472,7 +2472,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 {
@@ -3194,8 +3194,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'.`);
@@ -3223,7 +3223,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;
@@ -3316,8 +3316,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,
@@ -3339,7 +3339,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),
         };
     }
@@ -3396,7 +3396,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;
@@ -3652,21 +3652,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;
     }
@@ -3674,23 +3674,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;
@@ -3749,12 +3749,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);
@@ -3786,7 +3786,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);
     }
@@ -3831,14 +3831,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.
@@ -3881,7 +3881,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];
         }
     }
@@ -3931,12 +3931,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);
         }
@@ -3950,8 +3950,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 });
     }
 }
@@ -3969,7 +3969,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.
@@ -3988,7 +3988,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.
@@ -4230,7 +4230,7 @@ function addVNodeToChildLWC(vnode) {
 // [st]atic node
 function st(fragment, key) {
     return {
-        type: 4 /* Static */,
+        type: 4 /* VNodeType.Static */,
         sel: undefined,
         key,
         elm: undefined,
@@ -4264,7 +4264,7 @@ function h(sel, data, children = EmptyArray) {
     let elm;
     const { key } = data;
     return {
-        type: 2 /* Element */,
+        type: 2 /* VNodeType.Element */,
         sel,
         data,
         children,
@@ -4301,11 +4301,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);
     }
@@ -4339,7 +4339,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,
@@ -4447,7 +4447,7 @@ function f(items) {
 function t(text) {
     let sel, key, elm;
     return {
-        type: 0 /* Text */,
+        type: 0 /* VNodeType.Text */,
         sel,
         text,
         elm,
@@ -4459,7 +4459,7 @@ function t(text) {
 function co(text) {
     let sel, key, elm;
     return {
-        type: 1 /* Comment */,
+        type: 1 /* VNodeType.Comment */,
         sel,
         text,
         elm,
@@ -4508,7 +4508,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;
@@ -4530,7 +4530,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;
@@ -4653,7 +4653,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;
@@ -4709,19 +4709,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.
@@ -4730,7 +4730,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));
         }
@@ -4751,7 +4751,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;
@@ -4760,7 +4760,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;
@@ -4769,7 +4769,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]);
         }
@@ -4872,7 +4872,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) {
@@ -4882,7 +4882,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) {
@@ -4892,7 +4892,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) {
@@ -4902,7 +4902,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);
     }
 }
 
@@ -4928,11 +4928,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);
         }
     }
@@ -4940,7 +4940,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 {
@@ -4953,13 +4953,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];
@@ -5014,7 +5014,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;
@@ -5072,7 +5072,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.`);
@@ -5111,7 +5111,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
@@ -5133,7 +5133,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);
@@ -5314,12 +5314,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);
   }
@@ -5327,7 +5327,7 @@ function connectRootElement(elm) {
   runConnectedCallback(vm);
   rehydrate(vm);
   logGlobalOperationEnd(7
-  /* GlobalHydrate */
+  /* OperationId.GlobalHydrate */
   , vm);
 }
 function disconnectRootElement(elm) {
@@ -5345,7 +5345,7 @@ function resetComponentStateWhenRemoved(vm) {
   } = vm;
 
   if (state !== 2
-  /* disconnected */
+  /* VMState.disconnected */
   ) {
     const {
       oar,
@@ -5374,9 +5374,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.`);
   }
 
@@ -5387,7 +5387,7 @@ function getNearestShadowAncestor(vm) {
   let ancestor = vm.owner;
 
   while (!isNull(ancestor) && ancestor.renderMode === 0
-  /* Light */
+  /* RenderMode.Light */
   ) {
     ancestor = ancestor.owner;
   }
@@ -5408,7 +5408,7 @@ function createVM(elm, ctor, renderer, options) {
     def,
     idx: idx++,
     state: 0
-    /* created */
+    /* VMState.created */
     ,
     isScheduled: false,
     isDirty: true,
@@ -5457,7 +5457,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.
@@ -5484,57 +5484,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 */
     ;
   }
 
@@ -5594,7 +5594,7 @@ function patchShadowRoot(vm, newCh) {
       runWithBoundaryProtection(vm, vm, () => {
         // pre
         logOperationStart(2
-        /* Patch */
+        /* OperationId.Patch */
         , vm);
       }, () => {
         // job
@@ -5602,14 +5602,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
@@ -5643,11 +5643,11 @@ function runRenderedCallback(vm) {
 
   if (!isUndefined$1(renderedCallback)) {
     logOperationStart(4
-    /* RenderedCallback */
+    /* OperationId.RenderedCallback */
     , vm);
     invokeComponentCallback(vm, renderedCallback);
     logOperationEnd(4
-    /* RenderedCallback */
+    /* OperationId.RenderedCallback */
     , vm);
   }
 }
@@ -5655,7 +5655,7 @@ let rehydrateQueue = [];
 
 function flushRehydrationQueue() {
   logGlobalOperationStart(8
-  /* GlobalRehydrate */
+  /* OperationId.GlobalRehydrate */
   );
 
   if (process.env.NODE_ENV !== 'production') {
@@ -5682,7 +5682,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.
 
@@ -5691,7 +5691,7 @@ function flushRehydrationQueue() {
   }
 
   logGlobalOperationEnd(8
-  /* GlobalRehydrate */
+  /* OperationId.GlobalRehydrate */
   );
 }
 
@@ -5701,13 +5701,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 {
@@ -5728,11 +5728,11 @@ function runConnectedCallback(vm) {
 
   if (!isUndefined$1(connectedCallback)) {
     logOperationStart(3
-    /* ConnectedCallback */
+    /* OperationId.ConnectedCallback */
     , vm);
     invokeComponentCallback(vm, connectedCallback);
     logOperationEnd(3
-    /* ConnectedCallback */
+    /* OperationId.ConnectedCallback */
     , vm);
   }
 }
@@ -5744,7 +5744,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.`);
   }
 
@@ -5757,7 +5757,7 @@ function runDisconnectedCallback(vm) {
   }
 
   vm.state = 2
-  /* disconnected */
+  /* VMState.disconnected */
   ; // reporting disconnection
 
   const {
@@ -5778,11 +5778,11 @@ function runDisconnectedCallback(vm) {
 
   if (!isUndefined$1(disconnectedCallback)) {
     logOperationStart(5
-    /* DisconnectedCallback */
+    /* OperationId.DisconnectedCallback */
     , vm);
     invokeComponentCallback(vm, disconnectedCallback);
     logOperationEnd(5
-    /* DisconnectedCallback */
+    /* OperationId.DisconnectedCallback */
     , vm);
   }
 }
@@ -5838,13 +5838,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);
@@ -5935,13 +5935,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);
     }
   }
@@ -6036,7 +6036,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
 
@@ -6078,7 +6078,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);
       },
@@ -6142,7 +6142,7 @@ function createConnector(vm, name, wireDef) {
         // (ever), while context can have identity
 
         if (vm.state === 1
-        /* connected */
+        /* VMState.connected */
         ) {
           computeConfigAndUpdate();
         }
@@ -6346,22 +6346,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;
     }
@@ -6369,7 +6369,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') {
@@ -6386,7 +6386,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') {
@@ -6409,14 +6409,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.
@@ -6442,7 +6442,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);
     }
@@ -6459,10 +6459,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
@@ -6645,19 +6645,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;
@@ -6811,7 +6811,7 @@ function getComponentConstructor(elm) {
     }
     return ctor;
 }
-/* version: 2.17.0 */
+/* version: 2.19.1 */
 
 /*
  * Copyright (c) 2018, salesforce.com, inc.
@@ -7340,7 +7340,7 @@ function buildCustomElementConstructor(Ctor) {
  * 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();
@@ -7429,7 +7429,7 @@ function createElement(sel, options) {
  * 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
@@ -7490,6 +7490,6 @@ defineProperty(LightningElement, 'CustomElementConstructor', {
 });
 freeze(LightningElement);
 seal(LightningElement.prototype);
-/* version: 2.17.0 */
+/* version: 2.19.1 */
 
 export { LightningElement, profilerControl as __unstable__ProfilerControl, api$1 as api, deprecatedBuildCustomElementConstructor as buildCustomElementConstructor, createContextProvider, createElement, freezeTemplate, getComponentConstructor, getComponentDef, hydrateComponent, isComponentConstructor, isNodeShadowed as isNodeFromTemplate, parseFragment, parseSVGFragment, readonly, register, registerComponent, registerDecorators, registerTemplate, renderer, sanitizeAttribute, setFeatureFlag, setFeatureFlagForTest, setHooks, swapComponent, swapStyle, swapTemplate, track, unwrap, wire };