@lwc/engine-core 2.11.1 → 2.11.3-238prod.0

package/LICENSE

@@ -0,0 +1,10 @@
+MIT LICENSE
+
+Copyright (c) 2018, Salesforce.com, Inc.
+All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/dist/engine-core.cjs.js

@@ -4802,236 +4802,6 @@ function invokeServiceHook(vm, cbs) {
     }
 }
 
-/*
- * Copyright (c) 2022, salesforce.com, inc.
- * All rights reserved.
- * SPDX-License-Identifier: MIT
- * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
- */
-function hydrate(vnode, node) {
-    switch (vnode.type) {
-        case 0 /* Text */:
-            hydrateText(vnode, node);
-            break;
-        case 1 /* Comment */:
-            hydrateComment(vnode, node);
-            break;
-        case 2 /* Element */:
-            hydrateElement(vnode, node);
-            break;
-        case 3 /* CustomElement */:
-            hydrateCustomElement(vnode, node);
-            break;
-    }
-}
-function hydrateText(vnode, node) {
-    var _a;
-    if (process.env.NODE_ENV !== 'production') {
-        validateNodeType(vnode, node, 3 /* TEXT */);
-        const nodeValue = getProperty(node, 'nodeValue');
-        if (nodeValue !== vnode.text && !(nodeValue === '\u200D' && vnode.text === '')) {
-            logWarn('Hydration mismatch: text values do not match, will recover from the difference', vnode.owner);
-        }
-    }
-    // always set the text value to the one from the vnode.
-    setText(node, (_a = vnode.text) !== null && _a !== void 0 ? _a : null);
-    vnode.elm = node;
-}
-function hydrateComment(vnode, node) {
-    var _a;
-    if (process.env.NODE_ENV !== 'production') {
-        validateNodeType(vnode, node, 8 /* COMMENT */);
-        if (getProperty(node, 'nodeValue') !== vnode.text) {
-            logWarn('Hydration mismatch: comment values do not match, will recover from the difference', vnode.owner);
-        }
-    }
-    // always set the text value to the one from the vnode.
-    setProperty(node, 'nodeValue', (_a = vnode.text) !== null && _a !== void 0 ? _a : null);
-    vnode.elm = node;
-}
-function hydrateElement(vnode, node) {
-    if (process.env.NODE_ENV !== 'production') {
-        validateNodeType(vnode, node, 1 /* ELEMENT */);
-        validateElement(vnode, node);
-    }
-    const elm = node;
-    vnode.elm = elm;
-    const { context } = vnode.data;
-    const isDomManual = Boolean(!shared.isUndefined(context) && !shared.isUndefined(context.lwc) && context.lwc.dom === "manual" /* 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.
-        const { props } = vnode.data;
-        if (!shared.isUndefined(props) && !shared.isUndefined(props.innerHTML)) {
-            if (getProperty(elm, 'innerHTML') === props.innerHTML) {
-                // Do a shallow clone since VNodeData may be shared across VNodes due to hoist optimization
-                vnode.data = Object.assign(Object.assign({}, vnode.data), { props: cloneAndOmitKey(props, 'innerHTML') });
-            }
-            else {
-                logWarn(`Mismatch hydrating element <${getProperty(elm, 'tagName').toLowerCase()}>: innerHTML values do not match for element, will recover from the difference`, vnode.owner);
-            }
-        }
-    }
-    patchElementPropsAndAttrs(vnode);
-    if (!isDomManual) {
-        hydrateChildren(getChildNodes(vnode.elm), vnode.children, vnode.owner);
-    }
-}
-function hydrateCustomElement(vnode, node) {
-    if (process.env.NODE_ENV !== 'production') {
-        validateNodeType(vnode, node, 1 /* ELEMENT */);
-        validateElement(vnode, node);
-    }
-    const elm = node;
-    const { sel, mode, ctor, owner } = vnode;
-    const vm = createVM(elm, ctor, {
-        mode,
-        owner,
-        tagName: sel,
-    });
-    vnode.elm = elm;
-    vnode.vm = vm;
-    allocateChildren(vnode, vm);
-    patchElementPropsAndAttrs(vnode);
-    // Insert hook section:
-    if (process.env.NODE_ENV !== 'production') {
-        shared.assert.isTrue(vm.state === 0 /* created */, `${vm} cannot be recycled.`);
-    }
-    runConnectedCallback(vm);
-    if (vm.renderMode !== 0 /* Light */) {
-        // 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
-        hydrateChildren(getChildNodes(vnode.elm), vnode.children, vm);
-    }
-    hydrateVM(vm);
-}
-function hydrateChildren(elmChildren, children, vm) {
-    if (process.env.NODE_ENV !== 'production') {
-        const filteredVNodes = shared.ArrayFilter.call(children, (vnode) => !!vnode);
-        if (elmChildren.length !== filteredVNodes.length) {
-            logError(`Hydration mismatch: incorrect number of rendered nodes, expected ${filteredVNodes.length} but found ${elmChildren.length}.`, vm);
-            throwHydrationError();
-        }
-    }
-    let childNodeIndex = 0;
-    for (let i = 0; i < children.length; i++) {
-        const childVnode = children[i];
-        if (!shared.isNull(childVnode)) {
-            const childNode = elmChildren[childNodeIndex];
-            hydrate(childVnode, childNode);
-            childNodeIndex++;
-        }
-    }
-}
-function patchElementPropsAndAttrs(vnode) {
-    applyEventListeners(vnode);
-    patchProps(null, vnode);
-}
-function throwHydrationError() {
-    shared.assert.fail('Server rendered elements do not match client side generated elements');
-}
-function validateNodeType(vnode, node, nodeType) {
-    if (getProperty(node, 'nodeType') !== nodeType) {
-        logError('Hydration mismatch: incorrect node type received', vnode.owner);
-        shared.assert.fail('Hydration mismatch: incorrect node type received.');
-    }
-}
-function validateElement(vnode, elm) {
-    if (vnode.sel.toLowerCase() !== getProperty(elm, 'tagName').toLowerCase()) {
-        logError(`Hydration mismatch: expecting element with tag "${vnode.sel.toLowerCase()}" but found "${getProperty(elm, 'tagName').toLowerCase()}".`, vnode.owner);
-        throwHydrationError();
-    }
-    const hasIncompatibleAttrs = validateAttrs(vnode, elm);
-    const hasIncompatibleClass = validateClassAttr(vnode, elm);
-    const hasIncompatibleStyle = validateStyleAttr(vnode, elm);
-    const isVNodeAndElementCompatible = hasIncompatibleAttrs && hasIncompatibleClass && hasIncompatibleStyle;
-    if (!isVNodeAndElementCompatible) {
-        throwHydrationError();
-    }
-}
-function validateAttrs(vnode, elm) {
-    const { data: { attrs = {} }, } = vnode;
-    let nodesAreCompatible = true;
-    // Validate attributes, though we could always recovery from those by running the update mods.
-    // Note: intentionally ONLY matching vnodes.attrs to elm.attrs, in case SSR is adding extra attributes.
-    for (const [attrName, attrValue] of Object.entries(attrs)) {
-        const elmAttrValue = getAttribute(elm, attrName);
-        if (String(attrValue) !== elmAttrValue) {
-            logError(`Mismatch hydrating element <${getProperty(elm, 'tagName').toLowerCase()}>: attribute "${attrName}" has different values, expected "${attrValue}" but found "${elmAttrValue}"`, vnode.owner);
-            nodesAreCompatible = false;
-        }
-    }
-    return nodesAreCompatible;
-}
-function validateClassAttr(vnode, elm) {
-    const { data: { className, classMap }, } = vnode;
-    let nodesAreCompatible = true;
-    let vnodeClassName;
-    if (!shared.isUndefined(className) && String(className) !== getProperty(elm, 'className')) {
-        // className is used when class is bound to an expr.
-        nodesAreCompatible = false;
-        vnodeClassName = className;
-    }
-    else if (!shared.isUndefined(classMap)) {
-        // classMap is used when class is set to static value.
-        const classList = getClassList(elm);
-        let computedClassName = '';
-        // all classes from the vnode should be in the element.classList
-        for (const name in classMap) {
-            computedClassName += ' ' + name;
-            if (!classList.contains(name)) {
-                nodesAreCompatible = false;
-            }
-        }
-        vnodeClassName = computedClassName.trim();
-        if (classList.length > shared.keys(classMap).length) {
-            nodesAreCompatible = false;
-        }
-    }
-    if (!nodesAreCompatible) {
-        logError(`Mismatch hydrating element <${getProperty(elm, 'tagName').toLowerCase()}>: attribute "class" has different values, expected "${vnodeClassName}" but found "${getProperty(elm, 'className')}"`, vnode.owner);
-    }
-    return nodesAreCompatible;
-}
-function validateStyleAttr(vnode, elm) {
-    const { data: { style, styleDecls }, } = vnode;
-    const elmStyle = getAttribute(elm, 'style') || '';
-    let vnodeStyle;
-    let nodesAreCompatible = true;
-    if (!shared.isUndefined(style) && style !== elmStyle) {
-        nodesAreCompatible = false;
-        vnodeStyle = style;
-    }
-    else if (!shared.isUndefined(styleDecls)) {
-        const parsedVnodeStyle = parseStyleText(elmStyle);
-        const expectedStyle = [];
-        // styleMap is used when style is set to static value.
-        for (let i = 0, n = styleDecls.length; i < n; i++) {
-            const [prop, value, important] = styleDecls[i];
-            expectedStyle.push(`${prop}: ${value + (important ? ' important!' : '')}`);
-            const parsedPropValue = parsedVnodeStyle[prop];
-            if (shared.isUndefined(parsedPropValue)) {
-                nodesAreCompatible = false;
-            }
-            else if (!parsedPropValue.startsWith(value)) {
-                nodesAreCompatible = false;
-            }
-            else if (important && !parsedPropValue.endsWith('!important')) {
-                nodesAreCompatible = false;
-            }
-        }
-        if (shared.keys(parsedVnodeStyle).length > styleDecls.length) {
-            nodesAreCompatible = false;
-        }
-        vnodeStyle = shared.ArrayJoin.call(expectedStyle, ';');
-    }
-    if (!nodesAreCompatible) {
-        // style is used when class is bound to an expr.
-        logError(`Mismatch hydrating element <${getProperty(elm, 'tagName').toLowerCase()}>: attribute "style" has different values, expected "${vnodeStyle}" but found "${elmStyle}".`, vnode.owner);
-    }
-    return nodesAreCompatible;
-}
-
 /*
  * Copyright (c) 2018, salesforce.com, inc.
  * All rights reserved.
@@ -5077,32 +4847,12 @@ function connectRootElement(elm) {
   /* GlobalHydrate */
   , vm);
 }
