@odoo/owl 3.0.0-alpha.3 → 3.0.0-alpha.30

package/dist/types/common/owl_error.d.ts

@@ -1,3 +0,0 @@
-export declare class OwlError extends Error {
-    cause?: any;
-}

package/dist/types/common/types.d.ts

@@ -1,29 +0,0 @@
-export declare type customDirectives = Record<string, (node: Element, value: string, modifier: string[]) => void>;
-export declare enum ComputationState {
-    EXECUTED = 0,
-    STALE = 1,
-    PENDING = 2
-}
-export declare type Computation<T = any> = {
-    compute?: () => T;
-    state: ComputationState;
-    sources: Set<Atom | Derived<any, any>>;
-    isEager?: boolean;
-    isDerived?: boolean;
-    value: T;
-    childrenEffect?: Computation[];
-} & Opts;
-export declare type Opts = {
-    name?: string;
-};
-export declare type Atom<T = any> = {
-    value: T;
-    observers: Set<Computation>;
-} & Opts;
-export interface Derived<Prev, Next = Prev> extends Atom<Next>, Computation<Next> {
-}
-export declare type OldValue = any;
-export declare type Getter<V> = () => V | null;
-export declare type Setter<T, V> = (this: T, value: V) => void;
-export declare type MakeGetSetReturn<T, V> = readonly [Getter<V>] | readonly [Getter<V>, Setter<T, V>];
-export declare type MakeGetSet<T, V> = (obj: T) => MakeGetSetReturn<T, V>;

package/dist/types/common/utils.d.ts

@@ -1,8 +0,0 @@
-/**
- * Parses an XML string into an XML document, throwing errors on parser errors
- * instead of returning an XML document containing the parseerror.
- *
- * @param xml the string to parse
- * @returns an XML document corresponding to the content of the string
- */
-export declare function parseXML(xml: string): XMLDocument;

package/dist/types/compiler/code_generator.d.ts

