@odoo/owl 2.8.1 → 3.0.0-alpha.10

package/dist/owl.iife.runtime.js

@@ -0,0 +1,4098 @@
+(function (exports) {
+    'use strict';
+
+    // 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 (computation.isDerived)
+            onReadAtom(computation);
+        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 makeChildFiber(node, parent) {
+        let current = node.fiber;
+        if (current) {
+            cancelFibers(current.children);
+            current.root = null;
+        }
+        return new Fiber(node, parent);
+    }
+    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.deep = false;
+            this.childrenMap = {};
+            this.node = node;
+            this.parent = parent;
+            if (parent) {
+                this.deep = parent.deep;
+                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.willUpdateProps = [];
+            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(this.signalComputation);
+            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) {
+                if (!current.bdom && !fibersInError.has(current)) {
+                    if (deep) {
+                        // we want the render from this point on to be with deep=true
+                        current.deep = deep;
+                    }
+                    return;
+                }
+                // if current rendering was with deep=true, we want this one to be the same
+                deep = deep || current.deep;
+            }
+            else if (!this.bdom) {
+                return;
+            }
+            const fiber = makeRootFiber(this);
+            fiber.deep = deep;
+            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 */;
+        }
+        async updateAndRender(props, parentFiber) {
+            props = Object.assign({}, props);
+            // update
+            const fiber = makeChildFiber(this, parentFiber);
+            this.fiber = fiber;
+            const component = this.component;
+            let prom;
+            untrack(() => {
+                prom = Promise.all(this.willUpdateProps.map((f) => f.call(component, props)));
+            });
+            await prom;
+            if (fiber !== this.fiber) {
+                return;
+            }
+            this.props = props;
+            fiber.render();
+            const parentRoot = parentFiber.root;
+            if (this.willPatch.length) {
+                parentRoot.willPatch.push(fiber);
+            }
+            if (this.patched.length) {
+                parentRoot.patched.push(fiber);
+            }
+        }
+        /**
+         * 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();
+        }
+    }
+
+    let currentPluginManager = null;
+    const _getCurrentPluginManager = () => currentPluginManager;
+    class Plugin {
+        setup() { }
+    }
+    Plugin.id = "";
+    class PluginManager {
+        constructor(parent) {
+            var _a;
+            this.children = [];
+            this.onDestroyCb = [];
+            this.status = 0 /* STATUS.NEW */;
+            this.parent = parent;
+            (_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) {
+            const previousManager = currentPluginManager;
+            currentPluginManager = this;
+            const plugins = [];
+            // instantiate plugins
+            for (const pluginType of pluginTypes) {
+                if (!pluginType.id) {
+                    currentPluginManager = previousManager;
+                    throw new OwlError(`Plugin "${pluginType.name}" has no id`);
+                }
+                if (this.plugins.hasOwnProperty(pluginType.id)) {
+                    continue;
+                }
+                const plugin = new pluginType();
+                this.plugins[pluginType.id] = plugin;
+                plugins.push(plugin);
+            }
+            // setup phase
+            for (let p of plugins) {
+                p.setup();
+            }
+            currentPluginManager = previousManager;
+            if (!currentPluginManager) {
+                this.status = 1 /* STATUS.MOUNTED */;
+            }
+            return plugins;
+        }
+    }
+    function plugin(pluginType) {
+        // getCurrent will throw if we're not in a component
+        const manager = currentPluginManager || getCurrent().pluginManager;
+        let plugin = manager.getPluginById(pluginType.id);
+        if (!plugin) {
+            if (manager === currentPluginManager) {
+                manager.startPlugins([pluginType]);
+                plugin = manager.getPluginById(pluginType.id);
+            }
+            else {
+                throw new OwlError(`Unknown plugin "${pluginType.id}"`);
+            }
+        }
+        return plugin;
+    }
+
+    // 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) {
+        return 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) {
+        onReadAtom(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) {
+        const keyToAtomItem = targetToKeysToAtomItem.get(target);
+        if (!keyToAtomItem) {
+            return;
+        }
+        const atom = keyToAtomItem.get(key);
+        if (!atom) {
+            return;
+        }
+        onWriteAtom(atom);
+    }
+    // Maps proxy objects to the underlying target
+    const targets = new WeakMap();
+    const proxyCache = new WeakMap();
+    /**
+     * 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) {
+        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)
+            : basicProxyHandler();
+        const proxy = new Proxy(target, handler);
+        proxyCache.set(target, proxy);
+        targets.set(proxy, target);
+        return proxy;
+    }
+    /**
+     * Creates a basic proxy handler for regular objects and arrays.
+     *
+     * @param callback @see proxy
+     * @returns a proxy handler object
+     */
+    function basicProxyHandler() {
+        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);
+                return possiblyReactive(Reflect.get(target, key, receiver));
+            },
+            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);
+                }
+                // 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);
+                }
+                return ret;
+            },
+            deleteProperty(target, key) {
+                const ret = Reflect.deleteProperty(target, key);
+                // TODO: only notify when something was actually deleted
+                onWriteTargetKey(target, KEYCHANGES);
+                onWriteTargetKey(target, key);
+                return ret;
+            },
+            ownKeys(target) {
+                onReadTargetKey(target, KEYCHANGES);
+                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);
+                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) {
+        return (key) => {
+            key = toRaw(key);
+            onReadTargetKey(target, key);
+            return possiblyReactive(target[methodName](key));
+        };
+    }
+    /**
+     * 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) {
+        return function* () {
+            onReadTargetKey(target, KEYCHANGES);
+            const keys = target.keys();
+            for (const item of target[methodName]()) {
+                const key = keys.next().value;
+                onReadTargetKey(target, key);
+                yield possiblyReactive(item);
+            }
+        };
+    }
+    /**
+     * 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) {
+        return function forEach(forEachCb, thisArg) {
+            onReadTargetKey(target, KEYCHANGES);
+            target.forEach(function (val, key, targetObj) {
+                onReadTargetKey(target, key);
+                forEachCb.call(thisArg, possiblyReactive(val), possiblyReactive(key), possiblyReactive(targetObj));
+            }, 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) {
+        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);
+            }
+            if (originalValue !== target[getterName](key)) {
+                onWriteTargetKey(target, key);
+            }
+            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) {
+        return () => {
+            const allKeys = [...target.keys()];
+            target.clear();
+            onWriteTargetKey(target, KEYCHANGES);
+            for (const key of allKeys) {
+                onWriteTargetKey(target, key);
+            }
+        };
+    }
+    /**
+     * 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) => ({
+            has: makeKeyObserver("has", target),
+            add: delegateAndNotify("add", "has", target),
+            delete: delegateAndNotify("delete", "has", target),
+            keys: makeIteratorObserver("keys", target),
+            values: makeIteratorObserver("values", target),
+            entries: makeIteratorObserver("entries", target),
+            [Symbol.iterator]: makeIteratorObserver(Symbol.iterator, target),
+            forEach: makeForEachObserver(target),
+            clear: makeClearNotifier(target),
+            get size() {
+                onReadTargetKey(target, KEYCHANGES);
+                return target.size;
+            },
+        }),
+        Map: (target) => ({
+            has: makeKeyObserver("has", target),
+            get: makeKeyObserver("get", target),
+            set: delegateAndNotify("set", "get", target),
+            delete: delegateAndNotify("delete", "has", target),
+            keys: makeIteratorObserver("keys", target),
+            values: makeIteratorObserver("values", target),
+            entries: makeIteratorObserver("entries", target),
+            [Symbol.iterator]: makeIteratorObserver(Symbol.iterator, target),
+            forEach: makeForEachObserver(target),
+            clear: makeClearNotifier(target),
+            get size() {
+                onReadTargetKey(target, KEYCHANGES);
+                return target.size;
+            },
+        }),
+        WeakMap: (target) => ({
+            has: makeKeyObserver("has", target),
+            get: makeKeyObserver("get", target),
+            set: delegateAndNotify("set", "get", target),
+            delete: delegateAndNotify("delete", "has", target),
+        }),
+    };
+    /**
+     * 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) {
+        // TODO: if performance is an issue we can create the special handlers lazily when each
+        // property is read.
+        const specialHandlers = rawTypeToFuncHandlers[targetRawType](target);
+        return Object.assign(basicProxyHandler(), {
+            // 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);
+                return possiblyReactive(target[key]);
+            },
+        });
+    }
+
+    // -----------------------------------------------------------------------------
+    //  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 onWillUpdateProps(fn) {
+        const node = getCurrent();
+        node.willUpdateProps.push(decorate(node, fn, "onWillUpdateProps"));
+    }
+    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 = _getCurrentPluginManager();
+        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));
+    }
+
+    // -----------------------------------------------------------------------------
+    // helpers
+    // -----------------------------------------------------------------------------
+    const isUnionType = (t) => Array.isArray(t);
+    const isBaseType = (t) => typeof t !== "object";
+    const isValueType = (t) => typeof t === "object" && t && "value" in t;
+    function isOptional(t) {
+        return typeof t === "object" && "optional" in t ? t.optional || false : false;
+    }
+    function describeType(type) {
+        return type === "*" || type === true ? "value" : type.name.toLowerCase();
+    }
+    function describe(info) {
+        if (isBaseType(info)) {
+            return describeType(info);
+        }
+        else if (isUnionType(info)) {
+            return info.map(describe).join(" or ");
+        }
+        else if (isValueType(info)) {
+            return String(info.value);
+        }
+        if ("element" in info) {
+            return `list of ${describe({ type: info.element, optional: false })}s`;
+        }
+        if ("shape" in info) {
+            return `object`;
+        }
+        return describe(info.type || "*");
+    }
+    function toSchema(spec) {
+        return Object.fromEntries(spec.map((e) => e.endsWith("?") ? [e.slice(0, -1), { optional: true }] : [e, { type: "*", optional: false }]));
+    }
+    /**
+     * Main validate function
+     */
+    function validate(obj, spec) {
+        let errors = validateSchema(obj, spec);
+        if (errors.length) {
+            throw new OwlError("Invalid object: " + errors.join(", "));
+        }
+    }
+    /**
+     * Helper validate function, to get the list of errors. useful if one want to
+     * manipulate the errors without parsing an error object
+     */
+    function validateSchema(obj, schema) {
+        if (Array.isArray(schema)) {
+            schema = toSchema(schema);
+        }
+        // obj = toRaw(obj);
+        let errors = [];
+        // check if each value in obj has correct shape
+        for (let key in obj) {
+            if (key in schema) {
+                let result = validateType(key, obj[key], schema[key]);
+                if (result) {
+                    errors.push(result);
+                }
+            }
+            else if (!("*" in schema)) {
+                errors.push(`unknown key '${key}'`);
+            }
+        }
+        // check that all specified keys are defined in obj
+        for (let key in schema) {
+            const spec = schema[key];
+            if (key !== "*" && !isOptional(spec) && !(key in obj)) {
+                const isObj = typeof spec === "object" && !Array.isArray(spec);
+                const isAny = spec === "*" || (isObj && "type" in spec ? spec.type === "*" : isObj);
+                let detail = isAny ? "" : ` (should be a ${describe(spec)})`;
+                errors.push(`'${key}' is missing${detail}`);
+            }
+        }
+        return errors;
+    }
+    function validateBaseType(key, value, type) {
+        if (typeof type === "function") {
+            if (typeof value === "object") {
+                if (!(value instanceof type)) {
+                    return `'${key}' is not a ${describeType(type)}`;
+                }
+            }
+            else if (typeof value !== type.name.toLowerCase()) {
+                return `'${key}' is not a ${describeType(type)}`;
+            }
+        }
+        return null;
+    }
+    function validateArrayType(key, value, descr) {
+        if (!Array.isArray(value)) {
+            return `'${key}' is not a list of ${describe(descr)}s`;
+        }
+        for (let i = 0; i < value.length; i++) {
+            const error = validateType(`${key}[${i}]`, value[i], descr);
+            if (error) {
+                return error;
+            }
+        }
+        return null;
+    }
+    function validateType(key, value, descr) {
+        if (value === undefined) {
+            return isOptional(descr) ? null : `'${key}' is undefined (should be a ${describe(descr)})`;
+        }
+        else if (isBaseType(descr)) {
+            return validateBaseType(key, value, descr);
+        }
+        else if (isValueType(descr)) {
+            return value === descr.value ? null : `'${key}' is not equal to '${descr.value}'`;
+        }
+        else if (isUnionType(descr)) {
+            let validDescr = descr.find((p) => !validateType(key, value, p));
+            return validDescr ? null : `'${key}' is not a ${describe(descr)}`;
+        }
+        let result = null;
+        if ("element" in descr) {
+            result = validateArrayType(key, value, descr.element);
+        }
+        else if ("shape" in descr) {
+            if (typeof value !== "object" || Array.isArray(value)) {
+                result = `'${key}' is not an object`;
+            }
+            else {
+                const errors = validateSchema(value, descr.shape);
+                if (errors.length) {
+                    result = `'${key}' doesn't have the correct shape (${errors.join(", ")})`;
+                }
+            }
+        }
+        else if ("values" in descr) {
+            if (typeof value !== "object" || Array.isArray(value)) {
+                result = `'${key}' is not an object`;
+            }
+            else {
+                const errors = Object.entries(value)
+                    .map(([key, value]) => validateType(key, value, descr.values))
+                    .filter(Boolean);
+                if (errors.length) {
+                    result = `some of the values in '${key}' are invalid (${errors.join(", ")})`;
+                }
+            }
+        }
+        if ("type" in descr && !result) {
+            result = validateType(key, value, descr.type);
+        }
+        if ("validate" in descr && !result) {
+            result = !descr.validate(value) ? `'${key}' is not valid` : null;
+        }
+        return result;
+    }
+
+    function validateProps(componentName, props, validation, keys) {
+        const propsToValidate = Object.create(null);
+        const errors = [];
+        for (const key of keys) {
+            if (key in props) {
+                propsToValidate[key] = props[key];
+            }
+            if (propsToValidate[key] === undefined &&
+                !Array.isArray(validation) &&
+                validation[key].defaultValue !== undefined) {
+                if (!validation[key].optional) {
+                    errors.push(`A default value cannot be defined for the mandatory prop '${key}'`);
+                    continue;
+                }
+                propsToValidate[key] = validation[key].defaultValue;
+            }
+        }
+        errors.push(...validateSchema(propsToValidate, validation));
+        if (errors.length) {
+            throw new OwlError(`Invalid props for component '${componentName}': ` + errors.join(", "));
+            // node.app.handleError({
+            //   error: new OwlError(`Invalid props for component '${componentName}': ` + errors.join(", ")),
+            //   node,
+            // });
+        }
+    }
+    function props(validation) {
+        const node = getCurrent();
+        const isSchemaValidated = validation && !Array.isArray(validation);
+        function getProp(key) {
+            if (isSchemaValidated && node.props[key] === undefined) {
+                return validation[key].defaultValue;
+            }
+            return node.props[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 (validation) {
+            const keys = (isSchemaValidated ? Object.keys(validation) : validation).map((key) => key.endsWith("?") ? key.slice(0, -1) : key);
+            applyPropGetters(keys);
+            if (node.app.dev) {
+                validateProps(node.name, node.props, validation, keys);
+                node.willUpdateProps.push((np) => {
+                    validateProps(node.name, np, validation, keys);
+                });
+            }
+        }
+        else {
+            applyPropGetters(Object.keys(node.props));
+            node.willUpdateProps.push((np) => {
+                for (let key in result) {
+                    Reflect.deleteProperty(result, key);
+                }
+                applyPropGetters(Object.keys(np));
+            });
+        }
+        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,
+                slots: true,
+            });
+        }
+        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.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, hasSlotsProp, hasDynamicPropList, propList) {
+            const isDynamic = !isStatic;
+            let arePropsDifferent;
+            const hasNoProp = propList.length === 0;
+            if (hasSlotsProp) {
+                arePropsDifferent = (_1, _2) => true;
+            }
+            else if (hasDynamicPropList) {
+                arePropsDifferent = function (props1, props2) {
+                    for (let k in props1) {
+                        if (props1[k] !== props2[k]) {
+                            return true;
+                        }
+                    }
+                    return Object.keys(props1).length !== Object.keys(props2).length;
+                };
+            }
+            else if (hasNoProp) {
+                arePropsDifferent = (_1, _2) => false;
+            }
+            else {
+                arePropsDifferent = function (props1, props2) {
+                    for (let p of propList) {
+                        if (props1[p] !== props2[p]) {
+                            return true;
+                        }
+                    }
+                    return false;
+                };
+            }
+            const updateAndRender = ComponentNode.prototype.updateAndRender;
+            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) {
+                    if (arePropsDifferent(node.props, props) || parentFiber.deep || node.forceNextRender) {
+                        node.forceNextRender = false;
+                        updateAndRender.call(node, props, parentFiber);
+                    }
+                }
+                else {
+                    // 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);
+            return derivedComputation.value;
+        };
+    }
+
+    function signal(value, opts) {
+        const atom = {
+            value,
+            observers: new Set(),
+            name: opts === null || opts === void 0 ? void 0 : opts.name,
+        };
+        const read = () => {
+            onReadAtom(atom);
+            return atom.value;
+        };
+        const write = (newValue) => {
+            if (typeof newValue === "function") {
+                newValue = newValue(atom.value);
+            }
+            if (Object.is(atom.value, newValue))
+                return;
+            atom.value = newValue;
+            onWriteAtom(atom);
+        };
+        read.set = write;
+        read.update = (updater) => {
+            if (updater) {
+                write(updater(atom.value));
+            }
+            else {
+                onWriteAtom(atom);
+            }
+        };
+        return read;
+    }
+
+    class Resource {
+        constructor(name, type) {
+            this._items = signal([]);
+            this.items = computed(() => {
+                return this._items()
+                    .sort((el1, el2) => el1[0] - el2[0])
+                    .map((elem) => elem[1]);
+            });
+            this._name = name || "resource";
+            this._type = type;
+        }
+        add(item, sequence = 50) {
+            if (this._type) {
+                const error = validateType("item", item, this._type);
+                if (error) {
+                    throw new Error(`Invalid type: ${error} (resource '${this._name}')`);
+                }
+            }
+            this._items().push([sequence, item]);
+            this._items.update();
+            return this;
+        }
+        remove(item) {
+            const items = this._items().filter(([seq, val]) => val !== item);
+            this._items.set(items);
+            return this;
+        }
+    }
+    function useResource(r, elements) {
+        for (let elem of elements) {
+            r.add(elem);
+        }
+        onWillDestroy(() => {
+            for (let elem of elements) {
+                r.remove(elem);
+            }
+        });
+    }
+
+    class Registry {
+        constructor(name, type) {
+            this._map = signal(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 = name || "registry";
+            this._type = type;
+        }
+        addById(item, sequence = 50) {
+            if (!item.id) {
+                throw new Error(`Item should have an id key`);
+            }
+            return this.add(item.id, item, sequence);
+        }
+        add(key, value, sequence = 50) {
+            if (this._type) {
+                const error = validateType(key, value, this._type);
+                // todo: move error handling in validation.js
+                if (error) {
+                    throw new Error("Invalid type: " + error);
+                }
+            }
+            this._map()[key] = [sequence, value];
+            this._map.update();
+            return this;
+        }
+        get(key, defaultValue) {
+            const hasKey = key in this._map();
+            if (!hasKey && arguments.length < 2) {
+                throw new Error(`KeyNotFoundError: Cannot find key "${key}" in this registry`);
+            }
+            return hasKey ? this._map()[key][1] : defaultValue;
+        }
+        remove(key) {
+            delete this._map()[key];
+            this._map.update();
+        }
+    }
+
+    function status() {
+        const pm = _getCurrentPluginManager();
+        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) {
+        let cleanup = null;
+        let effectCleanup = effect(() => {
+            cleanup === null || cleanup === void 0 ? void 0 : cleanup();
+            cleanup = fn();
+        });
+        onWillDestroy(() => {
+            cleanup === null || cleanup === void 0 ? void 0 : cleanup();
+            effectCleanup();
+        });
+    }
+    // -----------------------------------------------------------------------------
+    // 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 correctly add and remove the event listener, whenever the
+     * component is mounted and unmounted.
+     *
+     * 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) {
+        const node = getCurrent();
+        const boundHandler = handler.bind(node.component);
+        onMounted(() => target.addEventListener(eventName, boundHandler, eventParams));
+        onWillUnmount(() => target.removeEventListener(eventName, boundHandler, eventParams));
+    }
+    function usePlugins(Plugins) {
+        const node = getCurrent();
+        const manager = new PluginManager(node.pluginManager);
+        node.pluginManager = manager;
+        onWillDestroy(() => manager.destroy());
+        return manager.startPlugins(Plugins);
+    }
+
+    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.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.onWillUpdateProps = onWillUpdateProps;
+    exports.plugin = plugin;
+    exports.props = props;
+    exports.proxy = proxy;
+    exports.signal = signal;
+    exports.status = status;
+    exports.toRaw = toRaw;
+    exports.untrack = untrack;
+    exports.useComponent = useComponent;
+    exports.useEffect = useEffect;
+    exports.useListener = useListener;
+    exports.usePlugins = usePlugins;
+    exports.useResource = useResource;
+    exports.validate = validate;
+    exports.validateType = validateType;
+    exports.whenReady = whenReady;
+    exports.xml = xml;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+
+    __info__.date = '2025-12-15T09:45:48.537Z';
+    __info__.hash = '4af29e6';
+    __info__.url = 'https://github.com/odoo/owl';
+
+
+})(this.owl = this.owl || {});