From bf7fccb3f731d068c8ffe8e1b90dbe6cb6302992 Mon Sep 17 00:00:00 2001
From: "Manushi Shah (mash)" <mash@odoo.com>
Date: Mon, 13 Mar 2023 15:50:36 +0530
Subject: [PATCH 1/6] Guessing Random Numbers

---
 Workshop Day 1/numberGuess.html | 57 +++++++++++++++++++++++++++++++++
 1 file changed, 57 insertions(+)
 create mode 100644 Workshop Day 1/numberGuess.html
diff --git a/Workshop Day 1/numberGuess.html b/Workshop Day 1/numberGuess.html
new file mode 100644
index 0000000..46911c9
--- /dev/null
+++ b/Workshop Day 1/numberGuess.html	
@@ -0,0 +1,57 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <title>Random Number Guess</title>
+        <script>
+            var rand = Math.floor(Math.random() * 10)+1;
+            var guesses = 5;
+            flag=0;
+            function check(){
+                let number = document.getElementById("no").value;
+                
+                
+                    if(number > rand){
+                        document.getElementById("result").innerHTML+="<br/>High!";
+                        console.log(guesses);
+                    }
+                    else if(number < rand){
+                        document.getElementById("result").innerHTML+="<br/>Low!";
+                        console.log(guesses);
+                    }
+                    else{
+                        document.getElementById("result").innerHTML+="<br/>Correct!";
+                        document.getElementById("no").disabled = true;
+                        flag=1;
+                    }
+
+                    guesses--;
+
+                    if (guesses == 0 && flag==0){
+                        result.innerHTML += "<br>Game over. The correct number was " + rand + "!!";
+                        document.getElementById("no").disabled = true;
+                    }
+
+                    document.getElementById("guessesRemaining").innerHTML = "Guesses remaining: " + guesses;
+                }
+        </script>
+        <style>
+            .container{
+               text-align: center;
+               padding: 50px;
+               float: left;
+               background-color: aquamarine;
+            }
+
+        </style>
+    </head>
+    <body>
+        <div class="container">
+            <h1>Guess a number</h1>
+            <p id="guessesRemaining">Guesses remaining: 3</p>
+            <p>Guess a number between 1 to 10 : </p>
+            <input type = "text" id = "no">
+            <button onclick="check()" id = "check">Check!</button>
+            <div id = "result">
+        </div>
+    </body>
+</html>
\ No newline at end of file

From 489d19b0e25d61147a439bacffbbf394ac6565db Mon Sep 17 00:00:00 2001
From: "Manushi Shah (mash)" <mash@odoo.com>
Date: Mon, 13 Mar 2023 18:55:09 +0530
Subject: [PATCH 2/6] Api Fetch and Next Button

---
 Workshop Day 1/apiFetch.html    | 111 ++++++++++++++++++++++++++++++++
 Workshop Day 1/numberGuess.html |  47 +++++++-------
 2 files changed, 134 insertions(+), 24 deletions(-)
 create mode 100644 Workshop Day 1/apiFetch.html

diff --git a/Workshop Day 1/apiFetch.html b/Workshop Day 1/apiFetch.html
new file mode 100644
index 0000000..b99c1a1
--- /dev/null
+++ b/Workshop Day 1/apiFetch.html	
@@ -0,0 +1,111 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <title>Fetching API</title>
+        <script>
+            
+            const url = "https://fakestoreapi.com/products";
+            const itemsPerPage = 5;  // Change this to adjust the number of items per page
+            let currentPage = 1;
+            let data = [];
+
+            async function getapi(url) {
+    
+                // Storing response
+                const response = await fetch(url);
+                
+                // Storing data in form of JSON
+                data = await response.json();
+                console.log(data);
+                if (response) {
+                    hideloader();
+                }
+                show(currentPage);
+            }
+
+            getapi(url);
+                
+            // Function to hide the loader
+            function hideloader() {
+                document.getElementById('loading').style.display = 'none';
+            }
+
+            function show(pageNumber) {
+                let start = (pageNumber - 1) * itemsPerPage;
+                let end = start + itemsPerPage;
+                let pageData = data.slice(start, end);
+
+                let tab = 
+                    `<tr>
+                    <th>Id</th>
+                    <th>Category</th>
+                    <th>Price</th>
+                    <th>Description</th>
+                    <th>Rating</th>
+                    <th>Count</th>
+                    <th>Image</th>
+                    </tr>`;
+                
+                // Loop to access all rows 
+
+                pageData.forEach(r => {
+                        
+                    tab += `<tr> 
+                    <td>${r.id} </td>
+                    <td>${r.category}</td>
+                    <td>${r.price}</td> 
+                    <td style="text-align:left">${r.description}</td>
+                    <td>${r.rating.rate} </td>
+                    <td>${r.rating.count} </td>
+                    <td><img src="${r.image}" alt="product image" width="100" height="100"></td>
+                </tr>`;
+
+                });
+
+                document.getElementById("products").innerHTML = tab;
+            }
+
+            function nextPage() {
+                currentPage++;
+                if (currentPage > Math.ceil(data.length / itemsPerPage)) {
+                    currentPage = 1;
+                }
+                show(currentPage);
+            }
+                        
+        </script>
+        <style>
+            table,td{
+                border: 2px solid black;
+                border-collapse: collapse;
+                text-align: center;
+            }
+            tr:hover{
+                background-color: rgb(192, 233, 249);
+            }
+            #next{
+                margin-top: 20px;
+                margin-left: 800px;
+                height: 40px;
+                width: 80px;
+                border-radius: 10px;
+            }
+            #next:hover{
+                background-color: rgb(18, 137, 153);
+                color: white;
+            }
+        </style>
+    </head>
+    <body>
+        <div class="d-flex justify-content-center">
+            <div class="spinner-border" 
+                 role="status" id="loading">
+                <span class="sr-only">Loading...</span>
+            </div>
+        </div>
+        <h1>Registered Products</h1>
+        <!-- table for showing data -->
+        <table id="products"></table>
+        <button onclick="nextPage()" id="next">Next</button>
+    </body>
+</html>
diff --git a/Workshop Day 1/numberGuess.html b/Workshop Day 1/numberGuess.html
index 46911c9..5268162 100644
--- a/Workshop Day 1/numberGuess.html	
+++ b/Workshop Day 1/numberGuess.html	
@@ -4,35 +4,34 @@
         <title>Random Number Guess</title>
         <script>
             var rand = Math.floor(Math.random() * 10)+1;
-            var guesses = 5;
+            var guesses = 3;
             flag=0;