@@ -1,152 +0,0 @@
-import { AST, ASTComment, ASTComponent, ASTDebug, ASTDomNode, ASTLog, ASTMulti, ASTSlot, ASTTCall, ASTTCallBlock, ASTTEsc, ASTText, ASTTForEach, ASTTif, ASTTKey, ASTTOut, ASTTPortal, ASTTranslation, ASTTranslationContext, ASTTSet, EventHandlers } from "./parser";
-declare type BlockType = "block" | "text" | "multi" | "list" | "html" | "comment";
-export interface Config {
-    translateFn?: (s: string, translationCtx: string) => string;
-    translatableAttributes?: string[];
-    dev?: boolean;
-}
-export interface CodeGenOptions extends Config {
-    hasSafeContext?: boolean;
-    name?: string;
-    hasGlobalValues: boolean;
-}
-declare class BlockDescription {
-    static nextBlockId: number;
-    varName: string;
-    blockName: string;
-    dynamicTagName: string | null;
-    isRoot: boolean;
-    hasDynamicChildren: boolean;
-    children: BlockDescription[];
-    data: string[];
-    dom?: Node;
-    currentDom?: Element;
-    childNumber: number;
-    target: CodeTarget;
-    type: BlockType;
-    parentVar: string;
-    id: number;
-    constructor(target: CodeTarget, type: BlockType);
-    insertData(str: string, prefix?: string): number;
-    insert(dom: Node): void;
-    generateExpr(expr: string): string;
-    asXmlString(): string;
-}
-interface Context {
-    block: BlockDescription | null;
-    index: number | string;
-    forceNewBlock: boolean;
-    isLast?: boolean;
-    translate: boolean;
-    translationCtx: string;
-    tKeyExpr: string | null;
-    nameSpace?: string;
-    tModelSelectedExpr?: string;
-    ctxVar?: string;
-    inPreTag?: boolean;
-}
-declare class CodeTarget {
-    name: string;
-    indentLevel: number;
-    loopLevel: number;
-    code: string[];
-    hasRoot: boolean;
-    hasCache: boolean;
-    shouldProtectScope: boolean;
-    on: EventHandlers | null;
-    hasRefWrapper: boolean;
-    constructor(name: string, on?: EventHandlers | null);
-    addLine(line: string, idx?: number): void;
-    generateCode(): string;
-    currentKey(ctx: Context): string;
-}
-export declare class CodeGenerator {
-    blocks: BlockDescription[];
-    nextBlockId: number;
-    hasSafeContext: boolean;
-    isDebug: boolean;
-    targets: CodeTarget[];
-    target: CodeTarget;
-    templateName?: string;
-    dev: boolean;
-    translateFn: (s: string, translationCtx: string) => string;
-    translatableAttributes: string[];
-    ast: AST;
-    staticDefs: {
-        id: string;
-        expr: string;
-    }[];
-    slotNames: Set<String>;
-    helpers: Set<string>;
-    constructor(ast: AST, options: CodeGenOptions);
-    generateCode(): string;
-    compileInNewTarget(prefix: string, ast: AST, ctx: Context, on?: EventHandlers | null): string;
-    addLine(line: string, idx?: number): void;
-    define(varName: string, expr: string): void;
-    insertAnchor(block: BlockDescription, index?: number): void;
-    createBlock(parentBlock: BlockDescription | null, type: BlockType, ctx: Context): BlockDescription;
-    insertBlock(expression: string, block: BlockDescription, ctx: Context): void;
-    /**
-     * Captures variables that are used inside of an expression. This is useful
-     * because in compiled code, almost all variables are accessed through the ctx
-     * object. In the case of functions, that lookup in the context can be delayed
-     * which can cause issues if the value has changed since the function was
-     * defined.
-     *
-     * @param expr the expression to capture
-     * @param forceCapture whether the expression should capture its scope even if
-     *  it doesn't contain a function. Useful when the expression will be used as
-     *  a function body.
-     * @returns a new expression that uses the captured values
-     */
-    captureExpression(expr: string, forceCapture?: boolean): string;
-    translate(str: string, translationCtx: string): string;
-    /**
-     * @returns the newly created block name, if any
-     */
-    compileAST(ast: AST, ctx: Context): string | null;
-    compileDebug(ast: ASTDebug, ctx: Context): string | null;
-    compileLog(ast: ASTLog, ctx: Context): string | null;
-    compileComment(ast: ASTComment, ctx: Context): string;
-    compileText(ast: ASTText, ctx: Context): string;
-    generateHandlerCode(rawEvent: string, handler: string): string;
-    compileTDomNode(ast: ASTDomNode, ctx: Context): string;
-    compileTEsc(ast: ASTTEsc, ctx: Context): string;
-    compileTOut(ast: ASTTOut, ctx: Context): string;
-    compileTIfBranch(content: AST, block: BlockDescription, ctx: Context): void;
-    compileTIf(ast: ASTTif, ctx: Context, nextNode?: ASTDomNode): string;
-    compileTForeach(ast: ASTTForEach, ctx: Context): string;
-    compileTKey(ast: ASTTKey, ctx: Context): string | null;
-    compileMulti(ast: ASTMulti, ctx: Context): string | null;
-    compileTCall(ast: ASTTCall, ctx: Context): string;
-    compileTCallBlock(ast: ASTTCallBlock, ctx: Context): string;
-    compileTSet(ast: ASTTSet, ctx: Context): null;
-    generateComponentKey(currentKey?: string): string;
-    /**
-     * Formats a prop name and value into a string suitable to be inserted in the
-     * generated code. For example:
-     *
-     * Name              Value            Result
-     * ---------------------------------------------------------
-     * "number"          "state"          "number: ctx['state']"
-     * "something"       ""               "something: undefined"
-     * "some-prop"       "state"          "'some-prop': ctx['state']"
-     * "onClick.bind"    "onClick"        "onClick: bind(ctx, ctx['onClick'])"
-     */
-    formatProp(name: string, value: string, attrsTranslationCtx: {
-        [name: string]: string;
-    } | null, translationCtx: string): string;
-    formatPropObject(obj: {
-        [prop: string]: any;
-    }, attrsTranslationCtx: {
-        [name: string]: string;
-    } | null, translationCtx: string): string[];
-    getPropString(props: string[], dynProps: string | null): string;
-    compileComponent(ast: ASTComponent, ctx: Context): string;
-    wrapWithEventCatcher(expr: string, on: EventHandlers): string;
-    compileTSlot(ast: ASTSlot, ctx: Context): string;
-    compileTTranslation(ast: ASTTranslation, ctx: Context): string | null;
-    compileTTranslationContext(ast: ASTTranslationContext, ctx: Context): string | null;
-    compileTPortal(ast: ASTTPortal, ctx: Context): string;
-}
-export {};

