@odoo/owl 2.8.1 → 3.0.0-alpha.10

package/dist/owl.es.runtime.js

@@ -0,0 +1,4050 @@
+// 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,
+};
+
+export { App, Component, EventBus, OwlError, Plugin, PluginManager, Registry, Resource, __info__, batched, blockDom, computed, effect, htmlEscape, markRaw, markup, mount, onError, onMounted, onPatched, onWillDestroy, onWillPatch, onWillStart, onWillUnmount, onWillUpdateProps, plugin, props, proxy, signal, status, toRaw, untrack, useComponent, useEffect, useListener, usePlugins, useResource, validate, validateType, whenReady, xml };
+
+
+__info__.date = '2025-12-15T09:45:48.537Z';
+__info__.hash = '4af29e6';
+__info__.url = 'https://github.com/odoo/owl';