+
             function check(){
+
                 let number = document.getElementById("no").value;
                 
-                
-                    if(number > rand){
-                        document.getElementById("result").innerHTML+="<br/>High!";
-                        console.log(guesses);
-                    }
-                    else if(number < rand){
-                        document.getElementById("result").innerHTML+="<br/>Low!";
-                        console.log(guesses);
-                    }
-                    else{
-                        document.getElementById("result").innerHTML+="<br/>Correct!";
-                        document.getElementById("no").disabled = true;
-                        flag=1;
-                    }
-
-                    guesses--;
-
-                    if (guesses == 0 && flag==0){
-                        result.innerHTML += "<br>Game over. The correct number was " + rand + "!!";
-                        document.getElementById("no").disabled = true;
-                    }
-
-                    document.getElementById("guessesRemaining").innerHTML = "Guesses remaining: " + guesses;
+                if(number > rand){
+                    document.getElementById("result").innerHTML+="<br/>High!";
+                    console.log(guesses);
                 }
+                else if(number < rand){
+                    document.getElementById("result").innerHTML+="<br/>Low!";
+                    console.log(guesses);
+                }
+                else{
+                    document.getElementById("result").innerHTML+="<br/>Correct!";
+                    document.getElementById("no").disabled = true;
+                    flag=1;
+                }
+                guesses--;
+                if (guesses == 0 && flag==0){
+                    result.innerHTML += "<br>Game over. The correct number was " + rand + "!!";
+                    document.getElementById("no").disabled = true;
+                }
+                document.getElementById("guessesRemaining").innerHTML = "Guesses remaining: " + guesses;
+
+            }
         </script>
         <style>
             .container{

From a3c6ee731681280e23f0e2ad561d0237be2d2446 Mon Sep 17 00:00:00 2001
From: "Manushi Shah (mash)" <mash@odoo.com>
Date: Tue, 14 Mar 2023 15:59:55 +0530
Subject: [PATCH 3/6] Number Guess using OWL

---
 Workshop Day 2/day2.html           |    7 +
 Workshop Day 2/day2.js             |  107 +
 Workshop Day 2/numberGuess.js      |   76 +
 Workshop Day 2/numberGuessOWL.html |    9 +
 Workshop Day 2/owl.js              | 5938 ++++++++++++++++++++++++++++
 5 files changed, 6137 insertions(+)
 create mode 100644 Workshop Day 2/day2.html
 create mode 100644 Workshop Day 2/day2.js
 create mode 100644 Workshop Day 2/numberGuess.js
 create mode 100644 Workshop Day 2/numberGuessOWL.html
 create mode 100644 Workshop Day 2/owl.js

diff --git a/Workshop Day 2/day2.html b/Workshop Day 2/day2.html
new file mode 100644
index 0000000..80ae8d2
--- /dev/null
+++ b/Workshop Day 2/day2.html	
@@ -0,0 +1,7 @@
+<!DOCTYPE html>
+<html>
+    <body>
+        <script src="owl.js"></script>
+        <script src="day2.js"></script>
+    </body>
+</html>
\ No newline at end of file
diff --git a/Workshop Day 2/day2.js b/Workshop Day 2/day2.js
new file mode 100644
index 0000000..b896704
--- /dev/null
+++ b/Workshop Day 2/day2.js	
@@ -0,0 +1,107 @@
+const {Component, mount, xml, onWillRender, onWillStart, onMounted, onWillPatch, onRendered, onPatched, onError,
+        onWillUnmount, onWillDestroy, useState, reactive, useEnv} = owl;
+
+const finalData = () => {
+    const apple = useEnv();
+    return useState(apple.store);
+}
+
+class dataList {
+    count = 0;
+    updateCount() { this.count++; }
+    getCount(){ return this.count; }
+}
+
+class Second extends Component{
+    static template = xml`
+        <b>Second</b><br/>
+        <t t-esc = "props.fruit"/><br/>
+        <t t-esc = "props.cafe.tea"/><br/>
+        <t t-esc = "this.bottle.getCount()"/><br/>
+    `;
+
+    static props = ["fruit","cafe"];
+
+    setup(){
+        this.bottle = finalData();
+    }
+}
+
+class Root extends Component{
+
+    static template = xml`
+            <b>Hello</b><br/>
+            <Second fruit="abc" cafe="cafe"/>
+            <button t-on-click="clickMe">Click!</button>
+        `;
+
+    abc = "apple";
+
+    setup(){
+        onWillRender(() => console.log("Will Render"));
+        onWillStart(() => console.log("Will Start"));
+        onMounted(() => console.log("Mounted"));
+        onWillPatch(() => console.log("Will Patch"));
+        onPatched(() => console.log("Patched"));
+        onRendered(() => console.log("Rendered"));
+        onWillUnmount(() => console.log("Will Unmount"));
+        onWillDestroy(() => console.log("Will Destroy"));
+        onError(() => console.log("Error"));
+
+        this.cafe = useState({tea:3, cofee:4});
+        this.cap = finalData();
+
+    }
+
+    clickMe(){
+        console.log("Clicked");
+        this.cap.updateCount();
+    }
+
+    static components = {Second};
+}
+
+const createData = () => {
+    return reactive(new dataList);
+}
+
+const env = { store : createData() }
+
+mount(Root, document.body, {dev : true, env});
+
+
+//2 components, guess and user input
+
+// const {Component, mount, xml} = owl;
+
+// class Second extends Component{
+//     static template = xml`
+//         <b>Second</b><br/>
+//         <t t-esc = "props.fruit"/><br/>
+//         <t t-esc = "props.veggies"/>
+//     `;
+
+//     static props = ["fruit","veggies"];
+// }
+
+// class Root extends Component{
+
+//     static template = xml`
+//             <b>Hello</b><br/>
+//             <Second fruit="abc" veggies/>
+//         `;
+
+//     abc = "apple";
+
+//     static prop = ["veggies"]
+//     static components = {Second};
+// }
+
+// class Veg extends Component{
+//     static template = xml`
+//             <Root veggies="tomato"/>
+//         `;
+//     static components = {Root};
+// }
+
+// mount(Root, document.body);
\ No newline at end of file
diff --git a/Workshop Day 2/numberGuess.js b/Workshop Day 2/numberGuess.js
new file mode 100644
index 0000000..f0c67d6
--- /dev/null
+++ b/Workshop Day 2/numberGuess.js	
@@ -0,0 +1,76 @@
+const {Component , mount , xml , useState, useEnv, reactive} = owl;
+
+const rand = Math.floor(Math.random()*10)+1;
+let guesses = 3;
+let flag=0;
+
+const finalData = () => {
+    const guess = useEnv();
+    return useState(guess.store);
+}
+
+class Input extends Component {
+    static template = xml`
+    <input type="text" id="data" placeholder="Enter number b/w 1 to 10"/>
+    `;
+
+    getInput(){
+        const input = document.getElementById("data").value;
+        console.log(input);
+        return input;
+    }
+    
+}
+
+class Root extends Component {
+    static template = xml`
+    <h1>Guess the Number</h1>
+    <p>Guess a number between 1 to 10 : </p>
+    <Input />
+    <div></div><br/>
+    <button t-on-click="check">Guess!</button>
+    `;
+
+    
+    static components = { Input };
+
+    setup(){
+        this.user = finalData();
+    }
+
+    check(){
+
+        let no = this.user.getInput()
+
+        console.log('clicked');
+        
+        console.log('co'+rand);
+
+        if(no > rand){
+            console.log("High");
+        }
+        else if(no < rand){
+            console.log("Low");
+        }
+        else{
+            console.log("Correct");
+            document.getElementById("data").disabled = true;
+            flag=1;
+        }
+
+        guesses--;
+
+        if(guesses==0 && flag==0){
+            console.log("Game over. The correct number was " + rand + "!!")
+            document.getElementById("data").disabled = true;
+        }
+    }
+}
+
+const createData = () => {
+    return reactive(new Input);
+}
+
+const env = {store : createData()};
+
+mount(Root,document.body,{dev: true,env});
\ No newline at end of file
diff --git a/Workshop Day 2/numberGuessOWL.html b/Workshop Day 2/numberGuessOWL.html
new file mode 100644
index 0000000..26c5db0
--- /dev/null
+++ b/Workshop Day 2/numberGuessOWL.html	
@@ -0,0 +1,9 @@
+<!DOCTYPE html>
+<html>
+    <body>
+        <script src = "owl.js"></script>
+        <script src = "numberGuess.js"></script>
+    </body>
+</html>
+
+
diff --git a/Workshop Day 2/owl.js b/Workshop Day 2/owl.js
new file mode 100644
index 0000000..b07d8c8
--- /dev/null
+++ b/Workshop Day 2/owl.js	
@@ -0,0 +1,5938 @@
+(function (exports) {
+    'use strict';
+
+    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
+    // -----------------------------------------------------------------------------
+    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 {
+                child2.mount(this.parentEl, child1.firstNode());
+                if (withBeforeRemove) {
+                    child1.beforeRemove();
+                }
+                child1.remove();
+                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);
+    }
+
+    // Custom error class that wraps error that happen in the owl lifecycle
+    class OwlError extends Error {
+    }
+    // Maps fibers to thrown errors
+    const fibersInError = new WeakMap();
+    const nodeErrorHandlers = new WeakMap();
+    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
+            for (let i = errorHandlers.length - 1; i >= 0; i--) {
+                try {
+                    errorHandlers[i](error);
+                    handled = true;
+                    break;
+                }
+                catch (e) {
+                    error = e;
+                }
+            }
+            if (handled) {
+                return true;
+            }
+        }
+        return _handleError(node.parent, error);
+    }
+    function handleError(params) {
+        let { error } = params;
+        // Wrap error if it wasn't wrapped by wrapError (ie when not in dev mode)
+        if (!(error instanceof OwlError)) {
+            error = Object.assign(new OwlError(`An error occured in the owl lifecycle (see this Error's "cause" property)`), { cause: error });
+        }
+        const node = "node" in params ? params.node : params.fiber.node;
+        const fiber = "fiber" in params ? params.fiber : node.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) {
+            console.warn(`[Owl] Unhandled error. Destroying the root component`);
+            try {
+                node.app.destroy();
+            }
+            catch (e) {
+                console.error(e);
+            }
+            throw error;
+        }
+    }
+
+    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)) {
+            setAttribute.call(this, attrs[0], attrs[1]);
+        }
+        else {
+            for (let k in attrs) {
+                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;
+                }
+                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)) {
+                    removeAttribute.call(this, k);
+                }
+            }
+            for (let k in attrs) {
+                const val = attrs[k];
+                if (val !== oldAttrs[k]) {
+                    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 || !currentTarget.ownerDocument.contains(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$1 = {};
+    /**
+     * 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$1) {
+            return cache$1[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$1[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("");
+                }
+                const attrs = node.attributes;
+                const ns = attrs.getNamedItem("block-ns");
+                if (ns) {
+                    attrs.removeNamedItem("block-ns");
+                    currentNS = ns.value;
+                }
+                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);
+                    }
+                    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, refList: [] };
+            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":
+                    const index = ctx.cbRefs.push(info.idx) - 1;
+                    ctx.locations.push({
+                        idx: info.idx,
+                        refIdx: info.refIdx,
+                        setData: makeRefSetter(index, ctx.refList),
+                        updateData: NO_OP,
+                    });
+            }
+        }
+    }
+    // -----------------------------------------------------------------------------
+    // building the concrete block class
+    // -----------------------------------------------------------------------------
+    function buildBlock(template, ctx) {
+        let B = createBlockClass(template, ctx);
+        if (ctx.cbRefs.length) {
+            const cbRefs = ctx.cbRefs;
+            const refList = ctx.refList;
+            let cbRefsNumber = cbRefs.length;
+            B = class extends B {
+                mount(parent, afterNode) {
+                    refList.push(new Array(cbRefsNumber));
+                    super.mount(parent, afterNode);
+                    for (let cbRef of refList.pop()) {
+                        cbRef();
+                    }
+                }
+                remove() {
+                    super.remove();
+                    for (let cbRef of cbRefs) {
+                        let fn = this.data[cbRef];
+                        fn(null);
+                    }
+                }
+            };
+        }
+        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 } = ctx;
+        const colN = collectors.length;
+        ctx.locations.sort((a, b) => a.idx - b.idx);
+        const locations = ctx.locations.map((loc) => ({
+            refIdx: loc.refIdx,
+            setData: loc.setData,
+            updateData: loc.updateData,
+        }));
+        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;
+            };
+            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;
+                        }
+                    }
+                }
+            };
+        }
+        return Block;
+    }
+    function setText(value) {
+        characterDataSetData.call(this, toText(value));
+    }
+    function makeRefSetter(index, refs) {
+        return function setRef(fn) {
+            refs[refs.length - 1][index] = () => fn(this);
+        };
+    }
+
+    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;
+            }
+            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 /* NEW */) {
+                node.destroy();
+                delete node.parent.children[node.parentKey];
+            }
+            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) {
+                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;
+            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
+                let mountedFibers = this.mounted;
+                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) {
+                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 /* 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 });
+            }
+        }
+    }
+
+    // Special key to subscribe to, to be notified of key creation/deletion
+    const KEYCHANGES = Symbol("Key changes");
+    // Used to specify the absence of a callback, can be used as WeakMap key but
+    // should only be used as a sentinel value and never called.
+    const NO_CALLBACK = () => {
+        throw new Error("Called NO_CALLBACK. Owl is broken, please report this to the maintainers.");
+    };
+    const objectToString = Object.prototype.toString;
+    const objectHasOwnProperty = Object.prototype.hasOwnProperty;
+    const SUPPORTED_RAW_TYPES = new Set(["Object", "Array", "Set", "Map", "WeakMap"]);
+    const COLLECTION_RAWTYPES = new Set(["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 reactive object.
+     *
+     * @param value the value to check
+     * @returns whether the value can be made reactive
+     */
+    function canBeMadeReactive(value) {
+        if (typeof value !== "object") {
+            return false;
+        }
+        return SUPPORTED_RAW_TYPES.has(rawType(value));
+    }
+    /**
+     * Creates a reactive from the given object/callback if possible and returns it,
+     * returns the original object otherwise.
+     *
+     * @param value the value make reactive
+     * @returns a reactive for the given object when possible, the original otherwise
+     */
+    function possiblyReactive(val, cb) {
+        return canBeMadeReactive(val) ? reactive(val, cb) : 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 reactive objet, return the raw (non reactive) underlying object
+     *
+     * @param value a reactive value
+     * @returns the underlying value
+     */
+    function toRaw(value) {
+        return targets.has(value) ? targets.get(value) : value;
+    }
+    const targetToKeysToCallbacks = new WeakMap();
+    /**
+     * 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 observeTargetKey(target, key, callback) {
+        if (callback === NO_CALLBACK) {
+            return;
+        }
+        if (!targetToKeysToCallbacks.get(target)) {
+            targetToKeysToCallbacks.set(target, new Map());
+        }
+        const keyToCallbacks = targetToKeysToCallbacks.get(target);
+        if (!keyToCallbacks.get(key)) {
+            keyToCallbacks.set(key, new Set());
+        }
+        keyToCallbacks.get(key).add(callback);
+        if (!callbacksToTargets.has(callback)) {
+            callbacksToTargets.set(callback, new Set());
+        }
+        callbacksToTargets.get(callback).add(target);
+    }
+    /**
+     * 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 notifyReactives(target, key) {
+        const keyToCallbacks = targetToKeysToCallbacks.get(target);
+        if (!keyToCallbacks) {
+            return;
+        }
+        const callbacks = keyToCallbacks.get(key);
+        if (!callbacks) {
+            return;
+        }
+        // Loop on copy because clearReactivesForCallback will modify the set in place
+        for (const callback of [...callbacks]) {
+            clearReactivesForCallback(callback);
+            callback();
+        }
+    }
+    const callbacksToTargets = new WeakMap();
+    /**
+     * Clears all subscriptions of the Reactives associated with a given callback.
+     *
+     * @param callback the callback for which the reactives need to be cleared
+     */
+    function clearReactivesForCallback(callback) {
+        const targetsToClear = callbacksToTargets.get(callback);
+        if (!targetsToClear) {
+            return;
+        }
+        for (const target of targetsToClear) {
+            const observedKeys = targetToKeysToCallbacks.get(target);
+            if (!observedKeys) {
+                continue;
+            }
+            for (const [key, callbacks] of observedKeys.entries()) {
+                callbacks.delete(callback);
+                if (!callbacks.size) {
+                    observedKeys.delete(key);
+                }
+            }
+        }
+        targetsToClear.clear();
+    }
+    function getSubscriptions(callback) {
+        const targets = callbacksToTargets.get(callback) || [];
+        return [...targets].map((target) => {
+            const keysToCallbacks = targetToKeysToCallbacks.get(target);
+            let keys = [];
+            if (keysToCallbacks) {
+                for (const [key, cbs] of keysToCallbacks) {
+                    if (cbs.has(callback)) {
+                        keys.push(key);
+                    }
+                }
+            }
+            return { target, keys };
+        });
+    }
+    // Maps reactive objects to the underlying target
+    const targets = new WeakMap();
+    const reactiveCache = new WeakMap();
+    /**
+     * Creates a reactive proxy for an object. Reading data on the reactive 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 reactive proxy
+     * @param callback the function to call when an observed property of the
+     *  reactive has changed
+     * @returns a proxy that tracks changes to it
+     */
+    function reactive(target, callback = NO_CALLBACK) {
+        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 reactive(targets.get(target), callback);
+        }
+        if (!reactiveCache.has(target)) {
+            reactiveCache.set(target, new WeakMap());
+        }
+        const reactivesForTarget = reactiveCache.get(target);
+        if (!reactivesForTarget.has(callback)) {
+            const targetRawType = rawType(target);
+            const handler = COLLECTION_RAWTYPES.has(targetRawType)
+                ? collectionsProxyHandler(target, callback, targetRawType)
+                : basicProxyHandler(callback);
+            const proxy = new Proxy(target, handler);
+            reactivesForTarget.set(callback, proxy);
+            targets.set(proxy, target);
+        }
+        return reactivesForTarget.get(callback);
+    }
+    /**
+     * Creates a basic proxy handler for regular objects and arrays.
+     *
+     * @param callback @see reactive
+     * @returns a proxy handler object
+     */
+    function basicProxyHandler(callback) {
+        return {
+            get(target, key, receiver) {
+                // non-writable non-configurable properties cannot be made reactive
+                const desc = Object.getOwnPropertyDescriptor(target, key);
+                if (desc && !desc.writable && !desc.configurable) {
+                    return Reflect.get(target, key, receiver);
+                }
+                observeTargetKey(target, key, callback);
+                return possiblyReactive(Reflect.get(target, key, receiver), callback);
+            },
+            set(target, key, value, receiver) {
+                const hadKey = objectHasOwnProperty.call(target, key);
+                const originalValue = Reflect.get(target, key, receiver);
+                const ret = Reflect.set(target, key, value, receiver);
+                if (!hadKey && objectHasOwnProperty.call(target, key)) {
+                    notifyReactives(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))) {
+                    notifyReactives(target, key);
+                }
+                return ret;
+            },
+            deleteProperty(target, key) {
+                const ret = Reflect.deleteProperty(target, key);
+                // TODO: only notify when something was actually deleted
+                notifyReactives(target, KEYCHANGES);
+                notifyReactives(target, key);
+                return ret;
+            },
+            ownKeys(target) {
+                observeTargetKey(target, KEYCHANGES, callback);
+                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.
+                observeTargetKey(target, KEYCHANGES, callback);
+                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 reactive
+     * @param callback @see reactive
+     */
+    function makeKeyObserver(methodName, target, callback) {
+        return (key) => {
+            key = toRaw(key);
+            observeTargetKey(target, key, callback);
+            return possiblyReactive(target[methodName](key), callback);
+        };
+    }
+    /**
+     * 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 reactive
+     * @param callback @see reactive
+     */
+    function makeIteratorObserver(methodName, target, callback) {
+        return function* () {
+            observeTargetKey(target, KEYCHANGES, callback);
+            const keys = target.keys();
+            for (const item of target[methodName]()) {
+                const key = keys.next().value;
+                observeTargetKey(target, key, callback);
+                yield possiblyReactive(item, callback);
+            }
+        };
+    }
+    /**
+     * 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 reactive.
+     *
+     * @param target @see reactive
+     * @param callback @see reactive
+     */
+    function makeForEachObserver(target, callback) {
+        return function forEach(forEachCb, thisArg) {
+            observeTargetKey(target, KEYCHANGES, callback);
+            target.forEach(function (val, key, targetObj) {
+                observeTargetKey(target, key, callback);
+                forEachCb.call(thisArg, possiblyReactive(val, callback), possiblyReactive(key, callback), possiblyReactive(targetObj, callback));
+            }, 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
+     * reactives 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 reactive
+     */
+    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) {
+                notifyReactives(target, KEYCHANGES);
+            }
+            if (originalValue !== value) {
+                notifyReactives(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 reactive
+     */
+    function makeClearNotifier(target) {
+        return () => {
+            const allKeys = [...target.keys()];
+            target.clear();
+            notifyReactives(target, KEYCHANGES);
+            for (const key of allKeys) {
+                notifyReactives(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
+     * reactive 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
+     * reactives that the key which is being added or deleted has been modified.
+     */
+    const rawTypeToFuncHandlers = {
+        Set: (target, callback) => ({
+            has: makeKeyObserver("has", target, callback),
+            add: delegateAndNotify("add", "has", target),
+            delete: delegateAndNotify("delete", "has", target),
+            keys: makeIteratorObserver("keys", target, callback),
+            values: makeIteratorObserver("values", target, callback),
+            entries: makeIteratorObserver("entries", target, callback),
+            [Symbol.iterator]: makeIteratorObserver(Symbol.iterator, target, callback),
+            forEach: makeForEachObserver(target, callback),
+            clear: makeClearNotifier(target),
+            get size() {
+                observeTargetKey(target, KEYCHANGES, callback);
+                return target.size;
+            },
+        }),
+        Map: (target, callback) => ({
+            has: makeKeyObserver("has", target, callback),
+            get: makeKeyObserver("get", target, callback),
+            set: delegateAndNotify("set", "get", target),
+            delete: delegateAndNotify("delete", "has", target),
+            keys: makeIteratorObserver("keys", target, callback),
+            values: makeIteratorObserver("values", target, callback),
+            entries: makeIteratorObserver("entries", target, callback),
+            [Symbol.iterator]: makeIteratorObserver(Symbol.iterator, target, callback),
+            forEach: makeForEachObserver(target, callback),
+            clear: makeClearNotifier(target),
+            get size() {
+                observeTargetKey(target, KEYCHANGES, callback);
+                return target.size;
+            },
+        }),
+        WeakMap: (target, callback) => ({
+            has: makeKeyObserver("has", target, callback),
+            get: makeKeyObserver("get", target, callback),
+            set: delegateAndNotify("set", "get", target),
+            delete: delegateAndNotify("delete", "has", target),
+        }),
+    };
+    /**
+     * Creates a proxy handler for collections (Set/Map/WeakMap)
+     *
+     * @param callback @see reactive
+     * @param target @see reactive
+     * @returns a proxy handler object
+     */
+    function collectionsProxyHandler(target, callback, targetRawType) {
+        // TODO: if performance is an issue we can create the special handlers lazily when each
+        // property is read.
+        const specialHandlers = rawTypeToFuncHandlers[targetRawType](target, callback);
+        return Object.assign(basicProxyHandler(callback), {
+            // FIXME: probably broken when part of prototype chain since we ignore the receiver
+            get(target, key) {
+                if (objectHasOwnProperty.call(specialHandlers, key)) {
+                    return specialHandlers[key];
+                }
+                observeTargetKey(target, key, callback);
+                return possiblyReactive(target[key], callback);
+            },
+        });
+    }
+
+    /**
+     * 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 called = false;
+        return async () => {
+            // This await blocks all calls to the callback here, then releases them sequentially
+            // in the next microtick. This line decides the granularity of the batch.
+            await Promise.resolve();
+            if (!called) {
+                called = true;
+                // wait for all calls in this microtick to fall through before resetting "called"
+                // so that only the first call to the batched function calls the original callback.
+                // Schedule this before calling the callback so that calls to the batched function
+                // within the callback will proceed only after resetting called to false, and have
+                // a chance to execute the callback again
+                Promise.resolve().then(() => (called = false));
+                callback();
+            }
+        };
+    }
+    function validateTarget(target) {
+        // Get the document and HTMLElement corresponding to the target to allow mounting in iframes
+        const document = target && target.ownerDocument;
+        if (document) {
+            const HTMLElement = document.defaultView.HTMLElement;
+            if (target instanceof HTMLElement) {
+                if (!document.body.contains(target)) {
+                    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 () { });
+    }
+    async function loadFile(url) {
+        const result = await fetch(url);
+        if (!result.ok) {
+            throw new OwlError("Error while fetching xml templates");
+        }
+        return await result.text();
+    }
+    /*
+     * 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 {
+    }
+    /*
+     * Marks a value as safe, that is, a value that can be injected as HTML directly.
+     * It should be used to wrap the value passed to a t-out directive to allow a raw rendering.
+     */
+    function markup(value) {
+        return new Markup(value);
+    }
+
+    let currentNode = null;
+    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;
+    }
+    /**
+     * Apply default props (only top level).
+     */
+    function applyDefaultProps(props, defaultProps) {
+        for (let propName in defaultProps) {
+            if (props[propName] === undefined) {
+                props[propName] = defaultProps[propName];
+            }
+        }
+    }
+    // -----------------------------------------------------------------------------
+    // Integration with reactivity system (useState)
+    // -----------------------------------------------------------------------------
+    const batchedRenderFunctions = new WeakMap();
+    /**
+     * Creates a reactive object that will be observed by the current component.
+     * Reading data from the returned object (eg during rendering) will cause the
+     * component to subscribe to that data and be rerendered when it changes.
+     *
+     * @param state the state to observe
+     * @returns a reactive object that will cause the component to re-render on
+     *  relevant changes
+     * @see reactive
+     */
+    function useState(state) {
+        const node = getCurrent();
+        let render = batchedRenderFunctions.get(node);
+        if (!render) {
+            render = batched(node.render.bind(node, false));
+            batchedRenderFunctions.set(node, render);
+            // manual implementation of onWillDestroy to break cyclic dependency
+            node.willDestroy.push(clearReactivesForCallback.bind(null, render));
+        }
+        return reactive(state, render);
+    }
+    class ComponentNode {
+        constructor(C, props, app, parent, parentKey) {
+            this.fiber = null;
+            this.bdom = null;
+            this.status = 0 /* NEW */;
+            this.forceNextRender = false;
+            this.children = Object.create(null);
+            this.refs = {};
+            this.willStart = [];
+            this.willUpdateProps = [];
+            this.willUnmount = [];
+            this.mounted = [];
+            this.willPatch = [];
+            this.patched = [];
+            this.willDestroy = [];
+            currentNode = this;
+            this.app = app;
+            this.parent = parent;
+            this.props = props;
+            this.parentKey = parentKey;
+            const defaultProps = C.defaultProps;
+            props = Object.assign({}, props);
+            if (defaultProps) {
+                applyDefaultProps(props, defaultProps);
+            }
+            const env = (parent && parent.childEnv) || app.env;
+            this.childEnv = env;
+            for (const key in props) {
+                const prop = props[key];
+                if (prop && typeof prop === "object" && targets.has(prop)) {
+                    props[key] = useState(prop);
+                }
+            }
+            this.component = new C(props, env, this);
+            const ctx = Object.assign(Object.create(this.component), { this: this.component });
+            this.renderFn = app.getTemplate(C.template).bind(this.component, ctx, this);
+            this.component.setup();
+            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 {
+                await Promise.all(this.willStart.map((f) => f.call(component)));
+            }
+            catch (e) {
+                this.app.handleError({ node: this, error: e });
+                return;
+            }
+            if (this.status === 0 /* NEW */ && this.fiber === fiber) {
+                fiber.render();
+            }
+        }
+        async render(deep) {
+            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 /* DESTROYED */) {
+                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();
+            }
+        }
+        destroy() {
+            let shouldRemove = this.status === 1 /* MOUNTED */;
+            this._destroy();
+            if (shouldRemove) {
+                this.bdom.remove();
+            }
+        }
+        _destroy() {
+            const component = this.component;
+            if (this.status === 1 /* 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 = 2 /* DESTROYED */;
+        }
+        async updateAndRender(props, parentFiber) {
+            const rawProps = props;
+            props = Object.assign({}, props);
+            // update
+            const fiber = makeChildFiber(this, parentFiber);
+            this.fiber = fiber;
+            const component = this.component;
+            const defaultProps = component.constructor.defaultProps;
+            if (defaultProps) {
+                applyDefaultProps(props, defaultProps);
+            }
+            currentNode = this;
+            for (const key in props) {
+                const prop = props[key];
+                if (prop && typeof prop === "object" && targets.has(prop)) {
+                    props[key] = useState(prop);
+                }
+            }
+            currentNode = null;
+            const prom = Promise.all(this.willUpdateProps.map((f) => f.call(component, props)));
+            await prom;
+            if (fiber !== this.fiber) {
+                return;
+            }
+            component.props = props;
+            this.props = rawProps;
+            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;
+            }
+        }
+        /**
+         * Sets a ref to a given HTMLElement.
+         *
+         * @param name the name of the ref to set
+         * @param el the HTMLElement to set the ref to. The ref is not set if the el
+         *  is null, but useRef will not return elements that are not in the DOM
+         */
+        setRef(name, el) {
+            if (el) {
+                this.refs[name] = el;
+            }
+        }
+        // ---------------------------------------------------------------------------
+        // 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 /* 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();
+        }
+        // ---------------------------------------------------------------------------
+        // Some debug helpers
+        // ---------------------------------------------------------------------------
+        get name() {
+            return this.component.constructor.name;
+        }
+        get subscriptions() {
+            const render = batchedRenderFunctions.get(this);
+            return render ? getSubscriptions(render) : [];
+        }
+    }
+
+    const TIMEOUT = Symbol("timeout");
+    function wrapError(fn, hookName) {
+        const error = new OwlError(`The following error occurred in ${hookName}: `);
+        const timeoutError = new OwlError(`${hookName}'s promise hasn't resolved after 3 seconds`);
+        const node = getCurrent();
+        return (...args) => {
+            const onError = (cause) => {
+                error.cause = cause;
+                if (cause instanceof Error) {
+                    error.message += `"${cause.message}"`;
+                }
+                else {
+                    error.message = `Something that is not an Error was thrown in ${hookName} (see this Error's "cause" property)`;
+                }
+                throw error;
+            };
+            try {
+                const result = fn(...args);
+                if (result instanceof Promise) {
+                    if (hookName === "onWillStart" || hookName === "onWillUpdateProps") {
+                        const fiber = node.fiber;
+                        Promise.race([
+                            result.catch(() => { }),
+                            new Promise((resolve) => setTimeout(() => resolve(TIMEOUT), 3000)),
+                        ]).then((res) => {
+                            if (res === TIMEOUT && node.fiber === fiber) {
+                                console.warn(timeoutError);
+                            }
+                        });
+                    }
+                    return result.catch(onError);
+                }
+                return result;
+            }
+            catch (cause) {
+                onError(cause);
+            }
+        };
+    }
+    // -----------------------------------------------------------------------------
+    //  hooks
+    // -----------------------------------------------------------------------------
+    function onWillStart(fn) {
+        const node = getCurrent();
+        const decorate = node.app.dev ? wrapError : (fn) => fn;
+        node.willStart.push(decorate(fn.bind(node.component), "onWillStart"));
+    }
+    function onWillUpdateProps(fn) {
+        const node = getCurrent();
+        const decorate = node.app.dev ? wrapError : (fn) => fn;
+        node.willUpdateProps.push(decorate(fn.bind(node.component), "onWillUpdateProps"));
+    }
+    function onMounted(fn) {
+        const node = getCurrent();
+        const decorate = node.app.dev ? wrapError : (fn) => fn;
+        node.mounted.push(decorate(fn.bind(node.component), "onMounted"));
+    }
+    function onWillPatch(fn) {
+        const node = getCurrent();
+        const decorate = node.app.dev ? wrapError : (fn) => fn;
+        node.willPatch.unshift(decorate(fn.bind(node.component), "onWillPatch"));
+    }
+    function onPatched(fn) {
+        const node = getCurrent();
+        const decorate = node.app.dev ? wrapError : (fn) => fn;
+        node.patched.push(decorate(fn.bind(node.component), "onPatched"));
+    }
+    function onWillUnmount(fn) {
+        const node = getCurrent();
+        const decorate = node.app.dev ? wrapError : (fn) => fn;
+        node.willUnmount.unshift(decorate(fn.bind(node.component), "onWillUnmount"));
+    }
+    function onWillDestroy(fn) {
+        const node = getCurrent();
+        const decorate = node.app.dev ? wrapError : (fn) => fn;
+        node.willDestroy.push(decorate(fn.bind(node.component), "onWillDestroy"));
+    }
+    function onWillRender(fn) {
+        const node = getCurrent();
+        const renderFn = node.renderFn;
+        const decorate = node.app.dev ? wrapError : (fn) => fn;
+        fn = decorate(fn.bind(node.component), "onWillRender");
+        node.renderFn = () => {
+            fn();
+            return renderFn();
+        };
+    }
+    function onRendered(fn) {
+        const node = getCurrent();
+        const renderFn = node.renderFn;
+        const decorate = node.app.dev ? wrapError : (fn) => fn;
+        fn = decorate(fn.bind(node.component), "onRendered");
+        node.renderFn = () => {
+            const result = renderFn();
+            fn();
+            return result;
+        };
+    }
+    function onError(callback) {
+        const node = getCurrent();
+        let handlers = nodeErrorHandlers.get(node);
+        if (!handlers) {
+            handlers = [];
+            nodeErrorHandlers.set(node, handlers);
+        }
+        handlers.push(callback.bind(node.component));
+    }
+
+    class Component {
+        constructor(props, env, node) {
+            this.props = props;
+            this.env = env;
+            this.__owl__ = node;
+        }
+        setup() { }
+        render(deep = false) {
+            this.__owl__.render(deep === true);
+        }
+    }
+    Component.template = "";
+
+    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.props.target, callSlot(ctx, node, key, "default", false, null));
+        };
+    }
+    class Portal extends Component {
+        setup() {
+            const node = this.__owl__;
+            onMounted(() => {
+                const portal = node.bdom;
+                if (!portal.target) {
+                    const target = document.querySelector(this.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__";
+    Portal.props = {
+        target: {
+            type: String,
+        },
+        slots: true,
+    };
+
+    // -----------------------------------------------------------------------------
+    // 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 && !result) {
+            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}' has not the correct shape (${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;
+    }
+
+    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.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) {
+            values = Object.keys(collection);
+            keys = Object.values(collection);
+        }
+        else {
+            throw new OwlError("Invalid loop expression");
+        }
+        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) {
+            return defaultValue ? toggler("default", defaultValue) : toggler("undefined", text(""));
+        }
+        let safeKey;
+        let block;
+        switch (typeof value) {
+            case "object":
+                if (value instanceof Markup) {
+                    safeKey = `string_safe`;
+                    block = html(value);
+                }
+                else if (value instanceof LazyValue) {
+                    safeKey = `lazy_value`;
+                    block = value.evaluate();
+                }
+                else if (value instanceof String) {
+                    safeKey = "string_unsafe";
+                    block = text(value);
+                }
+                else {
+                    // Assuming it is a block
+                    safeKey = "block_safe";
+                    block = value;
+                }
+                break;
+            case "string":
+                safeKey = "string_unsafe";
+                block = text(value);
+                break;
+            default:
+                safeKey = "string_unsafe";
+                block = text(String(value));
+        }
+        return toggler(safeKey, block);
+    }
+    /**
+     * Validate the component props (or next props) against the (static) props
+     * description.  This is potentially an expensive operation: it may needs to
+     * visit recursively the props and all the children to check if they are valid.
+     * This is why it is only done in 'dev' mode.
+     */
+    function validateProps(name, props, comp) {
+        const ComponentClass = typeof name !== "string"
+            ? name
+            : comp.constructor.components[name];
+        if (!ComponentClass) {
+            // this is an error, wrong component. We silently return here instead so the
+            // error is triggered by the usual path ('component' function)
+            return;
+        }
+        const schema = ComponentClass.props;
+        if (!schema) {
+            if (comp.__owl__.app.warnIfNoStaticProps) {
+                console.warn(`Component '${ComponentClass.name}' does not have a static props description`);
+            }
+            return;
+        }
+        const defaultProps = ComponentClass.defaultProps;
+        if (defaultProps) {
+            let isMandatory = (name) => Array.isArray(schema)
+                ? schema.includes(name)
+                : name in schema && !("*" in schema) && !isOptional(schema[name]);
+            for (let p in defaultProps) {
+                if (isMandatory(p)) {
+                    throw new OwlError(`A default value cannot be defined for a mandatory prop (name: '${p}', component: ${ComponentClass.name})`);
+                }
+            }
+        }
+        const errors = validateSchema(props, schema);
+        if (errors.length) {
+            throw new OwlError(`Invalid props for component '${ComponentClass.name}': ` + errors.join(", "));
+        }
+    }
+    function makeRefWrapper(node) {
+        let refNames = new Set();
+        return (name, fn) => {
+            if (refNames.has(name)) {
+                throw new OwlError(`Cannot set the same ref more than once in the same component, ref "${name}" was set multiple times in ${node.name}`);
+            }
+            refNames.add(name);
+            return fn;
+        };
+    }
+    const helpers = {
+        withDefault,
+        zero: Symbol("zero"),
+        isBoundary,
+        callSlot,
+        capture,
+        withKey,
+        prepareList,
+        setContextValue,
+        shallowEqual,
+        toNumber,
+        validateProps,
+        LazyValue,
+        safeOutput,
+        createCatcher,
+        markRaw,
+        OwlError,
+        makeRefWrapper,
+    };
+
+    const bdom = { text, createBlock, list, multi, html, toggler, comment };
+    function parseXML$1(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;
+    }
+    class TemplateSet {
+        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) {
+                this.addTemplates(config.templates);
+            }
+        }
+        static registerTemplate(name, fn) {
+            globalTemplates[name] = fn;
+        }
+        addTemplate(name, template) {
+            if (name in this.rawTemplates) {
+                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$1(xml);
+            for (const template of xml.querySelectorAll("[t-name]")) {
+                const name = template.getAttribute("t-name");
+                this.addTemplate(name, template);
+            }
+        }
+        getTemplate(name) {
+            if (!(name in this.templates)) {
+                const rawTemplate = 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, helpers);
+                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));
+        }
+    }
+    // -----------------------------------------------------------------------------
+    //  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);
+
+    /**
+     * Owl QWeb Expression Parser
+     *
+     * Owl needs in various contexts to be able to understand the structure of a
+     * string representing a javascript expression.  The usual goal is to be able
+     * to rewrite some variables.  For example, if a template has
+     *
+     *  ```xml
+     *  <t t-if="computeSomething({val: state.val})">...</t>
+     * ```
+     *
+     * this needs to be translated in something like this:
+     *
+     * ```js
+     *   if (context["computeSomething"]({val: context["state"].val})) { ... }
+     * ```
+     *
+     * This file contains the implementation of an extremely naive tokenizer/parser
+     * and evaluator for javascript expressions.  The supported grammar is basically
+     * only expressive enough to understand the shape of objects, of arrays, and
+     * various operators.
+     */
+    //------------------------------------------------------------------------------
+    // Misc types, constants and helpers
+    //------------------------------------------------------------------------------
+    const RESERVED_WORDS = "true,false,NaN,null,undefined,debugger,console,window,in,instanceof,new,function,return,eval,void,Math,RegExp,Array,Object,Date".split(",");
+    const WORD_REPLACEMENT = Object.assign(Object.create(null), {
+        and: "&&",
+        or: "||",
+        gt: ">",
+        gte: ">=",
+        lt: "<",
+        lte: "<=",
+    });
+    const STATIC_TOKEN_MAP = Object.assign(Object.create(null), {
+        "{": "LEFT_BRACE",
+        "}": "RIGHT_BRACE",
+        "[": "LEFT_BRACKET",
+        "]": "RIGHT_BRACKET",
+        ":": "COLON",
+        ",": "COMMA",
+        "(": "LEFT_PAREN",
+        ")": "RIGHT_PAREN",
+    });
+    // note that the space after typeof is relevant. It makes sure that the formatted
+    // expression has a space after typeof. Currently we don't support delete and void
+    const OPERATORS = "...,.,===,==,+,!==,!=,!,||,&&,>=,>,<=,<,?,-,*,/,%,typeof ,=>,=,;,in ,new ,|,&,^,~".split(",");
+    let tokenizeString = function (expr) {
+        let s = expr[0];
+        let start = s;
+        if (s !== "'" && s !== '"' && s !== "`") {
+            return false;
+        }
+        let i = 1;
+        let cur;
+        while (expr[i] && expr[i] !== start) {
+            cur = expr[i];
+            s += cur;
+            if (cur === "\\") {
+                i++;
+                cur = expr[i];
+                if (!cur) {
+                    throw new OwlError("Invalid expression");
+                }
+                s += cur;
+            }
+            i++;
+        }
+        if (expr[i] !== start) {
+            throw new OwlError("Invalid expression");
+        }
+        s += start;
+        if (start === "`") {
+            return {
+                type: "TEMPLATE_STRING",
+                value: s,
+                replace(replacer) {
+                    return s.replace(/\$\{(.*?)\}/g, (match, group) => {
+                        return "${" + replacer(group) + "}";
+                    });
+                },
+            };
+        }
+        return { type: "VALUE", value: s };
+    };
+    let tokenizeNumber = function (expr) {
+        let s = expr[0];
+        if (s && s.match(/[0-9]/)) {
+            let i = 1;
+            while (expr[i] && expr[i].match(/[0-9]|\./)) {
+                s += expr[i];
+                i++;
+            }
+            return { type: "VALUE", value: s };
+        }
+        else {
+            return false;
+        }
+    };
+    let tokenizeSymbol = function (expr) {
+        let s = expr[0];
+        if (s && s.match(/[a-zA-Z_\$]/)) {
+            let i = 1;
+            while (expr[i] && expr[i].match(/\w/)) {
+                s += expr[i];
+                i++;
+            }
+            if (s in WORD_REPLACEMENT) {
+                return { type: "OPERATOR", value: WORD_REPLACEMENT[s], size: s.length };
+            }
+            return { type: "SYMBOL", value: s };
+        }
+        else {
+            return false;
+        }
+    };
+    const tokenizeStatic = function (expr) {
+        const char = expr[0];
+        if (char && char in STATIC_TOKEN_MAP) {
+            return { type: STATIC_TOKEN_MAP[char], value: char };
+        }
+        return false;
+    };
+    const tokenizeOperator = function (expr) {
+        for (let op of OPERATORS) {
+            if (expr.startsWith(op)) {
+                return { type: "OPERATOR", value: op };
+            }
+        }
+        return false;
+    };
+    const TOKENIZERS = [
+        tokenizeString,
+        tokenizeNumber,
+        tokenizeOperator,
+        tokenizeSymbol,
+        tokenizeStatic,
+    ];
+    /**
+     * Convert a javascript expression (as a string) into a list of tokens. For
+     * example: `tokenize("1 + b")` will return:
+     * ```js
+     *  [
+     *   {type: "VALUE", value: "1"},
+     *   {type: "OPERATOR", value: "+"},
+     *   {type: "SYMBOL", value: "b"}
+     * ]
+     * ```
+     */
+    function tokenize(expr) {
+        const result = [];
+        let token = true;
+        let error;
+        let current = expr;
+        try {
+            while (token) {
+                current = current.trim();
+                if (current) {
+                    for (let tokenizer of TOKENIZERS) {
+                        token = tokenizer(current);
+                        if (token) {
+                            result.push(token);
+                            current = current.slice(token.size || token.value.length);
+                            break;
+                        }
+                    }
+                }
+                else {
+                    token = false;
+                }
+            }
+        }
+        catch (e) {
+            error = e; // Silence all errors and throw a generic error below
+        }
+        if (current.length || error) {
+            throw new OwlError(`Tokenizer error: could not tokenize \`${expr}\``);
+        }
+        return result;
+    }
+    //------------------------------------------------------------------------------
+    // Expression "evaluator"
+    //------------------------------------------------------------------------------
+    const isLeftSeparator = (token) => token && (token.type === "LEFT_BRACE" || token.type === "COMMA");
+    const isRightSeparator = (token) => token && (token.type === "RIGHT_BRACE" || token.type === "COMMA");
+    /**
+     * This is the main function exported by this file. This is the code that will
+     * process an expression (given as a string) and returns another expression with
+     * proper lookups in the context.
+     *
+     * Usually, this kind of code would be very simple to do if we had an AST (so,
+     * if we had a javascript parser), since then, we would only need to find the
+     * variables and replace them.  However, a parser is more complicated, and there
+     * are no standard builtin parser API.
+     *
+     * Since this method is applied to simple javasript expressions, and the work to
+     * be done is actually quite simple, we actually can get away with not using a
+     * parser, which helps with the code size.
+     *
+     * Here is the heuristic used by this method to determine if a token is a
+     * variable:
+     * - by default, all symbols are considered a variable
+     * - unless the previous token is a dot (in that case, this is a property: `a.b`)
+     * - or if the previous token is a left brace or a comma, and the next token is
+     *   a colon (in that case, this is an object key: `{a: b}`)
+     *
+     * Some specific code is also required to support arrow functions. If we detect
+     * the arrow operator, then we add the current (or some previous tokens) token to
+     * the list of variables so it does not get replaced by a lookup in the context
+     */
+    function compileExprToArray(expr) {
+        const localVars = new Set();
+        const tokens = tokenize(expr);
+        let i = 0;
+        let stack = []; // to track last opening [ or {
+        while (i < tokens.length) {
+            let token = tokens[i];
+            let prevToken = tokens[i - 1];
+            let nextToken = tokens[i + 1];
+            let groupType = stack[stack.length - 1];
+            switch (token.type) {
+                case "LEFT_BRACE":
+                case "LEFT_BRACKET":
+                    stack.push(token.type);
+                    break;
+                case "RIGHT_BRACE":
+                case "RIGHT_BRACKET":
+                    stack.pop();
+            }
+            let isVar = token.type === "SYMBOL" && !RESERVED_WORDS.includes(token.value);
+            if (token.type === "SYMBOL" && !RESERVED_WORDS.includes(token.value)) {
+                if (prevToken) {
+                    // normalize missing tokens: {a} should be equivalent to {a:a}
+                    if (groupType === "LEFT_BRACE" &&
+                        isLeftSeparator(prevToken) &&
+                        isRightSeparator(nextToken)) {
+                        tokens.splice(i + 1, 0, { type: "COLON", value: ":" }, { ...token });
+                        nextToken = tokens[i + 1];
+                    }
+                    if (prevToken.type === "OPERATOR" && prevToken.value === ".") {
+                        isVar = false;
+                    }
+                    else if (prevToken.type === "LEFT_BRACE" || prevToken.type === "COMMA") {
+                        if (nextToken && nextToken.type === "COLON") {
+                            isVar = false;
+                        }
+                    }
+                }
+            }
+            if (token.type === "TEMPLATE_STRING") {
+                token.value = token.replace((expr) => compileExpr(expr));
+            }
+            if (nextToken && nextToken.type === "OPERATOR" && nextToken.value === "=>") {
+                if (token.type === "RIGHT_PAREN") {
+                    let j = i - 1;
+                    while (j > 0 && tokens[j].type !== "LEFT_PAREN") {
+                        if (tokens[j].type === "SYMBOL" && tokens[j].originalValue) {
+                            tokens[j].value = tokens[j].originalValue;
+                            localVars.add(tokens[j].value); //] = { id: tokens[j].value, expr: tokens[j].value };
+                        }
+                        j--;
+                    }
+                }
+                else {
+                    localVars.add(token.value); //] = { id: token.value, expr: token.value };
+                }
+            }
+            if (isVar) {
+                token.varName = token.value;
+                if (!localVars.has(token.value)) {
+                    token.originalValue = token.value;
+                    token.value = `ctx['${token.value}']`;
+                }
+            }
+            i++;
+        }
+        // Mark all variables that have been used locally.
+        // This assumes the expression has only one scope (incorrect but "good enough for now")
+        for (const token of tokens) {
+            if (token.type === "SYMBOL" && token.varName && localVars.has(token.value)) {
+                token.originalValue = token.value;
+                token.value = `_${token.value}`;
+                token.isLocal = true;
+            }
+        }
+        return tokens;
+    }
+    // Leading spaces are trimmed during tokenization, so they need to be added back for some values
+    const paddedValues = new Map([["in ", " in "]]);
+    function compileExpr(expr) {
+        return compileExprToArray(expr)
+            .map((t) => paddedValues.get(t.value) || t.value)
+            .join("");
+    }
+    const INTERP_REGEXP = /\{\{.*?\}\}|\#\{.*?\}/g;
+    function replaceDynamicParts(s, replacer) {
+        let matches = s.match(INTERP_REGEXP);
+        if (matches && matches[0].length === s.length) {
+            return `(${replacer(s.slice(2, matches[0][0] === "{" ? -2 : -1))})`;
+        }
+        let r = s.replace(INTERP_REGEXP, (s) => "${" + replacer(s.slice(2, s[0] === "{" ? -2 : -1)) + "}");
+        return "`" + r + "`";
+    }
+    function interpolate(s) {
+        return replaceDynamicParts(s, compileExpr);
+    }
+
+    const whitespaceRE = /\s+/g;
+    // using a non-html document so that <inner/outer>HTML serializes as XML instead
+    // of HTML (as we will parse it as xml later)
+    const xmlDoc = document.implementation.createDocument(null, null, null);
+    const MODS = new Set(["stop", "capture", "prevent", "self", "synthetic"]);
+    let nextDataIds = {};
+    function generateId(prefix = "") {
+        nextDataIds[prefix] = (nextDataIds[prefix] || 0) + 1;
+        return prefix + nextDataIds[prefix];
+    }
+    function isProp(tag, key) {
+        switch (tag) {
+            case "input":
+                return (key === "checked" ||
+                    key === "indeterminate" ||
+                    key === "value" ||
+                    key === "readonly" ||
+                    key === "readOnly" ||
+                    key === "disabled");
+            case "option":
+                return key === "selected" || key === "disabled";
+            case "textarea":
+                return key === "value" || key === "readonly" || key === "readOnly" || key === "disabled";
+            case "select":
+                return key === "value" || key === "disabled";
+            case "button":
+            case "optgroup":
+                return key === "disabled";
+        }
+        return false;
+    }
+    // -----------------------------------------------------------------------------
+    // BlockDescription
+    // -----------------------------------------------------------------------------
+    class BlockDescription {
+        constructor(target, type) {
+            this.dynamicTagName = null;
+            this.isRoot = false;
+            this.hasDynamicChildren = false;
+            this.children = [];
+            this.data = [];
+            this.childNumber = 0;
+            this.parentVar = "";
+            this.id = BlockDescription.nextBlockId++;
+            this.varName = "b" + this.id;
+            this.blockName = "block" + this.id;
+            this.target = target;
+            this.type = type;
+        }
+        insertData(str, prefix = "d") {
+            const id = generateId(prefix);
+            this.target.addLine(`let ${id} = ${str};`);
+            return this.data.push(id) - 1;
+        }
+        insert(dom) {
+            if (this.currentDom) {
+                this.currentDom.appendChild(dom);
+            }
+            else {
+                this.dom = dom;
+            }
+        }
+        generateExpr(expr) {
+            if (this.type === "block") {
+                const hasChildren = this.children.length;
+                let params = this.data.length ? `[${this.data.join(", ")}]` : hasChildren ? "[]" : "";
+                if (hasChildren) {
+                    params += ", [" + this.children.map((c) => c.varName).join(", ") + "]";
+                }
+                if (this.dynamicTagName) {
+                    return `toggler(${this.dynamicTagName}, ${this.blockName}(${this.dynamicTagName})(${params}))`;
+                }
+                return `${this.blockName}(${params})`;
+            }
+            else if (this.type === "list") {
+                return `list(c_block${this.id})`;
+            }
+            return expr;
+        }
+        asXmlString() {
+            // Can't use outerHTML on text/comment nodes
+            // append dom to any element and use innerHTML instead
+            const t = xmlDoc.createElement("t");
+            t.appendChild(this.dom);
+            return t.innerHTML;
+        }
+    }
+    BlockDescription.nextBlockId = 1;
+    function createContext(parentCtx, params) {
+        return Object.assign({
+            block: null,
+            index: 0,
+            forceNewBlock: true,
+            translate: parentCtx.translate,
+            tKeyExpr: null,
+            nameSpace: parentCtx.nameSpace,
+            tModelSelectedExpr: parentCtx.tModelSelectedExpr,
+        }, params);
+    }
+    class CodeTarget {
+        constructor(name, on) {
+            this.indentLevel = 0;
+            this.loopLevel = 0;
+            this.code = [];
+            this.hasRoot = false;
+            this.hasCache = false;
+            this.shouldProtectScope = false;
+            this.hasRefWrapper = false;
+            this.name = name;
+            this.on = on || null;
+        }
+        addLine(line, idx) {
+            const prefix = new Array(this.indentLevel + 2).join("  ");
+            if (idx === undefined) {
+                this.code.push(prefix + line);
+            }
+            else {
+                this.code.splice(idx, 0, prefix + line);
+            }
+        }
+        generateCode() {
+            let result = [];
+            result.push(`function ${this.name}(ctx, node, key = "") {`);
+            if (this.shouldProtectScope) {
+                result.push(`  ctx = Object.create(ctx);`);
+                result.push(`  ctx[isBoundary] = 1`);
+            }
+            if (this.hasRefWrapper) {
+                result.push(`  let refWrapper = makeRefWrapper(this.__owl__);`);
+            }
+            if (this.hasCache) {
+                result.push(`  let cache = ctx.cache || {};`);
+                result.push(`  let nextCache = ctx.cache = {};`);
+            }
+            for (let line of this.code) {
+                result.push(line);
+            }
+            if (!this.hasRoot) {
+                result.push(`return text('');`);
+            }
+            result.push(`}`);
+            return result.join("\n  ");
+        }
+        currentKey(ctx) {
+            let key = this.loopLevel ? `key${this.loopLevel}` : "key";
+            if (ctx.tKeyExpr) {
+                key = `${ctx.tKeyExpr} + ${key}`;
+            }
+            return key;
+        }
+    }
+    const TRANSLATABLE_ATTRS = ["label", "title", "placeholder", "alt"];
+    const translationRE = /^(\s*)([\s\S]+?)(\s*)$/;
+    class CodeGenerator {
+        constructor(ast, options) {
+            this.blocks = [];
+            this.nextBlockId = 1;
+            this.isDebug = false;
+            this.targets = [];
+            this.target = new CodeTarget("template");
+            this.translatableAttributes = TRANSLATABLE_ATTRS;
+            this.staticDefs = [];
+            this.slotNames = new Set();
+            this.helpers = new Set();
+            this.translateFn = options.translateFn || ((s) => s);
+            if (options.translatableAttributes) {
+                const attrs = new Set(TRANSLATABLE_ATTRS);
+                for (let attr of options.translatableAttributes) {
+                    if (attr.startsWith("-")) {
+                        attrs.delete(attr.slice(1));
+                    }
+                    else {
+                        attrs.add(attr);
+                    }
+                }
+                this.translatableAttributes = [...attrs];
+            }
+            this.hasSafeContext = options.hasSafeContext || false;
+            this.dev = options.dev || false;
+            this.ast = ast;
+            this.templateName = options.name;
+        }
+        generateCode() {
+            const ast = this.ast;
+            this.isDebug = ast.type === 12 /* TDebug */;
+            BlockDescription.nextBlockId = 1;
+            nextDataIds = {};
+            this.compileAST(ast, {
+                block: null,
+                index: 0,
+                forceNewBlock: false,
+                isLast: true,
+                translate: true,
+                tKeyExpr: null,
+            });
+            // define blocks and utility functions
+            let mainCode = [`  let { text, createBlock, list, multi, html, toggler, comment } = bdom;`];
+            if (this.helpers.size) {
+                mainCode.push(`let { ${[...this.helpers].join(", ")} } = helpers;`);
+            }
+            if (this.templateName) {
+                mainCode.push(`// Template name: "${this.templateName}"`);
+            }
+            for (let { id, expr } of this.staticDefs) {
+                mainCode.push(`const ${id} = ${expr};`);
+            }
+            // define all blocks
+            if (this.blocks.length) {
+                mainCode.push(``);
+                for (let block of this.blocks) {
+                    if (block.dom) {
+                        let xmlString = block.asXmlString();
+                        xmlString = xmlString.replace(/\\/g, "\\\\").replace(/`/g, "\\`");
+                        if (block.dynamicTagName) {
+                            xmlString = xmlString.replace(/^<\w+/, `<\${tag || '${block.dom.nodeName}'}`);
+                            xmlString = xmlString.replace(/\w+>$/, `\${tag || '${block.dom.nodeName}'}>`);
+                            mainCode.push(`let ${block.blockName} = tag => createBlock(\`${xmlString}\`);`);
+                        }
+                        else {
+                            mainCode.push(`let ${block.blockName} = createBlock(\`${xmlString}\`);`);
+                        }
+                    }
+                }
+            }
+            // define all slots/defaultcontent function
+            if (this.targets.length) {
+                for (let fn of this.targets) {
+                    mainCode.push("");
+                    mainCode = mainCode.concat(fn.generateCode());
+                }
+            }
+            // generate main code
+            mainCode.push("");
+            mainCode = mainCode.concat("return " + this.target.generateCode());
+            const code = mainCode.join("\n  ");
+            if (this.isDebug) {
+                const msg = `[Owl Debug]\n${code}`;
+                console.log(msg);
+            }
+            return code;
+        }
+        compileInNewTarget(prefix, ast, ctx, on) {
+            const name = generateId(prefix);
+            const initialTarget = this.target;
+            const target = new CodeTarget(name, on);
+            this.targets.push(target);
+            this.target = target;
+            this.compileAST(ast, createContext(ctx));
+            this.target = initialTarget;
+            return name;
+        }
+        addLine(line, idx) {
+            this.target.addLine(line, idx);
+        }
+        define(varName, expr) {
+            this.addLine(`const ${varName} = ${expr};`);
+        }
+        insertAnchor(block, index = block.children.length) {
+            const tag = `block-child-${index}`;
+            const anchor = xmlDoc.createElement(tag);
+            block.insert(anchor);
+        }
+        createBlock(parentBlock, type, ctx) {
+            const hasRoot = this.target.hasRoot;
+            const block = new BlockDescription(this.target, type);
+            if (!hasRoot && !ctx.preventRoot) {
+                this.target.hasRoot = true;
+                block.isRoot = true;
+            }
+            if (parentBlock) {
+                parentBlock.children.push(block);
+                if (parentBlock.type === "list") {
+                    block.parentVar = `c_block${parentBlock.id}`;
+                }
+            }
+            return block;
+        }
+        insertBlock(expression, block, ctx) {
+            let blockExpr = block.generateExpr(expression);
+            if (block.parentVar) {
+                let key = this.target.currentKey(ctx);
+                this.helpers.add("withKey");
+                this.addLine(`${block.parentVar}[${ctx.index}] = withKey(${blockExpr}, ${key});`);
+                return;
+            }
+            if (ctx.tKeyExpr) {
+                blockExpr = `toggler(${ctx.tKeyExpr}, ${blockExpr})`;
+            }
+            if (block.isRoot && !ctx.preventRoot) {
+                if (this.target.on) {
+                    blockExpr = this.wrapWithEventCatcher(blockExpr, this.target.on);
+                }
+                this.addLine(`return ${blockExpr};`);
+            }
+            else {
+                this.define(block.varName, blockExpr);
+            }
+        }
+        /**
+         * Captures variables that are used inside of an expression. This is useful
+         * because in compiled code, almost all variables are accessed through the ctx
+         * object. In the case of functions, that lookup in the context can be delayed
+         * which can cause issues if the value has changed since the function was
+         * defined.
+         *
+         * @param expr the expression to capture
+         * @param forceCapture whether the expression should capture its scope even if
+         *  it doesn't contain a function. Useful when the expression will be used as
+         *  a function body.
+         * @returns a new expression that uses the captured values
+         */
+        captureExpression(expr, forceCapture = false) {
+            if (!forceCapture && !expr.includes("=>")) {
+                return compileExpr(expr);
+            }
+            const tokens = compileExprToArray(expr);
+            const mapping = new Map();
+            return tokens
+                .map((tok) => {
+                if (tok.varName && !tok.isLocal) {
+                    if (!mapping.has(tok.varName)) {
+                        const varId = generateId("v");
+                        mapping.set(tok.varName, varId);
+                        this.define(varId, tok.value);
+                    }
+                    tok.value = mapping.get(tok.varName);
+                }
+                return tok.value;
+            })
+                .join("");
+        }
+        /**
+         * @returns the newly created block name, if any
+         */
+        compileAST(ast, ctx) {
+            switch (ast.type) {
+                case 1 /* Comment */:
+                    return this.compileComment(ast, ctx);
+                case 0 /* Text */:
+                    return this.compileText(ast, ctx);
+                case 2 /* DomNode */:
+                    return this.compileTDomNode(ast, ctx);
+                case 4 /* TEsc */:
+                    return this.compileTEsc(ast, ctx);
+                case 8 /* TOut */:
+                    return this.compileTOut(ast, ctx);
+                case 5 /* TIf */:
+                    return this.compileTIf(ast, ctx);
+                case 9 /* TForEach */:
+                    return this.compileTForeach(ast, ctx);
+                case 10 /* TKey */:
+                    return this.compileTKey(ast, ctx);
+                case 3 /* Multi */:
+                    return this.compileMulti(ast, ctx);
+                case 7 /* TCall */:
+                    return this.compileTCall(ast, ctx);
+                case 15 /* TCallBlock */:
+                    return this.compileTCallBlock(ast, ctx);
+                case 6 /* TSet */:
+                    return this.compileTSet(ast, ctx);
+                case 11 /* TComponent */:
+                    return this.compileComponent(ast, ctx);
+                case 12 /* TDebug */:
+                    return this.compileDebug(ast, ctx);
+                case 13 /* TLog */:
+                    return this.compileLog(ast, ctx);
+                case 14 /* TSlot */:
+                    return this.compileTSlot(ast, ctx);
+                case 16 /* TTranslation */:
+                    return this.compileTTranslation(ast, ctx);
+                case 17 /* TPortal */:
+                    return this.compileTPortal(ast, ctx);
+            }
+        }
+        compileDebug(ast, ctx) {
+            this.addLine(`debugger;`);
+            if (ast.content) {
+                return this.compileAST(ast.content, ctx);
+            }
+            return null;
+        }
+        compileLog(ast, ctx) {
+            this.addLine(`console.log(${compileExpr(ast.expr)});`);
+            if (ast.content) {
+                return this.compileAST(ast.content, ctx);
+            }
+            return null;
+        }
+        compileComment(ast, ctx) {
+            let { block, forceNewBlock } = ctx;
+            const isNewBlock = !block || forceNewBlock;
+            if (isNewBlock) {
+                block = this.createBlock(block, "comment", ctx);
+                this.insertBlock(`comment(\`${ast.value}\`)`, block, {
+                    ...ctx,
+                    forceNewBlock: forceNewBlock && !block,
+                });
+            }
+            else {
+                const text = xmlDoc.createComment(ast.value);
+                block.insert(text);
+            }
+            return block.varName;
+        }
+        compileText(ast, ctx) {
+            let { block, forceNewBlock } = ctx;
+            let value = ast.value;
+            if (value && ctx.translate !== false) {
+                const match = translationRE.exec(value);
+                value = match[1] + this.translateFn(match[2]) + match[3];
+            }
+            if (!ctx.inPreTag) {
+                value = value.replace(whitespaceRE, " ");
+            }
+            if (!block || forceNewBlock) {
+                block = this.createBlock(block, "text", ctx);
+                this.insertBlock(`text(\`${value}\`)`, block, {
+                    ...ctx,
+                    forceNewBlock: forceNewBlock && !block,
+                });
+            }
+            else {
+                const createFn = ast.type === 0 /* Text */ ? xmlDoc.createTextNode : xmlDoc.createComment;
+                block.insert(createFn.call(xmlDoc, value));
+            }
+            return block.varName;
+        }
+        generateHandlerCode(rawEvent, handler) {
+            const modifiers = rawEvent
+                .split(".")
+                .slice(1)
+                .map((m) => {
+                if (!MODS.has(m)) {
+                    throw new OwlError(`Unknown event modifier: '${m}'`);
+                }
+                return `"${m}"`;
+            });
+            let modifiersCode = "";
+            if (modifiers.length) {
+                modifiersCode = `${modifiers.join(",")}, `;
+            }
+            return `[${modifiersCode}${this.captureExpression(handler)}, ctx]`;
+        }
+        compileTDomNode(ast, ctx) {
+            let { block, forceNewBlock } = ctx;
+            const isNewBlock = !block || forceNewBlock || ast.dynamicTag !== null || ast.ns;
+            let codeIdx = this.target.code.length;
+            if (isNewBlock) {
+                if ((ast.dynamicTag || ctx.tKeyExpr || ast.ns) && ctx.block) {
+                    this.insertAnchor(ctx.block);
+                }
+                block = this.createBlock(block, "block", ctx);
+                this.blocks.push(block);
+                if (ast.dynamicTag) {
+                    const tagExpr = generateId("tag");
+                    this.define(tagExpr, compileExpr(ast.dynamicTag));
+                    block.dynamicTagName = tagExpr;
+                }
+            }
+            // attributes
+            const attrs = {};
+            const nameSpace = ast.ns || ctx.nameSpace;
+            if (nameSpace && isNewBlock) {
+                // specific namespace uri
+                attrs["block-ns"] = nameSpace;
+            }
+            for (let key in ast.attrs) {
+                let expr, attrName;
+                if (key.startsWith("t-attf")) {
+                    expr = interpolate(ast.attrs[key]);
+                    const idx = block.insertData(expr, "attr");
+                    attrName = key.slice(7);
+                    attrs["block-attribute-" + idx] = attrName;
+                }
+                else if (key.startsWith("t-att")) {
+                    attrName = key === "t-att" ? null : key.slice(6);
+                    expr = compileExpr(ast.attrs[key]);
+                    if (attrName && isProp(ast.tag, attrName)) {
+                        if (attrName === "readonly") {
+                            // the property has a different name than the attribute
+                            attrName = "readOnly";
+                        }
+                        // we force a new string or new boolean to bypass the equality check in blockdom when patching same value
+                        if (attrName === "value") {
+                            // When the expression is falsy (except 0), fall back to an empty string
+                            expr = `new String((${expr}) === 0 ? 0 : ((${expr}) || ""))`;
+                        }
+                        else {
+                            expr = `new Boolean(${expr})`;
+                        }
+                        const idx = block.insertData(expr, "prop");
+                        attrs[`block-property-${idx}`] = attrName;
+                    }
+                    else {
+                        const idx = block.insertData(expr, "attr");
+                        if (key === "t-att") {
+                            attrs[`block-attributes`] = String(idx);
+                        }
+                        else {
+                            attrs[`block-attribute-${idx}`] = attrName;
+                        }
+                    }
+                }
+                else if (this.translatableAttributes.includes(key)) {
+                    attrs[key] = this.translateFn(ast.attrs[key]);
+                }
+                else {
+                    expr = `"${ast.attrs[key]}"`;
+                    attrName = key;
+                    attrs[key] = ast.attrs[key];
+                }
+                if (attrName === "value" && ctx.tModelSelectedExpr) {
+                    let selectedId = block.insertData(`${ctx.tModelSelectedExpr} === ${expr}`, "attr");
+                    attrs[`block-attribute-${selectedId}`] = "selected";
+                }
+            }
+            // t-model
+            let tModelSelectedExpr;
+            if (ast.model) {
+                const { hasDynamicChildren, baseExpr, expr, eventType, shouldNumberize, shouldTrim, targetAttr, specialInitTargetAttr, } = ast.model;
+                const baseExpression = compileExpr(baseExpr);
+                const bExprId = generateId("bExpr");
+                this.define(bExprId, baseExpression);
+                const expression = compileExpr(expr);
+                const exprId = generateId("expr");
+                this.define(exprId, expression);
+                const fullExpression = `${bExprId}[${exprId}]`;
+                let idx;
+                if (specialInitTargetAttr) {
+                    let targetExpr = targetAttr in attrs && `'${attrs[targetAttr]}'`;
+                    if (!targetExpr && ast.attrs) {
+                        // look at the dynamic attribute counterpart
+                        const dynamicTgExpr = ast.attrs[`t-att-${targetAttr}`];
+                        if (dynamicTgExpr) {
+                            targetExpr = compileExpr(dynamicTgExpr);
+                        }
+                    }
+                    idx = block.insertData(`${fullExpression} === ${targetExpr}`, "prop");
+                    attrs[`block-property-${idx}`] = specialInitTargetAttr;
+                }
+                else if (hasDynamicChildren) {
+                    const bValueId = generateId("bValue");
+                    tModelSelectedExpr = `${bValueId}`;
+                    this.define(tModelSelectedExpr, fullExpression);
+                }
+                else {
+                    idx = block.insertData(`${fullExpression}`, "prop");
+                    attrs[`block-property-${idx}`] = targetAttr;
+                }
+                this.helpers.add("toNumber");
+                let valueCode = `ev.target.${targetAttr}`;
+                valueCode = shouldTrim ? `${valueCode}.trim()` : valueCode;
+                valueCode = shouldNumberize ? `toNumber(${valueCode})` : valueCode;
+                const handler = `[(ev) => { ${fullExpression} = ${valueCode}; }]`;
+                idx = block.insertData(handler, "hdlr");
+                attrs[`block-handler-${idx}`] = eventType;
+            }
+            // event handlers
+            for (let ev in ast.on) {
+                const name = this.generateHandlerCode(ev, ast.on[ev]);
+                const idx = block.insertData(name, "hdlr");
+                attrs[`block-handler-${idx}`] = ev;
+            }
+            // t-ref
+            if (ast.ref) {
+                if (this.dev) {
+                    this.helpers.add("makeRefWrapper");
+                    this.target.hasRefWrapper = true;
+                }
+                const isDynamic = INTERP_REGEXP.test(ast.ref);
+                let name = `\`${ast.ref}\``;
+                if (isDynamic) {
+                    name = replaceDynamicParts(ast.ref, (expr) => this.captureExpression(expr, true));
+                }
+                let setRefStr = `(el) => this.__owl__.setRef((${name}), el)`;
+                if (this.dev) {
+                    setRefStr = `refWrapper(${name}, ${setRefStr})`;
+                }
+                const idx = block.insertData(setRefStr, "ref");
+                attrs["block-ref"] = String(idx);
+            }
+            const dom = xmlDoc.createElement(ast.tag);
+            for (const [attr, val] of Object.entries(attrs)) {
+                if (!(attr === "class" && val === "")) {
+                    dom.setAttribute(attr, val);
+                }
+            }
+            block.insert(dom);
+            if (ast.content.length) {
+                const initialDom = block.currentDom;
+                block.currentDom = dom;
+                const children = ast.content;
+                for (let i = 0; i < children.length; i++) {
+                    const child = ast.content[i];
+                    const subCtx = createContext(ctx, {
+                        block,
+                        index: block.childNumber,
+                        forceNewBlock: false,
+                        isLast: ctx.isLast && i === children.length - 1,
+                        tKeyExpr: ctx.tKeyExpr,
+                        nameSpace,
+                        tModelSelectedExpr,
+                        inPreTag: ctx.inPreTag || ast.tag === "pre",
+                    });
+                    this.compileAST(child, subCtx);
+                }
+                block.currentDom = initialDom;
+            }
+            if (isNewBlock) {
+                this.insertBlock(`${block.blockName}(ddd)`, block, ctx);
+                // may need to rewrite code!
+                if (block.children.length && block.hasDynamicChildren) {
+                    const code = this.target.code;
+                    const children = block.children.slice();
+                    let current = children.shift();
+                    for (let i = codeIdx; i < code.length; i++) {
+                        if (code[i].trimStart().startsWith(`const ${current.varName} `)) {
+                            code[i] = code[i].replace(`const ${current.varName}`, current.varName);
+                            current = children.shift();
+                            if (!current)
+                                break;
+                        }
+                    }
+                    this.addLine(`let ${block.children.map((c) => c.varName)};`, codeIdx);
+                }
+            }
+            return block.varName;
+        }
+        compileTEsc(ast, ctx) {
+            let { block, forceNewBlock } = ctx;
+            let expr;
+            if (ast.expr === "0") {
+                this.helpers.add("zero");
+                expr = `ctx[zero]`;
+            }
+            else {
+                expr = compileExpr(ast.expr);
+                if (ast.defaultValue) {
+                    this.helpers.add("withDefault");
+                    expr = `withDefault(${expr}, \`${ast.defaultValue}\`)`;
+                }
+            }
+            if (!block || forceNewBlock) {
+                block = this.createBlock(block, "text", ctx);
+                this.insertBlock(`text(${expr})`, block, { ...ctx, forceNewBlock: forceNewBlock && !block });
+            }
+            else {
+                const idx = block.insertData(expr, "txt");
+                const text = xmlDoc.createElement(`block-text-${idx}`);
+                block.insert(text);
+            }
+            return block.varName;
+        }
+        compileTOut(ast, ctx) {
+            let { block } = ctx;
+            if (block) {
+                this.insertAnchor(block);
+            }
+            block = this.createBlock(block, "html", ctx);
+            let blockStr;
+            if (ast.expr === "0") {
+                this.helpers.add("zero");
+                blockStr = `ctx[zero]`;
+            }
+            else if (ast.body) {
+                let bodyValue = null;
+                bodyValue = BlockDescription.nextBlockId;
+                const subCtx = createContext(ctx);
+                this.compileAST({ type: 3 /* Multi */, content: ast.body }, subCtx);
+                this.helpers.add("safeOutput");
+                blockStr = `safeOutput(${compileExpr(ast.expr)}, b${bodyValue})`;
+            }
+            else {
+                this.helpers.add("safeOutput");
+                blockStr = `safeOutput(${compileExpr(ast.expr)})`;
+            }
+            this.insertBlock(blockStr, block, ctx);
+            return block.varName;
+        }
+        compileTIfBranch(content, block, ctx) {
+            this.target.indentLevel++;
+            let childN = block.children.length;
+            this.compileAST(content, createContext(ctx, { block, index: ctx.index }));
+            if (block.children.length > childN) {
+                // we have some content => need to insert an anchor at correct index
+                this.insertAnchor(block, childN);
+            }
+            this.target.indentLevel--;
+        }
+        compileTIf(ast, ctx, nextNode) {
+            let { block, forceNewBlock } = ctx;
+            const codeIdx = this.target.code.length;
+            const isNewBlock = !block || (block.type !== "multi" && forceNewBlock);
+            if (block) {
+                block.hasDynamicChildren = true;
+            }
+            if (!block || (block.type !== "multi" && forceNewBlock)) {
+                block = this.createBlock(block, "multi", ctx);
+            }
+            this.addLine(`if (${compileExpr(ast.condition)}) {`);
+            this.compileTIfBranch(ast.content, block, ctx);
+            if (ast.tElif) {
+                for (let clause of ast.tElif) {
+                    this.addLine(`} else if (${compileExpr(clause.condition)}) {`);
+                    this.compileTIfBranch(clause.content, block, ctx);
+                }
+            }
+            if (ast.tElse) {
+                this.addLine(`} else {`);
+                this.compileTIfBranch(ast.tElse, block, ctx);
+            }
+            this.addLine("}");
+            if (isNewBlock) {
+                // note: this part is duplicated from end of compiledomnode:
+                if (block.children.length) {
+                    const code = this.target.code;
+                    const children = block.children.slice();
+                    let current = children.shift();
+                    for (let i = codeIdx; i < code.length; i++) {
+                        if (code[i].trimStart().startsWith(`const ${current.varName} `)) {
+                            code[i] = code[i].replace(`const ${current.varName}`, current.varName);
+                            current = children.shift();
+                            if (!current)
+                                break;
+                        }
+                    }
+                    this.addLine(`let ${block.children.map((c) => c.varName)};`, codeIdx);
+                }
+                // note: this part is duplicated from end of compilemulti:
+                const args = block.children.map((c) => c.varName).join(", ");
+                this.insertBlock(`multi([${args}])`, block, ctx);
+            }
+            return block.varName;
+        }
+        compileTForeach(ast, ctx) {
+            let { block } = ctx;
+            if (block) {
+                this.insertAnchor(block);
+            }
+            block = this.createBlock(block, "list", ctx);
+            this.target.loopLevel++;
+            const loopVar = `i${this.target.loopLevel}`;
+            this.addLine(`ctx = Object.create(ctx);`);
+            const vals = `v_block${block.id}`;
+            const keys = `k_block${block.id}`;
+            const l = `l_block${block.id}`;
+            const c = `c_block${block.id}`;
+            this.helpers.add("prepareList");
+            this.define(`[${keys}, ${vals}, ${l}, ${c}]`, `prepareList(${compileExpr(ast.collection)});`);
+            // Throw errors on duplicate keys in dev mode
+            if (this.dev) {
+                this.define(`keys${block.id}`, `new Set()`);
+            }
+            this.addLine(`for (let ${loopVar} = 0; ${loopVar} < ${l}; ${loopVar}++) {`);
+            this.target.indentLevel++;
+            this.addLine(`ctx[\`${ast.elem}\`] = ${vals}[${loopVar}];`);
+            if (!ast.hasNoFirst) {
+                this.addLine(`ctx[\`${ast.elem}_first\`] = ${loopVar} === 0;`);
+            }
+            if (!ast.hasNoLast) {
+                this.addLine(`ctx[\`${ast.elem}_last\`] = ${loopVar} === ${vals}.length - 1;`);
+            }
+            if (!ast.hasNoIndex) {
+                this.addLine(`ctx[\`${ast.elem}_index\`] = ${loopVar};`);
+            }
+            if (!ast.hasNoValue) {
+                this.addLine(`ctx[\`${ast.elem}_value\`] = ${keys}[${loopVar}];`);
+            }
+            this.define(`key${this.target.loopLevel}`, ast.key ? compileExpr(ast.key) : loopVar);
+            if (this.dev) {
+                // Throw error on duplicate keys in dev mode
+                this.helpers.add("OwlError");
+                this.addLine(`if (keys${block.id}.has(String(key${this.target.loopLevel}))) { throw new OwlError(\`Got duplicate key in t-foreach: \${key${this.target.loopLevel}}\`)}`);
+                this.addLine(`keys${block.id}.add(String(key${this.target.loopLevel}));`);
+            }
+            let id;
+            if (ast.memo) {
+                this.target.hasCache = true;
+                id = generateId();
+                this.define(`memo${id}`, compileExpr(ast.memo));
+                this.define(`vnode${id}`, `cache[key${this.target.loopLevel}];`);
+                this.addLine(`if (vnode${id}) {`);
+                this.target.indentLevel++;
+                this.addLine(`if (shallowEqual(vnode${id}.memo, memo${id})) {`);
+                this.target.indentLevel++;
+                this.addLine(`${c}[${loopVar}] = vnode${id};`);
+                this.addLine(`nextCache[key${this.target.loopLevel}] = vnode${id};`);
+                this.addLine(`continue;`);
+                this.target.indentLevel--;
+                this.addLine("}");
+                this.target.indentLevel--;
+                this.addLine("}");
+            }
+            const subCtx = createContext(ctx, { block, index: loopVar });
+            this.compileAST(ast.body, subCtx);
+            if (ast.memo) {
+                this.addLine(`nextCache[key${this.target.loopLevel}] = Object.assign(${c}[${loopVar}], {memo: memo${id}});`);
+            }
+            this.target.indentLevel--;
+            this.target.loopLevel--;
+            this.addLine(`}`);
+            if (!ctx.isLast) {
+                this.addLine(`ctx = ctx.__proto__;`);
+            }
+            this.insertBlock("l", block, ctx);
+            return block.varName;
+        }
+        compileTKey(ast, ctx) {
+            const tKeyExpr = generateId("tKey_");
+            this.define(tKeyExpr, compileExpr(ast.expr));
+            ctx = createContext(ctx, {
+                tKeyExpr,
+                block: ctx.block,
+                index: ctx.index,
+            });
+            return this.compileAST(ast.content, ctx);
+        }
+        compileMulti(ast, ctx) {
+            let { block, forceNewBlock } = ctx;
+            const isNewBlock = !block || forceNewBlock;
+            let codeIdx = this.target.code.length;
+            if (isNewBlock) {
+                const n = ast.content.filter((c) => c.type !== 6 /* TSet */).length;
+                let result = null;
+                if (n <= 1) {
+                    for (let child of ast.content) {
+                        const blockName = this.compileAST(child, ctx);
+                        result = result || blockName;
+                    }
+                    return result;
+                }
+                block = this.createBlock(block, "multi", ctx);
+            }
+            let index = 0;
+            for (let i = 0, l = ast.content.length; i < l; i++) {
+                const child = ast.content[i];
+                const isTSet = child.type === 6 /* TSet */;
+                const subCtx = createContext(ctx, {
+                    block,
+                    index,
+                    forceNewBlock: !isTSet,
+                    preventRoot: ctx.preventRoot,
+                    isLast: ctx.isLast && i === l - 1,
+                });
+                this.compileAST(child, subCtx);
+                if (!isTSet) {
+                    index++;
+                }
+            }
+            if (isNewBlock) {
+                if (block.hasDynamicChildren) {
+                    if (block.children.length) {
+                        const code = this.target.code;
+                        const children = block.children.slice();
+                        let current = children.shift();
+                        for (let i = codeIdx; i < code.length; i++) {
+                            if (code[i].trimStart().startsWith(`const ${current.varName} `)) {
+                                code[i] = code[i].replace(`const ${current.varName}`, current.varName);
+                                current = children.shift();
+                                if (!current)
+                                    break;
+                            }
+                        }
+                        this.addLine(`let ${block.children.map((c) => c.varName)};`, codeIdx);
+                    }
+                }
+                const args = block.children.map((c) => c.varName).join(", ");
+                this.insertBlock(`multi([${args}])`, block, ctx);
+            }
+            return block.varName;
+        }
+        compileTCall(ast, ctx) {
+            let { block, forceNewBlock } = ctx;
+            let ctxVar = ctx.ctxVar || "ctx";
+            if (ast.context) {
+                ctxVar = generateId("ctx");
+                this.addLine(`let ${ctxVar} = ${compileExpr(ast.context)};`);
+            }
+            if (ast.body) {
+                this.addLine(`${ctxVar} = Object.create(${ctxVar});`);
+                this.addLine(`${ctxVar}[isBoundary] = 1;`);
+                this.helpers.add("isBoundary");
+                const subCtx = createContext(ctx, { preventRoot: true, ctxVar });
+                const bl = this.compileMulti({ type: 3 /* Multi */, content: ast.body }, subCtx);
+                if (bl) {
+                    this.helpers.add("zero");
+                    this.addLine(`${ctxVar}[zero] = ${bl};`);
+                }
+            }
+            const isDynamic = INTERP_REGEXP.test(ast.name);
+            const subTemplate = isDynamic ? interpolate(ast.name) : "`" + ast.name + "`";
+            if (block) {
+                if (!forceNewBlock) {
+                    this.insertAnchor(block);
+                }
+            }
+            const key = `key + \`${this.generateComponentKey()}\``;
+            if (isDynamic) {
+                const templateVar = generateId("template");
+                if (!this.staticDefs.find((d) => d.id === "call")) {
+                    this.staticDefs.push({ id: "call", expr: `app.callTemplate.bind(app)` });
+                }
+                this.define(templateVar, subTemplate);
+                block = this.createBlock(block, "multi", ctx);
+                this.insertBlock(`call(this, ${templateVar}, ${ctxVar}, node, ${key})`, block, {
+                    ...ctx,
+                    forceNewBlock: !block,
+                });
+            }
+            else {
+                const id = generateId(`callTemplate_`);
+                this.staticDefs.push({ id, expr: `app.getTemplate(${subTemplate})` });
+                block = this.createBlock(block, "multi", ctx);
+                this.insertBlock(`${id}.call(this, ${ctxVar}, node, ${key})`, block, {
+                    ...ctx,
+                    forceNewBlock: !block,
+                });
+            }
+            if (ast.body && !ctx.isLast) {
+                this.addLine(`${ctxVar} = ${ctxVar}.__proto__;`);
+            }
+            return block.varName;
+        }
+        compileTCallBlock(ast, ctx) {
+            let { block, forceNewBlock } = ctx;
+            if (block) {
+                if (!forceNewBlock) {
+                    this.insertAnchor(block);
+                }
+            }
+            block = this.createBlock(block, "multi", ctx);
+            this.insertBlock(compileExpr(ast.name), block, { ...ctx, forceNewBlock: !block });
+            return block.varName;
+        }
+        compileTSet(ast, ctx) {
+            this.target.shouldProtectScope = true;
+            this.helpers.add("isBoundary").add("withDefault");
+            const expr = ast.value ? compileExpr(ast.value || "") : "null";
+            if (ast.body) {
+                this.helpers.add("LazyValue");
+                const bodyAst = { type: 3 /* Multi */, content: ast.body };
+                const name = this.compileInNewTarget("value", bodyAst, ctx);
+                let key = this.target.currentKey(ctx);
+                let value = `new LazyValue(${name}, ctx, this, node, ${key})`;
+                value = ast.value ? (value ? `withDefault(${expr}, ${value})` : expr) : value;
+                this.addLine(`ctx[\`${ast.name}\`] = ${value};`);
+            }
+            else {
+                let value;
+                if (ast.defaultValue) {
+                    if (ast.value) {
+                        value = `withDefault(${expr}, \`${ast.defaultValue}\`)`;
+                    }
+                    else {
+                        value = `\`${ast.defaultValue}\``;
+                    }
+                }
+                else {
+                    value = expr;
+                }
+                this.helpers.add("setContextValue");
+                this.addLine(`setContextValue(${ctx.ctxVar || "ctx"}, "${ast.name}", ${value});`);
+            }
+            return null;
+        }
+        generateComponentKey() {
+            const parts = [generateId("__")];
+            for (let i = 0; i < this.target.loopLevel; i++) {
+                parts.push(`\${key${i + 1}}`);
+            }
+            return parts.join("__");
+        }
+        /**
+         * Formats a prop name and value into a string suitable to be inserted in the
+         * generated code. For example:
+         *
+         * Name              Value            Result
+         * ---------------------------------------------------------
+         * "number"          "state"          "number: ctx['state']"
+         * "something"       ""               "something: undefined"
+         * "some-prop"       "state"          "'some-prop': ctx['state']"
+         * "onClick.bind"    "onClick"        "onClick: bind(ctx, ctx['onClick'])"
+         */
+        formatProp(name, value) {
+            value = this.captureExpression(value);
+            if (name.includes(".")) {
+                let [_name, suffix] = name.split(".");
+                name = _name;
+                switch (suffix) {
+                    case "bind":
+                        value = `(${value}).bind(this)`;
+                        break;
+                    case "alike":
+                        break;
+                    default:
+                        throw new OwlError("Invalid prop suffix");
+                }
+            }
+            name = /^[a-z_]+$/i.test(name) ? name : `'${name}'`;
+            return `${name}: ${value || undefined}`;
+        }
+        formatPropObject(obj) {
+            return Object.entries(obj).map(([k, v]) => this.formatProp(k, v));
+        }
+        getPropString(props, dynProps) {
+            let propString = `{${props.join(",")}}`;
+            if (dynProps) {
+                propString = `Object.assign({}, ${compileExpr(dynProps)}${props.length ? ", " + propString : ""})`;
+            }
+            return propString;
+        }
+        compileComponent(ast, ctx) {
+            let { block } = ctx;
+            // props
+            const hasSlotsProp = "slots" in (ast.props || {});
+            const props = ast.props ? this.formatPropObject(ast.props) : [];
+            // slots
+            let slotDef = "";
+            if (ast.slots) {
+                let ctxStr = "ctx";
+                if (this.target.loopLevel || !this.hasSafeContext) {
+                    ctxStr = generateId("ctx");
+                    this.helpers.add("capture");
+                    this.define(ctxStr, `capture(ctx)`);
+                }
+                let slotStr = [];
+                for (let slotName in ast.slots) {
+                    const slotAst = ast.slots[slotName];
+                    const params = [];
+                    if (slotAst.content) {
+                        const name = this.compileInNewTarget("slot", slotAst.content, ctx, slotAst.on);
+                        params.push(`__render: ${name}.bind(this), __ctx: ${ctxStr}`);
+                    }
+                    const scope = ast.slots[slotName].scope;
+                    if (scope) {
+                        params.push(`__scope: "${scope}"`);
+                    }
+                    if (ast.slots[slotName].attrs) {
+                        params.push(...this.formatPropObject(ast.slots[slotName].attrs));
+                    }
+                    const slotInfo = `{${params.join(", ")}}`;
+                    slotStr.push(`'${slotName}': ${slotInfo}`);
+                }
+                slotDef = `{${slotStr.join(", ")}}`;
+            }
+            if (slotDef && !(ast.dynamicProps || hasSlotsProp)) {
+                this.helpers.add("markRaw");
+                props.push(`slots: markRaw(${slotDef})`);
+            }
+            let propString = this.getPropString(props, ast.dynamicProps);
+            let propVar;
+            if ((slotDef && (ast.dynamicProps || hasSlotsProp)) || this.dev) {
+                propVar = generateId("props");
+                this.define(propVar, propString);
+                propString = propVar;
+            }
+            if (slotDef && (ast.dynamicProps || hasSlotsProp)) {
+                this.helpers.add("markRaw");
+                this.addLine(`${propVar}.slots = markRaw(Object.assign(${slotDef}, ${propVar}.slots))`);
+            }
+            // cmap key
+            const key = this.generateComponentKey();
+            let expr;
+            if (ast.isDynamic) {
+                expr = generateId("Comp");
+                this.define(expr, compileExpr(ast.name));
+            }
+            else {
+                expr = `\`${ast.name}\``;
+            }
+            if (this.dev) {
+                this.addLine(`helpers.validateProps(${expr}, ${propVar}, this);`);
+            }
+            if (block && (ctx.forceNewBlock === false || ctx.tKeyExpr)) {
+                // todo: check the forcenewblock condition
+                this.insertAnchor(block);
+            }
+            let keyArg = `key + \`${key}\``;
+            if (ctx.tKeyExpr) {
+                keyArg = `${ctx.tKeyExpr} + ${keyArg}`;
+            }
+            let id = generateId("comp");
+            const propList = [];
+            for (let p in ast.props || {}) {
+                let [name, suffix] = p.split(".");
+                if (!suffix) {
+                    propList.push(`"${name}"`);
+                }
+            }
+            this.staticDefs.push({
+                id,
+                expr: `app.createComponent(${ast.isDynamic ? null : expr}, ${!ast.isDynamic}, ${!!ast.slots}, ${!!ast.dynamicProps}, [${propList}])`,
+            });
+            if (ast.isDynamic) {
+                // If the component class changes, this can cause delayed renders to go
+                // through if the key doesn't change. Use the component name for now.
+                // This means that two component classes with the same name isn't supported
+                // in t-component. We can generate a unique id per class later if needed.
+                keyArg = `(${expr}).name + ${keyArg}`;
+            }
+            let blockExpr = `${id}(${propString}, ${keyArg}, node, this, ${ast.isDynamic ? expr : null})`;
+            if (ast.isDynamic) {
+                blockExpr = `toggler(${expr}, ${blockExpr})`;
+            }
+            // event handling
+            if (ast.on) {
+                blockExpr = this.wrapWithEventCatcher(blockExpr, ast.on);
+            }
+            block = this.createBlock(block, "multi", ctx);
+            this.insertBlock(blockExpr, block, ctx);
+            return block.varName;
+        }
+        wrapWithEventCatcher(expr, on) {
+            this.helpers.add("createCatcher");
+            let name = generateId("catcher");
+            let spec = {};
+            let handlers = [];
+            for (let ev in on) {
+                let handlerId = generateId("hdlr");
+                let idx = handlers.push(handlerId) - 1;
+                spec[ev] = idx;
+                const handler = this.generateHandlerCode(ev, on[ev]);
+                this.define(handlerId, handler);
+            }
+            this.staticDefs.push({ id: name, expr: `createCatcher(${JSON.stringify(spec)})` });
+            return `${name}(${expr}, [${handlers.join(",")}])`;
+        }
+        compileTSlot(ast, ctx) {
+            this.helpers.add("callSlot");
+            let { block } = ctx;
+            let blockString;
+            let slotName;
+            let dynamic = false;
+            let isMultiple = false;
+            if (ast.name.match(INTERP_REGEXP)) {
+                dynamic = true;
+                isMultiple = true;
+                slotName = interpolate(ast.name);
+            }
+            else {
+                slotName = "'" + ast.name + "'";
+                isMultiple = isMultiple || this.slotNames.has(ast.name);
+                this.slotNames.add(ast.name);
+            }
+            const dynProps = ast.attrs ? ast.attrs["t-props"] : null;
+            if (ast.attrs) {
+                delete ast.attrs["t-props"];
+            }
+            let key = this.target.loopLevel ? `key${this.target.loopLevel}` : "key";
+            if (isMultiple) {
+                key = `${key} + \`${this.generateComponentKey()}\``;
+            }
+            const props = ast.attrs ? this.formatPropObject(ast.attrs) : [];
+            const scope = this.getPropString(props, dynProps);
+            if (ast.defaultContent) {
+                const name = this.compileInNewTarget("defaultContent", ast.defaultContent, ctx);
+                blockString = `callSlot(ctx, node, ${key}, ${slotName}, ${dynamic}, ${scope}, ${name}.bind(this))`;
+            }
+            else {
+                if (dynamic) {
+                    let name = generateId("slot");
+                    this.define(name, slotName);
+                    blockString = `toggler(${name}, callSlot(ctx, node, ${key}, ${name}, ${dynamic}, ${scope}))`;
+                }
+                else {
+                    blockString = `callSlot(ctx, node, ${key}, ${slotName}, ${dynamic}, ${scope})`;
+                }
+            }
+            // event handling
+            if (ast.on) {
+                blockString = this.wrapWithEventCatcher(blockString, ast.on);
+            }
+            if (block) {
+                this.insertAnchor(block);
+            }
+            block = this.createBlock(block, "multi", ctx);
+            this.insertBlock(blockString, block, { ...ctx, forceNewBlock: false });
+            return block.varName;
+        }
+        compileTTranslation(ast, ctx) {
+            if (ast.content) {
+                return this.compileAST(ast.content, Object.assign({}, ctx, { translate: false }));
+            }
+            return null;
+        }
+        compileTPortal(ast, ctx) {
+            if (!this.staticDefs.find((d) => d.id === "Portal")) {
+                this.staticDefs.push({ id: "Portal", expr: `app.Portal` });
+            }
+            let { block } = ctx;
+            const name = this.compileInNewTarget("slot", ast.content, ctx);
+            const key = this.generateComponentKey();
+            let ctxStr = "ctx";
+            if (this.target.loopLevel || !this.hasSafeContext) {
+                ctxStr = generateId("ctx");
+                this.helpers.add("capture");
+                this.define(ctxStr, `capture(ctx)`);
+            }
+            let id = generateId("comp");
+            this.staticDefs.push({
+                id,
+                expr: `app.createComponent(null, false, true, false, false)`,
+            });
+            const target = compileExpr(ast.target);
+            const blockString = `${id}({target: ${target},slots: {'default': {__render: ${name}.bind(this), __ctx: ${ctxStr}}}}, key + \`${key}\`, node, ctx, Portal)`;
+            if (block) {
+                this.insertAnchor(block);
+            }
+            block = this.createBlock(block, "multi", ctx);
+            this.insertBlock(blockString, block, { ...ctx, forceNewBlock: false });
+            return block.varName;
+        }
+    }
+
+    // -----------------------------------------------------------------------------
+    // Parser
+    // -----------------------------------------------------------------------------
+    const cache = new WeakMap();
+    function parse(xml) {
+        if (typeof xml === "string") {
+            const elem = parseXML(`<t>${xml}</t>`).firstChild;
+            return _parse(elem);
+        }
+        let ast = cache.get(xml);
+        if (!ast) {
+            // we clone here the xml to prevent modifying it in place
+            ast = _parse(xml.cloneNode(true));
+            cache.set(xml, ast);
+        }
+        return ast;
+    }
+    function _parse(xml) {
+        normalizeXML(xml);
+        const ctx = { inPreTag: false, inSVG: false };
+        return parseNode(xml, ctx) || { type: 0 /* Text */, value: "" };
+    }
+    function parseNode(node, ctx) {
+        if (!(node instanceof Element)) {
+            return parseTextCommentNode(node, ctx);
+        }
+        return (parseTDebugLog(node, ctx) ||
+            parseTForEach(node, ctx) ||
+            parseTIf(node, ctx) ||
+            parseTPortal(node, ctx) ||
+            parseTCall(node, ctx) ||
+            parseTCallBlock(node) ||
+            parseTEscNode(node, ctx) ||
+            parseTKey(node, ctx) ||
+            parseTTranslation(node, ctx) ||
+            parseTSlot(node, ctx) ||
+            parseTOutNode(node, ctx) ||
+            parseComponent(node, ctx) ||
+            parseDOMNode(node, ctx) ||
+            parseTSetNode(node, ctx) ||
+            parseTNode(node, ctx));
+    }
+    // -----------------------------------------------------------------------------
+    // <t /> tag
+    // -----------------------------------------------------------------------------
+    function parseTNode(node, ctx) {
+        if (node.tagName !== "t") {
+            return null;
+        }
+        return parseChildNodes(node, ctx);
+    }
+    // -----------------------------------------------------------------------------
+    // Text and Comment Nodes
+    // -----------------------------------------------------------------------------
+    const lineBreakRE = /[\r\n]/;
+    function parseTextCommentNode(node, ctx) {
+        if (node.nodeType === Node.TEXT_NODE) {
+            let value = node.textContent || "";
+            if (!ctx.inPreTag && lineBreakRE.test(value) && !value.trim()) {
+                return null;
+            }
+            return { type: 0 /* Text */, value };
+        }
+        else if (node.nodeType === Node.COMMENT_NODE) {
+            return { type: 1 /* Comment */, value: node.textContent || "" };
+        }
+        return null;
+    }
+    // -----------------------------------------------------------------------------
+    // debugging
+    // -----------------------------------------------------------------------------
+    function parseTDebugLog(node, ctx) {
+        if (node.hasAttribute("t-debug")) {
+            node.removeAttribute("t-debug");
+            return {
+                type: 12 /* TDebug */,
+                content: parseNode(node, ctx),
+            };
+        }
+        if (node.hasAttribute("t-log")) {
+            const expr = node.getAttribute("t-log");
+            node.removeAttribute("t-log");
+            return {
+                type: 13 /* TLog */,
+                expr,
+                content: parseNode(node, ctx),
+            };
+        }
+        return null;
+    }
+    // -----------------------------------------------------------------------------
+    // Regular dom node
+    // -----------------------------------------------------------------------------
+    const hasDotAtTheEnd = /\.[\w_]+\s*$/;
+    const hasBracketsAtTheEnd = /\[[^\[]+\]\s*$/;
+    const ROOT_SVG_TAGS = new Set(["svg", "g", "path"]);
+    function parseDOMNode(node, ctx) {
+        const { tagName } = node;
+        const dynamicTag = node.getAttribute("t-tag");
+        node.removeAttribute("t-tag");
+        if (tagName === "t" && !dynamicTag) {
+            return null;
+        }
+        if (tagName.startsWith("block-")) {
+            throw new OwlError(`Invalid tag name: '${tagName}'`);
+        }
+        ctx = Object.assign({}, ctx);
+        if (tagName === "pre") {
+            ctx.inPreTag = true;
+        }
+        const shouldAddSVGNS = ROOT_SVG_TAGS.has(tagName) && !ctx.inSVG;
+        ctx.inSVG = ctx.inSVG || shouldAddSVGNS;
+        const ns = shouldAddSVGNS ? "http://www.w3.org/2000/svg" : null;
+        const ref = node.getAttribute("t-ref");
+        node.removeAttribute("t-ref");
+        const nodeAttrsNames = node.getAttributeNames();
+        let attrs = null;
+        let on = null;
+        let model = null;
+        for (let attr of nodeAttrsNames) {
+            const value = node.getAttribute(attr);
+            if (attr.startsWith("t-on")) {
+                if (attr === "t-on") {
+                    throw new OwlError("Missing event name with t-on directive");
+                }
+                on = on || {};
+                on[attr.slice(5)] = value;
+            }
+            else if (attr.startsWith("t-model")) {
+                if (!["input", "select", "textarea"].includes(tagName)) {
+                    throw new OwlError("The t-model directive only works with <input>, <textarea> and <select>");
+                }
+                let baseExpr, expr;
+                if (hasDotAtTheEnd.test(value)) {
+                    const index = value.lastIndexOf(".");
+                    baseExpr = value.slice(0, index);
+                    expr = `'${value.slice(index + 1)}'`;
+                }
+                else if (hasBracketsAtTheEnd.test(value)) {
+                    const index = value.lastIndexOf("[");
+                    baseExpr = value.slice(0, index);
+                    expr = value.slice(index + 1, -1);
+                }
+                else {
+                    throw new OwlError(`Invalid t-model expression: "${value}" (it should be assignable)`);
+                }
+                const typeAttr = node.getAttribute("type");
+                const isInput = tagName === "input";
+                const isSelect = tagName === "select";
+                const isTextarea = tagName === "textarea";
+                const isCheckboxInput = isInput && typeAttr === "checkbox";
+                const isRadioInput = isInput && typeAttr === "radio";
+                const isOtherInput = isInput && !isCheckboxInput && !isRadioInput;
+                const hasLazyMod = attr.includes(".lazy");
+                const hasNumberMod = attr.includes(".number");
+                const hasTrimMod = attr.includes(".trim");
+                const eventType = isRadioInput ? "click" : isSelect || hasLazyMod ? "change" : "input";
+                model = {
+                    baseExpr,
+                    expr,
+                    targetAttr: isCheckboxInput ? "checked" : "value",
+                    specialInitTargetAttr: isRadioInput ? "checked" : null,
+                    eventType,
+                    hasDynamicChildren: false,
+                    shouldTrim: hasTrimMod && (isOtherInput || isTextarea),
+                    shouldNumberize: hasNumberMod && (isOtherInput || isTextarea),
+                };
+                if (isSelect) {
+                    // don't pollute the original ctx
+                    ctx = Object.assign({}, ctx);
+                    ctx.tModelInfo = model;
+                }
+            }
+            else if (attr.startsWith("block-")) {
+                throw new OwlError(`Invalid attribute: '${attr}'`);
+            }
+            else if (attr !== "t-name") {
+                if (attr.startsWith("t-") && !attr.startsWith("t-att")) {
+                    throw new OwlError(`Unknown QWeb directive: '${attr}'`);
+                }
+                const tModel = ctx.tModelInfo;
+                if (tModel && ["t-att-value", "t-attf-value"].includes(attr)) {
+                    tModel.hasDynamicChildren = true;
+                }
+                attrs = attrs || {};
+                attrs[attr] = value;
+            }
+        }
+        const children = parseChildren(node, ctx);
+        return {
+            type: 2 /* DomNode */,
+            tag: tagName,
+            dynamicTag,
+            attrs,
+            on,
+            ref,
+            content: children,
+            model,
+            ns,
+        };
+    }
+    // -----------------------------------------------------------------------------
+    // t-esc
+    // -----------------------------------------------------------------------------
+    function parseTEscNode(node, ctx) {
+        if (!node.hasAttribute("t-esc")) {
+            return null;
+        }
+        const escValue = node.getAttribute("t-esc");
+        node.removeAttribute("t-esc");
+        const tesc = {
+            type: 4 /* TEsc */,
+            expr: escValue,
+            defaultValue: node.textContent || "",
+        };
+        let ref = node.getAttribute("t-ref");
+        node.removeAttribute("t-ref");
+        const ast = parseNode(node, ctx);
+        if (!ast) {
+            return tesc;
+        }
+        if (ast.type === 2 /* DomNode */) {
+            return {
+                ...ast,
+                ref,
+                content: [tesc],
+            };
+        }
+        if (ast.type === 11 /* TComponent */) {
+            throw new OwlError("t-esc is not supported on Component nodes");
+        }
+        return tesc;
+    }
+    // -----------------------------------------------------------------------------
+    // t-out
+    // -----------------------------------------------------------------------------
+    function parseTOutNode(node, ctx) {
+        if (!node.hasAttribute("t-out") && !node.hasAttribute("t-raw")) {
+            return null;
+        }
+        if (node.hasAttribute("t-raw")) {
+            console.warn(`t-raw has been deprecated in favor of t-out. If the value to render is not wrapped by the "markup" function, it will be escaped`);
+        }
+        const expr = (node.getAttribute("t-out") || node.getAttribute("t-raw"));
+        node.removeAttribute("t-out");
+        node.removeAttribute("t-raw");
+        const tOut = { type: 8 /* TOut */, expr, body: null };
+        const ref = node.getAttribute("t-ref");
+        node.removeAttribute("t-ref");
+        const ast = parseNode(node, ctx);
+        if (!ast) {
+            return tOut;
+        }
+        if (ast.type === 2 /* DomNode */) {
+            tOut.body = ast.content.length ? ast.content : null;
+            return {
+                ...ast,
+                ref,
+                content: [tOut],
+            };
+        }
+        return tOut;
+    }
+    // -----------------------------------------------------------------------------
+    // t-foreach and t-key
+    // -----------------------------------------------------------------------------
+    function parseTForEach(node, ctx) {
+        if (!node.hasAttribute("t-foreach")) {
+            return null;
+        }
+        const html = node.outerHTML;
+        const collection = node.getAttribute("t-foreach");
+        node.removeAttribute("t-foreach");
+        const elem = node.getAttribute("t-as") || "";
+        node.removeAttribute("t-as");
+        const key = node.getAttribute("t-key");
+        if (!key) {
+            throw new OwlError(`"Directive t-foreach should always be used with a t-key!" (expression: t-foreach="${collection}" t-as="${elem}")`);
+        }
+        node.removeAttribute("t-key");
+        const memo = node.getAttribute("t-memo") || "";
+        node.removeAttribute("t-memo");
+        const body = parseNode(node, ctx);
+        if (!body) {
+            return null;
+        }
+        const hasNoTCall = !html.includes("t-call");
+        const hasNoFirst = hasNoTCall && !html.includes(`${elem}_first`);
+        const hasNoLast = hasNoTCall && !html.includes(`${elem}_last`);
+        const hasNoIndex = hasNoTCall && !html.includes(`${elem}_index`);
+        const hasNoValue = hasNoTCall && !html.includes(`${elem}_value`);
+        return {
+            type: 9 /* TForEach */,
+            collection,
+            elem,
+            body,
+            memo,
+            key,
+            hasNoFirst,
+            hasNoLast,
+            hasNoIndex,
+            hasNoValue,
+        };
+    }
+    function parseTKey(node, ctx) {
+        if (!node.hasAttribute("t-key")) {
+            return null;
+        }
+        const key = node.getAttribute("t-key");
+        node.removeAttribute("t-key");
+        const body = parseNode(node, ctx);
+        if (!body) {
+            return null;
+        }
+        return { type: 10 /* TKey */, expr: key, content: body };
+    }
+    // -----------------------------------------------------------------------------
+    // t-call
+    // -----------------------------------------------------------------------------
+    function parseTCall(node, ctx) {
+        if (!node.hasAttribute("t-call")) {
+            return null;
+        }
+        const subTemplate = node.getAttribute("t-call");
+        const context = node.getAttribute("t-call-context");
+        node.removeAttribute("t-call");
+        node.removeAttribute("t-call-context");
+        if (node.tagName !== "t") {
+            const ast = parseNode(node, ctx);
+            const tcall = { type: 7 /* TCall */, name: subTemplate, body: null, context };
+            if (ast && ast.type === 2 /* DomNode */) {
+                ast.content = [tcall];
+                return ast;
+            }
+            if (ast && ast.type === 11 /* TComponent */) {
+                return {
+                    ...ast,
+                    slots: { default: { content: tcall, scope: null, on: null, attrs: null } },
+                };
+            }
+        }
+        const body = parseChildren(node, ctx);
+        return {
+            type: 7 /* TCall */,
+            name: subTemplate,
+            body: body.length ? body : null,
+            context,
+        };
+    }
+    // -----------------------------------------------------------------------------
+    // t-call-block
+    // -----------------------------------------------------------------------------
+    function parseTCallBlock(node, ctx) {
+        if (!node.hasAttribute("t-call-block")) {
+            return null;
+        }
+        const name = node.getAttribute("t-call-block");
+        return {
+            type: 15 /* TCallBlock */,
+            name,
+        };
+    }
+    // -----------------------------------------------------------------------------
+    // t-if
+    // -----------------------------------------------------------------------------
+    function parseTIf(node, ctx) {
+        if (!node.hasAttribute("t-if")) {
+            return null;
+        }
+        const condition = node.getAttribute("t-if");
+        node.removeAttribute("t-if");
+        const content = parseNode(node, ctx) || { type: 0 /* Text */, value: "" };
+        let nextElement = node.nextElementSibling;
+        // t-elifs
+        const tElifs = [];
+        while (nextElement && nextElement.hasAttribute("t-elif")) {
+            const condition = nextElement.getAttribute("t-elif");
+            nextElement.removeAttribute("t-elif");
+            const tElif = parseNode(nextElement, ctx);
+            const next = nextElement.nextElementSibling;
+            nextElement.remove();
+            nextElement = next;
+            if (tElif) {
+                tElifs.push({ condition, content: tElif });
+            }
+        }
+        // t-else
+        let tElse = null;
+        if (nextElement && nextElement.hasAttribute("t-else")) {
+            nextElement.removeAttribute("t-else");
+            tElse = parseNode(nextElement, ctx);
+            nextElement.remove();
+        }
+        return {
+            type: 5 /* TIf */,
+            condition,
+            content,
+            tElif: tElifs.length ? tElifs : null,
+            tElse,
+        };
+    }
+    // -----------------------------------------------------------------------------
+    // t-set directive
+    // -----------------------------------------------------------------------------
+    function parseTSetNode(node, ctx) {
+        if (!node.hasAttribute("t-set")) {
+            return null;
+        }
+        const name = node.getAttribute("t-set");
+        const value = node.getAttribute("t-value") || null;
+        const defaultValue = node.innerHTML === node.textContent ? node.textContent || null : null;
+        let body = null;
+        if (node.textContent !== node.innerHTML) {
+            body = parseChildren(node, ctx);
+        }
+        return { type: 6 /* TSet */, name, value, defaultValue, body };
+    }
+    // -----------------------------------------------------------------------------
+    // Components
+    // -----------------------------------------------------------------------------
+    // Error messages when trying to use an unsupported directive on a component
+    const directiveErrorMap = new Map([
+        [
+            "t-ref",
+            "t-ref is no longer supported on components. Consider exposing only the public part of the component's API through a callback prop.",
+        ],
+        ["t-att", "t-att makes no sense on component: props are already treated as expressions"],
+        [
+            "t-attf",
+            "t-attf is not supported on components: use template strings for string interpolation in props",
+        ],
+    ]);
+    function parseComponent(node, ctx) {
+        let name = node.tagName;
+        const firstLetter = name[0];
+        let isDynamic = node.hasAttribute("t-component");
+        if (isDynamic && name !== "t") {
+            throw new OwlError(`Directive 't-component' can only be used on <t> nodes (used on a <${name}>)`);
+        }
+        if (!(firstLetter === firstLetter.toUpperCase() || isDynamic)) {
+            return null;
+        }
+        if (isDynamic) {
+            name = node.getAttribute("t-component");
+            node.removeAttribute("t-component");
+        }
+        const dynamicProps = node.getAttribute("t-props");
+        node.removeAttribute("t-props");
+        const defaultSlotScope = node.getAttribute("t-slot-scope");
+        node.removeAttribute("t-slot-scope");
+        let on = null;
+        let props = null;
+        for (let name of node.getAttributeNames()) {
+            const value = node.getAttribute(name);
+            if (name.startsWith("t-")) {
+                if (name.startsWith("t-on-")) {
+                    on = on || {};
+                    on[name.slice(5)] = value;
+                }
+                else {
+                    const message = directiveErrorMap.get(name.split("-").slice(0, 2).join("-"));
+                    throw new OwlError(message || `unsupported directive on Component: ${name}`);
+                }
+            }
+            else {
+                props = props || {};
+                props[name] = value;
+            }
+        }
+        let slots = null;
+        if (node.hasChildNodes()) {
+            const clone = node.cloneNode(true);
+            // named slots
+            const slotNodes = Array.from(clone.querySelectorAll("[t-set-slot]"));
+            for (let slotNode of slotNodes) {
+                if (slotNode.tagName !== "t") {
+                    throw new OwlError(`Directive 't-set-slot' can only be used on <t> nodes (used on a <${slotNode.tagName}>)`);
+                }
+                const name = slotNode.getAttribute("t-set-slot");
+                // check if this is defined in a sub component (in which case it should
+                // be ignored)
+                let el = slotNode.parentElement;
+                let isInSubComponent = false;
+                while (el !== clone) {
+                    if (el.hasAttribute("t-component") || el.tagName[0] === el.tagName[0].toUpperCase()) {
+                        isInSubComponent = true;
+                        break;
+                    }
+                    el = el.parentElement;
+                }
+                if (isInSubComponent) {
+                    continue;
+                }
+                slotNode.removeAttribute("t-set-slot");
+                slotNode.remove();
+                const slotAst = parseNode(slotNode, ctx);
+                let on = null;
+                let attrs = null;
+                let scope = null;
+                for (let attributeName of slotNode.getAttributeNames()) {
+                    const value = slotNode.getAttribute(attributeName);
+                    if (attributeName === "t-slot-scope") {
+                        scope = value;
+                        continue;
+                    }
+                    else if (attributeName.startsWith("t-on-")) {
+                        on = on || {};
+                        on[attributeName.slice(5)] = value;
+                    }
+                    else {
+                        attrs = attrs || {};
+                        attrs[attributeName] = value;
+                    }
+                }
+                slots = slots || {};
+                slots[name] = { content: slotAst, on, attrs, scope };
+            }
+            // default slot
+            const defaultContent = parseChildNodes(clone, ctx);
+            slots = slots || {};
+            // t-set-slot="default" has priority over content
+            if (defaultContent && !slots.default) {
+                slots.default = { content: defaultContent, on, attrs: null, scope: defaultSlotScope };
+            }
+        }
+        return { type: 11 /* TComponent */, name, isDynamic, dynamicProps, props, slots, on };
+    }
+    // -----------------------------------------------------------------------------
+    // Slots
+    // -----------------------------------------------------------------------------
+    function parseTSlot(node, ctx) {
+        if (!node.hasAttribute("t-slot")) {
+            return null;
+        }
+        const name = node.getAttribute("t-slot");
+        node.removeAttribute("t-slot");
+        let attrs = null;
+        let on = null;
+        for (let attributeName of node.getAttributeNames()) {
+            const value = node.getAttribute(attributeName);
+            if (attributeName.startsWith("t-on-")) {
+                on = on || {};
+                on[attributeName.slice(5)] = value;
+            }
+            else {
+                attrs = attrs || {};
+                attrs[attributeName] = value;
+            }
+        }
+        return {
+            type: 14 /* TSlot */,
+            name,
+            attrs,
+            on,
+            defaultContent: parseChildNodes(node, ctx),
+        };
+    }
+    function parseTTranslation(node, ctx) {
+        if (node.getAttribute("t-translation") !== "off") {
+            return null;
+        }
+        node.removeAttribute("t-translation");
+        return {
+            type: 16 /* TTranslation */,
+            content: parseNode(node, ctx),
+        };
+    }
+    // -----------------------------------------------------------------------------
+    // Portal
+    // -----------------------------------------------------------------------------
+    function parseTPortal(node, ctx) {
+        if (!node.hasAttribute("t-portal")) {
+            return null;
+        }
+        const target = node.getAttribute("t-portal");
+        node.removeAttribute("t-portal");
+        const content = parseNode(node, ctx);
+        if (!content) {
+            return {
+                type: 0 /* Text */,
+                value: "",
+            };
+        }
+        return {
+            type: 17 /* TPortal */,
+            target,
+            content,
+        };
+    }
+    // -----------------------------------------------------------------------------
+    // helpers
+    // -----------------------------------------------------------------------------
+    /**
+     * Parse all the child nodes of a given node and return a list of ast elements
+     */
+    function parseChildren(node, ctx) {
+        const children = [];
+        for (let child of node.childNodes) {
+            const childAst = parseNode(child, ctx);
+            if (childAst) {
+                if (childAst.type === 3 /* Multi */) {
+                    children.push(...childAst.content);
+                }
+                else {
+                    children.push(childAst);
+                }
+            }
+        }
+        return children;
+    }
+    /**
+     * Parse all the child nodes of a given node and return an ast if possible.
+     * In the case there are multiple children, they are wrapped in a astmulti.
+     */
+    function parseChildNodes(node, ctx) {
+        const children = parseChildren(node, ctx);
+        switch (children.length) {
+            case 0:
+                return null;
+            case 1:
+                return children[0];
+            default:
+                return { type: 3 /* Multi */, content: children };
+        }
+    }
+    /**
+     * Normalizes the content of an Element so that t-if/t-elif/t-else directives
+     * immediately follow one another (by removing empty text nodes or comments).
+     * Throws an error when a conditional branching statement is malformed. This
+     * function modifies the Element in place.
+     *
+     * @param el the element containing the tree that should be normalized
+     */
+    function normalizeTIf(el) {
+        let tbranch = el.querySelectorAll("[t-elif], [t-else]");
+        for (let i = 0, ilen = tbranch.length; i < ilen; i++) {
+            let node = tbranch[i];
+            let prevElem = node.previousElementSibling;
+            let pattr = (name) => prevElem.getAttribute(name);
+            let nattr = (name) => +!!node.getAttribute(name);
+            if (prevElem && (pattr("t-if") || pattr("t-elif"))) {
+                if (pattr("t-foreach")) {
+                    throw new OwlError("t-if cannot stay at the same level as t-foreach when using t-elif or t-else");
+                }
+                if (["t-if", "t-elif", "t-else"].map(nattr).reduce(function (a, b) {
+                    return a + b;
+                }) > 1) {
+                    throw new OwlError("Only one conditional branching directive is allowed per node");
+                }
+                // All text (with only spaces) and comment nodes (nodeType 8) between
+                // branch nodes are removed
+                let textNode;
+                while ((textNode = node.previousSibling) !== prevElem) {
+                    if (textNode.nodeValue.trim().length && textNode.nodeType !== 8) {
+                        throw new OwlError("text is not allowed between branching directives");
+                    }
+                    textNode.remove();
+                }
+            }
+            else {
+                throw new OwlError("t-elif and t-else directives must be preceded by a t-if or t-elif directive");
+            }
+        }
+    }
+    /**
+     * Normalizes the content of an Element so that t-esc directives on components
+     * are removed and instead places a <t t-esc=""> as the default slot of the
+     * component. Also throws if the component already has content. This function
+     * modifies the Element in place.
+     *
+     * @param el the element containing the tree that should be normalized
+     */
+    function normalizeTEsc(el) {
+        const elements = [...el.querySelectorAll("[t-esc]")].filter((el) => el.tagName[0] === el.tagName[0].toUpperCase() || el.hasAttribute("t-component"));
+        for (const el of elements) {
+            if (el.childNodes.length) {
+                throw new OwlError("Cannot have t-esc on a component that already has content");
+            }
+            const value = el.getAttribute("t-esc");
+            el.removeAttribute("t-esc");
+            const t = el.ownerDocument.createElement("t");
+            if (value != null) {
+                t.setAttribute("t-esc", value);
+            }
+            el.appendChild(t);
+        }
+    }
+    /**
+     * Normalizes the tree inside a given element and do some preliminary validation
+     * on it. This function modifies the Element in place.
+     *
+     * @param el the element containing the tree that should be normalized
+     */
+    function normalizeXML(el) {
+        normalizeTIf(el);
+        normalizeTEsc(el);
+    }
+    /**
+     * 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;
+    }
+
+    function compile(template, options = {}) {
+        // parsing
+        const ast = parse(template);
+        // some work
+        const hasSafeContext = template instanceof Node
+            ? !(template instanceof Element) || template.querySelector("[t-set], [t-call]") === null
+            : !template.includes("t-set") && !template.includes("t-call");
+        // code generation
+        const codeGenerator = new CodeGenerator(ast, { ...options, hasSafeContext });
+        const code = codeGenerator.generateCode();
+        // template function
+        return new Function("app, bdom, helpers", code);
+    }
+
+    // do not modify manually. This value is updated by the release script.
+    const version = "2.0.9";
+
+    // -----------------------------------------------------------------------------
+    //  Scheduler
+    // -----------------------------------------------------------------------------
+    class Scheduler {
+        constructor() {
+            this.tasks = new Set();
+            this.frame = 0;
+            this.delayedRenders = [];
+            this.requestAnimationFrame = Scheduler.requestAnimationFrame;
+        }
+        addFiber(fiber) {
+            this.tasks.add(fiber.root);
+        }
+        /**
+         * 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 !== 2 /* DESTROYED */ && f.node.fiber === f) {
+                        f.render();
+                    }
+                }
+            }
+            if (this.frame === 0) {
+                this.frame = this.requestAnimationFrame(() => {
+                    this.frame = 0;
+                    this.tasks.forEach((fiber) => this.processFiber(fiber));
+                    for (let task of this.tasks) {
+                        if (task.node.status === 2 /* DESTROYED */) {
+                            this.tasks.delete(task);
+                        }
+                    }
+                });
+            }
+        }
+        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 === 2 /* DESTROYED */) {
+                this.tasks.delete(fiber);
+                return;
+            }
+            if (fiber.counter === 0) {
+                if (!hasError) {
+                    fiber.complete();
+                }
+                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);
+
+    let hasBeenLogged = false;
+    const DEV_MSG = () => {
+        const hash = window.owl ? window.owl.__info__.hash : "master";
+        return `Owl is running in 'dev' mode.
+
+This is not suitable for production use.
+See https://github.com/odoo/owl/blob/${hash}/doc/reference/app.md#configuration for more information.`;
+    };
+    window.__OWL_DEVTOOLS__ || (window.__OWL_DEVTOOLS__ = {
+        apps: new Set(),
+        Fiber: Fiber,
+        RootFiber: RootFiber,
+    });
+    class App extends TemplateSet {
+        constructor(Root, config = {}) {
+            super(config);
+            this.scheduler = new Scheduler();
+            this.root = null;
+            this.name = config.name || "";
+            this.Root = Root;
+            window.__OWL_DEVTOOLS__.apps.add(this);
+            if (config.test) {
+                this.dev = true;
+            }
+            this.warnIfNoStaticProps = config.warnIfNoStaticProps || false;
+            if (this.dev && !config.test && !hasBeenLogged) {
+                console.info(DEV_MSG());
+                hasBeenLogged = true;
+            }
+            const env = config.env || {};
+            const descrs = Object.getOwnPropertyDescriptors(env);
+            this.env = Object.freeze(Object.create(Object.getPrototypeOf(env), descrs));
+            this.props = config.props || {};
+        }
+        mount(target, options) {
+            App.validateTarget(target);
+            if (this.dev) {
+                validateProps(this.Root, this.props, { __owl__: { app: this } });
+            }
+            const node = this.makeNode(this.Root, this.props);
+            const prom = this.mountNode(node, target, options);
+            this.root = node;
+            return prom;
+        }
+        makeNode(Component, props) {
+            return new ComponentNode(Component, props, this, null, null);
+        }
+        mountNode(node, target, options) {
+            const promise = new Promise((resolve, reject) => {
+                let isResolved = false;
+                // manually set a onMounted callback.
+                // that way, we are independant from the current node.
+                node.mounted.push(() => {
+                    resolve(node.component);
+                    isResolved = true;
+                });
+                // 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) => {
+                    if (!isResolved) {
+                        reject(e);
+                    }
+                    throw e;
+                });
+            });
+            node.mountComponent(target, options);
+            return promise;
+        }
+        destroy() {
+            if (this.root) {
+                this.scheduler.flush();
+                this.root.destroy();
+            }
+            window.__OWL_DEVTOOLS__.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.version = version;
+    async function mount(C, target, config = {}) {
+        return new App(C, config).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 /* MOUNTED */ : true) {
+                handler.call(node ? node.component : null, ev);
+            }
+        }
+        return stopped;
+    };
+
+    function status(component) {
+        switch (component.__owl__.status) {
+            case 0 /* NEW */:
+                return "new";
+            case 1 /* MOUNTED */:
+                return "mounted";
+            case 2 /* DESTROYED */:
+                return "destroyed";
+        }
+    }
+
+    // -----------------------------------------------------------------------------
+    // useRef
+    // -----------------------------------------------------------------------------
+    /**
+     * The purpose of this hook is to allow components to get a reference to a sub
+     * html node or component.
+     */
+    function useRef(name) {
+        const node = getCurrent();
+        const refs = node.refs;
+        return {
+            get el() {
+                const el = refs[name];
+                return (el === null || el === void 0 ? void 0 : el.ownerDocument.contains(el)) ? el : null;
+            },
+        };
+    }
+    // -----------------------------------------------------------------------------
+    // useEnv and useSubEnv
+    // -----------------------------------------------------------------------------
+    /**
+     * This hook is useful as a building block for some customized hooks, that may
+     * need a reference to the env of the component calling them.
+     */
+    function useEnv() {
+        return getCurrent().component.env;
+    }
+    function extendEnv(currentEnv, extension) {
+        const env = Object.create(currentEnv);
+        const descrs = Object.getOwnPropertyDescriptors(extension);
+        return Object.freeze(Object.defineProperties(env, descrs));
+    }
+    /**
+     * This hook is a simple way to let components use a sub environment.  Note that
+     * like for all hooks, it is important that this is only called in the
+     * constructor method.
+     */
+    function useSubEnv(envExtension) {
+        const node = getCurrent();
+        node.component.env = extendEnv(node.component.env, envExtension);
+        useChildSubEnv(envExtension);
+    }
+    function useChildSubEnv(envExtension) {
+        const node = getCurrent();
+        node.childEnv = extendEnv(node.childEnv, envExtension);
+    }
+    /**
+     * 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.
+     *
+     * @param {Effect} effect the effect to run on component mount and/or patch
+     * @param {()=>any[]} [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(effect, computeDependencies = () => [NaN]) {
+        let cleanup;
+        let dependencies;
+        onMounted(() => {
+            dependencies = computeDependencies();
+            cleanup = effect(...dependencies);
+        });
+        onPatched(() => {
+            const newDeps = computeDependencies();
+            const shouldReapply = newDeps.some((val, i) => val !== dependencies[i]);
+            if (shouldReapply) {
+                dependencies = newDeps;
+                if (cleanup) {
+                    cleanup();
+                }
+                cleanup = effect(...dependencies);
+            }
+        });
+        onWillUnmount(() => cleanup && cleanup());
+    }
+    // -----------------------------------------------------------------------------
+    // useExternalListener
+    // -----------------------------------------------------------------------------
+    /**
+     * When a component needs to listen to DOM Events on element(s) that are not
+     * part of his hierarchy, we can use the `useExternalListener` 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,
+     *  `useExternalListener(window, 'click', this._doSomething);`
+     * */
+    function useExternalListener(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));
+    }
+
+    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,
+    };
+
+    TemplateSet.prototype._compileTemplate = function _compileTemplate(name, template) {
+        return compile(template, {
+            name,
+            dev: this.dev,
+            translateFn: this.translateFn,
+            translatableAttributes: this.translatableAttributes,
+        });
+    };
+
+    exports.App = App;
+    exports.Component = Component;
+    exports.EventBus = EventBus;
+    exports.OwlError = OwlError;
+    exports.__info__ = __info__;
+    exports.blockDom = blockDom;
+    exports.loadFile = loadFile;
+    exports.markRaw = markRaw;
+    exports.markup = markup;
+    exports.mount = mount;
+    exports.onError = onError;
+    exports.onMounted = onMounted;
+    exports.onPatched = onPatched;
+    exports.onRendered = onRendered;
+    exports.onWillDestroy = onWillDestroy;
+    exports.onWillPatch = onWillPatch;
+    exports.onWillRender = onWillRender;
+    exports.onWillStart = onWillStart;
+    exports.onWillUnmount = onWillUnmount;
+    exports.onWillUpdateProps = onWillUpdateProps;
+    exports.reactive = reactive;
+    exports.status = status;
+    exports.toRaw = toRaw;
+    exports.useChildSubEnv = useChildSubEnv;
+    exports.useComponent = useComponent;
+    exports.useEffect = useEffect;
+    exports.useEnv = useEnv;
+    exports.useExternalListener = useExternalListener;
+    exports.useRef = useRef;
+    exports.useState = useState;
+    exports.useSubEnv = useSubEnv;
+    exports.validate = validate;
+    exports.whenReady = whenReady;
+    exports.xml = xml;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+
+    __info__.date = '2023-03-13T09:55:06.791Z';
+    __info__.hash = '8893e02';
+    __info__.url = 'https://github.com/odoo/owl';
+
+
+})(this.owl = this.owl || {});