package/dist/types/compiler/index.d.ts

@@ -1,13 +0,0 @@
-import type { customDirectives } from "../common/types";
-import type { TemplateSet } from "../runtime/template_set";
-import type { BDom } from "../runtime/blockdom";
-import { Config } from "./code_generator";
-export declare type Template = (context: any, vnode: any, key?: string) => BDom;
-export declare type TemplateFunction = (app: TemplateSet, bdom: any, helpers: any) => Template;
-interface CompileOptions extends Config {
-    name?: string;
-    customDirectives?: customDirectives;
-    hasGlobalValues: boolean;
-}
-export declare function compile(template: string | Element, options?: CompileOptions): TemplateFunction;
-export {};

package/dist/types/compiler/inline_expressions.d.ts

@@ -1,59 +0,0 @@
-export interface QWebVar {
-    id: string;
-    expr: string;
-    value?: string;
-    hasBody?: boolean;
-}
-declare type TKind = "LEFT_BRACE" | "RIGHT_BRACE" | "LEFT_BRACKET" | "RIGHT_BRACKET" | "LEFT_PAREN" | "RIGHT_PAREN" | "COMMA" | "VALUE" | "TEMPLATE_STRING" | "SYMBOL" | "OPERATOR" | "COLON";
-interface Token {
-    type: TKind;
-    value: string;
-    originalValue?: string;
-    size?: number;
-    varName?: string;
-    replace?: Function;
-    isLocal?: boolean;
-}
-/**
- * Convert a javascript expression (as a string) into a list of tokens. For
- * example: `tokenize("1 + b")` will return:
- * ```js
- *  [
- *   {type: "VALUE", value: "1"},
- *   {type: "OPERATOR", value: "+"},
- *   {type: "SYMBOL", value: "b"}
- * ]
- * ```
- */
-export declare function tokenize(expr: string): Token[];
-/**
- * This is the main function exported by this file. This is the code that will
- * process an expression (given as a string) and returns another expression with
- * proper lookups in the context.
- *
- * Usually, this kind of code would be very simple to do if we had an AST (so,
- * if we had a javascript parser), since then, we would only need to find the
- * variables and replace them.  However, a parser is more complicated, and there
- * are no standard builtin parser API.
- *
- * Since this method is applied to simple javasript expressions, and the work to
- * be done is actually quite simple, we actually can get away with not using a
- * parser, which helps with the code size.
- *
- * Here is the heuristic used by this method to determine if a token is a
- * variable:
- * - by default, all symbols are considered a variable
- * - unless the previous token is a dot (in that case, this is a property: `a.b`)
- * - or if the previous token is a left brace or a comma, and the next token is
- *   a colon (in that case, this is an object key: `{a: b}`)
- *
- * Some specific code is also required to support arrow functions. If we detect
- * the arrow operator, then we add the current (or some previous tokens) token to
- * the list of variables so it does not get replaced by a lookup in the context
- */
-export declare function compileExprToArray(expr: string): Token[];
-export declare function compileExpr(expr: string): string;
-export declare const INTERP_REGEXP: RegExp;
-export declare function replaceDynamicParts(s: string, replacer: (s: string) => string): string;
-export declare function interpolate(s: string): string;
-export {};

package/dist/types/compiler/parser.d.ts

