@odoo/owl 3.0.0-alpha.20 → 3.0.0-alpha.22

package/dist/owl.cjs.runtime.js

@@ -1,4070 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-// Custom error class that wraps error that happen in the owl lifecycle
-class OwlError extends Error {
-}
-
-// do not modify manually. This file is generated by the release script.
-const version = "3.0.0-alpha";
-
-class Component {
-    constructor(node) {
-        this.__owl__ = node;
-    }
-    setup() { }
-    render(deep = false) {
-        this.__owl__.render(deep === true);
-    }
-}
-Component.template = "";
-
-/**
- * Creates a batched version of a callback so that all calls to it in the same
- * microtick will only call the original callback once.
- *
- * @param callback the callback to batch
- * @returns a batched version of the original callback
- */
-function batched(callback) {
-    let scheduled = false;
-    return async (...args) => {
-        if (!scheduled) {
-            scheduled = true;
-            await Promise.resolve();
-            scheduled = false;
-            callback(...args);
-        }
-    };
-}
-/**
- * Determine whether the given element is contained in its ownerDocument:
- * either directly or with a shadow root in between.
- */
-function inOwnerDocument(el) {
-    if (!el) {
-        return false;
-    }
-    if (el.ownerDocument.contains(el)) {
-        return true;
-    }
-    const rootNode = el.getRootNode();
-    return rootNode instanceof ShadowRoot && el.ownerDocument.contains(rootNode.host);
-}
-/**
- * Determine whether the given element is contained in a specific root documnet:
- * either directly or with a shadow root in between or in an iframe.
- */
-function isAttachedToDocument(element, documentElement) {
-    let current = element;
-    const shadowRoot = documentElement.defaultView.ShadowRoot;
-    while (current) {
-        if (current === documentElement) {
-            return true;
-        }
-        if (current.parentNode) {
-            current = current.parentNode;
-        }
-        else if (current instanceof shadowRoot && current.host) {
-            current = current.host;
-        }
-        else {
-            return false;
-        }
-    }
-    return false;
-}
-function validateTarget(target) {
-    // Get the document and HTMLElement corresponding to the target to allow mounting in iframes
-    const document = target && target.ownerDocument;
-    if (document) {
-        if (!document.defaultView) {
-            throw new OwlError("Cannot mount a component: the target document is not attached to a window (defaultView is missing)");
-        }
-        const HTMLElement = document.defaultView.HTMLElement;
-        if (target instanceof HTMLElement || target instanceof ShadowRoot) {
-            if (!isAttachedToDocument(target, document)) {
-                throw new OwlError("Cannot mount a component on a detached dom node");
-            }
-            return;
-        }
-    }
-    throw new OwlError("Cannot mount component: the target is not a valid DOM element");
-}
-class EventBus extends EventTarget {
-    trigger(name, payload) {
-        this.dispatchEvent(new CustomEvent(name, { detail: payload }));
-    }
-}
-function whenReady(fn) {
-    return new Promise(function (resolve) {
-        if (document.readyState !== "loading") {
-            resolve(true);
-        }
-        else {
-            document.addEventListener("DOMContentLoaded", resolve, false);
-        }
-    }).then(fn || function () { });
-}
-/*
- * This class just transports the fact that a string is safe
- * to be injected as HTML. Overriding a JS primitive is quite painful though
- * so we need to redfine toString and valueOf.
- */
-class Markup extends String {
-}
-function htmlEscape(str) {
-    if (str instanceof Markup) {
-        return str;
-    }
-    if (str === undefined) {
-        return markup("");
-    }
-    if (typeof str === "number") {
-        return markup(String(str));
-    }
-    [
-        ["&", "&"],
-        ["<", "&lt;"],
-        [">", "&gt;"],
-        ["'", "&#x27;"],
-        ['"', "&quot;"],
-        ["`", "&#x60;"],
-    ].forEach((pairs) => {
-        str = String(str).replace(new RegExp(pairs[0], "g"), pairs[1]);
-    });
-    return markup(str);
-}
-function markup(valueOrStrings, ...placeholders) {
-    if (!Array.isArray(valueOrStrings)) {
-        return new Markup(valueOrStrings);
-    }
-    const strings = valueOrStrings;
-    let acc = "";
-    let i = 0;
-    for (; i < placeholders.length; ++i) {
-        acc += strings[i] + htmlEscape(placeholders[i]);
-    }
-    acc += strings[i];
-    return new Markup(acc);
-}
-
-var ComputationState;
-(function (ComputationState) {
-    ComputationState[ComputationState["EXECUTED"] = 0] = "EXECUTED";
-    ComputationState[ComputationState["STALE"] = 1] = "STALE";
-    ComputationState[ComputationState["PENDING"] = 2] = "PENDING";
-})(ComputationState || (ComputationState = {}));
-let Effects;
-let CurrentComputation;
-// export function computed<T>(fn: () => T, opts?: Opts) {
-//   // todo: handle cleanup
-//   let computedComputation: Computation = {
-//     state: ComputationState.STALE,
-//     sources: new Set(),
-//     isEager: true,
-//     compute: () => {
-//       return fn();
-//     },
-//     value: undefined,
-//     name: opts?.name,
-//   };
-//   updateComputation(computedComputation);
-// }
-function onReadAtom(atom) {
-    if (!CurrentComputation)
-        return;
-    CurrentComputation.sources.add(atom);
-    atom.observers.add(CurrentComputation);
-}
-function onWriteAtom(atom) {
-    collectEffects(() => {
-        for (const ctx of atom.observers) {
-            if (ctx.state === ComputationState.EXECUTED) {
-                if (ctx.isDerived)
-                    markDownstream(ctx);
-                else
-                    Effects.push(ctx);
-            }
-            ctx.state = ComputationState.STALE;
-        }
-    });
-    batchProcessEffects();
-}
-function collectEffects(fn) {
-    if (Effects)
-        return fn();
-    Effects = [];
-    try {
-        return fn();
-    }
-    finally {
-    }
-}
-const batchProcessEffects = batched(processEffects);
-function processEffects() {
-    if (!Effects)
-        return;
-    for (const computation of Effects) {
-        updateComputation(computation);
-    }
-    Effects = undefined;
-}
-function untrack(fn) {
-    return runWithComputation(undefined, fn);
-}
-function getCurrentComputation() {
-    return CurrentComputation;
-}
-function setComputation(computation) {
-    CurrentComputation = computation;
-}
-// todo: should probably use updateComputation instead.
-function runWithComputation(computation, fn) {
-    const previousComputation = CurrentComputation;
-    CurrentComputation = computation;
-    let result;
-    try {
-        result = fn();
-    }
-    finally {
-        CurrentComputation = previousComputation;
-    }
-    return result;
-}
-function updateComputation(computation) {
-    var _a;
-    const state = computation.state;
-    if (state === ComputationState.EXECUTED)
-        return;
-    if (state === ComputationState.PENDING) {
-        computeSources(computation);
-        // If the state is still not stale after processing the sources, it means
-        // none of the dependencies have changed.
-        // todo: test it
-        if (computation.state !== ComputationState.STALE) {
-            computation.state = ComputationState.EXECUTED;
-            return;
-        }
-    }
-    // todo: test performance. We might want to avoid removing the atoms to
-    // directly re-add them at compute. Especially as we are making them stale.
-    removeSources(computation);
-    const previousComputation = CurrentComputation;
-    CurrentComputation = computation;
-    computation.value = (_a = computation.compute) === null || _a === void 0 ? void 0 : _a.call(computation);
-    computation.state = ComputationState.EXECUTED;
-    CurrentComputation = previousComputation;
-}
-function removeSources(computation) {
-    const sources = computation.sources;
-    for (const source of sources) {
-        const observers = source.observers;
-        observers.delete(computation);
-        // todo: if source has no effect observer anymore, remove its sources too
-        // todo: test it
-    }
-    sources.clear();
-}
-function markDownstream(derived) {
-    for (const observer of derived.observers) {
-        // if the state has already been marked, skip it
-        if (observer.state)
-            continue;
-        observer.state = ComputationState.PENDING;
-        if (observer.isDerived)
-            markDownstream(observer);
-        else
-            Effects.push(observer);
-    }
-}
-function computeSources(derived) {
-    for (const source of derived.sources) {
-        if (!("compute" in source))
-            continue;
-        updateComputation(source);
-    }
-}
-
-// Maps fibers to thrown errors
-const fibersInError = new WeakMap();
-const nodeErrorHandlers = new WeakMap();
-function destroyApp(app, error) {
-    try {
-        app.destroy();
-    }
-    catch (e) {
-        // mute all errors here because we are in a corrupted state anyway
-    }
-    const e = Object.assign(new OwlError(`[Owl] Unhandled error. Destroying the root component`), {
-        cause: error,
-    });
-    return e;
-}
-function _handleError(node, error) {
-    if (!node) {
-        return false;
-    }
-    const fiber = node.fiber;
-    if (fiber) {
-        fibersInError.set(fiber, error);
-    }
-    const errorHandlers = nodeErrorHandlers.get(node);
-    if (errorHandlers) {
-        let handled = false;
-        // execute in the opposite order
-        const finalize = () => destroyApp(node.app, error);
-        for (let i = errorHandlers.length - 1; i >= 0; i--) {
-            try {
-                errorHandlers[i](error, finalize);
-                handled = true;
-                break;
-            }
-            catch (e) {
-                error = e;
-            }
-        }
-        if (handled) {
-            return true;
-        }
-    }
-    return _handleError(node.parent, error);
-}
-function handleError(params) {
-    let { error } = params;
-    const node = "node" in params ? params.node : params.fiber.node;
-    const fiber = "fiber" in params ? params.fiber : node.fiber;
-    if (fiber) {
-        // resets the fibers on components if possible. This is important so that
-        // new renderings can be properly included in the initial one, if any.
-        let current = fiber;
-        do {
-            current.node.fiber = current;
-            current = current.parent;
-        } while (current);
-        fibersInError.set(fiber.root, error);
-    }
-    const handled = _handleError(node, error);
-    if (!handled) {
-        throw destroyApp(node.app, error);
-    }
-}
-
-function filterOutModifiersFromData(dataList) {
-    dataList = dataList.slice();
-    const modifiers = [];
-    let elm;
-    while ((elm = dataList[0]) && typeof elm === "string") {
-        modifiers.push(dataList.shift());
-    }
-    return { modifiers, data: dataList };
-}
-const config = {
-    // whether or not blockdom should normalize DOM whenever a block is created.
-    // Normalizing dom mean removing empty text nodes (or containing only spaces)
-    shouldNormalizeDom: true,
-    // this is the main event handler. Every event handler registered with blockdom
-    // will go through this function, giving it the data registered in the block
-    // and the event
-    mainEventHandler: (data, ev, currentTarget) => {
-        if (typeof data === "function") {
-            data(ev);
-        }
-        else if (Array.isArray(data)) {
-            data = filterOutModifiersFromData(data).data;
-            data[0](data[1], ev);
-        }
-        return false;
-    },
-};
-
-// -----------------------------------------------------------------------------
-// Toggler node
-// -----------------------------------------------------------------------------
-const txt = document.createTextNode("");
-class VToggler {
-    constructor(key, child) {
-        this.key = key;
-        this.child = child;
-    }
-    mount(parent, afterNode) {
-        this.parentEl = parent;
-        this.child.mount(parent, afterNode);
-    }
-    moveBeforeDOMNode(node, parent) {
-        this.child.moveBeforeDOMNode(node, parent);
-    }
-    moveBeforeVNode(other, afterNode) {
-        this.moveBeforeDOMNode((other && other.firstNode()) || afterNode);
-    }
-    patch(other, withBeforeRemove) {
-        if (this === other) {
-            return;
-        }
-        let child1 = this.child;
-        let child2 = other.child;
-        if (this.key === other.key) {
-            child1.patch(child2, withBeforeRemove);
-        }
-        else {
-            const firstNode = child1.firstNode();
-            firstNode.parentElement.insertBefore(txt, firstNode);
-            if (withBeforeRemove) {
-                child1.beforeRemove();
-            }
-            child1.remove();
-            child2.mount(this.parentEl, txt);
-            this.child = child2;
-            this.key = other.key;
-        }
-    }
-    beforeRemove() {
-        this.child.beforeRemove();
-    }
-    remove() {
-        this.child.remove();
-    }
-    firstNode() {
-        return this.child.firstNode();
-    }
-    toString() {
-        return this.child.toString();
-    }
-}
-function toggler(key, child) {
-    return new VToggler(key, child);
-}
-
-const { setAttribute: elemSetAttribute, removeAttribute } = Element.prototype;
-const tokenList = DOMTokenList.prototype;
-const tokenListAdd = tokenList.add;
-const tokenListRemove = tokenList.remove;
-const isArray = Array.isArray;
-const { split, trim } = String.prototype;
-const wordRegexp = /\s+/;
-/**
- * We regroup here all code related to updating attributes in a very loose sense:
- * attributes, properties and classs are all managed by the functions in this
- * file.
- */
-function setAttribute(key, value) {
-    switch (value) {
-        case false:
-        case undefined:
-            removeAttribute.call(this, key);
-            break;
-        case true:
-            elemSetAttribute.call(this, key, "");
-            break;
-        default:
-            elemSetAttribute.call(this, key, value);
-    }
-}
-function createAttrUpdater(attr) {
-    return function (value) {
-        setAttribute.call(this, attr, value);
-    };
-}
-function attrsSetter(attrs) {
-    if (isArray(attrs)) {
-        if (attrs[0] === "class") {
-            setClass.call(this, attrs[1]);
-        }
-        else {
-            setAttribute.call(this, attrs[0], attrs[1]);
-        }
-    }
-    else {
-        for (let k in attrs) {
-            if (k === "class") {
-                setClass.call(this, attrs[k]);
-            }
-            else {
-                setAttribute.call(this, k, attrs[k]);
-            }
-        }
-    }
-}
-function attrsUpdater(attrs, oldAttrs) {
-    if (isArray(attrs)) {
-        const name = attrs[0];
-        const val = attrs[1];
-        if (name === oldAttrs[0]) {
-            if (val === oldAttrs[1]) {
-                return;
-            }
-            if (name === "class") {
-                updateClass.call(this, val, oldAttrs[1]);
-            }
-            else {
-                setAttribute.call(this, name, val);
-            }
-        }
-        else {
-            removeAttribute.call(this, oldAttrs[0]);
-            setAttribute.call(this, name, val);
-        }
-    }
-    else {
-        for (let k in oldAttrs) {
-            if (!(k in attrs)) {
-                if (k === "class") {
-                    updateClass.call(this, "", oldAttrs[k]);
-                }
-                else {
-                    removeAttribute.call(this, k);
-                }
-            }
-        }
-        for (let k in attrs) {
-            const val = attrs[k];
-            if (val !== oldAttrs[k]) {
-                if (k === "class") {
-                    updateClass.call(this, val, oldAttrs[k]);
-                }
-                else {
-                    setAttribute.call(this, k, val);
-                }
-            }
-        }
-    }
-}
-function toClassObj(expr) {
-    const result = {};
-    switch (typeof expr) {
-        case "string":
-            // we transform here a list of classes into an object:
-            //  'hey you' becomes {hey: true, you: true}
-            const str = trim.call(expr);
-            if (!str) {
-                return {};
-            }
-            let words = split.call(str, wordRegexp);
-            for (let i = 0, l = words.length; i < l; i++) {
-                result[words[i]] = true;
-            }
-            return result;
-        case "object":
-            // this is already an object but we may need to split keys:
-            // {'a': true, 'b c': true} should become {a: true, b: true, c: true}
-            for (let key in expr) {
-                const value = expr[key];
-                if (value) {
-                    key = trim.call(key);
-                    if (!key) {
-                        continue;
-                    }
-                    const words = split.call(key, wordRegexp);
-                    for (let word of words) {
-                        result[word] = value;
-                    }
-                }
-            }
-            return result;
-        case "undefined":
-            return {};
-        case "number":
-            return { [expr]: true };
-        default:
-            return { [expr]: true };
-    }
-}
-function setClass(val) {
-    val = val === "" ? {} : toClassObj(val);
-    // add classes
-    const cl = this.classList;
-    for (let c in val) {
-        tokenListAdd.call(cl, c);
-    }
-}
-function updateClass(val, oldVal) {
-    oldVal = oldVal === "" ? {} : toClassObj(oldVal);
-    val = val === "" ? {} : toClassObj(val);
-    const cl = this.classList;
-    // remove classes
-    for (let c in oldVal) {
-        if (!(c in val)) {
-            tokenListRemove.call(cl, c);
-        }
-    }
-    // add classes
-    for (let c in val) {
-        if (!(c in oldVal)) {
-            tokenListAdd.call(cl, c);
-        }
-    }
-}
-
-function createEventHandler(rawEvent) {
-    const eventName = rawEvent.split(".")[0];
-    const capture = rawEvent.includes(".capture");
-    if (rawEvent.includes(".synthetic")) {
-        return createSyntheticHandler(eventName, capture);
-    }
-    else {
-        return createElementHandler(eventName, capture);
-    }
-}
-// Native listener
-let nextNativeEventId = 1;
-function createElementHandler(evName, capture = false) {
-    let eventKey = `__event__${evName}_${nextNativeEventId++}`;
-    if (capture) {
-        eventKey = `${eventKey}_capture`;
-    }
-    function listener(ev) {
-        const currentTarget = ev.currentTarget;
-        if (!currentTarget || !inOwnerDocument(currentTarget))
-            return;
-        const data = currentTarget[eventKey];
-        if (!data)
-            return;
-        config.mainEventHandler(data, ev, currentTarget);
-    }
-    function setup(data) {
-        this[eventKey] = data;
-        this.addEventListener(evName, listener, { capture });
-    }
-    function remove() {
-        delete this[eventKey];
-        this.removeEventListener(evName, listener, { capture });
-    }
-    function update(data) {
-        this[eventKey] = data;
-    }
-    return { setup, update, remove };
-}
-// Synthetic handler: a form of event delegation that allows placing only one
-// listener per event type.
-let nextSyntheticEventId = 1;
-function createSyntheticHandler(evName, capture = false) {
-    let eventKey = `__event__synthetic_${evName}`;
-    if (capture) {
-        eventKey = `${eventKey}_capture`;
-    }
-    setupSyntheticEvent(evName, eventKey, capture);
-    const currentId = nextSyntheticEventId++;
-    function setup(data) {
-        const _data = this[eventKey] || {};
-        _data[currentId] = data;
-        this[eventKey] = _data;
-    }
-    function remove() {
-        delete this[eventKey];
-    }
-    return { setup, update: setup, remove };
-}
-function nativeToSyntheticEvent(eventKey, event) {
-    let dom = event.target;
-    while (dom !== null) {
-        const _data = dom[eventKey];
-        if (_data) {
-            for (const data of Object.values(_data)) {
-                const stopped = config.mainEventHandler(data, event, dom);
-                if (stopped)
-                    return;
-            }
-        }
-        dom = dom.parentNode;
-    }
-}
-const CONFIGURED_SYNTHETIC_EVENTS = {};
-function setupSyntheticEvent(evName, eventKey, capture = false) {
-    if (CONFIGURED_SYNTHETIC_EVENTS[eventKey]) {
-        return;
-    }
-    document.addEventListener(evName, (event) => nativeToSyntheticEvent(eventKey, event), {
-        capture,
-    });
-    CONFIGURED_SYNTHETIC_EVENTS[eventKey] = true;
-}
-
-const getDescriptor$3 = (o, p) => Object.getOwnPropertyDescriptor(o, p);
-const nodeProto$4 = Node.prototype;
-const nodeInsertBefore$3 = nodeProto$4.insertBefore;
-const nodeSetTextContent$1 = getDescriptor$3(nodeProto$4, "textContent").set;
-const nodeRemoveChild$3 = nodeProto$4.removeChild;
-// -----------------------------------------------------------------------------
-// Multi NODE
-// -----------------------------------------------------------------------------
-class VMulti {
-    constructor(children) {
-        this.children = children;
-    }
-    mount(parent, afterNode) {
-        const children = this.children;
-        const l = children.length;
-        const anchors = new Array(l);
-        for (let i = 0; i < l; i++) {
-            let child = children[i];
-            if (child) {
-                child.mount(parent, afterNode);
-            }
-            else {
-                const childAnchor = document.createTextNode("");
-                anchors[i] = childAnchor;
-                nodeInsertBefore$3.call(parent, childAnchor, afterNode);
-            }
-        }
-        this.anchors = anchors;
-        this.parentEl = parent;
-    }
-    moveBeforeDOMNode(node, parent = this.parentEl) {
-        this.parentEl = parent;
-        const children = this.children;
-        const anchors = this.anchors;
-        for (let i = 0, l = children.length; i < l; i++) {
-            let child = children[i];
-            if (child) {
-                child.moveBeforeDOMNode(node, parent);
-            }
-            else {
-                const anchor = anchors[i];
-                nodeInsertBefore$3.call(parent, anchor, node);
-            }
-        }
-    }
-    moveBeforeVNode(other, afterNode) {
-        if (other) {
-            const next = other.children[0];
-            afterNode = (next ? next.firstNode() : other.anchors[0]) || null;
-        }
-        const children = this.children;
-        const parent = this.parentEl;
-        const anchors = this.anchors;
-        for (let i = 0, l = children.length; i < l; i++) {
-            let child = children[i];
-            if (child) {
-                child.moveBeforeVNode(null, afterNode);
-            }
-            else {
-                const anchor = anchors[i];
-                nodeInsertBefore$3.call(parent, anchor, afterNode);
-            }
-        }
-    }
-    patch(other, withBeforeRemove) {
-        if (this === other) {
-            return;
-        }
-        const children1 = this.children;
-        const children2 = other.children;
-        const anchors = this.anchors;
-        const parentEl = this.parentEl;
-        for (let i = 0, l = children1.length; i < l; i++) {
-            const vn1 = children1[i];
-            const vn2 = children2[i];
-            if (vn1) {
-                if (vn2) {
-                    vn1.patch(vn2, withBeforeRemove);
-                }
-                else {
-                    const afterNode = vn1.firstNode();
-                    const anchor = document.createTextNode("");
-                    anchors[i] = anchor;
-                    nodeInsertBefore$3.call(parentEl, anchor, afterNode);
-                    if (withBeforeRemove) {
-                        vn1.beforeRemove();
-                    }
-                    vn1.remove();
-                    children1[i] = undefined;
-                }
-            }
-            else if (vn2) {
-                children1[i] = vn2;
-                const anchor = anchors[i];
-                vn2.mount(parentEl, anchor);
-                nodeRemoveChild$3.call(parentEl, anchor);
-            }
-        }
-    }
-    beforeRemove() {
-        const children = this.children;
-        for (let i = 0, l = children.length; i < l; i++) {
-            const child = children[i];
-            if (child) {
-                child.beforeRemove();
-            }
-        }
-    }
-    remove() {
-        const parentEl = this.parentEl;
-        if (this.isOnlyChild) {
-            nodeSetTextContent$1.call(parentEl, "");
-        }
-        else {
-            const children = this.children;
-            const anchors = this.anchors;
-            for (let i = 0, l = children.length; i < l; i++) {
-                const child = children[i];
-                if (child) {
-                    child.remove();
-                }
-                else {
-                    nodeRemoveChild$3.call(parentEl, anchors[i]);
-                }
-            }
-        }
-    }
-    firstNode() {
-        const child = this.children[0];
-        return child ? child.firstNode() : this.anchors[0];
-    }
-    toString() {
-        return this.children.map((c) => (c ? c.toString() : "")).join("");
-    }
-}
-function multi(children) {
-    return new VMulti(children);
-}
-
-const getDescriptor$2 = (o, p) => Object.getOwnPropertyDescriptor(o, p);
-const nodeProto$3 = Node.prototype;
-const characterDataProto$1 = CharacterData.prototype;
-const nodeInsertBefore$2 = nodeProto$3.insertBefore;
-const characterDataSetData$1 = getDescriptor$2(characterDataProto$1, "data").set;
-const nodeRemoveChild$2 = nodeProto$3.removeChild;
-class VSimpleNode {
-    constructor(text) {
-        this.text = text;
-    }
-    mountNode(node, parent, afterNode) {
-        this.parentEl = parent;
-        nodeInsertBefore$2.call(parent, node, afterNode);
-        this.el = node;
-    }
-    moveBeforeDOMNode(node, parent = this.parentEl) {
-        this.parentEl = parent;
-        nodeInsertBefore$2.call(parent, this.el, node);
-    }
-    moveBeforeVNode(other, afterNode) {
-        nodeInsertBefore$2.call(this.parentEl, this.el, other ? other.el : afterNode);
-    }
-    beforeRemove() { }
-    remove() {
-        nodeRemoveChild$2.call(this.parentEl, this.el);
-    }
-    firstNode() {
-        return this.el;
-    }
-    toString() {
-        return this.text;
-    }
-}
-class VText$1 extends VSimpleNode {
-    mount(parent, afterNode) {
-        this.mountNode(document.createTextNode(toText(this.text)), parent, afterNode);
-    }
-    patch(other) {
-        const text2 = other.text;
-        if (this.text !== text2) {
-            characterDataSetData$1.call(this.el, toText(text2));
-            this.text = text2;
-        }
-    }
-}
-class VComment extends VSimpleNode {
-    mount(parent, afterNode) {
-        this.mountNode(document.createComment(toText(this.text)), parent, afterNode);
-    }
-    patch() { }
-}
-function text(str) {
-    return new VText$1(str);
-}
-function comment(str) {
-    return new VComment(str);
-}
-function toText(value) {
-    switch (typeof value) {
-        case "string":
-            return value;
-        case "number":
-            return String(value);
-        case "boolean":
-            return value ? "true" : "false";
-        default:
-            return value || "";
-    }
-}
-
-const getDescriptor$1 = (o, p) => Object.getOwnPropertyDescriptor(o, p);
-const nodeProto$2 = Node.prototype;
-const elementProto = Element.prototype;
-const characterDataProto = CharacterData.prototype;
-const characterDataSetData = getDescriptor$1(characterDataProto, "data").set;
-const nodeGetFirstChild = getDescriptor$1(nodeProto$2, "firstChild").get;
-const nodeGetNextSibling = getDescriptor$1(nodeProto$2, "nextSibling").get;
-const NO_OP = () => { };
-function makePropSetter(name) {
-    return function setProp(value) {
-        // support 0, fallback to empty string for other falsy values
-        this[name] = value === 0 ? 0 : value ? value.valueOf() : "";
-    };
-}
-const cache = {};
-/**
- * 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
- */
-function createBlock(str) {
-    if (str in cache) {
-        return cache[str];
-    }
-    // step 0: prepare html base element
-    const doc = new DOMParser().parseFromString(`<t>${str}</t>`, "text/xml");
-    const node = doc.firstChild.firstChild;
-    if (config.shouldNormalizeDom) {
-        normalizeNode(node);
-    }
-    // step 1: prepare intermediate tree
-    const tree = buildTree(node);
-    // step 2: prepare block context
-    const context = buildContext(tree);
-    // step 3: build the final block class
-    const template = tree.el;
-    const Block = buildBlock(template, context);
-    cache[str] = Block;
-    return Block;
-}
-// -----------------------------------------------------------------------------
-// Helper
-// -----------------------------------------------------------------------------
-function normalizeNode(node) {
-    if (node.nodeType === Node.TEXT_NODE) {
-        if (!/\S/.test(node.textContent)) {
-            node.remove();
-            return;
-        }
-    }
-    if (node.nodeType === Node.ELEMENT_NODE) {
-        if (node.tagName === "pre") {
-            return;
-        }
-    }
-    for (let i = node.childNodes.length - 1; i >= 0; --i) {
-        normalizeNode(node.childNodes.item(i));
-    }
-}
-function buildTree(node, parent = null, domParentTree = null) {
-    switch (node.nodeType) {
-        case Node.ELEMENT_NODE: {
-            // HTMLElement
-            let currentNS = domParentTree && domParentTree.currentNS;
-            const tagName = node.tagName;
-            let el = undefined;
-            const info = [];
-            if (tagName.startsWith("block-text-")) {
-                const index = parseInt(tagName.slice(11), 10);
-                info.push({ type: "text", idx: index });
-                el = document.createTextNode("");
-            }
-            if (tagName.startsWith("block-child-")) {
-                if (!domParentTree.isRef) {
-                    addRef(domParentTree);
-                }
-                const index = parseInt(tagName.slice(12), 10);
-                info.push({ type: "child", idx: index });
-                el = document.createTextNode("");
-            }
-            currentNS || (currentNS = node.namespaceURI);
-            if (!el) {
-                el = currentNS
-                    ? document.createElementNS(currentNS, tagName)
-                    : document.createElement(tagName);
-            }
-            if (el instanceof Element) {
-                if (!domParentTree) {
-                    // some html elements may have side effects when setting their attributes.
-                    // For example, setting the src attribute of an <img/> will trigger a
-                    // request to get the corresponding image. This is something that we
-                    // don't want at compile time. We avoid that by putting the content of
-                    // the block in a <template/> element
-                    const fragment = document.createElement("template").content;
-                    fragment.appendChild(el);
-                }
-                const attrs = node.attributes;
-                for (let i = 0; i < attrs.length; i++) {
-                    const attrName = attrs[i].name;
-                    const attrValue = attrs[i].value;
-                    if (attrName.startsWith("block-handler-")) {
-                        const idx = parseInt(attrName.slice(14), 10);
-                        info.push({
-                            type: "handler",
-                            idx,
-                            event: attrValue,
-                        });
-                    }
-                    else if (attrName.startsWith("block-attribute-")) {
-                        const idx = parseInt(attrName.slice(16), 10);
-                        info.push({
-                            type: "attribute",
-                            idx,
-                            name: attrValue,
-                            tag: tagName,
-                        });
-                    }
-                    else if (attrName.startsWith("block-property-")) {
-                        const idx = parseInt(attrName.slice(15), 10);
-                        info.push({
-                            type: "property",
-                            idx,
-                            name: attrValue,
-                            tag: tagName,
-                        });
-                    }
-                    else if (attrName === "block-attributes") {
-                        info.push({
-                            type: "attributes",
-                            idx: parseInt(attrValue, 10),
-                        });
-                    }
-                    else if (attrName === "block-ref") {
-                        info.push({
-                            type: "ref",
-                            idx: parseInt(attrValue, 10),
-                        });
-                    }
-                    else {
-                        el.setAttribute(attrs[i].name, attrValue);
-                    }
-                }
-            }
-            const tree = {
-                parent,
-                firstChild: null,
-                nextSibling: null,
-                el,
-                info,
-                refN: 0,
-                currentNS,
-            };
-            if (node.firstChild) {
-                const childNode = node.childNodes[0];
-                if (node.childNodes.length === 1 &&
-                    childNode.nodeType === Node.ELEMENT_NODE &&
-                    childNode.tagName.startsWith("block-child-")) {
-                    const tagName = childNode.tagName;
-                    const index = parseInt(tagName.slice(12), 10);
-                    info.push({ idx: index, type: "child", isOnlyChild: true });
-                }
-                else {
-                    tree.firstChild = buildTree(node.firstChild, tree, tree);
-                    el.appendChild(tree.firstChild.el);
-                    let curNode = node.firstChild;
-                    let curTree = tree.firstChild;
-                    while ((curNode = curNode.nextSibling)) {
-                        curTree.nextSibling = buildTree(curNode, curTree, tree);
-                        el.appendChild(curTree.nextSibling.el);
-                        curTree = curTree.nextSibling;
-                    }
-                }
-            }
-            if (tree.info.length) {
-                addRef(tree);
-            }
-            return tree;
-        }
-        case Node.TEXT_NODE:
-        case Node.COMMENT_NODE: {
-            // text node or comment node
-            const el = node.nodeType === Node.TEXT_NODE
-                ? document.createTextNode(node.textContent)
-                : document.createComment(node.textContent);
-            return {
-                parent: parent,
-                firstChild: null,
-                nextSibling: null,
-                el,
-                info: [],
-                refN: 0,
-                currentNS: null,
-            };
-        }
-    }
-    throw new OwlError("boom");
-}
-function addRef(tree) {
-    tree.isRef = true;
-    do {
-        tree.refN++;
-    } while ((tree = tree.parent));
-}
-function parentTree(tree) {
-    let parent = tree.parent;
-    while (parent && parent.nextSibling === tree) {
-        tree = parent;
-        parent = parent.parent;
-    }
-    return parent;
-}
-function buildContext(tree, ctx, fromIdx) {
-    if (!ctx) {
-        const children = new Array(tree.info.filter((v) => v.type === "child").length);
-        ctx = { collectors: [], locations: [], children, cbRefs: [], refN: tree.refN };
-        fromIdx = 0;
-    }
-    if (tree.refN) {
-        const initialIdx = fromIdx;
-        const isRef = tree.isRef;
-        const firstChild = tree.firstChild ? tree.firstChild.refN : 0;
-        const nextSibling = tree.nextSibling ? tree.nextSibling.refN : 0;
-        //node
-        if (isRef) {
-            for (let info of tree.info) {
-                info.refIdx = initialIdx;
-            }
-            tree.refIdx = initialIdx;
-            updateCtx(ctx, tree);
-            fromIdx++;
-        }
-        // right
-        if (nextSibling) {
-            const idx = fromIdx + firstChild;
-            ctx.collectors.push({ idx, prevIdx: initialIdx, getVal: nodeGetNextSibling });
-            buildContext(tree.nextSibling, ctx, idx);
-        }
-        // left
-        if (firstChild) {
-            ctx.collectors.push({ idx: fromIdx, prevIdx: initialIdx, getVal: nodeGetFirstChild });
-            buildContext(tree.firstChild, ctx, fromIdx);
-        }
-    }
-    return ctx;
-}
-function updateCtx(ctx, tree) {
-    for (let info of tree.info) {
-        switch (info.type) {
-            case "text":
-                ctx.locations.push({
-                    idx: info.idx,
-                    refIdx: info.refIdx,
-                    setData: setText,
-                    updateData: setText,
-                });
-                break;
-            case "child":
-                if (info.isOnlyChild) {
-                    // tree is the parentnode here
-                    ctx.children[info.idx] = {
-                        parentRefIdx: info.refIdx,
-                        isOnlyChild: true,
-                    };
-                }
-                else {
-                    // tree is the anchor text node
-                    ctx.children[info.idx] = {
-                        parentRefIdx: parentTree(tree).refIdx,
-                        afterRefIdx: info.refIdx,
-                    };
-                }
-                break;
-            case "property": {
-                const refIdx = info.refIdx;
-                const setProp = makePropSetter(info.name);
-                ctx.locations.push({
-                    idx: info.idx,
-                    refIdx,
-                    setData: setProp,
-                    updateData: setProp,
-                });
-                break;
-            }
-            case "attribute": {
-                const refIdx = info.refIdx;
-                let updater;
-                let setter;
-                if (info.name === "class") {
-                    setter = setClass;
-                    updater = updateClass;
-                }
-                else {
-                    setter = createAttrUpdater(info.name);
-                    updater = setter;
-                }
-                ctx.locations.push({
-                    idx: info.idx,
-                    refIdx,
-                    setData: setter,
-                    updateData: updater,
-                });
-                break;
-            }
-            case "attributes":
-                ctx.locations.push({
-                    idx: info.idx,
-                    refIdx: info.refIdx,
-                    setData: attrsSetter,
-                    updateData: attrsUpdater,
-                });
-                break;
-            case "handler": {
-                const { setup, update } = createEventHandler(info.event);
-                ctx.locations.push({
-                    idx: info.idx,
-                    refIdx: info.refIdx,
-                    setData: setup,
-                    updateData: update,
-                });
-                break;
-            }
-            case "ref": {
-                ctx.locations.push({
-                    idx: info.idx,
-                    refIdx: info.refIdx,
-                    setData: NO_OP,
-                    updateData: NO_OP,
-                });
-                ctx.cbRefs.push(info.idx);
-                break;
-            }
-        }
-    }
-}
-// -----------------------------------------------------------------------------
-// building the concrete block class
-// -----------------------------------------------------------------------------
-function buildBlock(template, ctx) {
-    let B = createBlockClass(template, ctx);
-    if (ctx.children.length) {
-        B = class extends B {
-            constructor(data, children) {
-                super(data);
-                this.children = children;
-            }
-        };
-        B.prototype.beforeRemove = VMulti.prototype.beforeRemove;
-        return (data, children = []) => new B(data, children);
-    }
-    return (data) => new B(data);
-}
-function createBlockClass(template, ctx) {
-    const { refN, collectors, children, locations, cbRefs } = ctx;
-    const colN = collectors.length;
-    locations.sort((a, b) => a.idx - b.idx);
-    const locN = locations.length;
-    const childN = children.length;
-    const childrenLocs = children;
-    const isDynamic = refN > 0;
-    // these values are defined here to make them faster to lookup in the class
-    // block scope
-    const nodeCloneNode = nodeProto$2.cloneNode;
-    const nodeInsertBefore = nodeProto$2.insertBefore;
-    const elementRemove = elementProto.remove;
-    class Block {
-        constructor(data) {
-            this.data = data;
-        }
-        beforeRemove() { }
-        remove() {
-            elementRemove.call(this.el);
-        }
-        firstNode() {
-            return this.el;
-        }
-        moveBeforeDOMNode(node, parent = this.parentEl) {
-            this.parentEl = parent;
-            nodeInsertBefore.call(parent, this.el, node);
-        }
-        moveBeforeVNode(other, afterNode) {
-            nodeInsertBefore.call(this.parentEl, this.el, other ? other.el : afterNode);
-        }
-        toString() {
-            const div = document.createElement("div");
-            this.mount(div, null);
-            return div.innerHTML;
-        }
-        mount(parent, afterNode) {
-            const el = nodeCloneNode.call(template, true);
-            nodeInsertBefore.call(parent, el, afterNode);
-            this.el = el;
-            this.parentEl = parent;
-        }
-        patch(other, withBeforeRemove) { }
-    }
-    if (isDynamic) {
-        Block.prototype.mount = function mount(parent, afterNode) {
-            const el = nodeCloneNode.call(template, true);
-            // collecting references
-            const refs = new Array(refN);
-            this.refs = refs;
-            refs[0] = el;
-            for (let i = 0; i < colN; i++) {
-                const w = collectors[i];
-                refs[w.idx] = w.getVal.call(refs[w.prevIdx]);
-            }
-            // applying data to all update points
-            if (locN) {
-                const data = this.data;
-                for (let i = 0; i < locN; i++) {
-                    const loc = locations[i];
-                    loc.setData.call(refs[loc.refIdx], data[i]);
-                }
-            }
-            nodeInsertBefore.call(parent, el, afterNode);
-            // preparing all children
-            if (childN) {
-                const children = this.children;
-                for (let i = 0; i < childN; i++) {
-                    const child = children[i];
-                    if (child) {
-                        const loc = childrenLocs[i];
-                        const afterNode = loc.afterRefIdx ? refs[loc.afterRefIdx] : null;
-                        child.isOnlyChild = loc.isOnlyChild;
-                        child.mount(refs[loc.parentRefIdx], afterNode);
-                    }
-                }
-            }
-            this.el = el;
-            this.parentEl = parent;
-            if (cbRefs.length) {
-                const data = this.data;
-                const refs = this.refs;
-                for (let cbRef of cbRefs) {
-                    const { idx, refIdx } = locations[cbRef];
-                    const fn = data[idx];
-                    fn(refs[refIdx], null);
-                }
-            }
-        };
-        Block.prototype.patch = function patch(other, withBeforeRemove) {
-            if (this === other) {
-                return;
-            }
-            const refs = this.refs;
-            // update texts/attributes/
-            if (locN) {
-                const data1 = this.data;
-                const data2 = other.data;
-                for (let i = 0; i < locN; i++) {
-                    const val1 = data1[i];
-                    const val2 = data2[i];
-                    if (val1 !== val2) {
-                        const loc = locations[i];
-                        loc.updateData.call(refs[loc.refIdx], val2, val1);
-                    }
-                }
-                this.data = data2;
-            }
-            // update children
-            if (childN) {
-                let children1 = this.children;
-                const children2 = other.children;
-                for (let i = 0; i < childN; i++) {
-                    const child1 = children1[i];
-                    const child2 = children2[i];
-                    if (child1) {
-                        if (child2) {
-                            child1.patch(child2, withBeforeRemove);
-                        }
-                        else {
-                            if (withBeforeRemove) {
-                                child1.beforeRemove();
-                            }
-                            child1.remove();
-                            children1[i] = undefined;
-                        }
-                    }
-                    else if (child2) {
-                        const loc = childrenLocs[i];
-                        const afterNode = loc.afterRefIdx ? refs[loc.afterRefIdx] : null;
-                        child2.mount(refs[loc.parentRefIdx], afterNode);
-                        children1[i] = child2;
-                    }
-                }
-            }
-        };
-        Block.prototype.remove = function remove() {
-            if (cbRefs.length) {
-                const data = this.data;
-                const refs = this.refs;
-                for (let cbRef of cbRefs) {
-                    const { idx, refIdx } = locations[cbRef];
-                    const fn = data[idx];
-                    fn(null, refs[refIdx]);
-                }
-            }
-            elementRemove.call(this.el);
-        };
-    }
-    return Block;
-}
-function setText(value) {
-    characterDataSetData.call(this, toText(value));
-}
-
-const getDescriptor = (o, p) => Object.getOwnPropertyDescriptor(o, p);
-const nodeProto$1 = Node.prototype;
-const nodeInsertBefore$1 = nodeProto$1.insertBefore;
-const nodeAppendChild = nodeProto$1.appendChild;
-const nodeRemoveChild$1 = nodeProto$1.removeChild;
-const nodeSetTextContent = getDescriptor(nodeProto$1, "textContent").set;
-// -----------------------------------------------------------------------------
-// List Node
-// -----------------------------------------------------------------------------
-class VList {
-    constructor(children) {
-        this.children = children;
-    }
-    mount(parent, afterNode) {
-        const children = this.children;
-        const _anchor = document.createTextNode("");
-        this.anchor = _anchor;
-        nodeInsertBefore$1.call(parent, _anchor, afterNode);
-        const l = children.length;
-        if (l) {
-            const mount = children[0].mount;
-            for (let i = 0; i < l; i++) {
-                mount.call(children[i], parent, _anchor);
-            }
-        }
-        this.parentEl = parent;
-    }
-    moveBeforeDOMNode(node, parent = this.parentEl) {
-        this.parentEl = parent;
-        const children = this.children;
-        for (let i = 0, l = children.length; i < l; i++) {
-            children[i].moveBeforeDOMNode(node, parent);
-        }
-        parent.insertBefore(this.anchor, node);
-    }
-    moveBeforeVNode(other, afterNode) {
-        if (other) {
-            const next = other.children[0];
-            afterNode = (next ? next.firstNode() : other.anchor) || null;
-        }
-        const children = this.children;
-        for (let i = 0, l = children.length; i < l; i++) {
-            children[i].moveBeforeVNode(null, afterNode);
-        }
-        this.parentEl.insertBefore(this.anchor, afterNode);
-    }
-    patch(other, withBeforeRemove) {
-        if (this === other) {
-            return;
-        }
-        const ch1 = this.children;
-        const ch2 = other.children;
-        if (ch2.length === 0 && ch1.length === 0) {
-            return;
-        }
-        this.children = ch2;
-        const proto = ch2[0] || ch1[0];
-        const { mount: cMount, patch: cPatch, remove: cRemove, beforeRemove, moveBeforeVNode: cMoveBefore, firstNode: cFirstNode, } = proto;
-        const _anchor = this.anchor;
-        const isOnlyChild = this.isOnlyChild;
-        const parent = this.parentEl;
-        // fast path: no new child => only remove
-        if (ch2.length === 0 && isOnlyChild) {
-            if (withBeforeRemove) {
-                for (let i = 0, l = ch1.length; i < l; i++) {
-                    beforeRemove.call(ch1[i]);
-                }
-            }
-            nodeSetTextContent.call(parent, "");
-            nodeAppendChild.call(parent, _anchor);
-            return;
-        }
-        let startIdx1 = 0;
-        let startIdx2 = 0;
-        let startVn1 = ch1[0];
-        let startVn2 = ch2[0];
-        let endIdx1 = ch1.length - 1;
-        let endIdx2 = ch2.length - 1;
-        let endVn1 = ch1[endIdx1];
-        let endVn2 = ch2[endIdx2];
-        let mapping = undefined;
-        while (startIdx1 <= endIdx1 && startIdx2 <= endIdx2) {
-            // -------------------------------------------------------------------
-            if (startVn1 === null) {
-                startVn1 = ch1[++startIdx1];
-                continue;
-            }
-            // -------------------------------------------------------------------
-            if (endVn1 === null) {
-                endVn1 = ch1[--endIdx1];
-                continue;
-            }
-            // -------------------------------------------------------------------
-            let startKey1 = startVn1.key;
-            let startKey2 = startVn2.key;
-            if (startKey1 === startKey2) {
-                cPatch.call(startVn1, startVn2, withBeforeRemove);
-                ch2[startIdx2] = startVn1;
-                startVn1 = ch1[++startIdx1];
-                startVn2 = ch2[++startIdx2];
-                continue;
-            }
-            // -------------------------------------------------------------------
-            let endKey1 = endVn1.key;
-            let endKey2 = endVn2.key;
-            if (endKey1 === endKey2) {
-                cPatch.call(endVn1, endVn2, withBeforeRemove);
-                ch2[endIdx2] = endVn1;
-                endVn1 = ch1[--endIdx1];
-                endVn2 = ch2[--endIdx2];
-                continue;
-            }
-            // -------------------------------------------------------------------
-            if (startKey1 === endKey2) {
-                // bnode moved right
-                cPatch.call(startVn1, endVn2, withBeforeRemove);
-                ch2[endIdx2] = startVn1;
-                const nextChild = ch2[endIdx2 + 1];
-                cMoveBefore.call(startVn1, nextChild, _anchor);
-                startVn1 = ch1[++startIdx1];
-                endVn2 = ch2[--endIdx2];
-                continue;
-            }
-            // -------------------------------------------------------------------
-            if (endKey1 === startKey2) {
-                // bnode moved left
-                cPatch.call(endVn1, startVn2, withBeforeRemove);
-                ch2[startIdx2] = endVn1;
-                const nextChild = ch1[startIdx1];
-                cMoveBefore.call(endVn1, nextChild, _anchor);
-                endVn1 = ch1[--endIdx1];
-                startVn2 = ch2[++startIdx2];
-                continue;
-            }
-            // -------------------------------------------------------------------
-            mapping = mapping || createMapping(ch1, startIdx1, endIdx1);
-            let idxInOld = mapping[startKey2];
-            if (idxInOld === undefined) {
-                cMount.call(startVn2, parent, cFirstNode.call(startVn1) || null);
-            }
-            else {
-                const elmToMove = ch1[idxInOld];
-                cMoveBefore.call(elmToMove, startVn1, null);
-                cPatch.call(elmToMove, startVn2, withBeforeRemove);
-                ch2[startIdx2] = elmToMove;
-                ch1[idxInOld] = null;
-            }
-            startVn2 = ch2[++startIdx2];
-        }
-        // ---------------------------------------------------------------------
-        if (startIdx1 <= endIdx1 || startIdx2 <= endIdx2) {
-            if (startIdx1 > endIdx1) {
-                const nextChild = ch2[endIdx2 + 1];
-                const anchor = nextChild ? cFirstNode.call(nextChild) || null : _anchor;
-                for (let i = startIdx2; i <= endIdx2; i++) {
-                    cMount.call(ch2[i], parent, anchor);
-                }
-            }
-            else {
-                for (let i = startIdx1; i <= endIdx1; i++) {
-                    let ch = ch1[i];
-                    if (ch) {
-                        if (withBeforeRemove) {
-                            beforeRemove.call(ch);
-                        }
-                        cRemove.call(ch);
-                    }
-                }
-            }
-        }
-    }
-    beforeRemove() {
-        const children = this.children;
-        const l = children.length;
-        if (l) {
-            const beforeRemove = children[0].beforeRemove;
-            for (let i = 0; i < l; i++) {
-                beforeRemove.call(children[i]);
-            }
-        }
-    }
-    remove() {
-        const { parentEl, anchor } = this;
-        if (this.isOnlyChild) {
-            nodeSetTextContent.call(parentEl, "");
-        }
-        else {
-            const children = this.children;
-            const l = children.length;
-            if (l) {
-                const remove = children[0].remove;
-                for (let i = 0; i < l; i++) {
-                    remove.call(children[i]);
-                }
-            }
-            nodeRemoveChild$1.call(parentEl, anchor);
-        }
-    }
-    firstNode() {
-        const child = this.children[0];
-        return child ? child.firstNode() : undefined;
-    }
-    toString() {
-        return this.children.map((c) => c.toString()).join("");
-    }
-}
-function list(children) {
-    return new VList(children);
-}
-function createMapping(ch1, startIdx1, endIdx2) {
-    let mapping = {};
-    for (let i = startIdx1; i <= endIdx2; i++) {
-        mapping[ch1[i].key] = i;
-    }
-    return mapping;
-}
-
-const nodeProto = Node.prototype;
-const nodeInsertBefore = nodeProto.insertBefore;
-const nodeRemoveChild = nodeProto.removeChild;
-class VHtml {
-    constructor(html) {
-        this.content = [];
-        this.html = html;
-    }
-    mount(parent, afterNode) {
-        this.parentEl = parent;
-        const template = document.createElement("template");
-        template.innerHTML = this.html;
-        this.content = [...template.content.childNodes];
-        for (let elem of this.content) {
-            nodeInsertBefore.call(parent, elem, afterNode);
-        }
-        if (!this.content.length) {
-            const textNode = document.createTextNode("");
-            this.content.push(textNode);
-            nodeInsertBefore.call(parent, textNode, afterNode);
-        }
-    }
-    moveBeforeDOMNode(node, parent = this.parentEl) {
-        this.parentEl = parent;
-        for (let elem of this.content) {
-            nodeInsertBefore.call(parent, elem, node);
-        }
-    }
-    moveBeforeVNode(other, afterNode) {
-        const target = other ? other.content[0] : afterNode;
-        this.moveBeforeDOMNode(target);
-    }
-    patch(other) {
-        if (this === other) {
-            return;
-        }
-        const html2 = other.html;
-        if (this.html !== html2) {
-            const parent = this.parentEl;
-            // insert new html in front of current
-            const afterNode = this.content[0];
-            const template = document.createElement("template");
-            template.innerHTML = html2;
-            const content = [...template.content.childNodes];
-            for (let elem of content) {
-                nodeInsertBefore.call(parent, elem, afterNode);
-            }
-            if (!content.length) {
-                const textNode = document.createTextNode("");
-                content.push(textNode);
-                nodeInsertBefore.call(parent, textNode, afterNode);
-            }
-            // remove current content
-            this.remove();
-            this.content = content;
-            this.html = other.html;
-        }
-    }
-    beforeRemove() { }
-    remove() {
-        const parent = this.parentEl;
-        for (let elem of this.content) {
-            nodeRemoveChild.call(parent, elem);
-        }
-    }
-    firstNode() {
-        return this.content[0];
-    }
-    toString() {
-        return this.html;
-    }
-}
-function html(str) {
-    return new VHtml(str);
-}
-
-function createCatcher(eventsSpec) {
-    const n = Object.keys(eventsSpec).length;
-    class VCatcher {
-        constructor(child, handlers) {
-            this.handlerFns = [];
-            this.afterNode = null;
-            this.child = child;
-            this.handlerData = handlers;
-        }
-        mount(parent, afterNode) {
-            this.parentEl = parent;
-            this.child.mount(parent, afterNode);
-            this.afterNode = document.createTextNode("");
-            parent.insertBefore(this.afterNode, afterNode);
-            this.wrapHandlerData();
-            for (let name in eventsSpec) {
-                const index = eventsSpec[name];
-                const handler = createEventHandler(name);
-                this.handlerFns[index] = handler;
-                handler.setup.call(parent, this.handlerData[index]);
-            }
-        }
-        wrapHandlerData() {
-            for (let i = 0; i < n; i++) {
-                let handler = this.handlerData[i];
-                // handler = [...mods, fn, comp], so we need to replace second to last elem
-                let idx = handler.length - 2;
-                let origFn = handler[idx];
-                const self = this;
-                handler[idx] = function (ev) {
-                    const target = ev.target;
-                    let currentNode = self.child.firstNode();
-                    const afterNode = self.afterNode;
-                    while (currentNode && currentNode !== afterNode) {
-                        if (currentNode.contains(target)) {
-                            return origFn.call(this, ev);
-                        }
-                        currentNode = currentNode.nextSibling;
-                    }
-                };
-            }
-        }
-        moveBeforeDOMNode(node, parent = this.parentEl) {
-            this.parentEl = parent;
-            this.child.moveBeforeDOMNode(node, parent);
-            parent.insertBefore(this.afterNode, node);
-        }
-        moveBeforeVNode(other, afterNode) {
-            if (other) {
-                // check this with @ged-odoo for use in foreach
-                afterNode = other.firstNode() || afterNode;
-            }
-            this.child.moveBeforeVNode(other ? other.child : null, afterNode);
-            this.parentEl.insertBefore(this.afterNode, afterNode);
-        }
-        patch(other, withBeforeRemove) {
-            if (this === other) {
-                return;
-            }
-            this.handlerData = other.handlerData;
-            this.wrapHandlerData();
-            for (let i = 0; i < n; i++) {
-                this.handlerFns[i].update.call(this.parentEl, this.handlerData[i]);
-            }
-            this.child.patch(other.child, withBeforeRemove);
-        }
-        beforeRemove() {
-            this.child.beforeRemove();
-        }
-        remove() {
-            for (let i = 0; i < n; i++) {
-                this.handlerFns[i].remove.call(this.parentEl);
-            }
-            this.child.remove();
-            this.afterNode.remove();
-        }
-        firstNode() {
-            return this.child.firstNode();
-        }
-        toString() {
-            return this.child.toString();
-        }
-    }
-    return function (child, handlers) {
-        return new VCatcher(child, handlers);
-    };
-}
-
-function mount$1(vnode, fixture, afterNode = null) {
-    vnode.mount(fixture, afterNode);
-}
-function patch(vnode1, vnode2, withBeforeRemove = false) {
-    vnode1.patch(vnode2, withBeforeRemove);
-}
-function remove(vnode, withBeforeRemove = false) {
-    if (withBeforeRemove) {
-        vnode.beforeRemove();
-    }
-    vnode.remove();
-}
-
-function makeRootFiber(node) {
-    let current = node.fiber;
-    if (current) {
-        let root = current.root;
-        // lock root fiber because canceling children fibers may destroy components,
-        // which means any arbitrary code can be run in onWillDestroy, which may
-        // trigger new renderings
-        root.locked = true;
-        root.setCounter(root.counter + 1 - cancelFibers(current.children));
-        root.locked = false;
-        current.children = [];
-        current.childrenMap = {};
-        current.bdom = null;
-        if (fibersInError.has(current)) {
-            fibersInError.delete(current);
-            fibersInError.delete(root);
-            current.appliedToDom = false;
-            if (current instanceof RootFiber) {
-                // it is possible that this fiber is a fiber that crashed while being
-                // mounted, so the mounted list is possibly corrupted. We restore it to
-                // its normal initial state (which is empty list or a list with a mount
-                // fiber.
-                current.mounted = current instanceof MountFiber ? [current] : [];
-            }
-        }
-        return current;
-    }
-    const fiber = new RootFiber(node, null);
-    if (node.willPatch.length) {
-        fiber.willPatch.push(fiber);
-    }
-    if (node.patched.length) {
-        fiber.patched.push(fiber);
-    }
-    return fiber;
-}
-function throwOnRender() {
-    throw new OwlError("Attempted to render cancelled fiber");
-}
-/**
- * @returns number of not-yet rendered fibers cancelled
- */
-function cancelFibers(fibers) {
-    let result = 0;
-    for (let fiber of fibers) {
-        let node = fiber.node;
-        fiber.render = throwOnRender;
-        if (node.status === 0 /* STATUS.NEW */) {
-            node.cancel();
-        }
-        node.fiber = null;
-        if (fiber.bdom) {
-            // if fiber has been rendered, this means that the component props have
-            // been updated. however, this fiber will not be patched to the dom, so
-            // it could happen that the next render compare the current props with
-            // the same props, and skip the render completely. With the next line,
-            // we kindly request the component code to force a render, so it works as
-            // expected.
-            node.forceNextRender = true;
-        }
-        else {
-            result++;
-        }
-        result += cancelFibers(fiber.children);
-    }
-    return result;
-}
-class Fiber {
-    constructor(node, parent) {
-        this.bdom = null;
-        this.children = [];
-        this.appliedToDom = false;
-        this.childrenMap = {};
-        this.node = node;
-        this.parent = parent;
-        if (parent) {
-            const root = parent.root;
-            root.setCounter(root.counter + 1);
-            this.root = root;
-            parent.children.push(this);
-        }
-        else {
-            this.root = this;
-        }
-    }
-    render() {
-        // if some parent has a fiber => register in followup
-        let prev = this.root.node;
-        let scheduler = prev.app.scheduler;
-        let current = prev.parent;
-        while (current) {
-            if (current.fiber) {
-                let root = current.fiber.root;
-                if (root.counter === 0 && prev.parentKey in current.fiber.childrenMap) {
-                    current = root.node;
-                }
-                else {
-                    scheduler.delayedRenders.push(this);
-                    return;
-                }
-            }
-            prev = current;
-            current = current.parent;
-        }
-        // there are no current rendering from above => we can render
-        this._render();
-    }
-    _render() {
-        const node = this.node;
-        const root = this.root;
-        if (root) {
-            // todo: should use updateComputation somewhere else.
-            runWithComputation(node.signalComputation, () => {
-                try {
-                    this.bdom = true;
-                    this.bdom = node.renderFn();
-                }
-                catch (e) {
-                    node.app.handleError({ node, error: e });
-                }
-            });
-            root.setCounter(root.counter - 1);
-        }
-    }
-}
-class RootFiber extends Fiber {
-    constructor() {
-        super(...arguments);
-        this.counter = 1;
-        // only add stuff in this if they have registered some hooks
-        this.willPatch = [];
-        this.patched = [];
-        this.mounted = [];
-        // A fiber is typically locked when it is completing and the patch has not, or is being applied.
-        // i.e.: render triggered in onWillUnmount or in willPatch will be delayed
-        this.locked = false;
-    }
-    complete() {
-        const node = this.node;
-        this.locked = true;
-        let current = undefined;
-        let mountedFibers = this.mounted;
-        try {
-            // Step 1: calling all willPatch lifecycle hooks
-            for (current of this.willPatch) {
-                // because of the asynchronous nature of the rendering, some parts of the
-                // UI may have been rendered, then deleted in a followup rendering, and we
-                // do not want to call onWillPatch in that case.
-                let node = current.node;
-                if (node.fiber === current) {
-                    const component = node.component;
-                    for (let cb of node.willPatch) {
-                        cb.call(component);
-                    }
-                }
-            }
-            current = undefined;
-            // Step 2: patching the dom
-            node._patch();
-            this.locked = false;
-            // Step 4: calling all mounted lifecycle hooks
-            while ((current = mountedFibers.pop())) {
-                current = current;
-                if (current.appliedToDom) {
-                    for (let cb of current.node.mounted) {
-                        cb();
-                    }
-                }
-            }
-            // Step 5: calling all patched hooks
-            let patchedFibers = this.patched;
-            while ((current = patchedFibers.pop())) {
-                current = current;
-                if (current.appliedToDom) {
-                    for (let cb of current.node.patched) {
-                        cb();
-                    }
-                }
-            }
-        }
-        catch (e) {
-            // if mountedFibers is not empty, this means that a crash occured while
-            // calling the mounted hooks of some component. So, there may still be
-            // some component that have been mounted, but for which the mounted hooks
-            // have not been called. Here, we remove the willUnmount hooks for these
-            // specific component to prevent a worse situation (willUnmount being
-            // called even though mounted has not been called)
-            for (let fiber of mountedFibers) {
-                fiber.node.willUnmount = [];
-            }
-            this.locked = false;
-            node.app.handleError({ fiber: current || this, error: e });
-        }
-    }
-    setCounter(newValue) {
-        this.counter = newValue;
-        if (newValue === 0) {
-            this.node.app.scheduler.flush();
-        }
-    }
-}
-class MountFiber extends RootFiber {
-    constructor(node, target, options = {}) {
-        super(node, null);
-        this.target = target;
-        this.position = options.position || "last-child";
-    }
-    complete() {
-        let current = this;
-        try {
-            const node = this.node;
-            node.children = this.childrenMap;
-            node.app.constructor.validateTarget(this.target);
-            if (node.bdom) {
-                // this is a complicated situation: if we mount a fiber with an existing
-                // bdom, this means that this same fiber was already completed, mounted,
-                // but a crash occurred in some mounted hook. Then, it was handled and
-                // the new rendering is being applied.
-                node.updateDom();
-            }
-            else {
-                node.bdom = this.bdom;
-                if (this.position === "last-child" || this.target.childNodes.length === 0) {
-                    mount$1(node.bdom, this.target);
-                }
-                else {
-                    const firstChild = this.target.childNodes[0];
-                    mount$1(node.bdom, this.target, firstChild);
-                }
-            }
-            // unregistering the fiber before mounted since it can do another render
-            // and that the current rendering is obviously completed
-            node.fiber = null;
-            node.status = 1 /* STATUS.MOUNTED */;
-            this.appliedToDom = true;
-            let mountedFibers = this.mounted;
-            while ((current = mountedFibers.pop())) {
-                if (current.appliedToDom) {
-                    for (let cb of current.node.mounted) {
-                        cb();
-                    }
-                }
-            }
-        }
-        catch (e) {
-            this.node.app.handleError({ fiber: current, error: e });
-        }
-    }
-}
-
-let currentNode = null;
-function saveCurrent() {
-    let n = currentNode;
-    return () => {
-        currentNode = n;
-    };
-}
-function getCurrent() {
-    if (!currentNode) {
-        throw new OwlError("No active component (a hook function should only be called in 'setup')");
-    }
-    return currentNode;
-}
-function useComponent() {
-    return currentNode.component;
-}
-class ComponentNode {
-    constructor(C, props, app, parent, parentKey) {
-        this.fiber = null;
-        this.bdom = null;
-        this.status = 0 /* STATUS.NEW */;
-        this.forceNextRender = false;
-        this.children = Object.create(null);
-        this.willStart = [];
-        this.willUnmount = [];
-        this.mounted = [];
-        this.willPatch = [];
-        this.patched = [];
-        this.willDestroy = [];
-        this.name = C.name;
-        currentNode = this;
-        this.app = app;
-        this.parent = parent;
-        this.parentKey = parentKey;
-        this.pluginManager = parent ? parent.pluginManager : app.pluginManager;
-        this.signalComputation = {
-            value: undefined,
-            compute: () => this.render(false),
-            sources: new Set(),
-            state: ComputationState.EXECUTED,
-        };
-        this.props = Object.assign({}, props);
-        const previousComputation = getCurrentComputation();
-        setComputation(undefined);
-        this.component = new C(this);
-        const ctx = { this: this.component, __owl__: this };
-        this.renderFn = app.getTemplate(C.template).bind(this.component, ctx, this);
-        this.component.setup();
-        setComputation(previousComputation);
-        currentNode = null;
-    }
-    mountComponent(target, options) {
-        const fiber = new MountFiber(this, target, options);
-        this.app.scheduler.addFiber(fiber);
-        this.initiateRender(fiber);
-    }
-    async initiateRender(fiber) {
-        this.fiber = fiber;
-        if (this.mounted.length) {
-            fiber.root.mounted.push(fiber);
-        }
-        const component = this.component;
-        try {
-            let promises;
-            runWithComputation(undefined, () => {
-                promises = this.willStart.map((f) => f.call(component));
-            });
-            await Promise.all(promises);
-        }
-        catch (e) {
-            this.app.handleError({ node: this, error: e });
-            return;
-        }
-        if (this.status === 0 /* STATUS.NEW */ && this.fiber === fiber) {
-            fiber.render();
-        }
-    }
-    async render(deep) {
-        if (this.status >= 2 /* STATUS.CANCELLED */) {
-            return;
-        }
-        let current = this.fiber;
-        if (current && (current.root.locked || current.bdom === true)) {
-            await Promise.resolve();
-            // situation may have changed after the microtask tick
-            current = this.fiber;
-        }
-        if ((current && !current.bdom && !fibersInError.has(current)) || (!current && !this.bdom)) {
-            return;
-        }
-        const fiber = makeRootFiber(this);
-        this.fiber = fiber;
-        this.app.scheduler.addFiber(fiber);
-        await Promise.resolve();
-        if (this.status >= 2 /* STATUS.CANCELLED */) {
-            return;
-        }
-        // We only want to actually render the component if the following two
-        // conditions are true:
-        // * this.fiber: it could be null, in which case the render has been cancelled
-        // * (current || !fiber.parent): if current is not null, this means that the
-        //   render function was called when a render was already occurring. In this
-        //   case, the pending rendering was cancelled, and the fiber needs to be
-        //   rendered to complete the work.  If current is null, we check that the
-        //   fiber has no parent.  If that is the case, the fiber was downgraded from
-        //   a root fiber to a child fiber in the previous microtick, because it was
-        //   embedded in a rendering coming from above, so the fiber will be rendered
-        //   in the next microtick anyway, so we should not render it again.
-        if (this.fiber === fiber && (current || !fiber.parent)) {
-            fiber.render();
-        }
-    }
-    cancel() {
-        this._cancel();
-        delete this.parent.children[this.parentKey];
-        this.app.scheduler.scheduleDestroy(this);
-    }
-    _cancel() {
-        this.status = 2 /* STATUS.CANCELLED */;
-        const children = this.children;
-        for (let childKey in children) {
-            children[childKey]._cancel();
-        }
-    }
-    destroy() {
-        let shouldRemove = this.status === 1 /* STATUS.MOUNTED */;
-        this._destroy();
-        if (shouldRemove) {
-            this.bdom.remove();
-        }
-    }
-    _destroy() {
-        const component = this.component;
-        if (this.status === 1 /* STATUS.MOUNTED */) {
-            for (let cb of this.willUnmount) {
-                cb.call(component);
-            }
-        }
-        for (let child of Object.values(this.children)) {
-            child._destroy();
-        }
-        if (this.willDestroy.length) {
-            try {
-                for (let cb of this.willDestroy) {
-                    cb.call(component);
-                }
-            }
-            catch (e) {
-                this.app.handleError({ error: e, node: this });
-            }
-        }
-        this.status = 3 /* STATUS.DESTROYED */;
-    }
-    /**
-     * Finds a child that has dom that is not yet updated, and update it. This
-     * method is meant to be used only in the context of repatching the dom after
-     * a mounted hook failed and was handled.
-     */
-    updateDom() {
-        if (!this.fiber) {
-            return;
-        }
-        if (this.bdom === this.fiber.bdom) {
-            // If the error was handled by some child component, we need to find it to
-            // apply its change
-            for (let k in this.children) {
-                const child = this.children[k];
-                child.updateDom();
-            }
-        }
-        else {
-            // if we get here, this is the component that handled the error and rerendered
-            // itself, so we can simply patch the dom
-            this.bdom.patch(this.fiber.bdom, false);
-            this.fiber.appliedToDom = true;
-            this.fiber = null;
-        }
-    }
-    // ---------------------------------------------------------------------------
-    // Block DOM methods
-    // ---------------------------------------------------------------------------
-    firstNode() {
-        const bdom = this.bdom;
-        return bdom ? bdom.firstNode() : undefined;
-    }
-    mount(parent, anchor) {
-        const bdom = this.fiber.bdom;
-        this.bdom = bdom;
-        bdom.mount(parent, anchor);
-        this.status = 1 /* STATUS.MOUNTED */;
-        this.fiber.appliedToDom = true;
-        this.children = this.fiber.childrenMap;
-        this.fiber = null;
-    }
-    moveBeforeDOMNode(node, parent) {
-        this.bdom.moveBeforeDOMNode(node, parent);
-    }
-    moveBeforeVNode(other, afterNode) {
-        this.bdom.moveBeforeVNode(other ? other.bdom : null, afterNode);
-    }
-    patch() {
-        if (this.fiber && this.fiber.parent) {
-            // we only patch here renderings coming from above. renderings initiated
-            // by the component will be patched independently in the appropriate
-            // fiber.complete
-            this._patch();
-        }
-    }
-    _patch() {
-        let hasChildren = false;
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        for (let _k in this.children) {
-            hasChildren = true;
-            break;
-        }
-        const fiber = this.fiber;
-        this.children = fiber.childrenMap;
-        this.bdom.patch(fiber.bdom, hasChildren);
-        fiber.appliedToDom = true;
-        this.fiber = null;
-    }
-    beforeRemove() {
-        this._destroy();
-    }
-    remove() {
-        this.bdom.remove();
-    }
-}
-
-function assertType(value, validation) {
-    const issues = validateType(value, validation);
-    if (issues.length) {
-        const issueStrings = JSON.stringify(issues, (key, value) => {
-            if (typeof value === "function") {
-                return value.name;
-            }
-            return value;
-        }, 2);
-        throw new OwlError(`Value does not match the type\n${issueStrings}`);
-    }
-}
-function validateType(value, validation) {
-    return validation(value);
-}
-
-const any = function () {
-    return [];
-};
-const boolean = function validateBoolean(value) {
-    if (typeof value !== "boolean") {
-        return [{ type: "type", expected: Boolean, received: value }];
-    }
-    return [];
-};
-const number = function validateNumber(value) {
-    if (typeof value !== "number") {
-        return [{ type: "type", expected: Number, received: value }];
-    }
-    return [];
-};
-const string = function validateString(value) {
-    if (typeof value !== "string") {
-        return [{ type: "type", expected: String, received: value }];
-    }
-    return [];
-};
-function array(type) {
-    return function validateArray(value) {
-        if (!Array.isArray(value)) {
-            return [{ type: "type", expected: Array, received: value }];
-        }
-        if (type) {
-            return value.flatMap((element) => validateType(element, type));
-        }
-        return [];
-    };
-}
-function func(parameters, result) {
-    return function validateFunction(value) {
-        if (typeof value !== "function") {
-            return [{ type: "type", expected: Function, received: value }];
-        }
-        return [];
-    };
-}
-function instanceOf(type) {
-    return function validateInstanceOf(value) {
-        if (!(value instanceof type)) {
-            return [{ type: "type", expected: type, received: value }];
-        }
-        return [];
-    };
-}
-function keys(...keys) {
-    return function validateKeys(value) {
-        if (typeof value !== "object") {
-            return [{ type: "type", expected: Object, received: value }];
-        }
-        const valueKeys = Object.keys(value);
-        const missingKeys = keys.filter((key) => {
-            if (key.endsWith("?")) {
-                return true;
-            }
-            return !valueKeys.includes(key);
-        });
-        if (missingKeys.length) {
-            return [{ type: "missing keys", value, missingKeys }];
-        }
-        return [];
-    };
-}
-function literal(literal) {
-    return function validateLiteral(value) {
-        if (value !== literal) {
-            return [{ type: "exact value", expected: literal, received: value }];
-        }
-        return [];
-    };
-}
-function object(shape) {
-    return function validateObject(value) {
-        if (typeof value !== "object") {
-            return [{ type: "type", expected: Object, received: value }];
-        }
-        if (shape) {
-            const missingKeys = [];
-            const issues = [];
-            for (let key in shape) {
-                const subIssues = validateType(value[key], shape[key]);
-                if (key in value) {
-                    issues.push(...subIssues);
-                }
-                else {
-                    missingKeys.push(key);
-                }
-            }
-            if (missingKeys.length) {
-                issues.push({ type: "missing keys", value, missingKeys });
-            }
-            return issues;
-        }
-        return [];
-    };
-}
-function optional(type) {
-    return function validateOptional(value) {
-        if (value === undefined) {
-            return [];
-        }
-        return validateType(value, type);
-    };
-}
-function record(valueType) {
-    return function validateRecord(value) {
-        if (typeof value !== "object") {
-            return [{ type: "type", expected: Object, received: value }];
-        }
-        const issues = [];
-        for (let key in value) {
-            issues.push(...validateType(value[key], valueType));
-        }
-        return issues;
-    };
-}
-function tuple(...types) {
-    return function validateTuple(value) {
-        if (!Array.isArray(value)) {
-            return [{ type: "type", expected: Array, received: value }];
-        }
-        if (value.length !== types.length) {
-            return [{ type: "length", expected: types.length, received: value.length }];
-        }
-        return types.flatMap((type, index) => validateType(value[index], type));
-    };
-}
-function constructor(type) {
-    return function validateClass(value) {
-        if (!(typeof value === "function") || !(value === type || value.prototype instanceof type)) {
-            return [{ type: "type" }];
-        }
-        return [];
-    };
-}
-function union(...types) {
-    return function validateUnion(value) {
-        const validations = types.filter((type) => validateType(value, type).length);
-        if (validations.length) {
-            return [{ type: "union" }];
-        }
-        return [];
-    };
-}
-function signal$1(type) {
-    return function validateSignal(value) {
-        if (typeof value !== "function") {
-            return [{ type: "type", expected: Function, received: value }];
-        }
-        if (typeof value.set !== "function") {
-            return [{ type: "type", expected: Function, received: value.set }];
-        }
-        return [];
-    };
-}
-function reactiveValue(type) {
-    return function validateReactiveValue(value) {
-        if (typeof value !== "function") {
-            return [{ type: "type", expected: Function, received: value }];
-        }
-        return [];
-    };
-}
-
-var types = {
-    __proto__: null,
-    any: any,
-    boolean: boolean,
-    number: number,
-    string: string,
-    array: array,
-    func: func,
-    instanceOf: instanceOf,
-    keys: keys,
-    literal: literal,
-    object: object,
-    optional: optional,
-    record: record,
-    tuple: tuple,
-    constructor: constructor,
-    union: union,
-    signal: signal$1,
-    reactiveValue: reactiveValue
-};
-
-let currentProps = {};
-class Plugin {
-    static get id() {
-        var _a;
-        return (_a = this._shadowId) !== null && _a !== void 0 ? _a : this.name;
-    }
-    static set id(shadowId) {
-        this._shadowId = shadowId;
-    }
-    setup() { }
-}
-class PluginManager {
-    constructor(parent) {
-        var _a;
-        this.children = [];
-        this.onDestroyCb = [];
-        this.status = 0 /* STATUS.NEW */;
-        this.parent = parent || null;
-        (_a = this.parent) === null || _a === void 0 ? void 0 : _a.children.push(this);
-        this.plugins = this.parent ? Object.create(this.parent.plugins) : {};
-    }
-    destroy() {
-        for (let children of this.children) {
-            children.destroy();
-        }
-        const cbs = this.onDestroyCb;
-        while (cbs.length) {
-            cbs.pop()();
-        }
-        this.status = 3 /* STATUS.DESTROYED */;
-    }
-    getPluginById(id) {
-        return this.plugins[id] || null;
-    }
-    getPlugin(pluginType) {
-        return this.getPluginById(pluginType.id);
-    }
-    startPlugins(pluginTypes, pluginProps = {}) {
-        const previousManager = PluginManager.current;
-        PluginManager.current = this;
-        const plugins = [];
-        // instantiate plugins
-        for (const pluginType of pluginTypes) {
-            if (!pluginType.id) {
-                PluginManager.current = previousManager;
-                throw new OwlError(`Plugin "${pluginType.name}" has no id`);
-            }
-            if (this.plugins.hasOwnProperty(pluginType.id)) {
-                const existingPluginType = this.getPluginById(pluginType.id).constructor;
-                if (existingPluginType !== pluginType) {
-                    PluginManager.current = previousManager;
-                    throw new OwlError(`Trying to start a plugin with the same id as an other plugin (id: '${pluginType.id}', existing plugin: '${existingPluginType.name}', starting plugin: '${pluginType.name}')`);
-                }
-                continue;
-            }
-            currentProps = pluginProps[pluginType.id] || {};
-            const plugin = new pluginType();
-            this.plugins[pluginType.id] = plugin;
-            plugins.push(plugin);
-        }
-        currentProps = {};
-        // setup phase
-        for (let p of plugins) {
-            p.setup();
-        }
-        PluginManager.current = previousManager;
-        if (!PluginManager.current) {
-            this.status = 1 /* STATUS.MOUNTED */;
-        }
-        return plugins;
-    }
-}
-// kind of public to make it possible to manipulate from the outside
-PluginManager.current = null;
-function plugin(pluginType) {
-    // getCurrent will throw if we're not in a component
-    const manager = PluginManager.current || getCurrent().pluginManager;
-    let plugin = manager.getPluginById(pluginType.id);
-    if (!plugin) {
-        if (manager === PluginManager.current) {
-            manager.startPlugins([pluginType]);
-            plugin = manager.getPluginById(pluginType.id);
-        }
-        else {
-            throw new OwlError(`Unknown plugin "${pluginType.id}"`);
-        }
-    }
-    return plugin;
-}
-// todo: remove duplication with the actual props function
-plugin.props = function props(type, defaults = {}) {
-    function getProp(key) {
-        if (currentProps[key] === undefined) {
-            return defaults[key];
-        }
-        return currentProps[key];
-    }
-    const result = Object.create(null);
-    function applyPropGetters(keys) {
-        for (const key of keys) {
-            Reflect.defineProperty(result, key, {
-                enumerable: true,
-                get: getProp.bind(null, key),
-            });
-        }
-    }
-    if (type) {
-        const isSchemaValidated = type && !Array.isArray(type);
-        applyPropGetters((isSchemaValidated ? Object.keys(type) : type).map((key) => key.endsWith("?") ? key.slice(0, -1) : key));
-        const app = getCurrent().app;
-        if (app.dev) {
-            const validation = isSchemaValidated ? object(type) : keys(...type);
-            assertType(currentProps, validation);
-        }
-    }
-    else {
-        applyPropGetters(Object.keys(currentProps));
-    }
-    return currentProps;
-};
-
-// Special key to subscribe to, to be notified of key creation/deletion
-const KEYCHANGES = Symbol("Key changes");
-const objectToString = Object.prototype.toString;
-const objectHasOwnProperty = Object.prototype.hasOwnProperty;
-// Use arrays because Array.includes is faster than Set.has for small arrays
-const SUPPORTED_RAW_TYPES = ["Object", "Array", "Set", "Map", "WeakMap"];
-const COLLECTION_RAW_TYPES = ["Set", "Map", "WeakMap"];
-/**
- * extract "RawType" from strings like "[object RawType]" => this lets us ignore
- * many native objects such as Promise (whose toString is [object Promise])
- * or Date ([object Date]), while also supporting collections without using
- * instanceof in a loop
- *
- * @param obj the object to check
- * @returns the raw type of the object
- */
-function rawType(obj) {
-    return objectToString.call(toRaw(obj)).slice(8, -1);
-}
-/**
- * Checks whether a given value can be made into a proxy object.
- *
- * @param value the value to check
- * @returns whether the value can be made proxy
- */
-function canBeMadeReactive(value) {
-    if (typeof value !== "object") {
-        return false;
-    }
-    return SUPPORTED_RAW_TYPES.includes(rawType(value));
-}
-/**
- * Creates a proxy from the given object/callback if possible and returns it,
- * returns the original object otherwise.
- *
- * @param value the value make proxy
- * @returns a proxy for the given object when possible, the original otherwise
- */
-function possiblyReactive(val, atom) {
-    return !atom && canBeMadeReactive(val) ? proxy(val) : val;
-}
-const skipped = new WeakSet();
-/**
- * Mark an object or array so that it is ignored by the reactivity system
- *
- * @param value the value to mark
- * @returns the object itself
- */
-function markRaw(value) {
-    skipped.add(value);
-    return value;
-}
-/**
- * Given a proxy objet, return the raw (non proxy) underlying object
- *
- * @param value a proxy value
- * @returns the underlying value
- */
-function toRaw(value) {
-    return targets.has(value) ? targets.get(value) : value;
-}
-const targetToKeysToAtomItem = new WeakMap();
-function getTargetKeyAtom(target, key) {
-    let keyToAtomItem = targetToKeysToAtomItem.get(target);
-    if (!keyToAtomItem) {
-        keyToAtomItem = new Map();
-        targetToKeysToAtomItem.set(target, keyToAtomItem);
-    }
-    let atom = keyToAtomItem.get(key);
-    if (!atom) {
-        atom = {
-            value: undefined,
-            observers: new Set(),
-        };
-        keyToAtomItem.set(key, atom);
-    }
-    return atom;
-}
-/**
- * Observes a given key on a target with an callback. The callback will be
- * called when the given key changes on the target.
- *
- * @param target the target whose key should be observed
- * @param key the key to observe (or Symbol(KEYCHANGES) for key creation
- *  or deletion)
- * @param callback the function to call when the key changes
- */
-function onReadTargetKey(target, key, atom) {
-    onReadAtom(atom !== null && atom !== void 0 ? atom : getTargetKeyAtom(target, key));
-}
-/**
- * Notify Reactives that are observing a given target that a key has changed on
- * the target.
- *
- * @param target target whose Reactives should be notified that the target was
- *  changed.
- * @param key the key that changed (or Symbol `KEYCHANGES` if a key was created
- *   or deleted)
- */
-function onWriteTargetKey(target, key, atom) {
-    if (!atom) {
-        const keyToAtomItem = targetToKeysToAtomItem.get(target);
-        if (!keyToAtomItem) {
-            return;
-        }
-        if (!keyToAtomItem.has(key)) {
-            return;
-        }
-        atom = keyToAtomItem.get(key);
-    }
-    onWriteAtom(atom);
-}
-// Maps proxy objects to the underlying target
-const targets = new WeakMap();
-const proxyCache = new WeakMap();
-function proxifyTarget(target, atom) {
-    if (!canBeMadeReactive(target)) {
-        throw new OwlError(`Cannot make the given value reactive`);
-    }
-    if (skipped.has(target)) {
-        return target;
-    }
-    if (targets.has(target)) {
-        // target is reactive, create a reactive on the underlying object instead
-        return target;
-    }
-    const reactive = proxyCache.get(target);
-    if (reactive) {
-        return reactive;
-    }
-    const targetRawType = rawType(target);
-    const handler = COLLECTION_RAW_TYPES.includes(targetRawType)
-        ? collectionsProxyHandler(target, targetRawType, atom)
-        : basicProxyHandler(atom);
-    const proxy = new Proxy(target, handler);
-    proxyCache.set(target, proxy);
-    targets.set(proxy, target);
-    return proxy;
-}
-/**
- * Creates a reactive proxy for an object. Reading data on the proxy object
- * subscribes to changes to the data. Writing data on the object will cause the
- * notify callback to be called if there are suscriptions to that data. Nested
- * objects and arrays are automatically made reactive as well.
- *
- * Whenever you are notified of a change, all subscriptions are cleared, and if
- * you would like to be notified of any further changes, you should go read
- * the underlying data again. We assume that if you don't go read it again after
- * being notified, it means that you are no longer interested in that data.
- *
- * Subscriptions:
- * + Reading a property on an object will subscribe you to changes in the value
- *    of that property.
- * + Accessing an object's keys (eg with Object.keys or with `for..in`) will
- *    subscribe you to the creation/deletion of keys. Checking the presence of a
- *    key on the object with 'in' has the same effect.
- * - getOwnPropertyDescriptor does not currently subscribe you to the property.
- *    This is a choice that was made because changing a key's value will trigger
- *    this trap and we do not want to subscribe by writes. This also means that
- *    Object.hasOwnProperty doesn't subscribe as it goes through this trap.
- *
- * @param target the object for which to create a proxy proxy
- * @param callback the function to call when an observed property of the
- *  proxy has changed
- * @returns a proxy that tracks changes to it
- */
-function proxy(target) {
-    return proxifyTarget(target, null);
-}
-/**
- * Creates a basic proxy handler for regular objects and arrays.
- *
- * @param callback @see proxy
- * @returns a proxy handler object
- */
-function basicProxyHandler(atom) {
-    return {
-        get(target, key, receiver) {
-            // non-writable non-configurable properties cannot be made proxy
-            const desc = Object.getOwnPropertyDescriptor(target, key);
-            if (desc && !desc.writable && !desc.configurable) {
-                return Reflect.get(target, key, receiver);
-            }
-            onReadTargetKey(target, key, atom);
-            return possiblyReactive(Reflect.get(target, key, receiver), atom);
-        },
-        set(target, key, value, receiver) {
-            const hadKey = objectHasOwnProperty.call(target, key);
-            const originalValue = Reflect.get(target, key, receiver);
-            const ret = Reflect.set(target, key, toRaw(value), receiver);
-            if (!hadKey && objectHasOwnProperty.call(target, key)) {
-                onWriteTargetKey(target, KEYCHANGES, atom);
-            }
-            // While Array length may trigger the set trap, it's not actually set by this
-            // method but is updated behind the scenes, and the trap is not called with the
-            // new value. We disable the "same-value-optimization" for it because of that.
-            if (originalValue !== Reflect.get(target, key, receiver) ||
-                (key === "length" && Array.isArray(target))) {
-                onWriteTargetKey(target, key, atom);
-            }
-            return ret;
-        },
-        deleteProperty(target, key) {
-            const ret = Reflect.deleteProperty(target, key);
-            // TODO: only notify when something was actually deleted
-            onWriteTargetKey(target, KEYCHANGES, atom);
-            onWriteTargetKey(target, key, atom);
-            return ret;
-        },
-        ownKeys(target) {
-            onReadTargetKey(target, KEYCHANGES, atom);
-            return Reflect.ownKeys(target);
-        },
-        has(target, key) {
-            // TODO: this observes all key changes instead of only the presence of the argument key
-            // observing the key itself would observe value changes instead of presence changes
-            // so we may need a finer grained system to distinguish observing value vs presence.
-            onReadTargetKey(target, KEYCHANGES, atom);
-            return Reflect.has(target, key);
-        },
-    };
-}
-/**
- * Creates a function that will observe the key that is passed to it when called
- * and delegates to the underlying method.
- *
- * @param methodName name of the method to delegate to
- * @param target @see proxy
- * @param callback @see proxy
- */
-function makeKeyObserver(methodName, target, atom) {
-    return (key) => {
-        key = toRaw(key);
-        onReadTargetKey(target, key, atom);
-        return possiblyReactive(target[methodName](key), atom);
-    };
-}
-/**
- * Creates an iterable that will delegate to the underlying iteration method and
- * observe keys as necessary.
- *
- * @param methodName name of the method to delegate to
- * @param target @see proxy
- * @param callback @see proxy
- */
-function makeIteratorObserver(methodName, target, atom) {
-    return function* () {
-        onReadTargetKey(target, KEYCHANGES, atom);
-        const keys = target.keys();
-        for (const item of target[methodName]()) {
-            const key = keys.next().value;
-            onReadTargetKey(target, key, atom);
-            yield possiblyReactive(item, atom);
-        }
-    };
-}
-/**
- * Creates a forEach function that will delegate to forEach on the underlying
- * collection while observing key changes, and keys as they're iterated over,
- * and making the passed keys/values proxy.
- *
- * @param target @see proxy
- * @param callback @see proxy
- */
-function makeForEachObserver(target, atom) {
-    return function forEach(forEachCb, thisArg) {
-        onReadTargetKey(target, KEYCHANGES, atom);
-        target.forEach(function (val, key, targetObj) {
-            onReadTargetKey(target, key, atom);
-            forEachCb.call(thisArg, possiblyReactive(val, atom), possiblyReactive(key, atom), possiblyReactive(targetObj, atom));
-        }, thisArg);
-    };
-}
-/**
- * Creates a function that will delegate to an underlying method, and check if
- * that method has modified the presence or value of a key, and notify the
- * proxys appropriately.
- *
- * @param setterName name of the method to delegate to
- * @param getterName name of the method which should be used to retrieve the
- *  value before calling the delegate method for comparison purposes
- * @param target @see proxy
- */
-function delegateAndNotify(setterName, getterName, target, atom) {
-    return (key, value) => {
-        key = toRaw(key);
-        const hadKey = target.has(key);
-        const originalValue = target[getterName](key);
-        const ret = target[setterName](key, value);
-        const hasKey = target.has(key);
-        if (hadKey !== hasKey) {
-            onWriteTargetKey(target, KEYCHANGES, atom);
-        }
-        if (originalValue !== target[getterName](key)) {
-            onWriteTargetKey(target, key, atom);
-        }
-        return ret;
-    };
-}
-/**
- * Creates a function that will clear the underlying collection and notify that
- * the keys of the collection have changed.
- *
- * @param target @see proxy
- */
-function makeClearNotifier(target, atom) {
-    return () => {
-        const allKeys = [...target.keys()];
-        target.clear();
-        onWriteTargetKey(target, KEYCHANGES, atom);
-        for (const key of allKeys) {
-            onWriteTargetKey(target, key, atom);
-        }
-    };
-}
-/**
- * Maps raw type of an object to an object containing functions that can be used
- * to build an appropritate proxy handler for that raw type. Eg: when making a
- * proxy set, calling the has method should mark the key that is being
- * retrieved as observed, and calling the add or delete method should notify the
- * proxys that the key which is being added or deleted has been modified.
- */
-const rawTypeToFuncHandlers = {
-    Set: (target, atom) => ({
-        has: makeKeyObserver("has", target, atom),
-        add: delegateAndNotify("add", "has", target, atom),
-        delete: delegateAndNotify("delete", "has", target, atom),
-        keys: makeIteratorObserver("keys", target, atom),
-        values: makeIteratorObserver("values", target, atom),
-        entries: makeIteratorObserver("entries", target, atom),
-        [Symbol.iterator]: makeIteratorObserver(Symbol.iterator, target, atom),
-        forEach: makeForEachObserver(target, atom),
-        clear: makeClearNotifier(target, atom),
-        get size() {
-            onReadTargetKey(target, KEYCHANGES, atom);
-            return target.size;
-        },
-    }),
-    Map: (target, atom) => ({
-        has: makeKeyObserver("has", target, atom),
-        get: makeKeyObserver("get", target, atom),
-        set: delegateAndNotify("set", "get", target, atom),
-        delete: delegateAndNotify("delete", "has", target, atom),
-        keys: makeIteratorObserver("keys", target, atom),
-        values: makeIteratorObserver("values", target, atom),
-        entries: makeIteratorObserver("entries", target, atom),
-        [Symbol.iterator]: makeIteratorObserver(Symbol.iterator, target, atom),
-        forEach: makeForEachObserver(target, atom),
-        clear: makeClearNotifier(target, atom),
-        get size() {
-            onReadTargetKey(target, KEYCHANGES, atom);
-            return target.size;
-        },
-    }),
-    WeakMap: (target, atom) => ({
-        has: makeKeyObserver("has", target, atom),
-        get: makeKeyObserver("get", target, atom),
-        set: delegateAndNotify("set", "get", target, atom),
-        delete: delegateAndNotify("delete", "has", target, atom),
-    }),
-};
-/**
- * Creates a proxy handler for collections (Set/Map/WeakMap)
- *
- * @param callback @see proxy
- * @param target @see proxy
- * @returns a proxy handler object
- */
-function collectionsProxyHandler(target, targetRawType, atom) {
-    // TODO: if performance is an issue we can create the special handlers lazily when each
-    // property is read.
-    const specialHandlers = rawTypeToFuncHandlers[targetRawType](target, atom);
-    return Object.assign(basicProxyHandler(atom), {
-        // FIXME: probably broken when part of prototype chain since we ignore the receiver
-        get(target, key) {
-            if (objectHasOwnProperty.call(specialHandlers, key)) {
-                return specialHandlers[key];
-            }
-            onReadTargetKey(target, key, atom);
-            return possiblyReactive(target[key], atom);
-        },
-    });
-}
-
-// -----------------------------------------------------------------------------
-//  Scheduler
-// -----------------------------------------------------------------------------
-class Scheduler {
-    constructor() {
-        this.tasks = new Set();
-        this.frame = 0;
-        this.delayedRenders = [];
-        this.cancelledNodes = new Set();
-        this.processing = false;
-        this.requestAnimationFrame = Scheduler.requestAnimationFrame;
-    }
-    addFiber(fiber) {
-        this.tasks.add(fiber.root);
-    }
-    scheduleDestroy(node) {
-        this.cancelledNodes.add(node);
-        if (this.frame === 0) {
-            this.frame = this.requestAnimationFrame(() => this.processTasks());
-        }
-    }
-    /**
-     * Process all current tasks. This only applies to the fibers that are ready.
-     * Other tasks are left unchanged.
-     */
-    flush() {
-        if (this.delayedRenders.length) {
-            let renders = this.delayedRenders;
-            this.delayedRenders = [];
-            for (let f of renders) {
-                if (f.root && f.node.status !== 3 /* STATUS.DESTROYED */ && f.node.fiber === f) {
-                    f.render();
-                }
-            }
-        }
-        if (this.frame === 0) {
-            this.frame = this.requestAnimationFrame(() => this.processTasks());
-        }
-    }
-    processTasks() {
-        if (this.processing) {
-            return;
-        }
-        this.processing = true;
-        this.frame = 0;
-        for (let node of this.cancelledNodes) {
-            node._destroy();
-        }
-        this.cancelledNodes.clear();
-        for (let task of this.tasks) {
-            this.processFiber(task);
-        }
-        for (let task of this.tasks) {
-            if (task.node.status === 3 /* STATUS.DESTROYED */) {
-                this.tasks.delete(task);
-            }
-        }
-        this.processing = false;
-    }
-    processFiber(fiber) {
-        if (fiber.root !== fiber) {
-            this.tasks.delete(fiber);
-            return;
-        }
-        const hasError = fibersInError.has(fiber);
-        if (hasError && fiber.counter !== 0) {
-            this.tasks.delete(fiber);
-            return;
-        }
-        if (fiber.node.status === 3 /* STATUS.DESTROYED */) {
-            this.tasks.delete(fiber);
-            return;
-        }
-        if (fiber.counter === 0) {
-            if (!hasError) {
-                fiber.complete();
-            }
-            // at this point, the fiber should have been applied to the DOM, so we can
-            // remove it from the task list. If it is not the case, it means that there
-            // was an error and an error handler triggered a new rendering that recycled
-            // the fiber, so in that case, we actually want to keep the fiber around,
-            // otherwise it will just be ignored.
-            if (fiber.appliedToDom) {
-                this.tasks.delete(fiber);
-            }
-        }
-    }
-}
-// capture the value of requestAnimationFrame as soon as possible, to avoid
-// interactions with other code, such as test frameworks that override them
-Scheduler.requestAnimationFrame = window.requestAnimationFrame.bind(window);
-
-// -----------------------------------------------------------------------------
-//  hooks
-// -----------------------------------------------------------------------------
-function decorate(node, f, hookName) {
-    const result = f.bind(node.component);
-    if (node.app.dev) {
-        const suffix = f.name ? ` <${f.name}>` : "";
-        Reflect.defineProperty(result, "name", {
-            value: hookName + suffix,
-        });
-    }
-    return result;
-}
-function onWillStart(fn) {
-    const node = getCurrent();
-    node.willStart.push(decorate(node, fn, "onWillStart"));
-}
-function onMounted(fn) {
-    const node = getCurrent();
-    node.mounted.push(decorate(node, fn, "onMounted"));
-}
-function onWillPatch(fn) {
-    const node = getCurrent();
-    node.willPatch.unshift(decorate(node, fn, "onWillPatch"));
-}
-function onPatched(fn) {
-    const node = getCurrent();
-    node.patched.push(decorate(node, fn, "onPatched"));
-}
-function onWillUnmount(fn) {
-    const node = getCurrent();
-    node.willUnmount.unshift(decorate(node, fn, "onWillUnmount"));
-}
-function onWillDestroy(fn) {
-    const pm = PluginManager.current;
-    if (pm) {
-        pm.onDestroyCb.push(fn);
-    }
-    else {
-        const node = getCurrent();
-        node.willDestroy.unshift(decorate(node, fn, "onWillDestroy"));
-    }
-}
-function onError(callback) {
-    const node = getCurrent();
-    let handlers = nodeErrorHandlers.get(node);
-    if (!handlers) {
-        handlers = [];
-        nodeErrorHandlers.set(node, handlers);
-    }
-    handlers.push(callback.bind(node.component));
-}
-
-function props(type, defaults = {}) {
-    const node = getCurrent();
-    const result = Object.create(null);
-    function applyProps(keys) {
-        for (const key of keys) {
-            result[key] = node.props === undefined ? defaults[key] : node.props[key];
-        }
-    }
-    if (type) {
-        const isSchemaValidated = type && !Array.isArray(type);
-        const keys$1 = (isSchemaValidated ? Object.keys(type) : type).map((key) => key.endsWith("?") ? key.slice(0, -1) : key);
-        applyProps(keys$1);
-        if (node.app.dev) {
-            const validation = isSchemaValidated ? object(type) : keys(...type);
-            assertType(node.props, validation);
-        }
-    }
-    else {
-        applyProps(Object.keys(node.props));
-    }
-    return result;
-}
-
-const VText = text("").constructor;
-class VPortal extends VText {
-    constructor(selector, content) {
-        super("");
-        this.target = null;
-        this.selector = selector;
-        this.content = content;
-    }
-    mount(parent, anchor) {
-        super.mount(parent, anchor);
-        this.target = document.querySelector(this.selector);
-        if (this.target) {
-            this.content.mount(this.target, null);
-        }
-        else {
-            this.content.mount(parent, anchor);
-        }
-    }
-    beforeRemove() {
-        this.content.beforeRemove();
-    }
-    remove() {
-        if (this.content) {
-            super.remove();
-            this.content.remove();
-            this.content = null;
-        }
-    }
-    patch(other) {
-        super.patch(other);
-        if (this.content) {
-            this.content.patch(other.content, true);
-        }
-        else {
-            this.content = other.content;
-            this.content.mount(this.target, null);
-        }
-    }
-}
-/**
- * kind of similar to <t t-slot="default"/>, but it wraps it around a VPortal
- */
-function portalTemplate(app, bdom, helpers) {
-    let { callSlot } = helpers;
-    return function template(ctx, node, key = "") {
-        return new VPortal(ctx.this.props.target, callSlot(ctx, node, key, "default", false, null));
-    };
-}
-class Portal extends Component {
-    constructor() {
-        super(...arguments);
-        this.props = props({
-            target: string,
-        });
-    }
-    setup() {
-        const node = this.__owl__;
-        onMounted(() => {
-            const portal = node.bdom;
-            if (!portal.target) {
-                const target = document.querySelector(node.props.target);
-                if (target) {
-                    portal.content.moveBeforeDOMNode(target.firstChild, target);
-                }
-                else {
-                    throw new OwlError("invalid portal target");
-                }
-            }
-        });
-        onWillUnmount(() => {
-            const portal = node.bdom;
-            portal.remove();
-        });
-    }
-}
-Portal.template = "__portal__";
-
-const ObjectCreate = Object.create;
-/**
- * This file contains utility functions that will be injected in each template,
- * to perform various useful tasks in the compiled code.
- */
-function withDefault(value, defaultValue) {
-    return value === undefined || value === null || value === false ? defaultValue : value;
-}
-function callSlot(ctx, parent, key, name, dynamic, extra, defaultContent) {
-    key = key + "__slot_" + name;
-    const slots = ctx.__owl__.props.slots || {};
-    const { __render, __ctx, __scope } = slots[name] || {};
-    const slotScope = ObjectCreate(__ctx || {});
-    if (__scope) {
-        slotScope[__scope] = extra;
-    }
-    const slotBDom = __render ? __render(slotScope, parent, key) : null;
-    if (defaultContent) {
-        let child1 = undefined;
-        let child2 = undefined;
-        if (slotBDom) {
-            child1 = dynamic ? toggler(name, slotBDom) : slotBDom;
-        }
-        else {
-            child2 = defaultContent(ctx, parent, key);
-        }
-        return multi([child1, child2]);
-    }
-    return slotBDom || text("");
-}
-function capture(ctx) {
-    const result = ObjectCreate(ctx);
-    for (let k in ctx) {
-        result[k] = ctx[k];
-    }
-    return result;
-}
-function withKey(elem, k) {
-    elem.key = k;
-    return elem;
-}
-function prepareList(collection) {
-    let keys;
-    let values;
-    if (Array.isArray(collection)) {
-        keys = collection;
-        values = collection;
-    }
-    else if (collection instanceof Map) {
-        keys = [...collection.keys()];
-        values = [...collection.values()];
-    }
-    else if (Symbol.iterator in Object(collection)) {
-        keys = [...collection];
-        values = keys;
-    }
-    else if (collection && typeof collection === "object") {
-        values = Object.values(collection);
-        keys = Object.keys(collection);
-    }
-    else {
-        throw new OwlError(`Invalid loop expression: "${collection}" is not iterable`);
-    }
-    const n = values.length;
-    return [keys, values, n, new Array(n)];
-}
-const isBoundary = Symbol("isBoundary");
-function setContextValue(ctx, key, value) {
-    const ctx0 = ctx;
-    while (!ctx.hasOwnProperty(key) && !ctx.hasOwnProperty(isBoundary)) {
-        const newCtx = ctx.__proto__;
-        if (!newCtx) {
-            ctx = ctx0;
-            break;
-        }
-        ctx = newCtx;
-    }
-    ctx[key] = value;
-}
-function toNumber(val) {
-    const n = parseFloat(val);
-    return isNaN(n) ? val : n;
-}
-function shallowEqual(l1, l2) {
-    for (let i = 0, l = l1.length; i < l; i++) {
-        if (l1[i] !== l2[i]) {
-            return false;
-        }
-    }
-    return true;
-}
-class LazyValue {
-    constructor(fn, ctx, component, node, key) {
-        this.fn = fn;
-        this.ctx = capture(ctx);
-        this.component = component;
-        this.node = node;
-        this.key = key;
-    }
-    evaluate() {
-        return this.fn.call(this.component, this.ctx, this.node, this.key);
-    }
-    toString() {
-        return this.evaluate().toString();
-    }
-}
-/*
- * Safely outputs `value` as a block depending on the nature of `value`
- */
-function safeOutput(value, defaultValue) {
-    if (value === undefined || value === null) {
-        return defaultValue ? toggler("default", defaultValue) : toggler("undefined", text(""));
-    }
-    let safeKey;
-    let block;
-    if (value instanceof Markup) {
-        safeKey = `string_safe`;
-        block = html(value);
-    }
-    else if (value instanceof LazyValue) {
-        safeKey = `lazy_value`;
-        block = value.evaluate();
-    }
-    else {
-        safeKey = "string_unsafe";
-        block = text(value);
-    }
-    return toggler(safeKey, block);
-}
-function createRef(ref) {
-    if (!ref) {
-        throw new OwlError(`Ref is undefined or null`);
-    }
-    let add;
-    let remove;
-    if (ref.add && ref.remove) {
-        add = ref.add.bind(ref);
-        remove = ref.remove.bind(ref);
-    }
-    else if (ref.set) {
-        add = ref.set.bind(ref);
-        remove = () => ref.set(null);
-    }
-    else {
-        throw new OwlError(`Ref should implement either a 'set' function or 'add' and 'remove' functions`);
-    }
-    return (el, previousEl) => {
-        if (previousEl) {
-            remove(previousEl);
-        }
-        if (el) {
-            add(el);
-        }
-    };
-}
-function modelExpr(value) {
-    if (!value.set || typeof value !== "function") {
-        throw new OwlError(`Invalid t-model expression: expression should evaluate to a function with a 'set' method defined on it`);
-    }
-    return value;
-}
-const helpers = {
-    withDefault,
-    zero: Symbol("zero"),
-    isBoundary,
-    callSlot,
-    capture,
-    withKey,
-    prepareList,
-    setContextValue,
-    shallowEqual,
-    toNumber,
-    LazyValue,
-    safeOutput,
-    createCatcher,
-    markRaw,
-    OwlError,
-    createRef,
-    modelExpr,
-};
-
-/**
- * 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
- */
-function parseXML(xml) {
-    const parser = new DOMParser();
-    const doc = parser.parseFromString(xml, "text/xml");
-    if (doc.getElementsByTagName("parsererror").length) {
-        let msg = "Invalid XML in template.";
-        const parsererrorText = doc.getElementsByTagName("parsererror")[0].textContent;
-        if (parsererrorText) {
-            msg += "\nThe parser has produced the following error message:\n" + parsererrorText;
-            const re = /\d+/g;
-            const firstMatch = re.exec(parsererrorText);
-            if (firstMatch) {
-                const lineNumber = Number(firstMatch[0]);
-                const line = xml.split("\n")[lineNumber - 1];
-                const secondMatch = re.exec(parsererrorText);
-                if (line && secondMatch) {
-                    const columnIndex = Number(secondMatch[0]) - 1;
-                    if (line[columnIndex]) {
-                        msg +=
-                            `\nThe error might be located at xml line ${lineNumber} column ${columnIndex}\n` +
-                                `${line}\n${"-".repeat(columnIndex - 1)}^`;
-                    }
-                }
-            }
-        }
-        throw new OwlError(msg);
-    }
-    return doc;
-}
-
-const bdom = { text, createBlock, list, multi, html, toggler, comment };
-class TemplateSet {
-    static registerTemplate(name, fn) {
-        globalTemplates[name] = fn;
-    }
-    constructor(config = {}) {
-        this.rawTemplates = Object.create(globalTemplates);
-        this.templates = {};
-        this.Portal = Portal;
-        this.dev = config.dev || false;
-        this.translateFn = config.translateFn;
-        this.translatableAttributes = config.translatableAttributes;
-        if (config.templates) {
-            if (config.templates instanceof Document || typeof config.templates === "string") {
-                this.addTemplates(config.templates);
-            }
-            else {
-                for (const name in config.templates) {
-                    this.addTemplate(name, config.templates[name]);
-                }
-            }
-        }
-        this.getRawTemplate = config.getTemplate;
-        this.customDirectives = config.customDirectives || {};
-        this.runtimeUtils = { ...helpers, __globals__: config.globalValues || {} };
-        this.hasGlobalValues = Boolean(config.globalValues && Object.keys(config.globalValues).length);
-    }
-    addTemplate(name, template) {
-        if (name in this.rawTemplates) {
-            // this check can be expensive, just silently ignore double definitions outside dev mode
-            if (!this.dev) {
-                return;
-            }
-            const rawTemplate = this.rawTemplates[name];
-            const currentAsString = typeof rawTemplate === "string"
-                ? rawTemplate
-                : rawTemplate instanceof Element
-                    ? rawTemplate.outerHTML
-                    : rawTemplate.toString();
-            const newAsString = typeof template === "string" ? template : template.outerHTML;
-            if (currentAsString === newAsString) {
-                return;
-            }
-            throw new OwlError(`Template ${name} already defined with different content`);
-        }
-        this.rawTemplates[name] = template;
-    }
-    addTemplates(xml) {
-        if (!xml) {
-            // empty string
-            return;
-        }
-        xml = xml instanceof Document ? xml : parseXML(xml);
-        for (const template of xml.querySelectorAll("[t-name]")) {
-            const name = template.getAttribute("t-name");
-            this.addTemplate(name, template);
-        }
-    }
-    getTemplate(name) {
-        var _a;
-        if (!(name in this.templates)) {
-            const rawTemplate = ((_a = this.getRawTemplate) === null || _a === void 0 ? void 0 : _a.call(this, name)) || this.rawTemplates[name];
-            if (rawTemplate === undefined) {
-                let extraInfo = "";
-                try {
-                    const componentName = getCurrent().component.constructor.name;
-                    extraInfo = ` (for component "${componentName}")`;
-                }
-                catch { }
-                throw new OwlError(`Missing template: "${name}"${extraInfo}`);
-            }
-            const isFn = typeof rawTemplate === "function" && !(rawTemplate instanceof Element);
-            const templateFn = isFn ? rawTemplate : this._compileTemplate(name, rawTemplate);
-            // first add a function to lazily get the template, in case there is a
-            // recursive call to the template name
-            const templates = this.templates;
-            this.templates[name] = function (context, parent) {
-                return templates[name].call(this, context, parent);
-            };
-            const template = templateFn(this, bdom, this.runtimeUtils);
-            this.templates[name] = template;
-        }
-        return this.templates[name];
-    }
-    _compileTemplate(name, template) {
-        throw new OwlError(`Unable to compile a template. Please use owl full build instead`);
-    }
-    callTemplate(owner, subTemplate, ctx, parent, key) {
-        const template = this.getTemplate(subTemplate);
-        return toggler(subTemplate, template.call(owner, ctx, parent, key + subTemplate));
-    }
-}
-// -----------------------------------------------------------------------------
-//  xml tag helper
-// -----------------------------------------------------------------------------
-const globalTemplates = {};
-function xml(...args) {
-    const name = `__template__${xml.nextId++}`;
-    const value = String.raw(...args);
-    globalTemplates[name] = value;
-    return name;
-}
-xml.nextId = 1;
-TemplateSet.registerTemplate("__portal__", portalTemplate);
-
-let hasBeenLogged = false;
-const apps = new Set();
-window.__OWL_DEVTOOLS__ || (window.__OWL_DEVTOOLS__ = { apps, Fiber, RootFiber, toRaw, proxy });
-class App extends TemplateSet {
-    constructor(config = {}) {
-        super(config);
-        this.scheduler = new Scheduler();
-        this.roots = new Set();
-        this.name = config.name || "";
-        apps.add(this);
-        this.pluginManager = config.pluginManager || new PluginManager(null);
-        if (config.plugins) {
-            this.pluginManager.startPlugins(config.plugins);
-        }
-        if (config.test) {
-            this.dev = true;
-        }
-        if (this.dev && !config.test && !hasBeenLogged) {
-            console.info(`Owl is running in 'dev' mode.`);
-            hasBeenLogged = true;
-        }
-    }
-    createRoot(Root, config = {}) {
-        const props = config.props || {};
-        let resolve;
-        let reject;
-        const promise = new Promise((res, rej) => {
-            resolve = res;
-            reject = rej;
-        });
-        const restore = saveCurrent();
-        let node;
-        let error = null;
-        try {
-            node = this.makeNode(Root, props);
-        }
-        catch (e) {
-            error = e;
-            reject(e);
-        }
-        finally {
-            restore();
-        }
-        const root = {
-            node: node,
-            promise,
-            mount: (target, options) => {
-                if (error) {
-                    return promise;
-                }
-                App.validateTarget(target);
-                this.mountNode(node, target, resolve, reject, options);
-                return promise;
-            },
-            destroy: () => {
-                this.roots.delete(root);
-                node.destroy();
-                this.scheduler.processTasks();
-            },
-        };
-        this.roots.add(root);
-        return root;
-    }
-    makeNode(Component, props) {
-        return new ComponentNode(Component, props, this, null, null);
-    }
-    mountNode(node, target, resolve, reject, options) {
-        // Manually add the last resort error handler on the node
-        let handlers = nodeErrorHandlers.get(node);
-        if (!handlers) {
-            handlers = [];
-            nodeErrorHandlers.set(node, handlers);
-        }
-        handlers.unshift((e, finalize) => {
-            const finalError = finalize();
-            reject(finalError);
-        });
-        // manually set a onMounted callback.
-        // that way, we are independant from the current node.
-        node.mounted.push(() => {
-            resolve(node.component);
-            handlers.shift();
-        });
-        node.mountComponent(target, options);
-    }
-    destroy() {
-        for (let root of this.roots) {
-            root.destroy();
-        }
-        this.scheduler.processTasks();
-        apps.delete(this);
-    }
-    createComponent(name, isStatic) {
-        const isDynamic = !isStatic;
-        const initiateRender = ComponentNode.prototype.initiateRender;
-        return (props, key, ctx, parent, C) => {
-            let children = ctx.children;
-            let node = children[key];
-            if (isDynamic && node && node.component.constructor !== C) {
-                node = undefined;
-            }
-            const parentFiber = ctx.fiber;
-            if (!node) {
-                // new component
-                if (isStatic) {
-                    const components = parent.constructor.components;
-                    if (!components) {
-                        throw new OwlError(`Cannot find the definition of component "${name}", missing static components key in parent`);
-                    }
-                    C = components[name];
-                    if (!C) {
-                        throw new OwlError(`Cannot find the definition of component "${name}"`);
-                    }
-                    else if (!(C.prototype instanceof Component)) {
-                        throw new OwlError(`"${name}" is not a Component. It must inherit from the Component class`);
-                    }
-                }
-                node = new ComponentNode(C, props, this, ctx, key);
-                children[key] = node;
-                initiateRender.call(node, new Fiber(node, parentFiber));
-            }
-            parentFiber.childrenMap[key] = node;
-            return node;
-        };
-    }
-    handleError(...args) {
-        return handleError(...args);
-    }
-}
-App.validateTarget = validateTarget;
-App.apps = apps;
-App.version = version;
-async function mount(C, target, config = {}) {
-    const app = new App(config);
-    const root = app.createRoot(C, config);
-    return root.mount(target, config);
-}
-
-const mainEventHandler = (data, ev, currentTarget) => {
-    const { data: _data, modifiers } = filterOutModifiersFromData(data);
-    data = _data;
-    let stopped = false;
-    if (modifiers.length) {
-        let selfMode = false;
-        const isSelf = ev.target === currentTarget;
-        for (const mod of modifiers) {
-            switch (mod) {
-                case "self":
-                    selfMode = true;
-                    if (isSelf) {
-                        continue;
-                    }
-                    else {
-                        return stopped;
-                    }
-                case "prevent":
-                    if ((selfMode && isSelf) || !selfMode)
-                        ev.preventDefault();
-                    continue;
-                case "stop":
-                    if ((selfMode && isSelf) || !selfMode)
-                        ev.stopPropagation();
-                    stopped = true;
-                    continue;
-            }
-        }
-    }
-    // If handler is empty, the array slot 0 will also be empty, and data will not have the property 0
-    // We check this rather than data[0] being truthy (or typeof function) so that it crashes
-    // as expected when there is a handler expression that evaluates to a falsy value
-    if (Object.hasOwnProperty.call(data, 0)) {
-        const handler = data[0];
-        if (typeof handler !== "function") {
-            throw new OwlError(`Invalid handler (expected a function, received: '${handler}')`);
-        }
-        let node = data[1] ? data[1].__owl__ : null;
-        if (node ? node.status === 1 /* STATUS.MOUNTED */ : true) {
-            handler.call(node ? node.component : null, ev);
-        }
-    }
-    return stopped;
-};
-
-function computed(fn, opts) {
-    // todo: handle cleanup
-    let derivedComputation;
-    return () => {
-        derivedComputation !== null && derivedComputation !== void 0 ? derivedComputation : (derivedComputation = {
-            state: ComputationState.STALE,
-            sources: new Set(),
-            compute: () => {
-                onWriteAtom(derivedComputation);
-                return fn();
-            },
-            isDerived: true,
-            value: undefined,
-            observers: new Set(),
-            name: opts === null || opts === void 0 ? void 0 : opts.name,
-        });
-        updateComputation(derivedComputation);
-        onReadAtom(derivedComputation);
-        return derivedComputation.value;
-    };
-}
-
-const signalSymbol = Symbol("Signal");
-function buildSignal(value, set, opts) {
-    const atom = {
-        value,
-        observers: new Set(),
-        name: opts === null || opts === void 0 ? void 0 : opts.name,
-    };
-    let readValue = set(atom);
-    const read = () => {
-        onReadAtom(atom);
-        return readValue;
-    };
-    read[signalSymbol] = atom;
-    read.set = (newValue) => {
-        if (Object.is(atom.value, newValue)) {
-            return;
-        }
-        atom.value = newValue;
-        readValue = set(atom);
-        onWriteAtom(atom);
-    };
-    return read;
-}
-function signal(value, opts) {
-    return buildSignal(value, (atom) => atom.value, opts);
-}
-signal.invalidate = function (signal) {
-    if (!(signalSymbol in signal)) {
-        throw new OwlError(`Value is not a signal (${signal})`);
-    }
-    const atom = signal[signalSymbol];
-    onWriteAtom(atom);
-};
-signal.Array = function (initialValue, opts) {
-    return buildSignal(initialValue, (atom) => proxifyTarget(atom.value, atom), opts);
-};
-signal.Object = function (initialValue, opts) {
-    return buildSignal(initialValue, (atom) => proxifyTarget(atom.value, atom), opts);
-};
-signal.Map = function (initialValue, opts) {
-    return buildSignal(initialValue, (atom) => proxifyTarget(atom.value, atom), opts);
-};
-signal.Set = function (initialValue, opts) {
-    return buildSignal(initialValue, (atom) => proxifyTarget(atom.value, atom), opts);
-};
-
-class Resource {
-    constructor(options = {}) {
-        this._items = signal.Array([]);
-        this.items = computed(() => {
-            return this._items()
-                .sort((el1, el2) => el1[0] - el2[0])
-                .map((elem) => elem[1]);
-        });
-        // this._name = options.name || "resource";
-        this._validation = options.validation;
-    }
-    add(item, sequence = 50) {
-        if (this._validation) {
-            assertType(item, this._validation);
-        }
-        this._items().push([sequence, item]);
-        return this;
-    }
-    remove(item) {
-        const items = this._items().filter(([seq, val]) => val !== item);
-        this._items.set(items);
-        return this;
-    }
-    has(item) {
-        return this._items().some(([s, value]) => value === item);
-    }
-}
-function useResource(r, elements) {
-    for (let elem of elements) {
-        r.add(elem);
-    }
-    onWillDestroy(() => {
-        for (let elem of elements) {
-            r.remove(elem);
-        }
-    });
-}
-
-class Registry {
-    constructor(options = {}) {
-        this._map = signal.Object(Object.create(null));
-        this.entries = computed(() => {
-            const entries = Object.entries(this._map())
-                .sort((el1, el2) => el1[1][0] - el2[1][0])
-                .map(([str, elem]) => [str, elem[1]]);
-            return entries;
-        });
-        this.items = computed(() => this.entries().map((e) => e[1]));
-        this._name = options.name || "registry";
-        this._validation = options.validation;
-    }
-    addById(item, sequence = 50) {
-        if (!item.id) {
-            throw new OwlError(`Item should have an id key (registry '${this._name}')`);
-        }
-        return this.add(item.id, item, sequence);
-    }
-    add(key, value, sequence = 50) {
-        if (this._validation) {
-            assertType(value, this._validation);
-        }
-        this._map()[key] = [sequence, value];
-        return this;
-    }
-    get(key, defaultValue) {
-        const hasKey = key in this._map();
-        if (!hasKey && arguments.length < 2) {
-            throw new Error(`KeyNotFoundError: Cannot find key "${key}" (registry '${this._name}')`);
-        }
-        return hasKey ? this._map()[key][1] : defaultValue;
-    }
-    remove(key) {
-        delete this._map()[key];
-    }
-    has(key) {
-        return key in this._map();
-    }
-}
-
-function status() {
-    const pm = PluginManager.current;
-    const node = pm || getCurrent();
-    return () => {
-        switch (node.status) {
-            case 0 /* STATUS.NEW */:
-                return "new";
-            case 2 /* STATUS.CANCELLED */:
-                return "cancelled";
-            case 1 /* STATUS.MOUNTED */:
-                return pm ? "started" : "mounted";
-            case 3 /* STATUS.DESTROYED */:
-                return "destroyed";
-        }
-    };
-}
-
-function effect(fn, opts) {
-    var _a, _b, _c;
-    const effectComputation = {
-        state: ComputationState.STALE,
-        value: undefined,
-        compute() {
-            // In case the cleanup read an atom.
-            // todo: test it
-            setComputation(undefined);
-            //   CurrentComputation = undefined!;
-            // `removeSources` is made by `runComputation`.
-            unsubscribeEffect(effectComputation);
-            setComputation(effectComputation);
-            //   CurrentComputation = effectComputation;
-            return fn();
-        },
-        sources: new Set(),
-        childrenEffect: [],
-        name: opts === null || opts === void 0 ? void 0 : opts.name,
-    };
-    (_c = (_b = (_a = getCurrentComputation()) === null || _a === void 0 ? void 0 : _a.childrenEffect) === null || _b === void 0 ? void 0 : _b.push) === null || _c === void 0 ? void 0 : _c.call(_b, effectComputation);
-    updateComputation(effectComputation);
-    // Remove sources and unsubscribe
-    return () => {
-        // In case the cleanup read an atom.
-        // todo: test it
-        const previousComputation = getCurrentComputation();
-        setComputation(undefined);
-        unsubscribeEffect(effectComputation);
-        setComputation(previousComputation);
-    };
-}
-function unsubscribeEffect(effectComputation) {
-    removeSources(effectComputation);
-    cleanupEffect(effectComputation);
-    for (const children of effectComputation.childrenEffect) {
-        // Consider it executed to avoid it's re-execution
-        // todo: make a test for it
-        children.state = ComputationState.EXECUTED;
-        removeSources(children);
-        unsubscribeEffect(children);
-    }
-    effectComputation.childrenEffect.length = 0;
-}
-function cleanupEffect(computation) {
-    // the computation.value of an effect is a cleanup function
-    const cleanupFn = computation.value;
-    if (cleanupFn && typeof cleanupFn === "function") {
-        cleanupFn();
-        computation.value = undefined;
-    }
-}
-
-// -----------------------------------------------------------------------------
-// useEffect
-// -----------------------------------------------------------------------------
-/**
- * This hook will run a callback when a component is mounted and patched, and
- * will run a cleanup function before patching and before unmounting the
- * the component.
- *
- * @template T
- * @param {Effect<T>} effect the effect to run on component mount and/or patch
- * @param {()=>[...T]} [computeDependencies=()=>[NaN]] a callback to compute
- *      dependencies that will decide if the effect needs to be cleaned up and
- *      run again. If the dependencies did not change, the effect will not run
- *      again. The default value returns an array containing only NaN because
- *      NaN !== NaN, which will cause the effect to rerun on every patch.
- */
-function useEffect(fn) {
-    onWillDestroy(effect(fn));
-}
-// -----------------------------------------------------------------------------
-// useListener
-// -----------------------------------------------------------------------------
-/**
- * When a component needs to listen to DOM Events on element(s) that are not
- * part of his hierarchy, we can use the `useListener` hook.
- * It will immediately add the listener, and remove it whenever the plugin or
- * component is destroyed.
- *
- * Example:
- *  a menu needs to listen to the click on window to be closed automatically
- *
- * Usage:
- *  in the constructor of the OWL component that needs to be notified,
- *  `useListener(window, 'click', () => this._doSomething());`
- * */
-function useListener(target, eventName, handler, eventParams) {
-    target.addEventListener(eventName, handler, eventParams);
-    onWillDestroy(() => target.removeEventListener(eventName, handler, eventParams));
-}
-function providePlugins(Plugins, pluginProps) {
-    const node = getCurrent();
-    const manager = new PluginManager(node.pluginManager);
-    node.pluginManager = manager;
-    onWillDestroy(() => manager.destroy());
-    return manager.startPlugins(Plugins, pluginProps);
-}
-
-config.shouldNormalizeDom = false;
-config.mainEventHandler = mainEventHandler;
-const blockDom = {
-    config,
-    // bdom entry points
-    mount: mount$1,
-    patch,
-    remove,
-    // bdom block types
-    list,
-    multi,
-    text,
-    toggler,
-    createBlock,
-    html,
-    comment,
-};
-const __info__ = {
-    version: App.version,
-};
-
-exports.App = App;
-exports.Component = Component;
-exports.EventBus = EventBus;
-exports.OwlError = OwlError;
-exports.Plugin = Plugin;
-exports.PluginManager = PluginManager;
-exports.Registry = Registry;
-exports.Resource = Resource;
-exports.__info__ = __info__;
-exports.assertType = assertType;
-exports.batched = batched;
-exports.blockDom = blockDom;
-exports.computed = computed;
-exports.effect = effect;
-exports.htmlEscape = htmlEscape;
-exports.markRaw = markRaw;
-exports.markup = markup;
-exports.mount = mount;
-exports.onError = onError;
-exports.onMounted = onMounted;
-exports.onPatched = onPatched;
-exports.onWillDestroy = onWillDestroy;
-exports.onWillPatch = onWillPatch;
-exports.onWillStart = onWillStart;
-exports.onWillUnmount = onWillUnmount;
-exports.plugin = plugin;
-exports.props = props;
-exports.providePlugins = providePlugins;
-exports.proxy = proxy;
-exports.signal = signal;
-exports.status = status;
-exports.toRaw = toRaw;
-exports.types = types;
-exports.untrack = untrack;
-exports.useComponent = useComponent;
-exports.useEffect = useEffect;
-exports.useListener = useListener;
-exports.useResource = useResource;
-exports.validateType = validateType;
-exports.whenReady = whenReady;
-exports.xml = xml;
-
-
-__info__.date = '2026-01-14T19:21:38.789Z';
-__info__.hash = '2278017';
-__info__.url = 'https://github.com/odoo/owl';