From d74331a65754f04dbd6e915abf4e5e6ca7b43118 Mon Sep 17 00:00:00 2001
From: "Manushi Shah (mash)" <mash@odoo.com>
Date: Tue, 14 Mar 2023 19:04:41 +0530
Subject: [PATCH 4/6] Game: Rock Paper Scissors

---
 Workshop Day 2/paper.jpg              | Bin 0 -> 2626 bytes
 Workshop Day 2/rock.jpg               | Bin 0 -> 15004 bytes
 Workshop Day 2/rockPaperScissors.html |   7 +
 Workshop Day 2/rockPaperScissors.js   | 217 ++++++++++++++++++++++++++
 Workshop Day 2/scissors.png           | Bin 0 -> 33512 bytes
 5 files changed, 224 insertions(+)
 create mode 100644 Workshop Day 2/paper.jpg
 create mode 100644 Workshop Day 2/rock.jpg
 create mode 100644 Workshop Day 2/rockPaperScissors.html
 create mode 100644 Workshop Day 2/rockPaperScissors.js
 create mode 100644 Workshop Day 2/scissors.png

diff --git a/Workshop Day 2/paper.jpg b/Workshop Day 2/paper.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..e397a99daf6af29f0f2a5021697181387b09843a
GIT binary patch
literal 2626
zcmV-I3cdAGNk&FG3IG6CMM6+kP&gni3IG65fdHKWDp&$o0zOeFkVd1Tp`ju&7!Ys@
z32AQOXcvnZ)~PZK`D=O}+t;}R%s>5bEYen&oj03+2A`O__PvT?@C9d_=@VN;<^Ai`
zBvrK;dCz7LokCWM>nh#$uI5LXdS2JGUE47owh_wU-dmB~`uA{Z@{cr}5%B5N78BqQ
zekJMj;gCloyY@!1V-&uy<+^~WqU?Il&qPaa+9>~O4XpVc-TF9sXG-<w>%H#3q;mcX
zUiYjOTfMC#GWgB@Mhhu^xt}Av>BfUo=3phHy2F)ESY%#DD_v73c2Hv(?>%!nplyj!
z>%E{e_3-GQUTOToj+q|l4O~8V+{y9H;lmk=000fR?h+oDLFrr>oTu=r{<oyvqSIh(
z<Z7SQ=F}FzM?#o(aRb3y#rkwy_D{>6$@ydnBW2#hF#~xnleX}*Nkz-Y@2yrQ$k;e8
zzs5U2c>#NvVd<W*WU%+a!kUm5MILS6gOGos^v_r_a`IyyU<SRRgx_Q~gqj3qUeneL
zoV||^KnSeTXcKK|@`^V~rrmtiZ#9D_FKO!rCJzB1l#j8tVv64NVX8QqZjqULPgpW?
z_CXif{2d`!vzCV*Sy@Tz22Nhn)Dude%+{K6rlhH+g(Bq4`Fl@TGIH`^?ib`EQr6n<
zL6C$_{)^K+V9CqLjZU(()9+r<pKtB^0493Dlb5vc1Yt=`|AJ%xnc)-~Ua(~4?LA<T
zTDaSsCO`XA7LF2yL+CWUV9Cqcdch*Ln<j^+r3PXD+L#(PY@EHPtQj~=O;nj}fBs{C
zrF75wXa?hE$;;Y$!IOojtwE2sid+7LdQn`~44l2EtQel=;+Xq*&jyWePi+7udcl*I
zwD1J7DW+l_iZi5)HeGXAGII8wuwr|g>j<bb5aL&ke0*ne@p@;h87w{j|MnZ>PV`bk
z#`#wbivEk!Jz&Yp$&Fh>gOx2j<`o>MURm6{UYY9#OAogH04hfW6%^ApW~a>ug-W<%
z%)DNi>I$lfIHNLxxt|qTyyg3?YN7LH$;;Y$!IOojlmjo?^AJF%eS28+FW*prIC+<g
z(>-93VpRs#e2&c}WFX$mypd;_p!VOM#|@;T;HSDmIQJ=2K=Q~Td9S<#9dY1_Q`FE(
zk~^l02T9QVoN`i;-TPjDO{5bk@ex40wY$_K2dwH8*R)<?QTf|I)46HKUDke3gJ8lX
z-?i-*m{fWwK;rq@2-@Aay`h!{zL`kw++NXng-FiHGR9S4_SH$a@HE7`(Y>OLtdY$5
z9e`(Uj^q69AE3&kGVbv6hv+u5<ad6~-3!dhR2RkdbOgU>kg?gLFsU5Rd?w<~sz)>A
zQF&y;IJjRC3Iu1MG%)Kqw7LjI)|1u9E#djL0002~_N=?)MH21%SEUe4CleTIriH2{
zf&*M)9E^t=B=sOex3m9u^?!FjBmwmS!8Sdg+CG}^R;P|Hq}mVmpQKTZr!1D#QWh~8
zsBjR@{og*C=DLq$0UCc{I_-APDTy6#ykv+=bhaVloJ20O##rM#RaREHU0{d~L41&z
zfqGwb(FO=e!dT;|$oG#Oko%N1v8lz6ia!sJvqgwuvdDdo+!*%^UGQh&FqQthJ0F!@
zNIEjLRk%MeNuwQCEHi}fbQ-|&B=Ffu-C<cuRVQj)S0@E|j&3;nDsZT=adF?yIT{KF
zPVuox-csr`?)9?WiZX32<KZg?pj4_YUHid6!6?;X#=-3HLETQ~pJ0|VAxRo@22`~6
zwbgM$(}RWTab5+UvWq}I&ZET{SFZ7po?C=GPC_pMU<mDI^|Z2D;|gFF!=&ivG8{Ni
zlb#K`R=>y$ft;kqf?Y!>m{!5=4?4hS%DYqudr8^xX<{Rz`(ud?@Sfi|o)9tsfd*@#
zQc{#DUAw26`GvF6N2%S;RoAWw8+_9D5-S@Z8g7-U91CNz#m+Ryw)5GaE=)|b$V8SQ
z8Dz32DqAf90nS-fvAX^k54hLv>}9Rjaax`se^<MJWCGNEP?&{&+!{KIwNca8<R3h9
zJtYmc_z_@hgblcbq!TRqTwSX}O7_-$F9f^qUeYtpXxI)kkH}(&)=6EnL82B4QLHL@
z^pr(Jz9rDWv{eG6hI%y0U1FwIb+RYvN?2OHGQQoigY>|Y<}kokrv-V?Gy7(c5c~vg
zyT26xFRWrd7MLx-y*TJ>BDE^8^vsHbp^a=|$$qM_zH?J@pb4s^7jXqwT|rMYbBYiN
zLOe>#hSA;cx5-$;;uyJ{nv`}svxE80f95Y<6xQyDA1_^DaCc~YEiJTkb6z^5U5wgQ
zbRPCe?=n&RIkVjg(=4@At(YC*ygAe}eZ0Jj12D5A$#-j*j-?gM?OB8##3t&%HwIlG
zX3|N&YMK*}<DU^x$5G5Zw1~J5#|oGuhf&PVC%sjjXBY!vzqek|QVw`qn_K}WAg;-{
zC)(@^58z8){BF;T7IhXQe&EU<B6>o#LYjD#Ji1UZC(`NIoC3;ug2(1xEZ*Y*$3Qn<
zBH)i`mMxJyzz9Wg2UIS$Pdo%zZar{qOQbSJ2_LMxY<n--#$QoSV`&R5fFyDtTEU(3
zJY%XX4gcQ#NZ^x<z*a`!0*Mni&@(0ULEIe@0V~KI8&UvToT)zY+C@V)5x5dUMXb{(
zJg(cC1-<daE0Gj$a``)el<VG(Jy#Qk<xXwFGMVG{j0%8QH*Mh&wCM$<8Jbrh4t;ug
z^qaG2O#II56-vp{rJ>L)YW;V-;Or0*J_uMyP)u+^X(3jxSyTaa*|_r(`1D6+M4i}+
zZ<R7p;Ek0se~o$X*JB=*ekWuEka8Goypah8(m2BZQJ>(Y1W6?%Y;l~2)(-^TRCRBu
zfLXhYfb9`ZZ!mV>Ewuy_cmb;Yn~oLXJzOxLXFIr%Qt#(WWl8(xBUX$C2L!iI^1g}t
zp@V|z1Ka|-v_n^Vu<aYgu7~_XwV=+ZcT8Bo?7DGRukeTqcPw>KZ&J7TYR4GvG@_nB
zM<<EsABO{#O1t6x;CD<~n*9BwxH=5E#7{9>s3_qh7(XqKIFNYg5oP?*Fys%_1{i=(
z!!~A@XkK;Y5N&h1;e;m(-`S_vr?UPczpqbn46$<iq?5?>Cc@K47ZT!M*TnWu<;UJg
z(=%BPr+Y0+z|8qof*9z#f*{p$n7?P{7?}meR`6RtF&Kcwz{CkZam;dZ!U0sR6_ram
z9SB8qhI<$c%qFu7t^K{>cdw2r&g(HSR(c~)oBd5!k*g^Fc)Kv<V$(H|HY?{gffpTp
zyq9$C;a&d$bgm5kw-E=M`)%gqrW{oDCd%Fv{u`F{h2b~b7WY`d9Kgq2n!|Tylf~w#
zchXmF$3iQvDkSm@$#-o{!|8^p!lj!Ie$2Wh<05FHz|My=R55F%du8!E2v=i-*$~eB
k>jx)Hc25aH>@3V;LS~<{<8r@5*NI|!_ky(iyExPU07rNm<NyEw

literal 0
HcmV?d00001

diff --git a/Workshop Day 2/rock.jpg b/Workshop Day 2/rock.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..24c5c7a032c0f85ffd47cdf223ad5c4e57a07056
GIT binary patch
literal 15004
zcmeHtcT`l%((fK}&H@sLjO3hi&Ph;`$iNIR#DN(y=pZ=?2q++eWE7ArQ9(g+6p02v
za*!Y>Aj%s!=bo$gc>j3ot@Xb5);hglR`0I*Rdv;_uHCzOpH7|50Tg;#x>^7T(*!^Q
z0B|}FbZZ8{od7^rmk%HS000D#fv|ugOpgKcf7Wzh5CquE3GCnwadZQFLQuXw5O=Vn
z7v{$U?g=})@bPkVLxP>$At<mP%n{|~1BSc1`yx?35ER_Y6AVXsVMs727}NK6fumqx
z2aG6ZA1_}|s1R7o7j`ZQ?&%DMctXJlFMpU1*awF6^7V0qA<tBwD}{mKju-(>XVN{P
zXVT#q)le7`?(8XaI*;4!f<htWgoQnkLJ+8z15C)#%R@K-f)ExJ5)lRzlmieLr7#rO
z0p<+%RAk?7dCm@oLlxPtN*an7BGh3naGf9@*ySK2bH^YzM_DMlvJ#O(fLwqF!UKka
zfCD_-J&|$&itOjY<uLuTVPSS9B0>cpsFR$ThSr}vm@7s0KPThw?=R#pF68CoEG#N3
zD=RD_CM+f<h~W@K2700(0fL@Ljx!N|$k2cx9ev=4bElojggAKlq7>QL{}haH@j`ha
zUAz!~iT}mczsTnn{|lsxKsicaj8OOTf&GQU=x{ur6cPm${+Z((dTy#PI~e?@UTqi(
z6{zb0afTtab+yd@l7f*c<a|bhpVQ7A?hJQA{h}Z0_!mFI*T?-_E7VaK<_`0Kd7_XQ
zUQvvyKfH^;1kGRE7~6c2u(P3aj62jx7^Cn{*?$7g?9dFrxad!J|JE)HgRq#0h>W0!
zn4p;KU&=7T%;3&0s9!YxJ#u``c`&HI+$*Q<1B1dbO3(cQ{=+fC@XIL7DmZ6i2mgo1
z<W!MJ7)n<|kzG_&5)%h9vZAtQHvc&RxvMaT%P7nWIrGRLwjeQqd=@)!<X=+H-Rll>
zhPVs6!yRFsNSGkR*#~wGQual8T=&4t%GW~?6KfDpxFa{j10jDl{Kq;{boTOcc8C2n
z>WCpjFe^v#%w?GS!VbnnJJeCm(FX>>EMTScn7$12{-fg#S3*J@VD3maNFYQ(_$)Rt
zLw|J6nS_6aV)~e6`L9U+LxQS1>R+PH?wy=F#M4=kJwOl&bAtG~qu7=HzeqFxVfwjI
zXQuybE|J1n%*q*@-=p7n5`5-81jGjkGY>?-6nV`4%yc|TzXC1H43y5o`oD$3d8qvr
z3eFz?4lTj|^KeiQ{>6y1x%`Lif86$8xX$y~d2sxc$j<WP`4}caVnR&#uZ)Vh_$w#F
zJTZyb|19I4ZUK8H|H^Y<aUl^vMorfc2j~1zG{J;r0ucQ>5}B|9fTI5|0*4996QKWZ
z`QmgIPzQ+c@d@zphzJM>h>3`Z$>=G_NJ+_<FVIrbbFgx8va_<Yaq~+Hb6=9U#Ktb7
zDk>o>ucV~JC8VLNuAn2Ws3d<T1VltkOh!t^L_xtM&&$p$|G(W%UjUQ@SWqk|Hi#0y
zq6A@6f=)XDM$E1N3mXJFzXyN(VB>(WaPjalMB1~>#7`7V7ld^>1CU^2Kor;%n9DEr
zztaD?`o{zRBOZ{2n=^AY{&&^bgC$wDFvbTBa_j$<iC!T;uwQ@|2;$w3PX<x;7(v!2
zRDR3t8Zi5S@)92!Sl6z!GSc%VyXJb;sAH?R=6Bp!9G!3XRH1!nfVp&CI98tq*PP{t
zT`KxFycdQ^k;8bpiQ@n;Cc)0bSwRJa;@RE$9c%FeT8u;;y(WO6%bp~|RU(E}BSUk!
z#6#upa#`&6V#@OX=)HFc*A)FcAh|0me4>BF{l&L{Ro>sQqjuNsIO0W30Alv-X#k!J
z8U=fDnP-H%;qSco1UqY32Lcna{1EQ)yv|1$?c(+|4NH$<<_BiSzJCWWQLnrrF7s)k
zT6ee9#gK7fct!~mU2c5b-6KWKdH)H(ixyP6Q6F~a(fz#(jC2%EgRz9FgLfTlfF{An
z3u8Iqg~4m(=wCtDW~s=>_wRp<7jOk?vM<mW*ysu*Pm7R+yn!)tJ?4_5w!%e~*t0ZW
z*ZL1_3nf%Tf%KBHd!2cJV38(OD(3`%Yvo`fB^T@MLqL^|)(IuDas5?UNPE(XJ<-^U
zJOHOti%=*2t~{CmR-WG>Mi_quF4V<{w;XNx^|IA3Agt=WaMV*L)mVg<R--hhVaF{h
zuJKF(t7KBW%W7jrHZ>YC#ZA|!_VirLuKP>A`2~wT%mTcvO0^U{yKh!@uFxrTwLSe^
z+N*bY^!f>J)x72r=2oTD4Q-ut{{=_R6xcZxGt*0=hZ(Nr=EBM!M)HdC4rb9NUg0gT
zx+~;a*kuuM%O-xm7W^|1yY~SMFVdm~d4~!OU`vtc;ldJ{keOPzmWKMA#DjOuwuVSD
zap92bH-a$FgMT;BvN1Q>)QV~Z=oM54IhX*EZg&dj#w-0kxd<$Zt=bQ!bI}RVERA}y
zno9p01pty#3P&GJh}_BofnL|%vA9(XlrsHFhZyLhPY*F(JPCo`x<FxrX%_a(gYut%
zIQT<%rl_7o7?My3MJ`fO3amK|_Kl%Mv@k9fNX<_c6R5J(tGE)ANGs0uIO~pzQK-)S
zpW#q+!pHlU6HEk(d`AF-3;@raKF!6$sl7ALsW%?Zu!jk526_owdi)AS#7{T?mveFY
zhF#X@+xO6*)U6={{ctcqG9|(V=)=Yzwe~)CITHlhy4w6Rh{$<xtSg(P(r)iay_W*8
zYPv_yKWM3f@h`*#n3{?yZ%8JYzE#&Ev}S*7{pn|<Ysl16My2bZ|LavEHigV31Fmm!
zE3S5WN2w^x!gJyR033cXP&Qvb)jLJeHT|EVz+$elYFlQ8<Z&!7u47h?Z!*IJTXY!a
zRgfL;i$B-u6E0Z|*sV2R1kx<!VNuSdCq{k)tV+fzL6Sd9>FAc>5fwvC&SK-Kuq&(w
zSxf<-a5ZX&cD&*u^F3PE;7gvBM8*0lSeY(UKjSbH;~A!Yle2W;@(O-|qEDEnv|uSV
z`u>}(5-XJ*c;AJ$w_WqpJUxHKV6Mt7#YmXMG&V~=!xuLjgL@wXEY}pKKTYO?!Y`{`
z2D7lqu8iIV{|yEJKEt`TJ!B`(dQ}**&&c*M_kP0#x;WoMB|gr4@Eh7cL;rZ-|1l4+
zVz%W%6aW?o8yg!33xtE&iDMcF3md?p#HFC32Ai;nh>Fp$OI+aKR1vq&Q^jo82{4;@
z5H8j!FoE-RSLGCV<M?E~dYn%5t?+mDZ>IC=D8IxC;f$NdieHNQqRY1G#=WmAK4I75
zdc$GOP@WHk`F_@jq?-xLhHlrlxdkO@r1OQU@n&7q^3T_2@XAs8x;wiv&{7T$4w>Yc
z87t~~^)T>oH+*BZ<P^Z~9~4t%e)sX6(tPcvx@c4&6kb>)Fa2sl`NiI(^d%4Gu7SH^
zeo>#i61$6s+j4i7AIPH`#^qig8A5Ng9d+RiokWT|*BeR?4VH4XJ&|tAP_roiq&dK1
zY{feDBx?a4eF0ywNooDbg{<;VhIMmMEc#bj=W89(58FigPE786C%6l57^|#N$auoe
zl_@(zHyy<g#vUI2DJ&Ha*Kk*_i(z8Uw&UY;y2f#OE3r4?tJo$P(E~NpSgGp`^SYHO
z59y29CA4~1zIjm{dq_{ZF+O>fyV8}4tGG#MT=x2d(E;Z@vZdJ?x{munTg(ns>1h|n
zt=9#8agBM{6$uacI!(Z1!rbq@DvvEDC3oq9;%4=Z%Lfe+!`H0WN3&`6E|Mc3AhvcH
zq=E~-dFG89(KyTZ@4sU%2!>BAu#$%gUpZt-{E+g6M$(Z{sn18A^KeSL`SBGU^E;Bl
zuRVD#l)Ss4@Sb78D6x&-Tk&2cR<lzh!`dWe)5S{G+R!p=?5UR=P+1~b3bgwvpa*A+
z!w)jYcF24Em<wLM?KtmS7GPzf=5piNPSUNgn)@s-Kn2Vih}A}Uy^SO{)0#UiGS(@v
z*ZAg)o#%a@&)5UgKT4-rzI{)rk=F~?nZi@I;x0TY+P9pQFuGJYW1Oh8vFq6?RHGc4
zy-r3T%d(#fo(oT@mMK)2Eq1w)V9p?#b+hU~!X^>9(wZw-c+I!sgu6!BsMDS0eaaW;
zVd+;6He*8G<K#oL#V_K}haJ<;-oOzao)^NOg!K%%VV`)+ZcTsIxi|favF%4a>#NPC
zBKHo{<7flVt!620r+D991)Lse#Aov2A6J?6q%uaIs}H(my$;IhUuddgUy3A7ljySb
zvu9X~Tg&QT)IQie1(q~xi+S&xCN(mLb@1%Jzi3UEpY9ajj<B;)fP?Sq)TI`U+&6Ea
zGa30tixp2jOaCPxT*dL3aJ}q{l{?#=4D)NRD|1kTs6m(1=Mh=!yu_}~X;*i8RTk}R
zx&@!RTvTSvH4aj4v%T4w>*cH$9r^TDbECc`gL4*Q(KPMK9cdXQ*A2}pWsp?7cX)V5
z%kNiZxTZ!A3cvY<Ts4_AYl@4M8+#OCj5Tn<m-wZ>%)Y?X6Wg`g{Z9?4oSB|=da2T}
z$<RmQ_v#);m)6~*s&@n8=}!R-@=t#9&MpEgjgLb~H8pWegl~=K!`%-By{+4)YxtC|
zDK0;an|B!Va46DLtp)l}rrO$BN$EbkYm;h;MePNQm2<QraI;?Hf=-Prix-!>IGr+P
z{EJ=-W!=?EEgpRbFZWE%yy)lt=2;3-(q>I+WU`BCLHE;z{n^K{*&T*OGlOQUK16PA
zF=Zahu63`MrJ2W`>+#kHT_I^(q8V*Kk0UhcAV8#sbz@81lyRxCIM?PQk4m#;zN6y$
zuyuYH$d;QWiweNPZZb%%%l9l>a-hI1cVQykPyN%^WUXD>E^$BGbqDe94z4wAC)LkN
zyyWaWinXN|KaIVL5PN!iReiX6Kig00*xhe$E3|aC{C?rGRFuU7!EMy?Vv0hl)eNy^
zi%j@6`WCMWuGp>AtGWHI;`HvOHBw_Gu-sbgw;XKjNy0*_H5_nh%IfMS8bN14i2cO&
zDNrqp$-2y#stG3F{`5QmQQ8A4h$;~i^m&rSR8f>cqf?M#2FzbDos*35!-((m>G}jM
zqeag#0%$1zqm}}+pX0F3aI(f24rz+BOpZf<jsIs}KQGQuvQbchMcGBfR834F-qb2#
z9O7zb4n7ZYXi}=}Z{?-_nc?x2F&Vy`INke$VE?<O;HQ_WCIe0ZLXo^2!B0!KK9j^;
zy`FyxY@aZ_K*QUnK4~lF#CajSd^cz8!a^#&K=={^EYf07tetr?)~{vFsLcM<)|a9X
zm)D5JIuyR9n3G52Dd2aL$)#;sg}<Uu$@aiA`ZKQggWV4ah;QEU+hRm@F1^jKx)|ex
z12bjj{T9CFuF5_hR*V+rC*C63*VeT~v;;fHy-++!t5SEA$hT#QJ5iSy6DN>gV6-)j
zUhh!m;iT|?;g|MGJN6W)zf(1Roh_)tdF%a+_dKW^b{D}G2#cED6=Lixs2cf)R&T<_
zuy;lWAA2~c*q$7?kB@ez*J`<1^0+j#kj>1e+aNdV*iHd{&uv)Xva2)cdlyEhTC4et
z`HCGD*LM%7=WScp3@>ZfjB$SD=SuB0_?XKdT;^K(xRe~8LZHFY%Fc1z<7RB5^5)8n
zSufKL44PB5d8nY1%kP^RNC;W3DJG1IBzgY&DPGg(Y*=MQO_wIebG)Farwh^f0TNQ5
zu!oori(rCe@?-^#5*#BlA+1qF_E`^D3A>G04>}+$CH+iTZ|gnc6obLbnc;V_(l#88
z-=G&V_mty_*4!&HsE_>_8Y;Hh?OtV4(L7?J++FdXZ_B#FVC&qZJFa-eO+mt(uihg6
zp4^e8`@LEP>h`IM!6GRRAH<w=W&GPE_Xi{M<9rfT-?@T$AAazqO{3GlSD7Dlzh0Y6
z@3K|-RtR=&og6|}amF?yK~(5bGybD{rrfXIH$!0^A?n$O7h|?n2jw^huR)_+UdmQY
z2k*aHJJM^p5Ltq=gPJsSF6(>s(i56DnmngDBnC2YmxkKAuQKO*v`{{L`KayK`DWQw
zyRp|3y`n|k`D1tREsFK~DCZhfOxrIVQAb?~mVqV(r+s{OQ{Vidi1brz1iY^h`IH}Y
zvG~JGI^tSf`%;SkTl1`u(Xp{HZlaMyqlac3M7<?%f}ix2)13lD<%s<T6@#)aCHj*J
zf+YBcMFGzjYj?p<0;3V1R~xwAR`6CZCyV5SZ0B6CZy9^6Tj)=#W1cQePWs#|lZB(H
z$@HRA;p**YuLrNi2#eX6%>{Esukj)B@lg_H@q{lQ74qb2bZbU)OAIx>{k#+V#I+Bl
z+CIRnX-!m4dvhsR2GUlg6I($WHYF&2ZICFb@x7|uv$Z6coo8@2KPs>G&~Av{%T|fw
zp+u9;<%mX+-cFN>5`41K!&-s2AKkClO@H%;`UTlHu8i}SqlT!a3|qCJPy9Mn-S3Og
zm+0Q^*{hSmy4d=;gGaGKQLi9u{_Ba<`xODsTgzY6xK?BmDn#-aw*9#zCZD>nQMT;R
zkMPT7JWljXd0Uj7<V>a-+;9re+kP*m&gC4%^KaT)*hV5HI_8!qe<&oxNz*eb+1ggW
zuwTAUKRcL1GTG$QGWRU>ZY)J?zwkF|O#Ts|z|?gC92`6>OiB1W(SZO;3N}$yFedSc
zn1rP~tnS!RnYYgy-Tl|LQW>+#+==ra#NJp_MrG+p`YOLLmUSU7thb(7UXW~tro9PK
z%$@7ktgQoW&#+Ky^`<q#PXS9XW%Y-sR--Z~+h9+GKbxvMKlRYtY>~=Qi=6J88|c2n
z_kv%qC9B$idV9FTw#CeYKLm#8HoqrY^7tHjGKbdc9x^6ta`GZJu6}7rb2ZGX$=aVA
z1%-_c$@)&(;Y$-cJ<Z<w9QkJ0&q|4?6W+*7js|Rekr@Mi^WL^q=DU*1Uk064HyG61
z;hiPi1ZywKcKB@>g#<}7wfZTmTV`+-;!lCQgP~BRR**~ByU20%z&wfhvdDmqw>46|
zt>(cS^vwfQs1&ki@Tm_;z$1|gmJ!Xwor6}!PQiTh;HqPtXdT$5fU$U$!tG_y2IFE!
zO|RJ+?iF#jcX%hk*&f9Vh;8)Xb33O+RP*SCM%(KiBCFU@aRb%8yOvQqfJb!Ci*=$`
zOg^K1AurPGTnipVHuuX3l16jTu$AFxeQp)+oSGX+qc#U0G)R=C>65%&B33-)eR|d4
zhL(Wd6ze^Vd-tk5K!aJ+A+;}GPaxBo67{tzE8V{&`^*nnBRIwFg$lzq0^rX|E-(0(
z+%UbzN5AE4!Pa09?r|s)yyIRo@X2Q{YZOUDSbtl?XEu5RdC;UbDivGZZP?^|yDwd^
ztdsBUA=URKY@1e~y7k5<;vD&l&7YEt(`1IU3&o<n+o=tjy>G3mV%1RU-63hiB9$_j
zjaUkFuwKrB-1x3j;PJ5hd;ZFF%$JVr>`=v!+(%gc@gB8xUL^f<>Sf-cVo5I%H<IP6
z6jUy;nPjHSyy&n}tr;SwVu#MJie*UDDh0?{!j8G2)R{RJFRv*=dMG9;o_8!xg9e7x
z73Amwi?g3!c+Hz#jD`g5w>D}HBp_9$#8jRZbMr`S=-+}(hL<W7#D{Vl0C|TYS-rC3
z+c(EYNyw|SGD>!EWmDwtTSv8igkGR4HXY|@QO8!jblnnbB3~9J5=bzp6n~#mU?Ajf
zn>r=JErymwre{Ca8|x*-_&7gbf584nWT?}#pqEJf>%6=o53y*GT}!g`s5$@X#kPF<
zrh8DM+XOZm8Z8RcDKCvU$`ZPraUF-u)@R&2ZL110m`ihVx@KQ$brcMv9u?FN><Lzn
z23+gCAq-Tm5b)hvY8$e&@!1g<kZjqp=(n=`M9;@9gjBGA9dygM8ggXc-mc>B@hq6@
zE@g&QbmnSfw^NNYxcH~>Q(T0T8W?js(Zw0^Y9%|=jL-W<T-Iclb7oex486~xpV=yD
zzxu!|I?&O%nWw(fP%joj>WB>M8uw3l_f{c7ZrfjUl~E`|Sn>uTbbp@q!N@akp2AA#
zk{tYH_Dy5ldrnEp1;o<2X-gp_eN%k7_4?hGIrkW(h?O4bKFO=vP_neD<@BohiYDM_
zqEEYQF4>h%aY>7p_NDO!=u5GZz=HW}cpk?Lfh;{oNT#ClXO|{p3Qhr<##yof6^;Ty
z#j<1Z=L;Xg6<incY{a;S8TpKKw!|nu#GBZNORx=NZ<~rI3N%D1lCo&fgIu@hEMYfv
zN?{@O_RDlW+eg&jx*prTVDpzd1q{@XRb|t?uSbZ}F0E&N)5EW*VKZONE+79vRM}11
z=VG55;PX{a{zu0)AKmI?&+FYhcc~o0*NQ8;;f9y`I2XzecFa}l*MnXO4zH2jZNI`E
zLzA@ApYEQ>de7@#4g6i&wttoL^81jwOBP|1+-SX_lnEtKEa&#)+M{&t7799W(^tZ*
z-K~!|1gccNP)y>l)!DT%bwH&xsL-}sc4J97Q(w?TG>lXm^#=D6T*(5Sh4o%u^h<no
z5CRwO{(5<;r}`k5Jc&R4wljT{DX(EiZRHd}n1k0`NGA358?la=Zbn2@OsS##sbAgJ
zF9xfP{+MIyOQF~24cerj374#%xNPyj;QL|F5$A*nnvvzQORp@+Ajz7CPZ+w-?D>7e
z=q<CoQliOggYEnB?Sh(VFV^ow5VF@%f4LWwJ~JvqgPVz8;{?h0;#0Fa2d>V;IqdQ3
zpJ@B;jAdoeR``xR#`L|RsKR{Vvt)tIWnDL<!Rr#9yVz-FKkfrveBw{9zLYEeWY9mn
zVn=KEf$>|B4mRpY-B_wc?@_khXS4BcD{<ymClb<{hiEiM=}_YV-^u$Dqll%;;bLw#
zG7(kPgDD5gVYA;mPXWxM=llQ?INOW=Qgi-kZ~jmB9}oOr^*}}Ye^*DUlJH-NIPCxj
z=7T)+ZyAU%hdgLr0+rtpao9}&K(w9Ww<|ym00Y4Hhbno$LE>T#C;*&UM40+-h@g1@
zq|w%Jf{i(i_*(-#-vLZ*ymoMW+W$raI8xL>-kAMo2$1(1Dj)+WeDV4UWP%9(1_hx>
zRc>dJ$pEP;7?XZ!ID6~>E1J@{m4}WC{U1osyEJ<M8w(6Dff#hrxWC{40E`C!DmZBX
z1*i^ro+*B!>)4YYad=EI0rc|2VZoS#lb;(Fn9-x*Lv<_AZGBkqbl_(a0LU*o&3ZI5
z`rJCqM-T@<ekDrJkv7b>OU<=4W>8qFsQgOwxSj3l;qMV<^EEd2Ia&k#3w0LM(BIWC
zYcF+3?}r}wrA&ZT{fxuip~Yhv7_Fmw5JLc{{DdR`lF0yUzeD*wV)v48uZQ4Y#1aRf
z0Wj&aS?HAy39ojTe?7b<bpit>1Rf1Li49*9=LAB2l8UJ(-v{wT_RM<hW_vwl{P@d!
z0P5pTfEb{X`T!ySu%Nt(=KC4R8H)x32+W72U@UAH762swOauTdSI}Ev3XoC3B>{e!
z>N#67AukaDFaU5;fLedW{c%Mo0Dyltem<uCyThIT%KZ=F9}oP`c;M^+hZR!^JbT6d
z_t#Zt@7Z7xQ4=;5`@Hj4>$74a1?EMWPU!lse#I$3*7E+V@H<<^_nvm)TNS(a@$LFP
z$d^r4*3<3E%H0*7C^KtJye7noU_98qz^~WtnT3aKH)G$0uv1q#9xB786Nb%`7X&lP
zFx-`Y;lha5IxEuPk5vyT>K}&*nUeuW{ATa?aJ`FPl?<}fE2NDq>5b1URXI)+EEfHs
zyR2n**Be`{wQy-$V}xUmj83A@!PS4M7(dd_0Pn7RdchXmtvZ9ZtyQsB3Y}p^^FB+q
zmC|hd0tA_I`&W6y-)pm_?GDNHnvBBw$L5ws{K%i>zqC$I@5qO4yM0@%fH+fTO?Ny_
zni0-ecsQ|fC#<8M;hDYtQO!aTqEY58etO7-0dlZwKyRmVq^m#!%fkXv_q!EyD40fc
zy_GFPiLhOtUV?Ih4(sMw4V4vBrv1aU|4Lh!&)vWjA|@EmiXzT^dsc9z_-<eNjF&tC
z+b6ymKO$+0VJLjJ<mBQJEk68{FLSqc`JDYhq@Bf^Xj98oQ`<%8XLD0qb<GP#*CNR|
zHMI#R1W-vSyNtY5d^g?(XlCHq`YBY;Gce;Cx5o+M-xJ7>Cl7uY&XbQHaZ^moNZYX6
zmo`jIUTwRxNl*Av(@KJjrx=QaQ7#E0hsP8&^t#W^xoWRtyj6dW#=;s$aYX3H#qRLk
zTdY&L7=!pRMVYhHK5Se76BK7bi!lgOlQD%*fW0v#8I$Uc(H)Wb-9G~d!+aJv8(1_h
z>LZn{SHGVEGtakwj2}dG?0;D~1*qx2l_TDME}43#p8~u3ScXu0KaHyieeZjv@=kjU
zpx1m^w}0e03)6;4ab~b4jz(janZ6jw{Tn~_VPRmX(Yx>koI}Y{KbcdY;hUL51KZqN
zo8INf^{U>3+LN&z(usIAN7l9Z$~HD*8|KeuHYMZV`K<!8<hgHaz6&r6KQ`2BaN&7-
zqA5Sz#q(xOw5v4Rc6ra`<INzk_LPg%8{9EV*Cz|bm26G{68H!Wo;3#p>)Z$x>qPvP
zI^pY^1y7Glh@5>ko?C=nyQI_H#^`57>*4ls1BV}YGbQP&QCT&6r{zry^s)Nfc9+wZ
zI>n1%iAYXT((v%2Qy{mtB-y5%Zus5x#}#)(@40)o=u~9*Cf@#lbTvH4gXzw4zfJ0*
zETT-1{7P13<mCfDtdoEC(%O^>=e?of*eSqjv3ouC*t}j5wch!tPHKAeBHQv)=eTMD
z#xEb}y_bt+o?5DCk{&KS?$}j{zJ`#(R*&;}8b*+qW%kf%t>tCzBi$~=$&G@rv}Thd
z?0%gWIy&YT$)*W%nu=`4zB*LG`riOtmPG90=`Cs-!wczr)6JjuoY1-iI!UZ$d)E$G
zvoe?L3lgoKvZGTqQYyW?FGnbtiim9HQL)SA-0|Acwlb-Ia1D3pdbc4J-$k)wpP=ss
zXzDldH&rH5>YnJPx4oA~EuvQ!XQsO}4)IB4)-Et3<1`>_a@w|qeB1&Y51;qvClE|i
z<(qrdeO_HWj>dxC&LZZZzYP*>b7Q`x1bDpZk4UY0ruaA(`w`>70skf0xbG8J$^#v4
z!-zq5^`uffSFEo*rO)f-v0C`XQQCC!)ST4K1-=+soKVH7rEzS1r@RnX7m&EI_d(*4
zO`TWxS2Nh~cY~8j3CgsY{ieea=BGSvQTgu)w@!hev<(o|gxL2D$-|f{xw7fVvfj-~
zWsmEz-ptk}D3|URGwHWA%PudD7Yg!Mo^6uX6>m>(_Ql40K4SG^)nzKSW3yD4T`tl}
zBnq9byiTRaxliK{mMu4@C1HM%kibP0uyVcaB=phRrjNgtyB`S3lmBpBvez}9t?_^s
z5ljQ-ep^aON&T_+d&w9VOWOW*SDp<<#nd+?xZ^P|w0){>-zrb1q?;)waJhgj$WF$q
zrek1oZ>V_Kz2&Z%TE8O=W_L5PhSU4b)jmytJ%*ftf$@+Tl1>xz($yiZa4IOscOgRc
zA`{PO>=hPwVwPQ<SiZix)b$t1pp=(WOmr#M^N7*v5Pk&~Lu&bjH@C^NM?fHEw%$vY
zYJ+>`&vnBehT~?|r2(ljo9ex0;}HZ|ifk)Vl7V2KH?OYsw<)|LddWrEIboYl-DJ&@
zJ)(AhTjij^DMq+?fTxJpN6qS1>b_#Z>WB&Zvw}s%Rjyl4VwqQg)hpLn_j(W+f_hF$
zL>-@79;BWEJkgHzDugT6ZKYck0JFyGno(a-^1ca|eW}e=&5g{ht5gOAFYV-}c_NJ(
zvax9>aIMN&+4hvR$ntpKs2<Xg*5(8m3PzRd2R{hnIW+np(sqsXQ;>n5odyX>T3RA4
zUjWZw3D1xu_rQbf3aU39wPZ`G$;%}nQ58;kAH<Dts@8Zmy|z`7abhEm1#YflDL<$d
z;*NlajBwZfpl%jiB5+c2$>1s7GjCbYNf_CALV8hf#9O7;Xkh%fprKx@G)mNVeKc-x
zUUd0(Ux(BNkBT$mmd!?+=+?f~DexY+$*d8zXr|6+v3Fu9?2z7NUku8-S6W(b{-w9Z
zv9QM4s8o^1wTjk@;lw;e+<koG5!}2GR%8j8svg^a;UCu_=y3R0U{%qnMRd%;vfGAy
zIQgLoAtK`TNL1pyRLN`!vGeoQO|;1%{W?T<qzEr1tV9QtK6E5q`i@F{<oYJlq4%Jk
zkmHaX1%&pa&WCTz4*LF&cHDi;I?i%i?ZjHtqvfmn0*3*|#3F?IW?`a4oIrOQ=OwZ$
zO|4q{&bR|uTIAN*_^{G_x3JC0eTJYtHZA=-PugfBWjr@$XYy~IsPCF$-{3sVe`<pr
zuxsoDcKe!Q6}B*e+>>K0yFj}^VVR5^otcB<M5L6Y7*(Xfn$cy2{lWY+3JiACJ$Y7f
zDuVdXkOV`#f)~0Qrg}nx-6>B;%m9iMVcUZ{l6lIK5{~99YkZ2N3~jxvak;!M)}MI~
ziU?vj4J;y^9V&?1{f4o+O1~OP*IMPtXFN{Q&Hn0?CVnH#BBrmfjh5L&N4FfkUoWDP
znJ^|%Ho`K#YQC*(o!MC2Q^;zOtGya70_vCkIPvf`?ZOGIlIz74<Ia;VJlYgaxKw$B
zM$C#tP5(?m#jX|?plu-t(p5_?GWN`2nUd8wT(!Z%%1(2Ry7A8F8$vty`lZktQDp<3
zm4~cTMOp`bQ%tyz`dSU;su>e$kty6q&pvN!Sw?V_+3b(;ACX(_mpp7FZ6c%YhSi<$
zT+sow8Jly<58ZZ+pz^X|t53U1OpuXOfnPS-uVV4p!QI4_g`roNJ+r4mM{x31erHJ)
zMJOS~#Z^#xkt)}$Ytv0l@5d6RWnJBpS!0>P`ijYdjml(A-#U91rxzbvi06FVQ98K$
zwCQGFA4B2=gBO!shQ-TYltoQlYJ?M>57N^CXcyz?(f1YH4e|r~$RA`xJqPQ~MPJ@7
zt=c|NqX?=ni_Sc<@E_s#yA0X$IsQ&srsJG*6m<2#It))c=z4Z`;kag;-5uP_{Jcjb
zlsqfdN^Q}Ppk|B-sn{`Cp)M-R2_e3gT5>AWe0y2WrZTD9u0Nbu7=8q{M#7%wSe5f7
zW^Y}m$^K-P#vZs@`i1uDNU6R4tZ*^;byrdx34+6V-MHOvY`c<+bY@=*p*$*CkqHQN
zaHlyDW2q9ME9rak#xB)5&g%rja^s7jGNq4ZQ1@JaLvb|hOWBpH<M$cAb?LQrr71XW
zOQ0gqU|t-8C{FrXV{bS@-%Dq{*vv9aUp$m&RfnB3NiWG)f@ST{JTU&&x5C?9^6)98
zx2bOULsielrS?jjIoX{y{mZXr(sN&;XB3AT4TY|<U4&ytpWt*S%=Epk7_OJPGr)fQ
zMNYLRW&ff5R`}*)i%X5)wFN0q{n{<UGnsJCIVvFr^Bv0PtJ7;t>iLGoI!)-%{t1*h
z=VAKCq<0G>+osVI5mw0*EV;Ui>o~No)<4iRwSmPiNtmK!wAuo{ZI{7wqTo`dNK5mb
z50k_89wB!0;#T0i&ISE1<<2^hVtCe)ce}q$u;0%b;5giDW6%Y}CBhlMz2@W$<aMeg
zT#KZ=<Fq^N-^#7DMas4NJ=fT5)HhxJXt~<46ikquRG082UAOAqLD}woc0#H-yJ5>W
z&1u<*!*ZdOr1u{U92G?>WXazqG;VNwY~`aEH%Bn=^xAtq@+mdS3BNd4R6LQr3{N$_
z1S%k`h}fj3Scw-vqc^i?XssAop|AHvII+#QRDqhvcR$MYH9$|u33w*>x_bP}<dkD{
zq^Nh;_O~cFYa&m99(rpKJJQ-G;b!>y0`r%32?HJt&xkm?n&4vxm))^;maRC~h7Vr4
NSA#X5V@?&P{}-?GygC2?

literal 0
HcmV?d00001

diff --git a/Workshop Day 2/rockPaperScissors.html b/Workshop Day 2/rockPaperScissors.html
new file mode 100644
index 0000000..8d6c17d
--- /dev/null
+++ b/Workshop Day 2/rockPaperScissors.html	
@@ -0,0 +1,7 @@
+<!DOCTYPE html>
+<html>
+    <body>
+        <script src="owl.js"></script>
+        <script src="rockPaperScissors.js"></script>
+    </body>
+</html>
\ No newline at end of file
diff --git a/Workshop Day 2/rockPaperScissors.js b/Workshop Day 2/rockPaperScissors.js
new file mode 100644
index 0000000..2748d67
--- /dev/null
+++ b/Workshop Day 2/rockPaperScissors.js	
@@ -0,0 +1,217 @@
+const { Component, mount, xml, useState, useEnv, reactive } = owl;
+
+let guesses = 5;
+let yourCount = 0;
+let compCount = 0;
+
+const finalData = () => {
+  const guess = useEnv();
+  return useState(guess.store);
+};
+
+class Result extends Component{
+    static template = xml`
+    <div>
+      <div>Your Count: <t t-esc="this.user.getYourCount()" /></div>
+      <div>Computer Count: <t t-esc="this.user.getCompCount()"/></div> 
+    </div>
+  `;
+
+  setup() {
+    this.user = finalData();
+  }
+}
+
+class Input extends Component {
+  static template = xml`
+        <input type="text" id="data"/>
+
+    `;
+
+    getInput() {
+        const input = document.getElementById("data").value;
+        console.log("You: " + input);
+        return input;
+    }
+
+    yourCount = 0;
+    compCount = 0;
+    updateYourCount() {
+        this.yourCount++;
+    }
+    getYourCount() {
+        return this.yourCount;
+    }
+    updateCompCount() {
+        this.compCount++;
+    }
+    getCompCount() {
+        return this.compCount;
+    }
+
+}
+
+class Root extends Component {
+  static template = xml`
+    <div>
+      <h1>Rock Paper Scissors</h1>
+      <Input />
+      <div></div><br/>
+      <button t-on-click="check">Guess!</button>
+      <div></div><br/>
+      <Result/> 
+    </div>
+  `;
+
+  static components = { Input, Result};
+
+  setup() {
+    this.user = finalData();
+  }
+
+  check() {
+    const rand = Math.floor(Math.random() * 3) + 1;
+    console.log("Computer: " + rand);
+    let no = this.user.getInput();
+
+    if ((no == 1 && rand == 3) || (no == 2 && rand == 1) || (no == 3 && rand == 2)) {
+      console.log("You Win!");
+      this.user.updateYourCount();
+    } else if ((no == 2 && rand == 3) || (no == 3 && rand == 1) || (no == 1 && rand == 2)) {
+      console.log("Computer Wins!");
+      this.user.updateCompCount();
+    } else {
+      console.log("Draw");
+    }
+
+    guesses--;
+
+    if (guesses == 0) {
+      console.log("Game over");
+      document.getElementById("data").disabled = true;
+
+    }
+  }
+}
+
+const createData = () => {
+  return reactive(new Input());
+};
+
+const env = { store: createData() };
+
+mount(Root, document.body, { dev: true, env})
+
+{/* <button><img src = "rock.jpg" id = "data" style="height:200px" value="1"/></button>
+<button><img src = "paper.jpg" id = "data" style="height:200px" value="2"/></button>
+<button><img src = "scissors.png" id = "data" style="height:200px" value="3"/></button> */}
+
+// const { Component, mount, xml, useState, useEnv, reactive } = owl;
+
+// let guesses = 5;
+// let yourCount = 0;
+// let compCount = 0;
+
+// const finalData = () => {
+//   const guess = useEnv();
+//   return useState(guess.store);
+// };
+
+// class Input extends Component {
+//   static template = xml`<input type="text" id="data" placeholder="Enter number b/w 1 to 3"/>`;
+
+//   getInput() {
+//     const input = document.getElementById("data").value;
+//     console.log("You: " + input);
+//     return input;
+//   }
+
+//   yourCount = 0;
+//   compCount = 0;
+//   updateYourCount() {
+//     this.yourCount++;
+//   }
+//   getYourCount() {
+//     return this.yourCount;
+//   }
+//   updateCompCount() {
+//     this.compCount++;
+//   }
+//   getCompCount() {
+//     return this.compCount;
+//   }
+
+// }
+
+// class Root extends Component {
+//   static template = xml`
+//     <div>
+//       <h1>Rock Paper Scissors</h1>
+//       <Input />
+//       <div></div><br/>
+//       <button t-on-click="check">Guess!</button>
+//       <div></div><br/>
+//       <div>Your Count: <t t-esc="this.user.getYourCount()" /></div>
+//       <div>Computer Count: <t t-esc="this.user.getCompCount()"/></div>
+//       <Result t-if="guesses == 0" result="Result will be displayed here" />
+//     </div>
+//   `;
+
+//   static components = { Input, Result };
+
+//   setup() {
+//     this.user = finalData();
+//   }
+
+//   check() {
+//     const rand = Math.floor(Math.random() * 3) + 1;
+//     console.log("Computer: " + rand);
+//     let no = this.user.getInput();
+
+//     if ((no == 1 && rand == 3) || (no == 2 && rand == 1) || (no == 3 && rand == 2)) {
+//       console.log("You Win!");
+//       this.user.updateYourCount();
+//     } else if ((no == 2 && rand == 3) || (no == 3 && rand == 1) || (no == 1 && rand == 2)) {
+//       console.log("Computer Wins!");
+//       this.user.updateCompCount();
+//     } else {
+//       console.log("Draw");
+//     }
+
+//     guesses--;
+
+//     if (guesses == 0) {
+//       console.log("Game over");
+//       document.getElementById("data").disabled = true;
+
+//         let template = xml`
+//             <div>
+//             <Result result="Result will be displayed here" />
+//             </div>
+//      `;
+
+//       if (this.user.getYourCount() > this.user.getCompCount()) {
+//         this.result = "Congratulation!! You Win!!";
+//       } else if (this.user.getCompCount() > this.user.getYourCount()) {
+//         this.result = "Sorry!! Computer Wins!!";
+//       } else {
+//         this.result = "Match Draw";
+//       }
+//     }
+//   }
+// }
+
+// class Result extends Component {
+//   static template = xml`<div><br/><b>Result: </b><t t-esc="this.props.result" /><br/></div>`;
+
+//   static props = ["result"];
+// }
+
+// const createData = () => {
+//   return reactive(new Input());
+// };
+
+// const env = { store: createData() };
+
+// mount(Root, document.body, { dev: true, env})
+
diff --git a/Workshop Day 2/scissors.png b/Workshop Day 2/scissors.png
new file mode 100644
index 0000000000000000000000000000000000000000..bf306ec0f521dd81bd49e9c5f636de3091308c45
GIT binary patch
literal 33512
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

literal 0
HcmV?d00001


From 2fc4527f60c9594ae79fe9a2477928f1dbd0f9b3 Mon Sep 17 00:00:00 2001
From: "Manushi Shah (mash)" <mash@odoo.com>
Date: Wed, 15 Mar 2023 10:22:53 +0530
Subject: [PATCH 5/6] [IMP] Game: Rock Paper Scissors

---
 .../7934c6cf66ceade7c2986687946067b2.jpg      | Bin 0 -> 18757 bytes
 Workshop Day 2/paper.jpg                      | Bin 2626 -> 0 bytes
 Workshop Day 2/papers.jpg                     | Bin 0 -> 18325 bytes
 Workshop Day 2/rock.jpg                       | Bin 15004 -> 0 bytes
 Workshop Day 2/rockPaperScissors.js           | 200 +++++-------------
 Workshop Day 2/rocks.jpg                      | Bin 0 -> 19270 bytes
 Workshop Day 2/scissors.jpg                   | Bin 0 -> 18757 bytes
 Workshop Day 2/scissors.png                   | Bin 33512 -> 0 bytes
 8 files changed, 53 insertions(+), 147 deletions(-)
 create mode 100644 Workshop Day 2/7934c6cf66ceade7c2986687946067b2.jpg
 delete mode 100644 Workshop Day 2/paper.jpg
 create mode 100644 Workshop Day 2/papers.jpg
 delete mode 100644 Workshop Day 2/rock.jpg
 create mode 100644 Workshop Day 2/rocks.jpg
 create mode 100644 Workshop Day 2/scissors.jpg
 delete mode 100644 Workshop Day 2/scissors.png

diff --git a/Workshop Day 2/7934c6cf66ceade7c2986687946067b2.jpg b/Workshop Day 2/7934c6cf66ceade7c2986687946067b2.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..d935fe6f21975fffaa7a2add0b548d6e7ccfc3a4
GIT binary patch
literal 18757
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

literal 0
HcmV?d00001

diff --git a/Workshop Day 2/paper.jpg b/Workshop Day 2/paper.jpg
deleted file mode 100644
index e397a99daf6af29f0f2a5021697181387b09843a..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 2626
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

diff --git a/Workshop Day 2/papers.jpg b/Workshop Day 2/papers.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..9ab8dc765fdd3a8aaf2855089fb5b18bf46ef4a4
GIT binary patch
literal 18325
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
Glm7!0@$^>!

literal 0
HcmV?d00001

diff --git a/Workshop Day 2/rock.jpg b/Workshop Day 2/rock.jpg
deleted file mode 100644
index 24c5c7a032c0f85ffd47cdf223ad5c4e57a07056..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 15004
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
NSA#X5V@?&P{}-?GygC2?

diff --git a/Workshop Day 2/rockPaperScissors.js b/Workshop Day 2/rockPaperScissors.js
index 2748d67..8696d30 100644
--- a/Workshop Day 2/rockPaperScissors.js	
+++ b/Workshop Day 2/rockPaperScissors.js	
@@ -9,8 +9,8 @@ const finalData = () => {
   return useState(guess.store);
 };
 
-class Result extends Component{
-    static template = xml`
+class Result extends Component {
+  static template = xml`
     <div>
       <div>Your Count: <t t-esc="this.user.getYourCount()" /></div>
       <div>Computer Count: <t t-esc="this.user.getCompCount()"/></div> 
@@ -24,46 +24,48 @@ class Result extends Component{
 
 class Input extends Component {
   static template = xml`
-        <input type="text" id="data"/>
-
+        
+        <button id = "data" value="1"><img src="rocks.jpg" style="height:200px; width:200px"/></button>
+        <button id = "data" value="2"><img src="papers.jpg" style="height:200px; width:200px"/></button>
+        <button id = "data" value="3"><img src="scissors.jpg" style="height:200px; width:200px"/></button>
     `;
 
-    getInput() {
-        const input = document.getElementById("data").value;
-        console.log("You: " + input);
-        return input;
-    }
-
-    yourCount = 0;
-    compCount = 0;
-    updateYourCount() {
-        this.yourCount++;
-    }
-    getYourCount() {
-        return this.yourCount;
-    }
-    updateCompCount() {
-        this.compCount++;
-    }
-    getCompCount() {
-        return this.compCount;
-    }
+  getInput() {
+    const input = document.getElementById("data").value;
+    console.log("You: " + input);
+    return input;
+  }
 
+  yourCount = 0;
+  compCount = 0;
+  updateYourCount() {
+    this.yourCount++;
+  }
+  getYourCount() {
+    return this.yourCount;
+  }
+  updateCompCount() {
+    this.compCount++;
+  }
+  getCompCount() {
+    return this.compCount;
+  }
 }
 
 class Root extends Component {
   static template = xml`
-    <div>
+    <div style="text-align:center">
       <h1>Rock Paper Scissors</h1>
       <Input />
       <div></div><br/>
-      <button t-on-click="check">Guess!</button>
+      <button t-on-click="check" style="background-color: rgb(18, 137, 153); color: #ffffff; padding:6px; width:60px; border-radius:8px" id="play">Play!</button>
       <div></div><br/>
-      <Result/> 
+      <Result/>
+      <div id = "show"/> 
     </div>
   `;
 
-  static components = { Input, Result};
+  static components = { Input, Result };
 
   setup() {
     this.user = finalData();
@@ -74,10 +76,18 @@ class Root extends Component {
     console.log("Computer: " + rand);
     let no = this.user.getInput();
 
-    if ((no == 1 && rand == 3) || (no == 2 && rand == 1) || (no == 3 && rand == 2)) {
+    if (
+      (no == 1 && rand == 3) ||
+      (no == 2 && rand == 1) ||
+      (no == 3 && rand == 2)
+    ) {
       console.log("You Win!");
       this.user.updateYourCount();
-    } else if ((no == 2 && rand == 3) || (no == 3 && rand == 1) || (no == 1 && rand == 2)) {
+    } else if (
+      (no == 2 && rand == 3) ||
+      (no == 3 && rand == 1) ||
+      (no == 1 && rand == 2)
+    ) {
       console.log("Computer Wins!");
       this.user.updateCompCount();
     } else {
@@ -88,8 +98,18 @@ class Root extends Component {
 
     if (guesses == 0) {
       console.log("Game over");
-      document.getElementById("data").disabled = true;
-
+      document.getElementById("play").disabled = true;
+
+      if (this.user.getYourCount() > this.user.getCompCount()) {
+        document.getElementById("show").innerHTML =
+          "<br/><h3>Congratulation!! You WIN!!</h3>";
+      } else if (this.user.getYourCount() < this.user.getCompCount()) {
+        document.getElementById("show").innerHTML =
+          "<br/><h3>Sorryy!! Computer WINS!!</h3>";
+      } else {
+        document.getElementById("show").innerHTML =
+          "<br/><h3>Match Draw!!</h3>";
+      }
     }
   }
 }
@@ -100,118 +120,4 @@ const createData = () => {
 
 const env = { store: createData() };
 
-mount(Root, document.body, { dev: true, env})
-
-{/* <button><img src = "rock.jpg" id = "data" style="height:200px" value="1"/></button>
-<button><img src = "paper.jpg" id = "data" style="height:200px" value="2"/></button>
-<button><img src = "scissors.png" id = "data" style="height:200px" value="3"/></button> */}
-
-// const { Component, mount, xml, useState, useEnv, reactive } = owl;
-
-// let guesses = 5;
-// let yourCount = 0;
-// let compCount = 0;
-
-// const finalData = () => {
-//   const guess = useEnv();
-//   return useState(guess.store);
-// };
-
-// class Input extends Component {
-//   static template = xml`<input type="text" id="data" placeholder="Enter number b/w 1 to 3"/>`;
-
-//   getInput() {
-//     const input = document.getElementById("data").value;
-//     console.log("You: " + input);
-//     return input;
-//   }
-
-//   yourCount = 0;
-//   compCount = 0;
-//   updateYourCount() {
-//     this.yourCount++;
-//   }
-//   getYourCount() {
-//     return this.yourCount;
-//   }
-//   updateCompCount() {
-//     this.compCount++;
-//   }
-//   getCompCount() {
-//     return this.compCount;
-//   }
-
-// }
-
-// class Root extends Component {
-//   static template = xml`
-//     <div>
-//       <h1>Rock Paper Scissors</h1>
-//       <Input />
-//       <div></div><br/>
-//       <button t-on-click="check">Guess!</button>
-//       <div></div><br/>
-//       <div>Your Count: <t t-esc="this.user.getYourCount()" /></div>
-//       <div>Computer Count: <t t-esc="this.user.getCompCount()"/></div>
-//       <Result t-if="guesses == 0" result="Result will be displayed here" />
-//     </div>
-//   `;
-
-//   static components = { Input, Result };
-
-//   setup() {
-//     this.user = finalData();
-//   }
-
-//   check() {
-//     const rand = Math.floor(Math.random() * 3) + 1;
-//     console.log("Computer: " + rand);
-//     let no = this.user.getInput();
-
-//     if ((no == 1 && rand == 3) || (no == 2 && rand == 1) || (no == 3 && rand == 2)) {
-//       console.log("You Win!");
-//       this.user.updateYourCount();
-//     } else if ((no == 2 && rand == 3) || (no == 3 && rand == 1) || (no == 1 && rand == 2)) {
-//       console.log("Computer Wins!");
-//       this.user.updateCompCount();
-//     } else {
-//       console.log("Draw");
-//     }
-
-//     guesses--;
-
-//     if (guesses == 0) {
-//       console.log("Game over");
-//       document.getElementById("data").disabled = true;
-
-//         let template = xml`
-//             <div>
-//             <Result result="Result will be displayed here" />
-//             </div>
-//      `;
-
-//       if (this.user.getYourCount() > this.user.getCompCount()) {
-//         this.result = "Congratulation!! You Win!!";
-//       } else if (this.user.getCompCount() > this.user.getYourCount()) {
-//         this.result = "Sorry!! Computer Wins!!";
-//       } else {
-//         this.result = "Match Draw";
-//       }
-//     }
-//   }
-// }
-
-// class Result extends Component {
-//   static template = xml`<div><br/><b>Result: </b><t t-esc="this.props.result" /><br/></div>`;
-
-//   static props = ["result"];
-// }
-
-// const createData = () => {
-//   return reactive(new Input());
-// };
-
-// const env = { store: createData() };
-
-// mount(Root, document.body, { dev: true, env})
-
+mount(Root, document.body, { dev: true, env });
\ No newline at end of file
diff --git a/Workshop Day 2/rocks.jpg b/Workshop Day 2/rocks.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..69272ee1ef91d7477656b69febd50d59b61faaa5
GIT binary patch
literal 19270
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
W+6-&9ZXY3dF@3OZ(42QQ^FILE%i1mg

literal 0
HcmV?d00001

diff --git a/Workshop Day 2/scissors.jpg b/Workshop Day 2/scissors.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..d935fe6f21975fffaa7a2add0b548d6e7ccfc3a4
GIT binary patch
literal 18757
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

literal 0
HcmV?d00001

diff --git a/Workshop Day 2/scissors.png b/Workshop Day 2/scissors.png
deleted file mode 100644
index bf306ec0f521dd81bd49e9c5f636de3091308c45..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 33512
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


From 0224948725e71698f6125548bef9c58f6b7b84dd Mon Sep 17 00:00:00 2001
From: "Manushi Shah (mash)" <mash@odoo.com>
Date: Wed, 15 Mar 2023 10:27:18 +0530
Subject: [PATCH 6/6] [IMP] Game: Rock Paper Scissors

---
 Workshop Day 2/rockPaperScissors.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Workshop Day 2/rockPaperScissors.js b/Workshop Day 2/rockPaperScissors.js
index 8696d30..7829cfa 100644
--- a/Workshop Day 2/rockPaperScissors.js	
+++ b/Workshop Day 2/rockPaperScissors.js	
@@ -54,7 +54,7 @@ class Input extends Component {
 
 class Root extends Component {
   static template = xml`
-    <div style="text-align:center">
+    <div style="text-align:center; margin-top:200px" >
       <h1>Rock Paper Scissors</h1>
       <Input />
       <div></div><br/>