@@ -1,178 +0,0 @@
-import type { customDirectives } from "../common/types";
-export declare type EventHandlers = {
-    [eventName: string]: string;
-};
-export declare type Attrs = {
-    [attrs: string]: string;
-};
-export declare const enum ASTType {
-    Text = 0,
-    Comment = 1,
-    DomNode = 2,
-    Multi = 3,
-    TEsc = 4,
-    TIf = 5,
-    TSet = 6,
-    TCall = 7,
-    TOut = 8,
-    TForEach = 9,
-    TKey = 10,
-    TComponent = 11,
-    TDebug = 12,
-    TLog = 13,
-    TSlot = 14,
-    TCallBlock = 15,
-    TTranslation = 16,
-    TTranslationContext = 17,
-    TPortal = 18
-}
-export interface BaseAST {
-    type: ASTType;
-    hasNoRepresentation?: true;
-}
-export interface ASTText extends BaseAST {
-    type: ASTType.Text;
-    value: string;
-}
-export interface ASTComment extends BaseAST {
-    type: ASTType.Comment;
-    value: string;
-}
-interface TModelInfo {
-    baseExpr: string;
-    expr: string;
-    targetAttr: string;
-    eventType: "change" | "click" | "input";
-    shouldTrim: boolean;
-    shouldNumberize: boolean;
-    hasDynamicChildren: boolean;
-    specialInitTargetAttr: string | null;
-}
-export interface ASTDomNode extends BaseAST {
-    type: ASTType.DomNode;
-    tag: string;
-    content: AST[];
-    attrs: Attrs | null;
-    attrsTranslationCtx: Attrs | null;
-    ref: string | null;
-    on: EventHandlers | null;
-    model: TModelInfo | null;
-    dynamicTag: string | null;
-    ns: string | null;
-}
-export interface ASTMulti extends BaseAST {
-    type: ASTType.Multi;
-    content: AST[];
-}
-export interface ASTTEsc extends BaseAST {
-    type: ASTType.TEsc;
-    expr: string;
-    defaultValue: string;
-}
-export interface ASTTOut extends BaseAST {
-    type: ASTType.TOut;
-    expr: string;
-    body: AST[] | null;
-}
-export interface ASTTif extends BaseAST {
-    type: ASTType.TIf;
-    condition: string;
-    content: AST;
-    tElif: {
-        condition: string;
-        content: AST;
-    }[] | null;
-    tElse: AST | null;
-}
-export interface ASTTSet extends BaseAST {
-    type: ASTType.TSet;
-    name: string;
-    value: string | null;
-    defaultValue: string | null;
-    body: AST[] | null;
-    hasNoRepresentation: true;
-}
-export interface ASTTForEach extends BaseAST {
-    type: ASTType.TForEach;
-    collection: string;
-    elem: string;
-    body: AST;
-    memo: string;
-    hasNoFirst: boolean;
-    hasNoLast: boolean;
-    hasNoIndex: boolean;
-    hasNoValue: boolean;
-    key: string | null;
-}
-export interface ASTTKey extends BaseAST {
-    type: ASTType.TKey;
-    expr: string;
-    content: AST;
-}
-export interface ASTTCall extends BaseAST {
-    type: ASTType.TCall;
-    name: string;
-    body: AST[] | null;
-    context: string | null;
-}
-interface SlotDefinition {
-    content: AST | null;
-    scope: string | null;
-    on: EventHandlers | null;
-    attrs: Attrs | null;
-    attrsTranslationCtx: Attrs | null;
-}
-export interface ASTComponent extends BaseAST {
-    type: ASTType.TComponent;
-    name: string;
-    isDynamic: boolean;
-    dynamicProps: string | null;
-    on: EventHandlers | null;
-    props: {
-        [name: string]: string;
-    } | null;
-    propsTranslationCtx: {
-        [name: string]: string;
-    } | null;
-    slots: {
-        [name: string]: SlotDefinition;
-    } | null;
-}
-export interface ASTSlot extends BaseAST {
-    type: ASTType.TSlot;
-    name: string;
-    attrs: Attrs | null;
-    attrsTranslationCtx: Attrs | null;
-    on: EventHandlers | null;
-    defaultContent: AST | null;
-}
-export interface ASTTCallBlock extends BaseAST {
-    type: ASTType.TCallBlock;
-    name: string;
-}
-export interface ASTDebug extends BaseAST {
-    type: ASTType.TDebug;
-    content: AST | null;
-}
-export interface ASTLog extends BaseAST {
-    type: ASTType.TLog;
-    expr: string;
-    content: AST | null;
-}
-export interface ASTTranslation extends BaseAST {
-    type: ASTType.TTranslation;
-    content: AST | null;
-}
-export interface ASTTranslationContext extends BaseAST {
-    type: ASTType.TTranslationContext;
-    content: AST | null;
-    translationCtx: string;
-}
-export interface ASTTPortal extends BaseAST {
-    type: ASTType.TPortal;
-    target: string;
-    content: AST;
-}
-export declare type AST = ASTText | ASTComment | ASTDomNode | ASTMulti | ASTTEsc | ASTTif | ASTTSet | ASTTCall | ASTTOut | ASTTForEach | ASTTKey | ASTComponent | ASTSlot | ASTTCallBlock | ASTLog | ASTDebug | ASTTranslation | ASTTranslationContext | ASTTPortal;
-export declare function parse(xml: string | Element, customDir?: customDirectives): AST;
-export {};

