@lwc/engine-core 2.7.0 → 2.7.4

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@lwc/engine-core",
-    "version": "2.7.0",
+    "version": "2.7.4",
     "description": "Core LWC engine APIs.",
     "homepage": "https://lwc.dev/",
     "repository": {
@@ -24,8 +24,8 @@
         "types/"
     ],
     "dependencies": {
-        "@lwc/features": "2.7.0",
-        "@lwc/shared": "2.7.0"
+        "@lwc/features": "2.7.4",
+        "@lwc/shared": "2.7.4"
     },
     "devDependencies": {
         "observable-membrane": "2.0.0"
@@ -33,5 +33,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "656663a9f95f90bd648c6fc2200201afc0156393"
+    "gitHead": "df4eda8be794fa5f7a01148c137eea4e546a0844"
 }

package/types/framework/api.d.ts

@@ -1,6 +1,6 @@
 import { SlotSet } from './vm';
-import { VNode, VNodes, VElement, VText, VCustomElement, VComment, VElementData } from '../3rdparty/snabbdom/types';
 import { LightningElementConstructor } from './base-lightning-element';
+import { VNode, VNodes, VElement, VText, VCustomElement, VComment, VElementData } from './vnodes';
 declare function h(sel: string, data: VElementData, children: VNodes): VElement;
 declare function ti(value: any): number;
 declare function s(slotName: string, data: VElementData, children: VNodes, slotset: SlotSet | undefined): VElement | VNodes;

package/types/framework/component.d.ts

@@ -1,8 +1,8 @@
 import { VM } from './vm';
-import { VNodes } from '../3rdparty/snabbdom/types';
 import { ReactiveObserver } from '../libs/mutation-tracker';
 import { LightningElementConstructor } from './base-lightning-element';
 import { Template } from './template';
+import { VNodes } from './vnodes';
 /**
  * INTERNAL: This function can only be invoked by compiled code. The compiler
  * will prevent this function from being imported by userland code.

package/types/framework/def.d.ts

@@ -34,6 +34,7 @@ export interface ComponentDef {
  */
 export declare function isComponentConstructor(ctor: unknown): ctor is LightningElementConstructor;
 export declare function getComponentInternalDef(Ctor: unknown): ComponentDef;
+export declare function getComponentHtmlPrototype(Ctor: unknown): HTMLElementConstructor;
 declare const enum PropDefType {
     any = "any"
 }

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

@@ -0,0 +1,2 @@
+export declare const HTMLElementConstructor: typeof HTMLElement;
+export declare const HTMLElementPrototype: HTMLElement;

package/types/framework/hydration.d.ts

@@ -0,0 +1,3 @@
+import { VM } from './vm';
+import { VNodes } from './vnodes';
+export declare function hydrateChildren(elmChildren: NodeListOf<ChildNode>, children: VNodes, vm: VM): void;

package/types/framework/invoker.d.ts

@@ -1,6 +1,6 @@
 import { VM } from './vm';
 import { LightningElement, LightningElementConstructor } from './base-lightning-element';
-import { VNodes } from '../3rdparty/snabbdom/types';
+import { VNodes } from './vnodes';
 export declare let isInvokingRender: boolean;
 export declare let vmBeingConstructed: VM | null;
 export declare function isBeingConstructed(vm: VM): boolean;

package/types/framework/main.d.ts

@@ -6,7 +6,7 @@ export { default as track } from './decorators/track';
 export { default as wire } from './decorators/wire';
 export { readonly } from './readonly';
 export { setFeatureFlag, setFeatureFlagForTest } from '@lwc/features';
-export { getComponentInternalDef } from './def';
+export { getComponentHtmlPrototype } from './def';
 export { createVM, connectRootElement, disconnectRootElement, getAssociatedVMIfPresent, hydrateRootElement, } from './vm';
 export { registerComponent } from './component';
 export { registerTemplate } from './secure-template';
@@ -18,5 +18,5 @@ export { profilerControl as __unstable__ProfilerControl } from './profiler';
 export { getUpgradableConstructor } from './upgradable-element';
 export { swapTemplate, swapComponent, swapStyle } from './hot-swaps';
 export { setHooks } from './overridable-hooks';