-function hydrateRootElement(elm) {
-  const vm = getAssociatedVM(elm);
-  runConnectedCallback(vm);
-  hydrateVM(vm);
-}
 function disconnectRootElement(elm) {
   const vm = getAssociatedVM(elm);
   resetComponentStateWhenRemoved(vm);
 }
 function appendVM(vm) {
   rehydrate(vm);
-}
-function hydrateVM(vm) {
-  if (shared.isTrue(vm.isDirty)) {
-    // manually diffing/patching here.
-    // This routine is:
-    // patchShadowRoot(vm, children);
-    //  -> addVnodes.
-    const children = renderComponent(vm);
-    vm.children = children;
-    const vmChildren = vm.renderMode === 0
-    /* Light */
-    ? getChildNodes(vm.elm) : getChildNodes(vm.elm.shadowRoot);
-    hydrateChildren(vmChildren, children, vm);
-    runRenderedCallback(vm);
-  }
 } // just in case the component comes back, with this we guarantee re-rendering it
 // while preventing any attempt to rehydration until after reinsertion.
 
@@ -5407,7 +5157,6 @@ function runRenderedCallback(vm) {
     , vm);
   }
 }
-
 let rehydrateQueue = [];
 
 function flushRehydrationQueue() {
@@ -6064,6 +5813,298 @@ function readonly(obj) {
     return reactiveMembrane.getReadOnlyProxy(obj);
 }
 
+/*
+ * Copyright (c) 2022, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+// flag indicating if the hydration recovered from the DOM mismatch
+let hasMismatch = false;
+function hydrateRoot(vm) {
+    hasMismatch = false;
+    runConnectedCallback(vm);
+    hydrateVM(vm);
+    if (hasMismatch) {
+        logError('Hydration completed with errors.', vm);
+    }
+}
+function hydrateVM(vm) {
+    const children = renderComponent(vm);
+    vm.children = children;
+    const parentNode = vm.renderRoot;
+    hydrateChildren(getFirstChild(parentNode), children, parentNode, vm);
+    runRenderedCallback(vm);
+}
+function hydrateNode(node, vnode) {
+    let hydratedNode;
+    switch (vnode.type) {
+        case 0 /* Text */:
+            hydratedNode = hydrateText(node, vnode);
+            break;
+        case 1 /* Comment */:
+            hydratedNode = hydrateComment(node, vnode);
+            break;
+        case 2 /* Element */:
+            hydratedNode = hydrateElement(node, vnode);
+            break;
+        case 3 /* CustomElement */:
+            hydratedNode = hydrateCustomElement(node, vnode);
+            break;
+    }
+    return nextSibling(hydratedNode);
+}
+function hydrateText(node, vnode) {
+    var _a;
+    if (!hasCorrectNodeType(vnode, node, 3 /* TEXT */)) {
+        return handleMismatch(node, vnode);
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        const nodeValue = getProperty(node, 'nodeValue');
+        if (nodeValue !== vnode.text && !(nodeValue === '\u200D' && vnode.text === '')) {
+            logWarn('Hydration mismatch: text values do not match, will recover from the difference', vnode.owner);
+        }
+    }
+    setText(node, (_a = vnode.text) !== null && _a !== void 0 ? _a : null);
+    vnode.elm = node;
+    return node;
+}
+function hydrateComment(node, vnode) {
+    var _a;
+    if (!hasCorrectNodeType(vnode, node, 8 /* COMMENT */)) {
+        return handleMismatch(node, vnode);
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        const nodeValue = getProperty(node, 'nodeValue');
+        if (nodeValue !== vnode.text) {
+            logWarn('Hydration mismatch: comment values do not match, will recover from the difference', vnode.owner);
+        }
+    }
+    setProperty(node, 'nodeValue', (_a = vnode.text) !== null && _a !== void 0 ? _a : null);
+    vnode.elm = node;
+    return node;
+}
+function hydrateElement(elm, vnode) {
+    if (!hasCorrectNodeType(vnode, elm, 1 /* ELEMENT */) ||
+        !isMatchingElement(vnode, elm)) {
+        return handleMismatch(elm, vnode);
+    }
+    vnode.elm = elm;
+    const { context } = vnode.data;
+    const isDomManual = Boolean(!shared.isUndefined(context) && !shared.isUndefined(context.lwc) && context.lwc.dom === "manual" /* 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.
+        const { props } = vnode.data;
+        if (!shared.isUndefined(props) && !shared.isUndefined(props.innerHTML)) {
+            if (getProperty(elm, 'innerHTML') === props.innerHTML) {
+                // Do a shallow clone since VNodeData may be shared across VNodes due to hoist optimization
+                vnode.data = Object.assign(Object.assign({}, vnode.data), { props: cloneAndOmitKey(props, 'innerHTML') });
+            }
+            else {
+                if (process.env.NODE_ENV !== 'production') {
+                    logWarn(`Mismatch hydrating element <${getProperty(elm, 'tagName').toLowerCase()}>: innerHTML values do not match for element, will recover from the difference`, vnode.owner);
+                }
+            }
+        }
+    }
+    patchElementPropsAndAttrs(vnode);
+    if (!isDomManual) {
+        hydrateChildren(getFirstChild(elm), vnode.children, elm, vnode.owner);
+    }
+    return elm;
+}
+function hydrateCustomElement(elm, vnode) {
+    if (!hasCorrectNodeType(vnode, elm, 1 /* ELEMENT */) ||
+        !isMatchingElement(vnode, elm)) {
+        return handleMismatch(elm, vnode);
+    }
+    const { sel, mode, ctor, owner } = vnode;
+    const vm = createVM(elm, ctor, {
+        mode,
+        owner,
+        tagName: sel,
+    });
+    vnode.elm = elm;
+    vnode.vm = vm;
+    allocateChildren(vnode, vm);
+    patchElementPropsAndAttrs(vnode);
+    // Insert hook section:
+    if (process.env.NODE_ENV !== 'production') {
+        shared.assert.isTrue(vm.state === 0 /* created */, `${vm} cannot be recycled.`);
+    }
+    runConnectedCallback(vm);
+    if (vm.renderMode !== 0 /* Light */) {
+        // 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
+        hydrateChildren(getFirstChild(elm), vnode.children, elm, vm);
+    }
+    hydrateVM(vm);
+    return elm;
+}
+function hydrateChildren(node, children, parentNode, owner) {
+    let hasWarned = false;
+    let nextNode = node;
+    let anchor = null;
+    for (let i = 0; i < children.length; i++) {
+        const childVnode = children[i];
+        if (!shared.isNull(childVnode)) {
+            if (nextNode) {
+                nextNode = hydrateNode(nextNode, childVnode);
+                anchor = childVnode.elm;
+            }
+            else {
+                hasMismatch = true;
+                if (process.env.NODE_ENV !== 'production') {
+                    if (!hasWarned) {
+                        hasWarned = true;
+                        logError(`Hydration mismatch: incorrect number of rendered nodes. Client produced more nodes than the server.`, owner);
+                    }
+                }
+                mount(childVnode, parentNode, anchor);
+                anchor = childVnode.elm;
+            }
+        }
+    }
+    if (nextNode) {
+        hasMismatch = true;
+        if (process.env.NODE_ENV !== 'production') {
+            if (!hasWarned) {
+                logError(`Hydration mismatch: incorrect number of rendered nodes. Server rendered more nodes than the client.`, owner);
+            }
+        }
+        do {
+            const current = nextNode;
+            nextNode = nextSibling(nextNode);
+            removeNode(current, parentNode);
+        } while (nextNode);
+    }
+}
+function handleMismatch(node, vnode, msg) {
+    hasMismatch = true;
+    if (!shared.isUndefined(msg)) {
+        if (process.env.NODE_ENV !== 'production') {
+            logError(msg, vnode.owner);
+        }
+    }
+    const parentNode = getProperty(node, 'parentNode');
+    mount(vnode, parentNode, node);
+    removeNode(node, parentNode);
+    return vnode.elm;
+}
+function patchElementPropsAndAttrs(vnode) {
+    applyEventListeners(vnode);
+    patchProps(null, vnode);
+}
+function hasCorrectNodeType(vnode, node, nodeType) {
+    if (getProperty(node, 'nodeType') !== nodeType) {
+        if (process.env.NODE_ENV !== 'production') {
+            logError('Hydration mismatch: incorrect node type received', vnode.owner);
+        }
+        return false;
+    }
+    return true;
+}
+function isMatchingElement(vnode, elm) {
+    if (vnode.sel.toLowerCase() !== getProperty(elm, 'tagName').toLowerCase()) {
+        if (process.env.NODE_ENV !== 'production') {
+            logError(`Hydration mismatch: expecting element with tag "${vnode.sel.toLowerCase()}" but found "${getProperty(elm, 'tagName').toLowerCase()}".`, vnode.owner);
+        }
+        return false;
+    }
+    const hasIncompatibleAttrs = validateAttrs(vnode, elm);
+    const hasIncompatibleClass = validateClassAttr(vnode, elm);
+    const hasIncompatibleStyle = validateStyleAttr(vnode, elm);
+    return hasIncompatibleAttrs && hasIncompatibleClass && hasIncompatibleStyle;
+}
+function validateAttrs(vnode, elm) {
+    const { data: { attrs = {} }, } = vnode;
+    let nodesAreCompatible = true;
+    // Validate attributes, though we could always recovery from those by running the update mods.
+    // Note: intentionally ONLY matching vnodes.attrs to elm.attrs, in case SSR is adding extra attributes.
+    for (const [attrName, attrValue] of Object.entries(attrs)) {
+        const elmAttrValue = getAttribute(elm, attrName);
+        if (String(attrValue) !== elmAttrValue) {
+            if (process.env.NODE_ENV !== 'production') {
+                logError(`Mismatch hydrating element <${getProperty(elm, 'tagName').toLowerCase()}>: attribute "${attrName}" has different values, expected "${attrValue}" but found "${elmAttrValue}"`, vnode.owner);
+            }
+            nodesAreCompatible = false;
+        }
+    }
+    return nodesAreCompatible;
+}
+function validateClassAttr(vnode, elm) {
+    const { data: { className, classMap }, } = vnode;
+    let nodesAreCompatible = true;
+    let vnodeClassName;
+    if (!shared.isUndefined(className) && String(className) !== getProperty(elm, 'className')) {
+        // className is used when class is bound to an expr.
+        nodesAreCompatible = false;
+        vnodeClassName = className;
+    }
+    else if (!shared.isUndefined(classMap)) {
+        // classMap is used when class is set to static value.
+        const classList = getClassList(elm);
+        let computedClassName = '';
+        // all classes from the vnode should be in the element.classList
+        for (const name in classMap) {
+            computedClassName += ' ' + name;
+            if (!classList.contains(name)) {
+                nodesAreCompatible = false;
+            }
+        }
+        vnodeClassName = computedClassName.trim();
+        if (classList.length > shared.keys(classMap).length) {
+            nodesAreCompatible = false;
+        }
+    }
+    if (!nodesAreCompatible) {
+        if (process.env.NODE_ENV !== 'production') {
+            logError(`Mismatch hydrating element <${getProperty(elm, 'tagName').toLowerCase()}>: attribute "class" has different values, expected "${vnodeClassName}" but found "${getProperty(elm, 'className')}"`, vnode.owner);
+        }
+    }
+    return nodesAreCompatible;
+}
+function validateStyleAttr(vnode, elm) {
+    const { data: { style, styleDecls }, } = vnode;
+    const elmStyle = getAttribute(elm, 'style') || '';
+    let vnodeStyle;
+    let nodesAreCompatible = true;
+    if (!shared.isUndefined(style) && style !== elmStyle) {
+        nodesAreCompatible = false;
+        vnodeStyle = style;
+    }
+    else if (!shared.isUndefined(styleDecls)) {
+        const parsedVnodeStyle = parseStyleText(elmStyle);
+        const expectedStyle = [];
+        // styleMap is used when style is set to static value.
+        for (let i = 0, n = styleDecls.length; i < n; i++) {
+            const [prop, value, important] = styleDecls[i];
+            expectedStyle.push(`${prop}: ${value + (important ? ' important!' : '')}`);
+            const parsedPropValue = parsedVnodeStyle[prop];
+            if (shared.isUndefined(parsedPropValue)) {
+                nodesAreCompatible = false;
+            }
+            else if (!parsedPropValue.startsWith(value)) {
+                nodesAreCompatible = false;
+            }
+            else if (important && !parsedPropValue.endsWith('!important')) {
+                nodesAreCompatible = false;
+            }
+        }
+        if (shared.keys(parsedVnodeStyle).length > styleDecls.length) {
+            nodesAreCompatible = false;
+        }
+        vnodeStyle = shared.ArrayJoin.call(expectedStyle, ';');
+    }
+    if (!nodesAreCompatible) {
+        if (process.env.NODE_ENV !== 'production') {
+            logError(`Mismatch hydrating element <${getProperty(elm, 'tagName').toLowerCase()}>: attribute "style" has different values, expected "${vnodeStyle}" but found "${elmStyle}".`, vnode.owner);
+        }
+    }
+    return nodesAreCompatible;
+}
+
 /*
  * Copyright (c) 2018, salesforce.com, inc.
  * All rights reserved.
@@ -6096,7 +6137,7 @@ exports.getAssociatedVMIfPresent = getAssociatedVMIfPresent;
 exports.getComponentDef = getComponentDef;
 exports.getComponentHtmlPrototype = getComponentHtmlPrototype;
 exports.getUpgradableConstructor = getUpgradableConstructor;
-exports.hydrateRootElement = hydrateRootElement;
+exports.hydrateRoot = hydrateRoot;
 exports.isComponentConstructor = isComponentConstructor;
 exports.readonly = readonly;
 exports.register = register;
@@ -6151,4 +6192,4 @@ exports.swapTemplate = swapTemplate;
 exports.track = track;
 exports.unwrap = unwrap;
 exports.wire = wire;
-/* version: 2.11.1 */
+/* version: 2.11.3-238prod.0 */