package/dist/types/compiler/standalone/index.d.ts

@@ -1,2 +0,0 @@
-import "./setup_jsdom";
-export declare function compileTemplates(paths: string[]): Promise<string>;

package/dist/types/compiler/standalone/setup_jsdom.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/types/index.d.ts

@@ -1 +0,0 @@
-export * from "./runtime";

package/dist/types/runtime/app.d.ts

@@ -1,62 +0,0 @@
-import { Component, ComponentConstructor, Props } from "./component";
-import { ComponentNode } from "./component_node";
-import { handleError } from "./error_handling";
-import { Fiber, RootFiber, MountOptions } from "./fibers";
-import { Scheduler } from "./scheduler";
-import { TemplateSet, TemplateSetConfig } from "./template_set";
-import { validateTarget } from "./utils";
-import { toRaw, reactive } from "./reactivity";
-import { PluginCtor, PluginManager } from "./plugins";
-export interface Env {
-    [key: string]: any;
-}
-export interface RootConfig<P, E> {
-    props?: P;
-    env?: E;
-    Plugins?: PluginCtor[];
-}
-export interface AppConfig<P, E> extends TemplateSetConfig, RootConfig<P, E> {
-    name?: string;
-    test?: boolean;
-    warnIfNoStaticProps?: boolean;
-}
-declare global {
-    interface Window {
-        __OWL_DEVTOOLS__: {
-            apps: Set<App>;
-            Fiber: typeof Fiber;
-            RootFiber: typeof RootFiber;
-            toRaw: typeof toRaw;
-            reactive: typeof reactive;
-        };
-    }
-}
-interface Root<P extends Props, E> {
-    node: ComponentNode<P, E>;
-    mount(target: HTMLElement | ShadowRoot, options?: MountOptions): Promise<Component<P, E>>;
-    destroy(): void;
-}
-export declare class App<T extends abstract new (...args: any) => any = any, Plugins = any, P extends object = any, E = any> extends TemplateSet {
-    static validateTarget: typeof validateTarget;
-    static apps: Set<App<any, any, any, any>>;
-    static version: string;
-    name: string;
-    Root: ComponentConstructor<P, Plugins, E>;
-    props: P;
-    env: E;
-    scheduler: Scheduler;
-    subRoots: Set<ComponentNode>;
-    root: ComponentNode<P, E> | null;
-    warnIfNoStaticProps: boolean;
-    pluginManager: PluginManager;
-    constructor(Root: ComponentConstructor<P, Plugins, E>, config?: AppConfig<P, E>);
-    mount(target: HTMLElement | ShadowRoot, options?: MountOptions): Promise<Component<P, E> & InstanceType<T>>;
-    createRoot<Props extends object, Plugins = any, SubEnv = any>(Root: ComponentConstructor<Props, Plugins, E>, config?: RootConfig<Props, SubEnv>): Root<Props, SubEnv>;
-    makeNode(Component: ComponentConstructor, props: any): ComponentNode;
-    mountNode(node: ComponentNode, target: HTMLElement | ShadowRoot, options?: MountOptions): any;
-    destroy(): void;
-    createComponent<P extends Props>(name: string | null, isStatic: boolean, hasSlotsProp: boolean, hasDynamicPropList: boolean, propList: string[]): (props: P, key: string, ctx: ComponentNode, parent: any, C: any) => any;
-    handleError(...args: Parameters<typeof handleError>): void;
-}
-export declare function mount<T extends abstract new (...args: any) => any = any, Plugins = any, P extends object = any, E = any>(C: T & ComponentConstructor<P, Plugins, E>, target: HTMLElement, config?: AppConfig<P, E> & MountOptions): Promise<Component<P, Plugins, E> & InstanceType<T>>;
-export {};