-export type { Renderer } from './renderer';
 export type { ConfigValue as WireConfigValue, ContextValue as WireContextValue, DataCallback, WireAdapter, WireAdapterConstructor, WireAdapterSchemaValue, } from './wiring';
+export { setAssertInstanceOfHTMLElement, setAttachShadow, setCreateComment, setCreateElement, setCreateText, setDefineCustomElement, setDispatchEvent, setGetAttribute, setGetBoundingClientRect, setGetChildNodes, setGetChildren, setGetClassList, setGetCustomElement, setGetElementsByClassName, setGetElementsByTagName, setGetFirstChild, setGetFirstElementChild, setGetLastChild, setGetLastElementChild, setGetProperty, setHTMLElement, setInsert, setInsertGlobalStylesheet, setInsertStylesheet, setIsConnected, setIsHydrating, setIsNativeShadowDefined, setIsSyntheticShadowDefined, setNextSibling, setQuerySelector, setQuerySelectorAll, setRemove, setRemoveAttribute, setRemoveEventListener, setSetAttribute, setSetCSSStyleProperty, setSetProperty, setSetText, setSsr, setAddEventListener, } from '../renderer';

package/types/framework/modules/attrs.d.ts

@@ -1,7 +1,2 @@
-import { VElement } from '../../3rdparty/snabbdom/types';
-declare function updateAttrs(oldVnode: VElement, vnode: VElement): void;
-declare const _default: {
-    create: (vnode: VElement) => void;
-    update: typeof updateAttrs;
-};
-export default _default;
+import { VBaseElement } from '../vnodes';
+export declare function patchAttributes(oldVnode: VBaseElement | null, vnode: VBaseElement): void;

package/types/framework/modules/computed-class-attr.d.ts

@@ -1,7 +1,2 @@
-import { VElement } from '../../3rdparty/snabbdom/types';
-declare function updateClassAttribute(oldVnode: VElement, vnode: VElement): void;
-declare const _default: {
-    create: (vnode: VElement) => void;
-    update: typeof updateClassAttribute;
-};
-export default _default;
+import { VBaseElement } from '../vnodes';
+export declare function patchClassAttribute(oldVnode: VBaseElement | null, vnode: VBaseElement): void;

package/types/framework/modules/computed-style-attr.d.ts

@@ -1,7 +1,2 @@
-import { VNode } from '../../3rdparty/snabbdom/types';
-declare function updateStyleAttribute(oldVnode: VNode, vnode: VNode): void;
-declare const _default: {
-    create: (vnode: VNode) => void;
-    update: typeof updateStyleAttribute;
-};
-export default _default;
+import { VBaseElement } from '../vnodes';
+export declare function patchStyleAttribute(oldVnode: VBaseElement | null, vnode: VBaseElement): void;

package/types/framework/modules/events.d.ts

@@ -1,14 +1,2 @@
-import { VNode } from '../../3rdparty/snabbdom/types';
-interface VNodeEventListener extends EventListener {
-    vnode?: VNode;
-}
-interface InteractiveVNode extends VNode {
-    listener: VNodeEventListener | undefined;
-}
-declare function updateAllEventListeners(oldVnode: InteractiveVNode, vnode: InteractiveVNode): void;
-declare function createAllEventListeners(vnode: VNode): void;
-declare const _default: {
-    update: typeof updateAllEventListeners;
-    create: typeof createAllEventListeners;
-};
-export default _default;
+import { VBaseElement } from '../vnodes';
+export declare function applyEventListeners(vnode: VBaseElement): void;

package/types/framework/modules/props.d.ts

@@ -1,7 +1,2 @@
-import { VElement } from '../../3rdparty/snabbdom/types';
-declare function update(oldVnode: VElement, vnode: VElement): void;
-declare const _default: {
-    create: (vnode: VElement) => void;
-    update: typeof update;
-};
-export default _default;
+import { VBaseElement } from '../vnodes';
+export declare function patchProps(oldVnode: VBaseElement | null, vnode: VBaseElement): void;

package/types/framework/modules/static-class-attr.d.ts

@@ -1,6 +1,2 @@
-import { VNode } from '../../3rdparty/snabbdom/types';
-declare function createClassAttribute(vnode: VNode): void;
-declare const _default: {
-    create: typeof createClassAttribute;
-};
-export default _default;
+import { VBaseElement } from '../vnodes';
+export declare function applyStaticClassAttribute(vnode: VBaseElement): void;

