@lwc/engine-core 2.26.2 → 2.28.0

package/dist/engine-core.cjs.js

@@ -3229,6 +3229,9 @@ function isSameVnode(vnode1, vnode2) {
 function isVCustomElement(vnode) {
     return vnode.type === 3 /* VNodeType.CustomElement */;
 }
+function isVScopedSlotFragment(vnode) {
+    return vnode.type === 6 /* VNodeType.ScopedSlotFragment */;
+}
 
 /*
  * Copyright (c) 2018, salesforce.com, inc.
@@ -4066,13 +4069,24 @@ function allocateChildren(vnode, vm) {
     shadowMode
   } = vm;
 
+  if (process.env.NODE_ENV !== 'production') {
+    // If any of the children being allocated is a scoped slot fragment, make sure the receiving
+    // component is a light DOM component. This is mainly to validate light dom parent running
+    // in native shadow mode.
+    if (renderMode !== 0
+    /* RenderMode.Light */
+    && shared.ArraySome.call(children, child => !shared.isNull(child) && isVScopedSlotFragment(child))) {
+      logError(`Invalid usage of 'lwc:slot-data' on ${getComponentTag(vm)} tag. Scoped slot content can only be passed to a light dom child.`);
+    }
+  }
+
   if (shadowMode === 1
   /* ShadowMode.Synthetic */
   || renderMode === 0
   /* RenderMode.Light */
   ) {
     // slow path
-    allocateInSlot(vm, children); // save the allocated children in case this vnode is reused.
+    allocateInSlot(vm, children, vnode.owner); // save the allocated children in case this vnode is reused.
 
     vnode.aChildren = children; // every child vnode is now allocated, and the host should receive none directly, it receives them via the shadow!
 
@@ -4108,13 +4122,19 @@ function createViewModelHook(elm, vnode, renderer) {
   return vm;
 }
 
-function allocateInSlot(vm, children) {
-  var _a;
+function allocateInSlot(vm, children, owner) {
+  var _a, _b;
 
   const {
-    cmpSlots: oldSlots
+    cmpSlots: {
+      slotAssignments: oldSlotsMapping
+    }
   } = vm;
-  const cmpSlots = vm.cmpSlots = shared.create(null);
+  const cmpSlotsMapping = shared.create(null);
+  vm.cmpSlots = {
+    owner,
+    slotAssignments: cmpSlotsMapping
+  };
 
   for (let i = 0, len = children.length; i < len; i += 1) {
     const vnode = children[i];
@@ -4126,19 +4146,21 @@ function allocateInSlot(vm, children) {
     let slotName = '';
 
     if (isVBaseElement(vnode)) {
-      slotName = ((_a = vnode.data.attrs) === null || _a === void 0 ? void 0 : _a.slot) || '';
+      slotName = (_b = (_a = vnode.data.attrs) === null || _a === void 0 ? void 0 : _a.slot) !== null && _b !== void 0 ? _b : '';
+    } else if (isVScopedSlotFragment(vnode)) {
+      slotName = vnode.slotName;
     }
 
-    const vnodes = cmpSlots[slotName] = cmpSlots[slotName] || [];
+    const vnodes = cmpSlotsMapping[slotName] = cmpSlotsMapping[slotName] || [];
     shared.ArrayPush.call(vnodes, vnode);
   }
 
   if (shared.isFalse(vm.isDirty)) {
     // We need to determine if the old allocation is really different from the new one
     // and mark the vm as dirty
-    const oldKeys = shared.keys(oldSlots);
+    const oldKeys = shared.keys(oldSlotsMapping);
 
-    if (oldKeys.length !== shared.keys(cmpSlots).length) {
+    if (oldKeys.length !== shared.keys(cmpSlotsMapping).length) {
       markComponentAsDirty(vm);
       return;
     }
@@ -4146,15 +4168,15 @@ function allocateInSlot(vm, children) {
     for (let i = 0, len = oldKeys.length; i < len; i += 1) {
       const key = oldKeys[i];
 
-      if (shared.isUndefined(cmpSlots[key]) || oldSlots[key].length !== cmpSlots[key].length) {
+      if (shared.isUndefined(cmpSlotsMapping[key]) || oldSlotsMapping[key].length !== cmpSlotsMapping[key].length) {
         markComponentAsDirty(vm);
         return;
       }
 
-      const oldVNodes = oldSlots[key];
-      const vnodes = cmpSlots[key];
+      const oldVNodes = oldSlotsMapping[key];
+      const vnodes = cmpSlotsMapping[key];
 
-      for (let j = 0, a = cmpSlots[key].length; j < a; j += 1) {
+      for (let j = 0, a = cmpSlotsMapping[key].length; j < a; j += 1) {
         if (oldVNodes[j] !== vnodes[j]) {
           markComponentAsDirty(vm);
           return;
@@ -4354,6 +4376,18 @@ const SymbolIterator = Symbol.iterator;
 function addVNodeToChildLWC(vnode) {
     shared.ArrayPush.call(getVMBeingRendered().velements, vnode);
 }
+// [s]coped [s]lot [f]actory
+function ssf(slotName, factory) {
+    return {
+        type: 6 /* VNodeType.ScopedSlotFragment */,
+        factory,
+        owner: getVMBeingRendered(),
+        elm: undefined,
+        sel: undefined,
+        key: undefined,
+        slotName,
+    };
+}
 // [st]atic node
 function st(fragment, key) {
     return {
@@ -4437,9 +4471,46 @@ function s(slotName, data, children, slotset) {
         shared.assert.isTrue(shared.isArray(children), `h() 3rd argument children must be an array.`);
     }
     if (!shared.isUndefined(slotset) &&
-        !shared.isUndefined(slotset[slotName]) &&
-        slotset[slotName].length !== 0) {
-        children = slotset[slotName];
+        !shared.isUndefined(slotset.slotAssignments) &&
+        !shared.isUndefined(slotset.slotAssignments[slotName]) &&
+        slotset.slotAssignments[slotName].length !== 0) {
+        children = slotset.slotAssignments[slotName].reduce((accumulator, vnode) => {
+            if (vnode) {
+                const assignedNodeIsScopedSlot = isVScopedSlotFragment(vnode);
+                // The only sniff test for a scoped <slot> element is the presence of `slotData`
+                const isScopedSlotElement = !shared.isUndefined(data.slotData);
+                // Check if slot types of parent and child are matching
+                if (assignedNodeIsScopedSlot !== isScopedSlotElement) {
+                    if (process.env.NODE_ENV !== 'production') {
+                        logError(`Mismatched slot types for ${slotName === '' ? '(default)' : slotName} slot. Both parent and child component must use standard type or scoped type for a given slot.`, slotset.owner);
+                    }
+                    // Ignore slot content from parent
+                    return accumulator;
+                }
+                // If the passed slot content is factory, evaluate it and add the produced vnodes
+                if (assignedNodeIsScopedSlot) {
+                    const vmBeingRenderedInception = getVMBeingRendered();
+                    let scopedSlotChildren = [];
+                    // Evaluate in the scope of the slot content's owner
+                    // if a slotset is provided, there will always be an owner. The only case where owner is
+                    // undefined is for root components, but root components cannot accept slotted content
+                    setVMBeingRendered(slotset.owner);
+                    try {
+                        scopedSlotChildren = vnode.factory(data.slotData);
+                    }
+                    finally {
+                        setVMBeingRendered(vmBeingRenderedInception);
+                    }
+                    return shared.ArrayConcat.call(accumulator, scopedSlotChildren);
+                }
+                else {
+                    // If the slot content is standard type, the content is static, no additional
+                    // processing needed on the vnode
+                    return shared.ArrayConcat.call(accumulator, vnode);
+                }
+            }
+            return accumulator;
+        }, []);
     }
     const vmBeingRendered = getVMBeingRendered();
     const { renderMode, shadowMode } = vmBeingRendered;
@@ -4759,6 +4830,7 @@ const api = shared.freeze({
     gid,
     fid,
     shc,
+    ssf,
 });
 
 /*
@@ -4895,9 +4967,9 @@ function validateSlots(vm, html) {
     }
     const { cmpSlots } = vm;
     const { slots = EmptyArray } = html;
-    for (const slotName in cmpSlots) {
+    for (const slotName in cmpSlots.slotAssignments) {
         // eslint-disable-next-line @lwc/lwc-internal/no-production-assert
-        shared.assert.isTrue(shared.isArray(cmpSlots[slotName]), `Slots can only be set to an array, instead received ${shared.toString(cmpSlots[slotName])} for slot "${slotName}" in ${vm}.`);
+        shared.assert.isTrue(shared.isArray(cmpSlots.slotAssignments[slotName]), `Slots can only be set to an array, instead received ${shared.toString(cmpSlots.slotAssignments[slotName])} for slot "${slotName}" in ${vm}.`);
         if (slotName !== '' && shared.ArrayIndexOf.call(slots, slotName) === -1) {
             // TODO [#1297]: this should never really happen because the compiler should always validate
             // eslint-disable-next-line @lwc/lwc-internal/no-production-assert
@@ -5394,7 +5466,9 @@ function createVM(elm, ctor, renderer, options) {
     velements: EmptyArray,
     cmpProps: shared.create(null),
     cmpFields: shared.create(null),
-    cmpSlots: shared.create(null),
+    cmpSlots: {
+      slotAssignments: shared.create(null)
+    },
     oar: shared.create(null),
     cmpTemplate: null,
     hydrated: Boolean(hydrated),
@@ -6845,4 +6919,4 @@ exports.swapTemplate = swapTemplate;
 exports.track = track;
 exports.unwrap = unwrap;
 exports.wire = wire;
-/* version: 2.26.2 */
+/* version: 2.28.0 */

package/dist/engine-core.js

@@ -1,7 +1,7 @@
 /* proxy-compat-disable */
 import { lwcRuntimeFlags } from '@lwc/features';
 export { setFeatureFlag, setFeatureFlagForTest } from '@lwc/features';
-import { seal, create, isUndefined as isUndefined$1, isFunction as isFunction$1, ArrayPush as ArrayPush$1, ArrayIndexOf, ArraySplice, StringToLowerCase, isNull, ArrayJoin, isFrozen, defineProperty, hasOwnProperty as hasOwnProperty$1, assign, forEach, keys, AriaPropNameToAttrNameMap, getPropertyDescriptor, defineProperties, getOwnPropertyNames as getOwnPropertyNames$1, getPrototypeOf as getPrototypeOf$1, setPrototypeOf, isObject, freeze, assert, KEY__SYNTHETIC_MODE, isFalse, isTrue, toString as toString$1, getOwnPropertyDescriptor as getOwnPropertyDescriptor$1, LWC_VERSION_COMMENT_REGEX, LWC_VERSION, htmlPropertyToAttribute, ArraySlice, ArrayMap, isArray as isArray$1, KEY__SCOPED_CSS, StringCharCodeAt, XML_NAMESPACE, XLINK_NAMESPACE, isString, StringSlice, SVG_NAMESPACE, KEY__SHADOW_STATIC, KEY__SHADOW_RESOLVER, isNumber, StringReplace, noop, ArrayUnshift, ArrayFilter, ArrayCopyWithin, ArrayFill, ArraySort, ArrayReverse, ArrayShift, ArrayPop } from '@lwc/shared';
+import { seal, create, isUndefined as isUndefined$1, isFunction as isFunction$1, ArrayPush as ArrayPush$1, ArrayIndexOf, ArraySplice, StringToLowerCase, isNull, ArrayJoin, isFrozen, defineProperty, hasOwnProperty as hasOwnProperty$1, assign, forEach, keys, AriaPropNameToAttrNameMap, getPropertyDescriptor, defineProperties, getOwnPropertyNames as getOwnPropertyNames$1, getPrototypeOf as getPrototypeOf$1, setPrototypeOf, isObject, freeze, assert, KEY__SYNTHETIC_MODE, isFalse, isTrue, toString as toString$1, getOwnPropertyDescriptor as getOwnPropertyDescriptor$1, LWC_VERSION_COMMENT_REGEX, LWC_VERSION, htmlPropertyToAttribute, ArraySlice, ArrayMap, isArray as isArray$1, KEY__SCOPED_CSS, StringCharCodeAt, XML_NAMESPACE, XLINK_NAMESPACE, isString, StringSlice, SVG_NAMESPACE, KEY__SHADOW_STATIC, KEY__SHADOW_RESOLVER, ArraySome, ArrayConcat as ArrayConcat$1, isNumber, StringReplace, noop, ArrayUnshift, ArrayFilter, ArrayCopyWithin, ArrayFill, ArraySort, ArrayReverse, ArrayShift, ArrayPop } from '@lwc/shared';
 
 /*
  * Copyright (c) 2018, salesforce.com, inc.
@@ -3226,6 +3226,9 @@ function isSameVnode(vnode1, vnode2) {
 function isVCustomElement(vnode) {
     return vnode.type === 3 /* VNodeType.CustomElement */;
 }
+function isVScopedSlotFragment(vnode) {
+    return vnode.type === 6 /* VNodeType.ScopedSlotFragment */;
+}
 
 /*
  * Copyright (c) 2018, salesforce.com, inc.
@@ -4063,13 +4066,24 @@ function allocateChildren(vnode, vm) {
     shadowMode
   } = vm;
 
+  if (process.env.NODE_ENV !== 'production') {
+    // If any of the children being allocated is a scoped slot fragment, make sure the receiving
+    // component is a light DOM component. This is mainly to validate light dom parent running
+    // in native shadow mode.
+    if (renderMode !== 0
+    /* RenderMode.Light */
+    && ArraySome.call(children, child => !isNull(child) && isVScopedSlotFragment(child))) {
+      logError(`Invalid usage of 'lwc:slot-data' on ${getComponentTag(vm)} tag. Scoped slot content can only be passed to a light dom child.`);
+    }
+  }
+
   if (shadowMode === 1
   /* ShadowMode.Synthetic */
   || renderMode === 0
   /* RenderMode.Light */
   ) {
     // slow path
-    allocateInSlot(vm, children); // save the allocated children in case this vnode is reused.
+    allocateInSlot(vm, children, vnode.owner); // save the allocated children in case this vnode is reused.
 
     vnode.aChildren = children; // every child vnode is now allocated, and the host should receive none directly, it receives them via the shadow!
 
@@ -4105,13 +4119,19 @@ function createViewModelHook(elm, vnode, renderer) {
   return vm;
 }
 
-function allocateInSlot(vm, children) {
-  var _a;
+function allocateInSlot(vm, children, owner) {
+  var _a, _b;
 
   const {
-    cmpSlots: oldSlots
+    cmpSlots: {
+      slotAssignments: oldSlotsMapping
+    }
   } = vm;
-  const cmpSlots = vm.cmpSlots = create(null);
+  const cmpSlotsMapping = create(null);
+  vm.cmpSlots = {
+    owner,
+    slotAssignments: cmpSlotsMapping
+  };
 
   for (let i = 0, len = children.length; i < len; i += 1) {
     const vnode = children[i];
@@ -4123,19 +4143,21 @@ function allocateInSlot(vm, children) {
     let slotName = '';
 
     if (isVBaseElement(vnode)) {
-      slotName = ((_a = vnode.data.attrs) === null || _a === void 0 ? void 0 : _a.slot) || '';
+      slotName = (_b = (_a = vnode.data.attrs) === null || _a === void 0 ? void 0 : _a.slot) !== null && _b !== void 0 ? _b : '';
+    } else if (isVScopedSlotFragment(vnode)) {
+      slotName = vnode.slotName;
     }
 
-    const vnodes = cmpSlots[slotName] = cmpSlots[slotName] || [];
+    const vnodes = cmpSlotsMapping[slotName] = cmpSlotsMapping[slotName] || [];
     ArrayPush$1.call(vnodes, vnode);
   }
 
   if (isFalse(vm.isDirty)) {
     // We need to determine if the old allocation is really different from the new one
     // and mark the vm as dirty
-    const oldKeys = keys(oldSlots);
+    const oldKeys = keys(oldSlotsMapping);
 
-    if (oldKeys.length !== keys(cmpSlots).length) {
+    if (oldKeys.length !== keys(cmpSlotsMapping).length) {
       markComponentAsDirty(vm);
       return;
     }
@@ -4143,15 +4165,15 @@ function allocateInSlot(vm, children) {
     for (let i = 0, len = oldKeys.length; i < len; i += 1) {
       const key = oldKeys[i];
 
-      if (isUndefined$1(cmpSlots[key]) || oldSlots[key].length !== cmpSlots[key].length) {
+      if (isUndefined$1(cmpSlotsMapping[key]) || oldSlotsMapping[key].length !== cmpSlotsMapping[key].length) {
         markComponentAsDirty(vm);
         return;
       }
 
-      const oldVNodes = oldSlots[key];
-      const vnodes = cmpSlots[key];
+      const oldVNodes = oldSlotsMapping[key];
+      const vnodes = cmpSlotsMapping[key];
 
-      for (let j = 0, a = cmpSlots[key].length; j < a; j += 1) {
+      for (let j = 0, a = cmpSlotsMapping[key].length; j < a; j += 1) {
         if (oldVNodes[j] !== vnodes[j]) {
           markComponentAsDirty(vm);
           return;
@@ -4351,6 +4373,18 @@ const SymbolIterator = Symbol.iterator;
 function addVNodeToChildLWC(vnode) {
     ArrayPush$1.call(getVMBeingRendered().velements, vnode);
 }
+// [s]coped [s]lot [f]actory
+function ssf(slotName, factory) {
+    return {
+        type: 6 /* VNodeType.ScopedSlotFragment */,
+        factory,
+        owner: getVMBeingRendered(),
+        elm: undefined,
+        sel: undefined,
+        key: undefined,
+        slotName,
+    };
+}
 // [st]atic node
 function st(fragment, key) {
     return {
@@ -4434,9 +4468,46 @@ function s(slotName, data, children, slotset) {
         assert.isTrue(isArray$1(children), `h() 3rd argument children must be an array.`);
     }
     if (!isUndefined$1(slotset) &&
-        !isUndefined$1(slotset[slotName]) &&
-        slotset[slotName].length !== 0) {
-        children = slotset[slotName];
+        !isUndefined$1(slotset.slotAssignments) &&
+        !isUndefined$1(slotset.slotAssignments[slotName]) &&
+        slotset.slotAssignments[slotName].length !== 0) {
+        children = slotset.slotAssignments[slotName].reduce((accumulator, vnode) => {
+            if (vnode) {
+                const assignedNodeIsScopedSlot = isVScopedSlotFragment(vnode);
+                // The only sniff test for a scoped <slot> element is the presence of `slotData`
+                const isScopedSlotElement = !isUndefined$1(data.slotData);
+                // Check if slot types of parent and child are matching
+                if (assignedNodeIsScopedSlot !== isScopedSlotElement) {
+                    if (process.env.NODE_ENV !== 'production') {
+                        logError(`Mismatched slot types for ${slotName === '' ? '(default)' : slotName} slot. Both parent and child component must use standard type or scoped type for a given slot.`, slotset.owner);
+                    }
+                    // Ignore slot content from parent
+                    return accumulator;
+                }
+                // If the passed slot content is factory, evaluate it and add the produced vnodes
+                if (assignedNodeIsScopedSlot) {
+                    const vmBeingRenderedInception = getVMBeingRendered();
+                    let scopedSlotChildren = [];
+                    // Evaluate in the scope of the slot content's owner
+                    // if a slotset is provided, there will always be an owner. The only case where owner is
+                    // undefined is for root components, but root components cannot accept slotted content
+                    setVMBeingRendered(slotset.owner);
+                    try {
+                        scopedSlotChildren = vnode.factory(data.slotData);
+                    }
+                    finally {
+                        setVMBeingRendered(vmBeingRenderedInception);
+                    }
+                    return ArrayConcat$1.call(accumulator, scopedSlotChildren);
+                }
+                else {
+                    // If the slot content is standard type, the content is static, no additional
+                    // processing needed on the vnode
+                    return ArrayConcat$1.call(accumulator, vnode);
+                }
+            }
+            return accumulator;
+        }, []);
     }
     const vmBeingRendered = getVMBeingRendered();
     const { renderMode, shadowMode } = vmBeingRendered;
@@ -4756,6 +4827,7 @@ const api = freeze({
     gid,
     fid,
     shc,
+    ssf,
 });
 
 /*
@@ -4892,9 +4964,9 @@ function validateSlots(vm, html) {
     }
     const { cmpSlots } = vm;
     const { slots = EmptyArray } = html;
-    for (const slotName in cmpSlots) {
+    for (const slotName in cmpSlots.slotAssignments) {
         // 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}.`);
+        assert.isTrue(isArray$1(cmpSlots.slotAssignments[slotName]), `Slots can only be set to an array, instead received ${toString$1(cmpSlots.slotAssignments[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/lwc-internal/no-production-assert
@@ -5391,7 +5463,9 @@ function createVM(elm, ctor, renderer, options) {
     velements: EmptyArray,
     cmpProps: create(null),
     cmpFields: create(null),
-    cmpSlots: create(null),
+    cmpSlots: {
+      slotAssignments: create(null)
+    },
     oar: create(null),
     cmpTemplate: null,
     hydrated: Boolean(hydrated),
@@ -6806,4 +6880,4 @@ function getComponentConstructor(elm) {
 }
 
 export { LightningElement, profilerControl as __unstable__ProfilerControl, api$1 as api, connectRootElement, createContextProvider, createVM, disconnectRootElement, freezeTemplate, getAssociatedVMIfPresent, getComponentConstructor, getComponentDef, getComponentHtmlPrototype, hydrateRoot, isComponentConstructor, parseFragment, parseSVGFragment, readonly, register, registerComponent, registerDecorators, registerTemplate, sanitizeAttribute, setHooks, swapComponent, swapStyle, swapTemplate, track, unwrap, wire };
-/* version: 2.26.2 */
+/* version: 2.28.0 */

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@lwc/engine-core",
-    "version": "2.26.2",
+    "version": "2.28.0",
     "description": "Core LWC engine APIs.",
     "homepage": "https://lwc.dev/",
     "repository": {
@@ -24,8 +24,8 @@
         "types/"
     ],
     "dependencies": {
-        "@lwc/features": "2.26.2",
-        "@lwc/shared": "2.26.2"
+        "@lwc/features": "2.28.0",
+        "@lwc/shared": "2.28.0"
     },
     "devDependencies": {
         "observable-membrane": "2.0.0"
@@ -43,4 +43,4 @@
             }
         }
     }
-}
+}

package/types/framework/api.d.ts

@@ -1,6 +1,7 @@
 import { SlotSet } from './vm';
 import { LightningElementConstructor } from './base-lightning-element';
-import { VNode, VNodes, VElement, VText, VCustomElement, VComment, VElementData, VStatic, Key, VFragment } from './vnodes';
+import { VNode, VNodes, VElement, VText, VCustomElement, VComment, VElementData, VStatic, Key, VFragment, VScopedSlotFragment } from './vnodes';
+declare function ssf(slotName: string, factory: (value: any) => VNodes): VScopedSlotFragment;
 declare function st(fragment: Element, key: Key): VStatic;
 declare function fr(key: Key, children: VNodes, stable: 0 | 1): VFragment;
 declare function h(sel: string, data: VElementData, children?: VNodes): VElement;
@@ -47,6 +48,7 @@ declare const api: Readonly<{
     gid: typeof gid;
     fid: typeof fid;
     shc: typeof shc;
+    ssf: typeof ssf;
 }>;
 export default api;
 export declare type RenderAPI = typeof api;

package/types/framework/vm.d.ts

@@ -10,7 +10,10 @@ export interface TemplateCache {
     [key: string]: any;
 }
 export interface SlotSet {
-    [key: string]: VNodes;
+    slotAssignments: {
+        [key: string]: VNodes;
+    };
+    owner?: VM;
 }
 export declare const enum VMState {
     created = 0,
@@ -91,7 +94,8 @@ export interface VM<N = HostNode, E = HostElement> {
     cmpProps: {
         [name: string]: any;
     };
-    /** The mapping between the slot names and the slotted VNodes. */
+    /** Contains information about the mapping between the slot names and the slotted VNodes, and
+     *  the owner of the slot content. */
     cmpSlots: SlotSet;
     /** The component internal reactive properties. */
     cmpFields: {

package/types/framework/vnodes.d.ts

@@ -7,9 +7,10 @@ export declare const enum VNodeType {
     Element = 2,
     CustomElement = 3,
     Static = 4,
-    Fragment = 5
+    Fragment = 5,
+    ScopedSlotFragment = 6
 }
-export declare type VNode = VText | VComment | VElement | VCustomElement | VStatic | VFragment;
+export declare type VNode = VText | VComment | VElement | VCustomElement | VStatic | VFragment | VScopedSlotFragment;
 export declare type VParentElement = VElement | VCustomElement | VFragment;
 export declare type VNodes = Readonly<Array<VNode | null>>;
 export interface BaseVParent {
@@ -22,6 +23,11 @@ export interface BaseVNode {
     key: Key | undefined;
     owner: VM;
 }
+export interface VScopedSlotFragment extends BaseVNode {
+    factory: (value: any) => VNodes;
+    type: VNodeType.ScopedSlotFragment;
+    slotName: string;
+}
 export interface VStatic extends BaseVNode {
     type: VNodeType.Static;
     sel: undefined;
@@ -77,7 +83,9 @@ export interface VNodeData {
 export interface VElementData extends VNodeData {
     readonly key: Key;
     readonly ref?: string;
+    readonly slotData?: any;
 }
 export declare function isVBaseElement(vnode: VNode): vnode is VElement | VCustomElement;
 export declare function isSameVnode(vnode1: VNode, vnode2: VNode): boolean;
 export declare function isVCustomElement(vnode: VBaseElement): vnode is VCustomElement;
+export declare function isVScopedSlotFragment(vnode: VNode): vnode is VScopedSlotFragment;

package/types/3rdparty/snabbdom/snabbdom.d.ts

@@ -1,11 +0,0 @@
-/**
-@license
-Copyright (c) 2015 Simon Friis Vindum.
-This code may only be used under the MIT License found at
-https://github.com/snabbdom/snabbdom/blob/master/LICENSE
-Code distributed by Snabbdom as part of the Snabbdom project at
-https://github.com/snabbdom/snabbdom/
-*/
-import { VNodes } from './types';
-export declare function updateDynamicChildren(parentElm: Node, oldCh: VNodes, newCh: VNodes): void;
-export declare function updateStaticChildren(parentElm: Node, oldCh: VNodes, newCh: VNodes): void;

package/types/3rdparty/snabbdom/types.d.ts

@@ -1,70 +0,0 @@
-/**
- @license
- Copyright (c) 2015 Simon Friis Vindum.
- This code may only be used under the MIT License found at
- https://github.com/snabbdom/snabbdom/blob/master/LICENSE
- Code distributed by Snabbdom as part of the Snabbdom project at
- https://github.com/snabbdom/snabbdom/
- */
-import { VM } from '../../framework/vm';
-export declare type Key = string | number;
-export declare type VNodes = Array<VNode | null>;
-export interface VNode {
-    sel: string | undefined;
-    data: VNodeData;
-    children: VNodes | undefined;
-    elm: Node | undefined;
-    parentElm?: Element;
-    text: string | undefined;
-    key: Key | undefined;
-    hook: Hooks<any>;
-    owner: VM;
-}
-export interface VElement extends VNode {
-    sel: string;
-    data: VElementData;
-    children: VNodes;
-    elm: Element | undefined;
-    text: undefined;
-    key: Key;
-}
-export interface VCustomElement extends VElement {
-    mode: 'closed' | 'open';
-    ctor: any;
-    aChildren?: VNodes;
-}
-export interface VText extends VNode {
-    sel: undefined;
-    children: undefined;
-    elm: Node | undefined;
-    text: string;
-    key: undefined;
-}
-export interface VComment extends VNode {
-    sel: undefined;
-    children: undefined;
-    text: string;
-    key: undefined;
-}
-export interface VNodeData {
-    props?: Record<string, any>;
-    attrs?: Record<string, string | number | boolean>;
-    className?: string;
-    style?: string;
-    classMap?: Record<string, boolean>;
-    styleDecls?: Array<[string, string, boolean]>;
-    context?: Record<string, Record<string, any>>;
-    on?: Record<string, Function>;
-    svg?: boolean;
-}
-export interface VElementData extends VNodeData {
-    key: Key;
-}
-export interface Hooks<N extends VNode> {
-    create: (vNode: N) => void;
-    insert: (vNode: N, parentNode: Node, referenceNode: Node | null) => void;
-    move: (vNode: N, parentNode: Node, referenceNode: Node | null) => void;
-    update: (oldVNode: N, vNode: N) => void;
-    remove: (vNode: N, parentNode: Node) => void;
-    hydrate: (vNode: N, node: Node) => void;
-}

package/types/framework/api-helpers.d.ts

@@ -1,15 +0,0 @@
-/**
- * EXPERIMENTAL: This function acts like a hook for Lightning Locker Service and other similar
- * libraries to sanitize HTML content. This hook process the content passed via the template to
- * lwc:inner-html directive.
- * It is meant to be overridden with setSanitizeHtmlContentHook
- */
-export declare let sanitizeHtmlContentHook: SanitizeHtmlContentHook;
-export declare type SanitizeHtmlContentHook = (content: unknown) => string;
-/**
- * Sets the sanitizeHtmlContentHook.
- *
- * @param newHookImpl
- * @returns oldHookImplementation.
- */
-export declare function setSanitizeHtmlContentHook(newHookImpl: SanitizeHtmlContentHook): SanitizeHtmlContentHook;

package/types/framework/hooks.d.ts

@@ -1,9 +0,0 @@
-import { VM } from './vm';
-import { VNodes, VCustomElement, VElement, VText, VComment, Hooks } from './vnodes';
-export declare const TextHook: Hooks<VText>;
-export declare const CommentHook: Hooks<VComment>;
-export declare const ElementHook: Hooks<VElement>;
-export declare const CustomElementHook: Hooks<VCustomElement>;
-export declare function patchChildren(parent: ParentNode, oldCh: VNodes, newCh: VNodes): void;
-export declare function hydrateChildrenHook(elmChildren: NodeListOf<ChildNode>, children: VNodes, vm?: VM): void;
-export declare function markAsDynamicChildren(children: VNodes): void;

package/types/framework/modules/scope-token-class.d.ts

@@ -1,2 +0,0 @@
-import { VM } from '../vm';
-export declare function getScopeTokenClass(owner: VM): string | null;

package/types/framework/performance-timing.d.ts

@@ -1,10 +0,0 @@
-import { VM } from './vm';
-export declare type MeasurementPhase = 'constructor' | 'render' | 'patch' | 'connectedCallback' | 'disconnectedCallback' | 'renderedCallback' | 'errorCallback';
-export declare enum GlobalMeasurementPhase {
-    REHYDRATE = "lwc-rehydrate",
-    HYDRATE = "lwc-hydrate"
-}
-export declare const startMeasure: (phase: MeasurementPhase, vm: VM) => void;
-export declare const endMeasure: (phase: MeasurementPhase, vm: VM) => void;
-export declare const startGlobalMeasure: (phase: GlobalMeasurementPhase, vm?: VM<any, any> | undefined) => void;
-export declare const endGlobalMeasure: (phase: GlobalMeasurementPhase, vm?: VM<any, any> | undefined) => void;

package/types/framework/upgradable-element.d.ts

@@ -1,7 +0,0 @@
-import type { RendererAPI } from './renderer';
-declare type UpgradeCallback = (elm: HTMLElement) => void;
-interface UpgradableCustomElementConstructor extends CustomElementConstructor {
-    new (upgradeCallback?: UpgradeCallback): HTMLElement;
-}
-export declare function getUpgradableConstructor(tagName: string, renderer: RendererAPI): CustomElementConstructor | UpgradableCustomElementConstructor;
-export {};

package/types/renderer.d.ts

@@ -1,119 +0,0 @@
-export declare type HostNode = any;
-export declare type HostElement = any;
-declare type N = HostNode;
-declare type E = HostElement;
-export declare let ssr: boolean;
-export declare function setSsr(ssrImpl: boolean): void;
-export declare let isNativeShadowDefined: boolean;
-export declare function setIsNativeShadowDefined(isNativeShadowDefinedImpl: boolean): void;
-export declare let isSyntheticShadowDefined: boolean;
-export declare function setIsSyntheticShadowDefined(isSyntheticShadowDefinedImpl: boolean): void;
-declare type HTMLElementType = typeof HTMLElement;
-declare let HTMLElementExported: HTMLElementType;
-export { HTMLElementExported as HTMLElement };
-export declare function setHTMLElement(HTMLElementImpl: HTMLElementType): void;
-declare type isHydratingFunc = () => boolean;
-export declare let isHydrating: isHydratingFunc;
-export declare function setIsHydrating(isHydratingImpl: isHydratingFunc): void;
-declare type insertFunc = (node: N, parent: E, anchor: N | null) => void;
-export declare let insert: insertFunc;
-export declare function setInsert(insertImpl: insertFunc): void;
-declare type removeFunc = (node: N, parent: E) => void;
-export declare let remove: removeFunc;
-export declare function setRemove(removeImpl: removeFunc): void;
-declare type createElementFunc = (tagName: string, namespace?: string) => E;
-export declare let createElement: createElementFunc;
-export declare function setCreateElement(createElementImpl: createElementFunc): void;
-declare type createTextFunc = (content: string) => N;
-export declare let createText: createTextFunc;
-export declare function setCreateText(createTextImpl: createTextFunc): void;
-declare type createCommentFunc = (content: string) => N;
-export declare let createComment: createCommentFunc;
-export declare function setCreateComment(createCommentImpl: createCommentFunc): void;
-declare type nextSiblingFunc = (node: N) => N | null;
-export declare let nextSibling: nextSiblingFunc;
-export declare function setNextSibling(nextSiblingImpl: nextSiblingFunc): void;
-declare type attachShadowFunc = (element: E, options: ShadowRootInit) => N;
-export declare let attachShadow: attachShadowFunc;
-export declare function setAttachShadow(attachShadowImpl: attachShadowFunc): void;
-declare type getPropertyFunc = (node: N, key: string) => any;
-export declare let getProperty: getPropertyFunc;
-export declare function setGetProperty(getPropertyImpl: getPropertyFunc): void;
-declare type setPropertyFunc = (node: N, key: string, value: any) => void;
-export declare let setProperty: setPropertyFunc;
-export declare function setSetProperty(setPropertyImpl: setPropertyFunc): void;
-declare type setTextFunc = (node: N, content: string) => void;
-export declare let setText: setTextFunc;
-export declare function setSetText(setTextImpl: setTextFunc): void;
-declare type getAttributeFunc = (element: E, name: string, namespace?: string | null) => string | null;
-export declare let getAttribute: getAttributeFunc;
-export declare function setGetAttribute(getAttributeImpl: getAttributeFunc): void;
-declare type setAttributeFunc = (element: E, name: string, value: string, namespace?: string | null) => void;
-export declare let setAttribute: setAttributeFunc;
-export declare function setSetAttribute(setAttributeImpl: setAttributeFunc): void;
-declare type removeAttributeFunc = (element: E, name: string, namespace?: string | null) => void;
-export declare let removeAttribute: removeAttributeFunc;
-export declare function setRemoveAttribute(removeAttributeImpl: removeAttributeFunc): void;
-declare type addEventListenerFunc = (target: N, type: string, callback: (event: Event) => any, options?: AddEventListenerOptions | boolean) => void;
-export declare let addEventListener: addEventListenerFunc;
-export declare function setAddEventListener(addEventListenerImpl: addEventListenerFunc): void;
-declare type removeEventListenerFunc = (target: N, type: string, callback: (event: Event) => any, options?: EventListenerOptions | boolean) => void;
-export declare let removeEventListener: removeEventListenerFunc;
-export declare function setRemoveEventListener(removeEventListenerImpl: removeEventListenerFunc): void;
-declare type dispatchEventFunc = (target: N, event: Event) => boolean;
-export declare let dispatchEvent: dispatchEventFunc;
-export declare function setDispatchEvent(dispatchEventImpl: dispatchEventFunc): void;
-declare type getClassListFunc = (element: E) => DOMTokenList;
-export declare let getClassList: getClassListFunc;
-export declare function setGetClassList(getClassListImpl: getClassListFunc): void;
-declare type setCSSStylePropertyFunc = (element: E, name: string, value: string, important: boolean) => void;
-export declare let setCSSStyleProperty: setCSSStylePropertyFunc;
-export declare function setSetCSSStyleProperty(setCSSStylePropertyImpl: setCSSStylePropertyFunc): void;
-declare type getBoundingClientRectFunc = (element: E) => ClientRect;
-export declare let getBoundingClientRect: getBoundingClientRectFunc;
-export declare function setGetBoundingClientRect(getBoundingClientRectImpl: getBoundingClientRectFunc): void;
-declare type querySelectorFunc = (element: E, selectors: string) => E | null;
-export declare let querySelector: querySelectorFunc;
-export declare function setQuerySelector(querySelectorImpl: querySelectorFunc): void;
-declare type querySelectorAllFunc = (element: E, selectors: string) => NodeList;
-export declare let querySelectorAll: querySelectorAllFunc;
-export declare function setQuerySelectorAll(querySelectorAllImpl: querySelectorAllFunc): void;
-declare type getElementsByTagNameFunc = (element: E, tagNameOrWildCard: string) => HTMLCollection;
-export declare let getElementsByTagName: getElementsByTagNameFunc;
-export declare function setGetElementsByTagName(getElementsByTagNameImpl: getElementsByTagNameFunc): void;
-declare type getElementsByClassNameFunc = (element: E, names: string) => HTMLCollection;
-export declare let getElementsByClassName: getElementsByClassNameFunc;
-export declare function setGetElementsByClassName(getElementsByClassNameImpl: getElementsByClassNameFunc): void;
-declare type getChildrenFunc = (element: E) => HTMLCollection;
-export declare let getChildren: getChildrenFunc;
-export declare function setGetChildren(getChildrenImpl: getChildrenFunc): void;
-declare type getChildNodesFunc = (element: E) => NodeList;
-export declare let getChildNodes: getChildNodesFunc;
-export declare function setGetChildNodes(getChildNodesImpl: getChildNodesFunc): void;
-declare type getFirstChildFunc = (element: E) => N | null;
-export declare let getFirstChild: getFirstChildFunc;
-export declare function setGetFirstChild(getFirstChildImpl: getFirstChildFunc): void;
-declare type getFirstElementChildFunc = (element: E) => E | null;
-export declare let getFirstElementChild: getFirstElementChildFunc;
-export declare function setGetFirstElementChild(getFirstElementChildImpl: getFirstElementChildFunc): void;
-declare type getLastChildFunc = (element: E) => N | null;
-export declare let getLastChild: getLastChildFunc;
-export declare function setGetLastChild(getLastChildImpl: getLastChildFunc): void;
-declare type getLastElementChildFunc = (element: E) => E | null;
-export declare let getLastElementChild: getLastElementChildFunc;
-export declare function setGetLastElementChild(getLastElementChildImpl: getLastElementChildFunc): void;
-declare type isConnectedFunc = (node: N) => boolean;
-export declare let isConnected: isConnectedFunc;
-export declare function setIsConnected(isConnectedImpl: isConnectedFunc): void;
-declare type insertStylesheetFunc = (content: string, target?: ShadowRoot) => void;
-export declare let insertStylesheet: insertStylesheetFunc;
-export declare function setInsertStylesheet(insertStylesheetImpl: insertStylesheetFunc): void;
-declare type assertInstanceOfHTMLElementFunc = (elm: any, msg: string) => void;
-export declare let assertInstanceOfHTMLElement: assertInstanceOfHTMLElementFunc;
-export declare function setAssertInstanceOfHTMLElement(assertInstanceOfHTMLElementImpl: assertInstanceOfHTMLElementFunc): void;
-declare type defineCustomElementFunc = (name: string, constructor: CustomElementConstructor, options?: ElementDefinitionOptions) => void;
-export declare let defineCustomElement: defineCustomElementFunc;
-export declare function setDefineCustomElement(defineCustomElementImpl: defineCustomElementFunc): void;
-declare type getCustomElementFunc = (name: string) => CustomElementConstructor | undefined;
-export declare let getCustomElement: getCustomElementFunc;
-export declare function setGetCustomElement(getCustomElementImpl: getCustomElementFunc): void;