package/dist/types/runtime/blockdom/attributes.d.ts

@@ -1,6 +0,0 @@
-import type { Setter } from "./block_compiler";
-export declare function createAttrUpdater(attr: string): Setter<HTMLElement>;
-export declare function attrsSetter(this: HTMLElement, attrs: any): void;
-export declare function attrsUpdater(this: HTMLElement, attrs: any, oldAttrs: any): void;
-export declare function setClass(this: HTMLElement, val: any): void;
-export declare function updateClass(this: HTMLElement, val: any, oldVal: any): void;

package/dist/types/runtime/blockdom/block_compiler.d.ts

@@ -1,21 +0,0 @@
-import type { VNode } from "./index";
-declare type BlockType = (data?: any[], children?: VNode[]) => VNode;
-/**
- * Compiling blocks is a multi-step process:
- *
- * 1. build an IntermediateTree from the HTML element. This intermediate tree
- *    is a binary tree structure that encode dynamic info sub nodes, and the
- *    path required to reach them
- * 2. process the tree to build a block context, which is an object that aggregate
- *    all dynamic info in a list, and also, all ref indexes.
- * 3. process the context to build appropriate builder/setter functions
- * 4. make a dynamic block class, which will efficiently collect references and
- *    create/update dynamic locations/children
- *
- * @param str
- * @returns a new block type, that can build concrete blocks
- */
-export declare function createBlock(str: string): BlockType;
-export declare type Setter<T = any> = (this: T, value: any) => void;
-export declare type Updater<T = any> = (this: T, value: any, oldVal: any) => void;
-export {};

package/dist/types/runtime/blockdom/config.d.ts

@@ -1,8 +0,0 @@
-export declare function filterOutModifiersFromData(dataList: any[]): {
-    modifiers: string[];
-    data: any[];
-};
-export declare const config: {
-    shouldNormalizeDom: boolean;
-    mainEventHandler: (data: any, ev: Event, currentTarget?: EventTarget | null | undefined) => boolean;
-};

package/dist/types/runtime/blockdom/event_catcher.d.ts

@@ -1,7 +0,0 @@
-import type { VNode } from "./index";
-declare type EventsSpec = {
-    [name: string]: number;
-};
-declare type Catcher = (child: VNode, handlers: any[]) => VNode;
-export declare function createCatcher(eventsSpec: EventsSpec): Catcher;
-export {};

package/dist/types/runtime/blockdom/events.d.ts

@@ -1,8 +0,0 @@
-declare type EventHandlerSetter = (this: HTMLElement, data: any) => void;
-interface EventHandlerCreator {
-    setup: EventHandlerSetter;
-    update: EventHandlerSetter;
-    remove: (this: HTMLElement) => void;
-}
-export declare function createEventHandler(rawEvent: string): EventHandlerCreator;
-export {};