package/types/framework/modules/static-style-attr.d.ts

@@ -1,6 +1,2 @@
-import { VNode } from '../../3rdparty/snabbdom/types';
-declare function createStyleAttribute(vnode: VNode): void;
-declare const _default: {
-    create: typeof createStyleAttribute;
-};
-export default _default;
+import { VBaseElement } from '../vnodes';
+export declare function applyStaticStyleAttribute(vnode: VBaseElement): void;

package/types/framework/rendering.d.ts

@@ -0,0 +1,9 @@
+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 allocateChildren(vnode: VCustomElement, vm: VM): void;
+export declare function markAsDynamicChildren(children: VNodes): void;

package/types/framework/services.d.ts

@@ -1,6 +1,6 @@
-import { VNodeData } from '../3rdparty/snabbdom/types';
 import { ComponentDef } from './def';
 import { VM, Context } from './vm';
+import { VNodeData } from './vnodes';
 declare type ServiceCallback = (component: object, data: VNodeData, def: ComponentDef, context: Context) => void;
 interface ServiceDef {
     connected?: ServiceCallback;

package/types/framework/stylesheet.d.ts

@@ -1,6 +1,6 @@
-import { VNode } from '../3rdparty/snabbdom/types';
 import { VM } from './vm';
 import { Template } from './template';
+import { VNode } from './vnodes';
 /**
  * Function producing style based on a host and a shadow selector. This function is invoked by
  * the engine with different values depending on the mode that the component is running on.

package/types/framework/template.d.ts

@@ -1,7 +1,7 @@
-import { VNode, VNodes } from '../3rdparty/snabbdom/types';
 import { RenderAPI } from './api';
 import { SlotSet, TemplateCache, VM } from './vm';
 import { TemplateStylesheetFactories } from './stylesheet';
+import { VNode, VNodes } from './vnodes';
 export interface Template {
     (api: RenderAPI, cmp: object, slotSet: SlotSet, cache: TemplateCache): VNodes;
     /** The list of slot names used in the template. */

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

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

package/types/framework/vm.d.ts

@@ -1,10 +1,10 @@
+import type { HostNode, HostElement } from '../renderer';
 import { Template } from './template';
 import { ComponentDef } from './def';
-import { LightningElement } from './base-lightning-element';
+import { LightningElement, LightningElementConstructor } from './base-lightning-element';
 import { ReactiveObserver } from './mutation-tracker';
 import { AccessorReactiveObserver } from './decorators/api';
-import { Renderer, HostNode, HostElement } from './renderer';
-import { VNodes, VCustomElement, VNode } from '../3rdparty/snabbdom/types';
+import { VNodes, VCustomElement, VNode } from './vnodes';
 declare type ShadowRootMode = 'open' | 'closed';
 export interface TemplateCache {
     [key: string]: any;
@@ -29,6 +29,9 @@ export declare const enum ShadowSupportMode {
     Any = "any",
     Default = "reset"
 }
+export declare const enum LwcDomMode {
+    Manual = "manual"
+}
 export interface Context {
     /** The string used for synthetic shadow DOM and light DOM style scoping. */
     stylesheetToken: string | undefined;
@@ -60,7 +63,6 @@ export interface VM<N = HostNode, E = HostElement> {
     /** The owner VM or null for root elements. */
     readonly owner: VM<N, E> | null;
     /** Rendering operations associated with the VM */
-    readonly renderer: Renderer<N, E>;
     renderMode: RenderMode;
     shadowMode: ShadowMode;
     /** The component creation index. */
@@ -97,7 +99,10 @@ export interface VM<N = HostNode, E = HostElement> {
     /** The component instance. */
     component: LightningElement;
     /** The custom element shadow root. */
-    cmpRoot: ShadowRoot | null;
+    shadowRoot: ShadowRoot | null;
+    /** The component render root. If the component is a shadow DOM component, it is its shadow
+     * root. If the component is a light DOM component it the element itself. */
+    renderRoot: ShadowRoot | HostElement;
     /** The template reactive observer. */
     tro: ReactiveObserver;
     /** The accessor reactive observers. Is only used when the ENABLE_REACTIVE_SETTER feature flag
@@ -123,11 +128,10 @@ export declare function disconnectRootElement(elm: any): void;
 export declare function appendVM(vm: VM): void;
 export declare function hydrateVM(vm: VM): void;
 export declare function removeVM(vm: VM): void;
-export declare function createVM<HostNode, HostElement>(elm: HostElement, def: ComponentDef, options: {
+export declare function createVM<HostNode, HostElement>(elm: HostElement, ctor: LightningElementConstructor, options: {
     mode: ShadowRootMode;
     owner: VM<HostNode, HostElement> | null;
     tagName: string;
-    renderer: Renderer;
 }): VM;
 export declare function associateVM(obj: VMAssociable, vm: VM): void;
 export declare function getAssociatedVM(obj: VMAssociable): VM;
@@ -135,8 +139,6 @@ export declare function getAssociatedVMIfPresent(obj: VMAssociable): VM | undefi
 export declare function runConnectedCallback(vm: VM): void;
 export declare function resetComponentRoot(vm: VM): void;
 export declare function scheduleRehydration(vm: VM): void;
-export declare function allocateInSlot(vm: VM, children: VNodes): void;
 export declare function runWithBoundaryProtection(vm: VM, owner: VM | null, pre: () => void, job: () => void, post: () => void): void;
 export declare function forceRehydration(vm: VM): void;
-export declare function getRenderRoot(vm: VM): ShadowRoot | HostElement;
 export {};

package/types/{3rdparty/snabbdom/types.d.ts → framework/vnodes.d.ts}

@@ -1,51 +1,50 @@
-/**
- @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';
+import { VM } from './vm';
 export declare type Key = string | number;
+export declare const enum VNodeType {
+    Text = 0,
+    Comment = 1,
+    Element = 2,
+    CustomElement = 3
+}
+export declare type VNode = VText | VComment | VElement | VCustomElement;
+export declare type VParentElement = VElement | VCustomElement;
 export declare type VNodes = Array<VNode | null>;
-export interface VNode {
-    sel: string | undefined;
-    data: VNodeData;
-    children: VNodes | undefined;
+export interface BaseVNode {
+    type: VNodeType;
     elm: Node | undefined;
-    parentElm?: Element;
-    text: string | undefined;
+    sel: string | undefined;
     key: Key | undefined;
     hook: Hooks<any>;
     owner: VM;
 }
-export interface VElement extends VNode {
+export interface VText extends BaseVNode {
+    type: VNodeType.Text;
+    sel: undefined;
+    text: string;
+    key: undefined;
+}
+export interface VComment extends BaseVNode {
+    type: VNodeType.Comment;
+    sel: undefined;
+    text: string;
+    key: undefined;
+}
+export interface VBaseElement extends BaseVNode {
     sel: string;
     data: VElementData;
     children: VNodes;
     elm: Element | undefined;
-    text: undefined;
     key: Key;
 }
-export interface VCustomElement extends VElement {
+export interface VElement extends VBaseElement {
+    type: VNodeType.Element;
+}
+export interface VCustomElement extends VBaseElement {
+    type: VNodeType.CustomElement;
     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>;
@@ -54,7 +53,7 @@ export interface VNodeData {
     classMap?: Record<string, boolean>;
     styleDecls?: Array<[string, string, boolean]>;
     context?: Record<string, Record<string, any>>;
-    on?: Record<string, Function>;
+    on?: Record<string, (event: Event) => any>;
     svg?: boolean;
 }
 export interface VElementData extends VNodeData {
@@ -66,5 +65,6 @@ export interface Hooks<N extends VNode> {
     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;
 }
+export declare function isVBaseElement(vnode: VNode): vnode is VElement | VCustomElement;
+export declare function isSameVnode(vnode1: VNode, vnode2: VNode): boolean;

package/types/renderer.d.ts

@@ -0,0 +1,122 @@
+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 insertGlobalStylesheetFunc = (content: string) => void;
+export declare let insertGlobalStylesheet: insertGlobalStylesheetFunc;
+export declare function setInsertGlobalStylesheet(insertGlobalStylesheetImpl: insertGlobalStylesheetFunc): void;
+declare type insertStylesheetFunc = (content: string, target: N) => 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;

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/framework/hooks.d.ts

@@ -1,22 +0,0 @@
-import { VM } from './vm';
-import { VNode, VCustomElement, VElement, VNodes } from '../3rdparty/snabbdom/types';
-export declare function updateNodeHook(oldVnode: VNode, vnode: VNode): void;
-export declare function insertNodeHook(vnode: VNode, parentNode: Node, referenceNode: Node | null): void;
-export declare function removeNodeHook(vnode: VNode, parentNode: Node): void;
-export declare function createElmHook(vnode: VElement): void;
-export declare const enum LWCDOMMode {
-    manual = "manual"
-}
-export declare function hydrateElmHook(vnode: VElement): void;
-export declare function fallbackElmHook(elm: Element, vnode: VElement): void;
-export declare function updateElmHook(oldVnode: VElement, vnode: VElement): void;
-export declare function updateChildrenHook(oldVnode: VElement, vnode: VElement): void;
-export declare function allocateChildrenHook(vnode: VCustomElement, vm: VM): void;
-export declare function createViewModelHook(elm: HTMLElement, vnode: VCustomElement): void;
-export declare function createCustomElmHook(vnode: VCustomElement): void;
-export declare function createChildrenHook(vnode: VElement): void;
-export declare function hydrateChildrenHook(elmChildren: NodeListOf<ChildNode>, children: VNodes, vm?: VM): void;
-export declare function updateCustomElmHook(oldVnode: VCustomElement, vnode: VCustomElement): void;
-export declare function removeElmHook(vnode: VElement): void;
-export declare function markAsDynamicChildren(children: VNodes): void;
-export declare function hasDynamicChildren(children: VNodes): boolean;

package/types/framework/renderer.d.ts

@@ -1,46 +0,0 @@
-export declare type HostNode = any;
-export declare type HostElement = any;
-export interface Renderer<N = HostNode, E = HostElement> {
-    ssr: boolean;
-    isHydrating(): boolean;
-    isNativeShadowDefined: boolean;
-    isSyntheticShadowDefined: boolean;
-    insert(node: N, parent: E, anchor: N | null): void;
-    remove(node: N, parent: E): void;
-    createElement(tagName: string, namespace?: string): E;
-    createText(content: string): N;
-    createComment(content: string): N;
-    nextSibling(node: N): N | null;
-    attachShadow(element: E, options: ShadowRootInit): N;
-    getProperty(node: N, key: string): any;
-    setProperty(node: N, key: string, value: any): void;
-    setText(node: N, content: string): void;
-    getAttribute(element: E, name: string, namespace?: string | null): string | null;
-    setAttribute(element: E, name: string, value: string, namespace?: string | null): void;
-    removeAttribute(element: E, name: string, namespace?: string | null): void;
-    addEventListener(target: E, type: string, callback: (event: Event) => any, options?: AddEventListenerOptions | boolean): void;
-    removeEventListener(target: E, type: string, callback: (event: Event) => any, options?: EventListenerOptions | boolean): void;
-    dispatchEvent(target: N, event: Event): boolean;
-    getClassList(element: E): DOMTokenList;
-    setCSSStyleProperty(element: E, name: string, value: string, important: boolean): void;
-    getBoundingClientRect(element: E): ClientRect;
-    querySelector(element: E, selectors: string): E | null;
-    querySelectorAll(element: E, selectors: string): NodeList;
-    getElementsByTagName(element: E, tagNameOrWildCard: string): HTMLCollection;
-    getElementsByClassName(element: E, names: string): HTMLCollection;
-    getChildren(element: E): HTMLCollection;
-    getChildNodes(element: E): NodeList;
-    getFirstChild(element: E): N | null;
-    getFirstElementChild(element: E): E | null;
-    getLastChild(element: E): N | null;
-    getLastElementChild(element: E): E | null;
-    isConnected(node: N): boolean;
-    insertGlobalStylesheet(content: string): void;
-    insertStylesheet(content: string, target: N): void;
-    assertInstanceOfHTMLElement?(elm: any, msg: string): void;
-    defineCustomElement(name: string, constructor: CustomElementConstructor, options?: ElementDefinitionOptions): void;
-    getCustomElement(name: string): CustomElementConstructor | undefined;
-    HTMLElement: typeof HTMLElement;
-}
-export declare const HTMLElementConstructor: typeof HTMLElement;
-export declare const HTMLElementPrototype: HTMLElement;