package/dist/types/runtime/blockdom/html.d.ts

@@ -1,17 +0,0 @@
-import type { VNode } from "./index";
-declare class VHtml {
-    html: string;
-    parentEl?: HTMLElement | undefined;
-    content: ChildNode[];
-    constructor(html: string);
-    mount(parent: HTMLElement, afterNode: Node | null): void;
-    moveBeforeDOMNode(node: Node | null, parent?: HTMLElement | undefined): void;
-    moveBeforeVNode(other: VHtml | null, afterNode: Node | null): void;
-    patch(other: VHtml): void;
-    beforeRemove(): void;
-    remove(): void;
-    firstNode(): Node;
-    toString(): string;
-}
-export declare function html(str: string): VNode<VHtml>;
-export {};

package/dist/types/runtime/blockdom/index.d.ts

@@ -1,26 +0,0 @@
-export { config } from "./config";
-export { toggler } from "./toggler";
-export { createBlock } from "./block_compiler";
-export { list } from "./list";
-export { multi } from "./multi";
-export { text, comment } from "./text";
-export { html } from "./html";
-export { createCatcher } from "./event_catcher";
-export interface VNode<T = any> {
-    mount(parent: HTMLElement, afterNode: Node | null): void;
-    moveBeforeDOMNode(node: Node | null, parent?: HTMLElement): void;
-    moveBeforeVNode(other: T | null, afterNode: Node | null): void;
-    patch(other: T, withBeforeRemove: boolean): void;
-    beforeRemove(): void;
-    remove(): void;
-    firstNode(): Node | undefined;
-    el?: undefined | HTMLElement | Text;
-    parentEl?: undefined | HTMLElement;
-    isOnlyChild?: boolean | undefined;
-    key?: any;
-}
-export declare type BDom = VNode<any>;
-export declare function mount(vnode: VNode, fixture: HTMLElement, afterNode?: Node | null): void;
-export declare function patch(vnode1: VNode, vnode2: VNode, withBeforeRemove?: boolean): void;
-export declare function remove(vnode: VNode, withBeforeRemove?: boolean): void;
-export declare function withKey(vnode: VNode, key: any): VNode<any>;

package/dist/types/runtime/blockdom/list.d.ts

@@ -1,18 +0,0 @@
-import type { VNode } from "./index";
-declare class VList {
-    children: VNode[];
-    anchor: Node | undefined;
-    parentEl?: HTMLElement | undefined;
-    isOnlyChild?: boolean | undefined;
-    constructor(children: VNode[]);
-    mount(parent: HTMLElement, afterNode: Node | null): void;
-    moveBeforeDOMNode(node: Node | null, parent?: HTMLElement | undefined): void;
-    moveBeforeVNode(other: VList | null, afterNode: Node | null): void;
-    patch(other: VList, withBeforeRemove: boolean): void;
-    beforeRemove(): void;
-    remove(): void;
-    firstNode(): Node | undefined;
-    toString(): string;
-}
-export declare function list(children: VNode[]): VNode<VList>;
-export {};

package/dist/types/runtime/blockdom/multi.d.ts

@@ -1,17 +0,0 @@
-import type { VNode } from "./index";
-export declare class VMulti {
-    children: (VNode | undefined)[];
-    anchors?: Node[] | undefined;
-    parentEl?: HTMLElement | undefined;
-    isOnlyChild?: boolean | undefined;
-    constructor(children: (VNode | undefined)[]);
-    mount(parent: HTMLElement, afterNode: Node | null): void;
-    moveBeforeDOMNode(node: Node | null, parent?: HTMLElement | undefined): void;
-    moveBeforeVNode(other: VMulti | null, afterNode: Node | null): void;
-    patch(other: VMulti, withBeforeRemove: boolean): void;
-    beforeRemove(): void;
-    remove(): void;
-    firstNode(): Node | undefined;
-    toString(): string;
-}
-export declare function multi(children: (VNode | undefined)[]): VNode<VMulti>;